C語言實現嵌入式狀態機簡單描述與應用

嵌入式狀態機是一種常用的軟件設計模式，它能夠提高代碼的可讀性和可維護性。狀態機是一個抽象的概念，它描述了一個系統或者組件的不同狀態以及在不同狀態下如何響應輸入和事件。狀態機可以應用于各種領域，比如通信協議、嵌入式系統、控制系統等。

在C語言中，可以使用有限狀態機（FSM）實現嵌入式狀態機。有限狀態機可以通過一組狀態和狀態之間的轉換來描述系統或者組件的行為。在嵌入式系統中，通常使用循環或者中斷處理程序來實現狀態機

當系統需要執行某個任務時，可以根據狀態機的狀態選擇不同的操作，例如：

控制系統狀態：例如控制器根據狀態機的狀態選擇執行不同的操作，從而控制整個系統的狀態，例如開關燈、控制電機等。
系統調度：例如操作系統根據狀態機的狀態選擇執行不同的任務，從而實現系統的調度。
系統事件處理：例如網絡通信系統根據狀態機的狀態選擇不同的數據處理方式，例如處理接收到的數據、發送數據等。
系統錯誤處理：例如系統出現錯誤時，可以根據狀態機的狀態選擇不同的錯誤處理方式，例如重新啟動系統、輸出錯誤信息等。

總之，狀態機可以幫助我們將系統的復雜性分解為多個簡單的狀態，根據不同的狀態選擇執行不同的操作，從而更好地實現系統的設計與開發。

主要流程

定義狀態和事件

首先需要定義系統可能存在的所有狀態，通常用枚舉類型來表示。同時需要定義可能發生的所有事件，例如輸入的數據、定時器到達等。
初始化狀態機

在程序啟動時，需要將狀態機初始化為特定的狀態。
定義狀態轉換和動作

使用switch-case if-else 函數指針等語句來定義狀態轉換和動作。當事件發生時，判斷當前狀態，并根據不同的事件執行相應的動作，并將狀態轉換為下一個狀態。
事件處理

當有事件發生時，將事件作為參數傳遞給狀態機，并調用狀態轉換和動作函數。
循環執行

狀態機通常作為一個獨立的任務運行，并在一個無限循環中等待事件的發生。

舉例

1#include 
 2
 3// 定義狀態機的所有可能狀態
 4enum {
 5    STATE_IDLE,
 6    STATE_RUNNING,
 7    STATE_COMPLETE,
 8    NUM_STATES
 9};
10
11// 定義狀態機的事件類型
12enum {
13    EVENT_START,
14    EVENT_STOP,
15    NUM_EVENTS
16};
17
18// 定義狀態機的數據結構
19typedef struct {
20    int current_state;
21    void (*process_event)(int event);
22} state_machine_t;
23
24// 定義狀態機的處理函數
25void idle_state(int event) {
26    if (event == EVENT_START) {
27        printf("Idle state: starting...\\n");
28        // 將狀態機的當前狀態改為運行狀態
29        state_machine.current_state = STATE_RUNNING;
30    }
31}
32
33void running_state(int event) {
34    if (event == EVENT_STOP) {
35        printf("Running state: stopping...\\n");
36        // 將狀態機的當前狀態改為完成狀態
37        state_machine.current_state = STATE_COMPLETE;
38    }
39}
40
41void complete_state(int event) {
42    printf("Complete state: done.\\n");
43}
44
45// 初始化狀態機
46state_machine_t state_machine = {
47    .current_state = STATE_IDLE,
48    .process_event = idle_state
49};
50
51int main() {
52    // 在循環中讀取事件并將其傳遞給狀態機
53    while (1) {
54        int event;
55        scanf("%d", &event);
56        state_machine.process_event(event);
57        if (state_machine.current_state == STATE_COMPLETE) {
58            break;
59        }
60    }
61    return 0;
62}

在上面的例子中，我們定義了三個狀態：空閑狀態、運行狀態和完成狀態。我們還定義了兩個事件：啟動事件和停止事件。狀態機的數據結構包含當前狀態和處理當前狀態的函數的指針。我們還定義了三個處理函數，分別處理空閑狀態、運行狀態和完成狀態。在處理函數中，我們根據當前狀態和事件決定下一個狀態以及執行相應的操作。在應用程序中，我們初始化狀態機，然后在循環中讀取事件并將其進行傳遞。

事例二

1// 定義狀態枚舉值
 2typedef enum {
 3  STATE_OFF,
 4  STATE_ON
 5} led_state_t;
 6
 7// 定義狀態機結構體
 8typedef struct {
 9  led_state_t state;  // 當前狀態
10  void (*turn_on)();  // 執行開啟操作的函數指針
11  void (*turn_off)(); // 執行關閉操作的函數指針
12} led_fsm_t;
13
14// 初始化狀態機
15void led_fsm_init(led_fsm_t* fsm, void (*turn_on)(), void (*turn_off)()) {
16  fsm->state = STATE_OFF;
17  fsm->turn_on = turn_on;
18  fsm->turn_off = turn_off;
19}
20
21// 狀態機的狀態轉換
22void led_fsm_transition(led_fsm_t* fsm, bool button_pressed) {
23  switch (fsm->state) {
24    case STATE_OFF:
25      if (button_pressed) {
26        fsm->state = STATE_ON;
27        fsm->turn_on();
28      }
29      break;
30    case STATE_ON:
31      if (button_pressed) {
32        fsm->state = STATE_OFF;
33        fsm->turn_off();
34      }
35      break;
36    default:
37      break;
38  }
39}
40
41// 主函數
42int main() {
43  // 定義LED狀態機
44  led_fsm_t led_fsm;
45  // 初始化狀態機
46  led_fsm_init(&led_fsm, turn_on_led, turn_off_led);
47  while (1) {
48    // 讀取輸入
49    bool button_pressed = read_button();
50    // 狀態機的狀態轉換
51    led_fsm_transition(&led_fsm, button_pressed);
52    // 等待下一次執行
53    delay(10);
54  }
55  return 0;
56}

示例3

1/*舉類型state_t，其中包含四個狀態：IDLE、WAITING、RUNNING和STOPPED。*/
 2typedef enum {
 3    STATE_IDLE,
 4    STATE_WALKING,
 5    STATE_TURNING_LEFT,
 6    STATE_TURNING_RIGHT,
 7    STATE_STOPPED
 8} robot_state_t;
 9
10void transition_fn(void);
11/*用于存儲當前狀態和狀態轉移規則*/
12typedef struct {
13    robot_state_t current_state;
14    void (*transition_fn)(void);
15} robot_t;
16
17robot_t robot;
18
19int main(void) {
20    // initialize robot
21    robot.current_state = STATE_IDLE;
22    robot.transition_fn = transition_fn;
23
24    // main loop
25    while (1) {
26        switch (robot.current_state) {
27            case STATE_IDLE:
28                // do nothing
29                break;
30            case STATE_WALKING:
31                // move robot forward
32                break;
33            case STATE_TURNING_LEFT:
34                // turn robot left
35                break;
36            case STATE_TURNING_RIGHT:
37                // turn robot right
38                break;
39            case STATE_STOPPED:
40                // stop robot
41                break;
42        }
43    }
44}
45
46void transition_fn(void) {
47    switch (robot.current_state) {
48        case STATE_IDLE:
49            // transition to STATE_WALKING
50            robot.current_state = STATE_WALKING;
51            break;
52        case STATE_WALKING:
53            // transition to STATE_TURNING_LEFT or STATE_TURNING_RIGHT or STATE_STOPPED
54            if (/* condition for turning left */) {
55                robot.current_state = STATE_TURNING_LEFT;
56            } else if (/* condition for turning right */) {
57                robot.current_state = STATE_TURNING_RIGHT;
58            } else if (/* condition for stopping */) {
59                robot.current_state = STATE_STOPPED;
60            }
61            break;
62        case STATE_TURNING_LEFT:
63            // transition to STATE_WALKING
64            robot.current_state = STATE_WALKING;
65            break;
66        case STATE_TURNING_RIGHT:
67            // transition to STATE_WALKING
68            robot.current_state = STATE_WALKING;
69            break;
70        case STATE_STOPPED:
71            // transition to STATE_IDLE
72            robot.current_state = STATE_IDLE;
73            break;
74    }
75}