#include "stm32f1xx_hal.h"#include <stdio.h>
// 引脚定义#define KEY_PIN GPIO_PIN_0#define KEY_PORT
GPIOA#define LED_PIN GPIO_PIN_13#define LED_PORT GPIOC
// 状态定义typedef enum {
   KEY_IDLE, // 按键空闲状态
   KEY_DEBOUNCE, // 按键消抖状态
   KEY_PRESSED, // 按键按下状态
   KEY_RELEASE // 按键释放状态
} KeyState_t;
// 全局变量
KeyState_t key_state = KEY_IDLE;uint32_t debounce_time
= 0;uint32_t key_press_duration = 0;
// 函数声明void SystemClock_Config(void);void MX_GPIO_
Init(void);void Error_Handler(void);
// 实际按键读取函数（STM32 HAL库）int is_key_down(void) {
   return (HAL_GPIO_ReadPin(KEY_PORT, KEY_PIN) ==
GPIO_PIN_RESET) ? 1 : 0;
}
// 实际系统时间函数（STM32 HAL库）uint32_t get_millis(void) {
   return HAL_GetTick();
}
// 按键按下处理函数void on_key_pressed(void) {
   printf("Key pressed!\n");
   HAL_GPIO_WritePin(LED_PORT, LED_PIN, GPIO_PIN_SET);
}
// 按键释放处理函数void on_key_released(void) {
   printf("Key released! Duration: %lums\n", key_press_duration);
   HAL_GPIO_WritePin(LED_PORT, LED_PIN, GPIO_PIN_RESET);
   key_press_duration = 0;
}
// 状态机处理函数void key_fsm(void) {
   switch (key_state) {
      case KEY_IDLE:
          if (is_key_down()) {
             key_state = KEY_DEBOUNCE;
            debounce_time = get_millis();
            printf("State: IDLE -> DEBOUNCE\n");
         }
break;

      case KEY_DEBOUNCE:
          if (get_millis() - debounce_time > 20) {
            if (is_key_down()) {
               key_state = KEY_PRESSED;
               on_key_pressed();
               printf("State: DEBOUNCE -> PRESSED\n");
          } else {
                key_state = KEY_IDLE;
                printf("State: DEBOUNCE -> IDLE\n");
          }
       }
       break;

   case KEY_PRESSED:
       key_press_duration = get_millis() - debounce_time;
       if (!is_key_down()) {
         key_state = KEY_RELEASE;
          printf("State: PRESSED -> RELEASE\n");
       }
       break;

case KEY_RELEASE:
       on_key_released();
       key_state = KEY_IDLE;
      printf("State: RELEASE -> IDLE\n");
       break;

   default:
       // 处理未知状态，增强鲁棒性
      key_state = KEY_IDLE;
       printf("Unknown state! Reset to IDLE\n");
       break;
   }
}
// 主函数int main(void) {
    // 初始化
    ......

   printf("Starting key state machine demo...\n");

   while (1) {
      key_fsm();
       HAL_Delay(10); // 10ms延时，降低CPU占用
    }

   return 0;
}

#include <stdio.h>#include <stdint.h>
// 状态和事件定义（指定uint8_t类型节省内存）typedef enum : uint8_t {
   STATE_A,
   STATE_B,
   STATE_C,
   STATE_COUNT
} State;
typedef enum : uint8_t {
   EVENT_X,
   EVENT_Y,
   EVENT_Z,
   EVENT_COUNT
} Event;
// 状态表项结构typedef struct {
   State next_state;
   void (*action)(void);
} TransitionEntry;
// 动作函数void action_A_to_B(void) { printf("Transition from A to B\n");
}void action_A_to_C(void) { printf("Transition from A to C\n");
}void action_B_to_A(void)
{ printf("Transition from B to A\n"); }void action_B_to_C(void) { printf
("Transition from B to C\n"); }void action_C_to_A(void) { printf
("Transition from C to A\n"); }void action_C_to_B(void) { printf
("Transition from C to B\n"); }void action_no_op(void) { /* 无操作 */ }
void action_error(void) { printf("Error: Invalid state/event!\n"); }
// 状态表定义const TransitionEntry state_table
[STATE_COUNT][EVENT_COUNT] = {
   [STATE_A] = {
      [EVENT_X] = { .next_state = STATE_B, .action = action_A_to_B },
      [EVENT_Y] = { .next_state = STATE_C, .action = action_A_to_C },
      [EVENT_Z] = { .next_state = STATE_A, .action = action_no_op }
   },
   [STATE_B] = {
       [EVENT_X] = { .next_state = STATE_A, .action = action_B_to_A },
      [EVENT_Y] = { .next_state = STATE_C, .action = action_B_to_C },
      [EVENT_Z] = { .next_state = STATE_B, .action = action_no_op }
   },
   [STATE_C] = {
      [EVENT_X] = { .next_state = STATE_A, .action = action_C_to_A },
      [EVENT_Y] = { .next_state = STATE_B, .action = action_C_to_B },
      [EVENT_Z] = { .next_state = STATE_C, .action = action_no_op }
   }
};
// 当前状态
State current_state = STATE_A;
    // 事件处理函数（含边界检查）void process_event(Event event) {
// 边界检查：防止数组越界
   if (current_state >= STATE_COUNT || event >= EVENT_COUNT) {
      action_error();
      current_state = STATE_A; // 复位到初始状态
      return;
   }

   TransitionEntry entry = state_table[current_state][event];

   if (entry.action != NULL) {
       entry.action();
   }

   current_state = entry.next_state;
    printf("Current state: %d\n", current_state);
}
// 主函数int main(void) {
   printf("Starting state table demo...\n");
   printf("Initial state: %d\n", current_state);

    // 模拟事件序列
   Event events[] = { EVENT_X, EVENT_Y,
EVENT_Z, EVENT_X, 5 }; // 最后一个非法事件测试

    for (int i = 0; i < sizeof(events)/sizeof(events[0]); i++) {
       printf("Processing event: %d\n", events[i]);
      process_event(events[i]);
   }

    return 0;
}

#include <stdio.h>#include <stdint.h>
// 事件类型定义typedef enum { EVT_BUTTON,
EVT_TIMEOUT, EVT_MAX } EventType;
// 状态函数原型typedef void (*state_handler_t)(EventType evt);
// 状态函数声明void state_off(EventType evt);void
state_on(EventType evt);void handle_error(void);
// 全局变量state_handler_t current_state = &state_off;uint32_t light_on_time = 0;
// 动作函数void turn_led_on(void) { printf("LED turned ON\n"); }
void turn_led_off(void) { printf("LED turned OFF\n"); }void handle_error(void)
{ printf("Error handled\n"); }
// 状态函数实现void state_off(EventType evt) {
   switch (evt) {
      case EVT_BUTTON:
         turn_led_on();
         current_state = &state_on;
          light_on_time = 0;
         printf("State: OFF -> ON\n");
         break;
      default:
          printf("State OFF: Ignored event %d\n", evt);
         break;
   }
}
void state_on(EventType evt) {
   switch (evt) {
      case EVT_BUTTON:
         turn_led_off();
         current_state = &state_off;
         printf("State: ON -> OFF\n");
          break;
       case EVT_TIMEOUT:
         turn_led_off();
         current_state = &state_off;
          printf("State: ON -> OFF (Timeout)\n");
         break;
      default:
         printf("State ON: Ignored event %d\n", evt);
          break;
   }
}
// 状态机执行函数（含空指针检查）void state_machine_run(EventType evt) {
   if (current_state != NULL) {
      current_state(evt);
    } else {
      // 处理空指针异常
      handle_error();
      current_state = &state_off; // 复位到初始状态
   }
}
// 模拟事件生成
EventType get_next_event(void) {
   static int count = 0;
   EventType events[] = { EVT_BUTTON,
EVT_TIMEOUT, EVT_BUTTON, EVT_BUTTON };
   return events[count++ % 4];
}
// 主函数int main(void) {
    printf("Starting function pointer state machine demo...\n");

   // 模拟运行
    for (int i = 0; i < 5; i++) {
       EventType evt = get_next_event();
       printf("Processing event: %d\n", evt);
      state_machine_run(evt);

      // 模拟延时
       for (int j = 0; j < 1000000; j++);
    }

    // 测试空指针恢复
    printf("\nTesting error recovery...\n");
   current_state = NULL;
    state_machine_run(EVT_BUTTON);

   return 0;
}

#include <iostream>
// 状态接口class State {public:
virtual void handle(class Context* context) = 0;
virtual ~State() {}
};
// 具体状态类：关闭状态class OffState : public State {public:
void handle(Context* context) override;
};
// 具体状态类：开启状态class OnState : public State {public:
void handle(Context* context) override;
};
// 上下文类class Context {private:
    State* current_state_;
   public:
   Context() : current_state_(new OffState()) {}
    ~Context() {
      delete current_state_; // 手动释放内存
    }

    void set_state(State* new_state) {
      if (current_state_ != nullptr)
         delete current_state_;
       current_state_ = new_state;
    }

   void request() {
       if (current_state_ != nullptr) {
         current_state_->handle(this);
       }
    }

   void display_state(const std::string& state_name) {
      std::cout << "Current state: " << state_name << std::endl;
   }
};
// 状态处理实现void OffState::handle(Context* context) {
    context->display_state("Off");
    std::cout << "Switching to On state" << std::endl;
   context->set_state(new OnState());
}
void OnState::handle(Context* context) {
   context->display_state("On");
    std::cout << "Switching to Off    state" << std::endl;
   context->set_state(new OffState());
}
// 主函数int main() {
    std::cout << "Starting object-oriented state pattern demo..." << std::endl;

   Context context;

   // 模拟几次状态转换
    for (int i = 0; i < 3; i++) {
       context.request();
   }

   return 0;
}

#include <stdio.h>#include <stdint.h>
// 状态定义typedef enum {
   STATE_ROOT,
   STATE_ON,
   STATE_OFF,
   STATE_ON_NORMAL,
   STATE_ON_BRIGHT,
   STATE_COUNT
} StateType;
// 事件定义typedef enum {
   EVT_BUTTON_PRESS,
   EVT_BUTTON_LONG_PRESS,
   EVT_TIMEOUT,
   EVT_MAX
} EventType;
// 状态处理函数原型typedef StateType (*state_handler_t)(EventType evt);
// 定义父-子状态映射表（明确层级关系）const
StateType parent_state_map[STATE_COUNT] = {
   [STATE_ROOT] = STATE_ROOT, // 根状态无父状态
   [STATE_ON] = STATE_ROOT, // ON的父状态是根
   [STATE_OFF] = STATE_ROOT, // OFF的父状态是根
   [STATE_ON_NORMAL] = STATE_ON, // NORMAL的父状态是ON
   [STATE_ON_BRIGHT] = STATE_ON // BRIGHT的父状态是ON
};
// 状态处理函数
StateType root_state(EventType evt) {
    printf("Root state handling event: %d\n", evt);
    return STATE_ROOT; // 保持当前状态
}

StateType on_state(EventType evt) {
   switch (evt) {
      case EVT_BUTTON_PRESS:
          printf("On state: Button press -> switching to Off\n");
         return STATE_OFF;
       case EVT_BUTTON_LONG_PRESS:
          printf("On state: Long press -> entering brightness mode\n");
         return STATE_ON;
       default:
         printf("On state: Passing event to root\n");
          return STATE_ON; // 保持当前状态
   }
}

StateType off_state(EventType evt) {
   switch (evt) {
      case EVT_BUTTON_PRESS:
         printf("Off state: Button press -> switching to On\n");
         return STATE_ON;
      default:
          printf("Off state: Passing event to root\n");
         return STATE_OFF; // 保持当前状态
   }
}

StateType on_normal_state(EventType evt) {
   switch (evt) {
      case EVT_BUTTON_LONG_PRESS:
      nbsp;  printf("Normal mode: Long press -> switching to Bright mode\n");
   ;   return STATE_ON_BRIGHT;
      default:
   nbsp;     // 无需处理，事件将传递给父状态
   return STATE_ON_NORMAL;
   }

StateType on_bright_state(EventType evt) {
    switch (evt) {
       case EVT_BUTTON_LONG_PRESS:
         printf("Bright mode: Long press -> switching to Normal mode\n");
         return STATE_ON_NORMAL;
      default:
         // 无需处理，事件将传递给父状态
         return STATE_ON_BRIGHT;
    }
}
// 状态表state_handler_t state_table[STATE_COUNT] = {
   [STATE_ROOT] = root_state,
   [STATE_ON] = on_state,
   [STATE_OFF] = off_state,
   [STATE_ON_NORMAL] = on_normal_state,
   [STATE_ON_BRIGHT] = on_bright_state
};
   // 事件传递函数（父状态优先处理，递归传递）
void hsm_dispatch_event(StateType* current_state, EventType evt) {
// 1. 先调用当前状态的处理函数，获取新状态
   StateType new_state = state_table[*current_state](evt);

// 2. 更新当前状态
*current_state = new_state;

// 3. 若当前状态不是根状态，传递给父状态
    StateType parent = parent_state_map[*current_state];
   if (parent != *current_state) { // 避免根状态递归
      hsm_dispatch_event(&parent, evt);
   }
}
// 状态机上下文typedef struct {
   StateType current_state;
    uint32_t timer;
} StateMachine;
// 主函数int main(void) {
   printf("Starting hierarchical state machine demo...\n");

   StateMachine fsm = { .current_state = STATE_OFF };

   // 测试事件序列
   EventType events[] =
{ EVT_BUTTON_PRESS,
EVT_BUTTON_LONG_PRESS, EVT_BUTTON_PRESS };

   for (int i = 0; i < sizeof(events)/sizeof(events[0]); i++) {
       printf("\nProcessing event: %d\n", events[i]);
       hsm_dispatch_event(&fsm.current_state, events[i]);
      printf("Final state after event: %d\n", fsm.current_state);
   }

    return 0;
}