嵌入式C语言设计模式 - 状态机模式

概念：

状态机设计模式（State Machine Design Pattern）是一种行为型设计模式，用于管理对象的状态及其相应的行为。它将对象的行为和状态进行解耦，使得对象在不同状态下可以有不同的行为。

组成部分：

状态（State）：表示对象所处的状态。每个状态都会定义一组可能的行为，并且这些行为只能在该状态下执行。

上下文（Context）：包含状态机的主要逻辑，负责根据当前状态调用相应的行为。上下文还能够维护当前状态和处理状态转换。

事件（Event）：触发状态转换的外部输入。当事件发生时，状态机会根据当前状态和事件类型执行相应的操作，可能导致状态的变化。

行为（Action）：与每个状态相关联的具体操作。每个状态可以定义一组行为，用于在特定状态下执行相应的逻辑。

工作原理：

初始化：将对象的初始状态设置为合适的状态。

处理事件：当外部事件发生时，上下文将会根据当前状态和事件类型触发相应的行为。

状态转换：在行为执行后，状态机可能会根据一定的条件决定是否需要进行状态转换。状态转换可以将对象的状态从一个状态转变为另一个状态。

执行行为：根据新的状态，上下文将调用相应状态下定义的行为。

整理成大白话就是首先要定义状态，确定系统中可能存在的各个状态，并将每个状态抽象为一个独立的类，这些类实现了共同的接口，然后确定状态之间的转换规则，即在特定的条件下从一个状态转移到另一个状态。这些条件可以来自外部的事件、用户输入等。最后还需要创建一个上下文方法，该方法包含对当前状态的引用，并提供相应的方法来触发状态的转换。上下文方法负责根据转换规则决定状态的改变。

实践：

业务场景：有一个灯，按下开按钮，就会开灯，按下关按钮就会关灯

分析：

1、确定状态：只有开灯和关灯两种确定的状态

2、上下文：封装处理状态流转和执行状态改变后的行为

3、事件：把用户按下按钮视为触发事件

4、行为：执行状态改变后的方法，比如按下开灯按钮后需要去执行开灯的工作

#include <stdio.h>

// 状态枚举
typedef enum {
    OPEN_STATE,
    CLOSE_STATE
} State;

// 状态机结构体
typedef struct {
    State current_state;
} LightStateMachine;

// 上下文处理函数
void light_fsm_event(LightStateMachine *machine) {
	if (machine->current_state == OPEN_STATE) {
        printf("正在关闭灯...\n");
		// todo 执行关灯行为
		machine->current_state = CLOSE_STATE;
    } else if (machine->current_state == CLOSE_STATE) {
        printf("正在开启灯...\n");
		// todo 执行开灯行为
        machine->current_state = OPEN_STATE;
    }
}

int main() {
    // 创建实例对象
    LightStateMachine machine;
    
    // 初始化为关闭状态
    machine.current_state = CLOSE_STATE;
    
    // 模拟按下按钮操作触发事件
    light_fsm_event(&machine);   // 正在开启灯...
    light_fsm_event(&machine);   // 正在关闭灯...

    return 0;
}

但是这样代码会有点局限性，每增加一种状态就需要增加 if/else 来控制，不是很友好

改造如下：

#include <stdio.h>

// 状态枚举
typedef enum {
    OPEN_STATE,
    CLOSE_STATE,
    // TODO: 添加其他状态
    STATE_COUNT
} State;

// 状态机结构体
typedef struct {
    State current_state;
} LightStateMachine;

// 上下文处理函数类型定义
typedef void (*StateHandler)(LightStateMachine *);

// 开启状态处理函数
void open_state_handler(LightStateMachine *machine) {
    printf("正在关闭灯...\n");
    // TODO: 执行关闭灯行为
    machine->current_state = CLOSE_STATE;
}

// 关闭状态处理函数
void close_state_handler(LightStateMachine *machine) {
    printf("正在开启灯...\n");
    // TODO: 执行开启灯行为
    machine->current_state = OPEN_STATE;
}

// 状态处理函数映射表
const StateHandler state_handlers[STATE_COUNT] = {
    open_state_handler,
    close_state_handler,
    // TODO: 添加其他状态处理函数
};

// 上下文处理函数
void light_fsm_event(LightStateMachine *machine) {
    StateHandler handler = state_handlers[machine->current_state];
    handler(machine);
}

int main() {
    // 创建实例对象
    LightStateMachine machine;
    
    // 初始化为关闭状态
    machine.current_state = CLOSE_STATE;
    
    // 模拟按下按钮操作触发事件
    light_fsm_event(&machine);   // 正在开启灯...
    light_fsm_event(&machine);   // 正在关闭灯...

    return 0;
}

状态机设计模式在嵌入式中还是很常见的设计模式，那我们能不能设计一套框架出来，以后适用的业务场景可以直接复用，提高效率呢？

通用框架：

思路：

这是一个有限状态机（Finite State Machine，FSM）的框架，某个对象的行为取决于其内部状态的变化，而这种状态的变化又是由外部事件的触发所引起的。

定义状态：确定需要的状态及其对应的枚举值，以 State 枚举类型表示

定义转换规则：确定状态之间的转换规则，即在某个状态下触发某个事件后，应该切换到哪个状态。将这些规则组织成一个转换规则数组，并定义为 TransitionRule 结构体数组

设计状态处理函数：根据每个状态的不同，为每个状态值定义相应的处理函数。这些处理函数将根据状态来执行相应的操作或逻辑

设计状态机数据结构：设计一个数据结构来存储状态机的相关信息，包括当前状态、转换规则和处理函数等

触发状态转换和处理：

• 当外部事件触发时，调用有限状态机的状态转换函数，并传入触发事件所对应的状态值或事件参数。
• 在状态转换函数中，根据当前状态和转换规则，自动地将状态切换到下一个状态，并调用对应的处理函数执行相应的操作

代码实现：

state_machine.h

#ifndef STATE_MACHINE_H_
#define STATE_MACHINE_H_

#include <stdlib.h>

/* 状态枚举 */
typedef enum {
    STATE_1,
    STATE_2,
    STATE_3,
    /* 添加其他状态 */
    STATE_MAX
} State;

/* 事件枚举 */
typedef enum {
    EVENT_1,
    EVENT_2,
    EVENT_3,
    /* 添加其他事件 */
    EVENT_MAX
} Event;

/* 状态处理函数签名，有两个参数：上下文指针和事件 */
typedef void (*StateHandler)(void *context, Event event);

/* 动作函数签名，有两个参数：上下文指针和事件 */
typedef void (*Action)(void *context, Event event);

/* 条件判断函数签名，有两个参数：上下文指针和事件，返回值为 int 类型 */
typedef int (*Condition)(void *context, Event event);

/* 状态转换规则结构体, 用于定义状态之间的转换规则 */
typedef struct {
    State currentState;      /* 当前状态 */
    Event event;             /* 表示触发状态转换的事件 */
    Condition condition;     /* 条件函数，用于判断是否满足执行该转换规则的条件 */
    Action action;           /* 动作函数，用于执行状态转换时需要执行的动作 */
    State nextState;         /* 转移到的下一个状态 */
    StateHandler handler;    /* 状态处理函数，用于处理进入新状态后的操作 */
} TransitionRule;

/* 状态机结构体, 用于表示状态机本身，并存储状态机的状态和上下文数据 */
typedef struct {
    State currentState;         /* 当前状态 */
    TransitionRule *rules;      /* 状态转换规则数组的指针,用于存储所有的状态转换规则 */
    size_t ruleCount;           /* 状态转换规则的数量 */
    void *context;              /* 指向状态机的上下文数据的指针 */
    StateHandler handlers[STATE_MAX];    /* 状态处理函数表,用于存储每个状态对应的处理函数 */
} StateMachine;

/* 初始化状态机, 用于初始化状态机。它接受转换规则数组、规则数量、上下文数据指针和状态处理函数数组作为参数，并将它们存储在 StateMachine 结构体中 */
void state_machine_init(StateMachine *machine, TransitionRule *rules, size_t ruleCount, void *context, StateHandler *handlers);

/* 执行状态机处理,用于处理事件。它接受一个事件作为参数，并根据当前状态以及转换规则判断是否需要执行状态转换和相关的动作 */
void state_machine_handle_event(StateMachine *machine, Event event);

/* 获取当前状态 */
State state_machine_get_current_state(StateMachine *machine);

#endif

state_machine.c

#include "state_machine.h"


/**
 * 初始化状态机
 * 
 * @param machine   指向 StateMachine 结构体的指针
 * @param rules     状态转换规则数组
 * @param ruleCount 转换规则的数量
 * @param context   指向状态机上下文数据的指针
 * @param handlers  状态处理函数数组
 */
void state_machine_init(StateMachine *machine, TransitionRule *rules, size_t ruleCount, void *context, StateHandler *handlers) {
    // 设置当前状态为第一个转换规则的当前状态
    machine->currentState = rules[0].currentState;
    
    // 存储转换规则数组、规则数量和上下文数据
    machine->rules = rules;
    machine->ruleCount = ruleCount;
    machine->context = context;

    // 将状态处理函数数组初始化为空
    for (size_t i = 0; i < STATE_MAX; i++) {
        machine->handlers[i] = NULL;
    }

    // 根据规则的当前状态，从处理函数数组中获取对应的处理函数并存储到状态处理函数数组中
    for (size_t i = 0; i < ruleCount; i++) {
        machine->handlers[machine->rules[i].currentState] = handlers[machine->rules[i].currentState];
    }
}



/* 执行状态机处理 */
void state_machine_handle_event(StateMachine *machine, Event event) {
    for (size_t i = 0; i < machine->ruleCount; ++i) {
        /* 查找匹配的状态转换规则 */
        if (machine->currentState == machine->rules[i].currentState && event == machine->rules[i].event) {
            /* 检查条件判断 */
            if (machine->rules[i].condition(machine->context, event)) {
                /* 执行动作函数 */
                if (machine->rules[i].action != NULL) {
                    machine->rules[i].action(machine->context, event);
                }

                /* 更新当前状态 */
                machine->currentState = machine->rules[i].nextState;

                /* 调用对应状态的处理函数 */
                if (machine->handlers[machine->currentState] != NULL) {
                    machine->handlers[machine->currentState](machine->context, event);
                }
                break;
            } else {
                /* 处理条件不满足的情况 */
                // TODO: 错误处理代码
                break;
            }
        }
    }
}



/* 获取当前状态 */
State state_machine_get_current_state(StateMachine *machine) {
    return machine->currentState;
}

举例：

业务场景：按键长按时触发录音，接收到录音数据的同时把录音数据t发送到服务器，按键松手则停止录音

#include <stdio.h>
#include <stdbool.h>
#include "state_machine.h"

typedef enum {
    Idle,
    Recording,
    Stopped
} RecorderState;

typedef enum {
    ButtonPressed,
    ButtonReleased
} Event;

typedef struct {
    /* 录音相关数据 */
    bool isRecording;
    /* WebSocket 连接相关数据 */
    bool isConnected;
    /* 其他上下文数据 */
    // ...
} RecorderContext;

/* 动作函数的实现 */
void start_recording(void *context, Event event) {
    RecorderContext *ctx = (RecorderContext *)context;
    ctx->isRecording = true;
    printf("Start recording\n");
}

void stop_recording(void *context, Event event) {
    RecorderContext *ctx = (RecorderContext *)context;
    ctx->isRecording = false;
    printf("Stop recording\n");
}

void send_data(void *context, Event event) {
    RecorderContext *ctx = (RecorderContext *)context;
    if (ctx->isConnected) {
        printf("Sending data to server\n");
        // Send recording data via WebSocket
    }
}

/* 条件判断函数的实现 */
int is_button_pressed(void *context, Event event) {
    RecorderContext *ctx = (RecorderContext *)context;
    return event == ButtonPressed;
}

int is_button_released(void *context, Event event) {
    RecorderContext *ctx = (RecorderContext *)context;
    return event == ButtonReleased;
}

/* 状态处理函数的实现 */
void idle_state_handler(void *context, Event event) {
    printf("Idle State\n");
}

void recording_state_handler(void *context, Event event) {
    printf("Recording State\n");
}

void stopped_state_handler(void *context, Event event) {
    printf("Stopped State\n");
}

int main() {
    /* 创建录音状态机的上下文数据 */
    RecorderContext recorderContext;
    recorderContext.isRecording = false;
    recorderContext.isConnected = true;

    /* 创建录音状态转换规则数组 */
    TransitionRule recorderRules[] = {
        {Idle, ButtonPressed, is_button_pressed, start_recording, Recording, recording_state_handler},
        {Recording, ButtonReleased, is_button_released, stop_recording, Stopped, stopped_state_handler},
        {Recording, ButtonPressed, is_button_pressed, send_data, Recording, NULL}
    };
    size_t recorderRuleCount = sizeof(recorderRules) / sizeof(recorderRules[0]);

    /* 创建录音状态机 */
    StateMachine recorderMachine;
    state_machine_init(&recorderMachine, recorderRules, recorderRuleCount, &recorderContext,
                       (StateHandler[]){idle_state_handler, recording_state_handler, stopped_state_handler});

    /* 模拟按键事件 */
    printf("Initial state: %d\n", state_machine_get_current_state(&recorderMachine));  // 初始状态
    state_machine_handle_event(&recorderMachine, ButtonPressed);  // 按键按下，开始录音
    state_machine_handle_event(&recorderMachine, ButtonPressed);  // 按键继续按下，发送录音数据
    state_machine_handle_event(&recorderMachine, ButtonReleased);  // 按键松开，停止录音
    state_machine_handle_event(&recorderMachine, ButtonPressed);  // 按键按下，开始录音

    return 0;
}

看完点赞收藏谢谢大家。