c语言之fsm状态机实现

已于 2024-08-13 17:37:21 修改
阅读量80 收藏
点赞数
分类专栏： MCU相关专栏 文章标签： c语言 算法 开发语言
于 2024-08-12 17:00:31 首次发布
原文链接：https://blog.csdn.net/xinghuanmeiying/article/details/89387451?utm_medium=distribute.pc_relevant_t0.none-task-blog-2~default~BlogCommendFromMachineLearnPai2~default-1.baidujs&dist_request_id=&depth_1-utm_source=distribute.pc_relevant_t0.none-task-bl
版权

1. 状态机模块实现

状态机编程思想，能够使复杂的逻辑代码变得更加的简单，且逻辑思路更加清晰严谨。下面根据另一篇博文介绍的状态机思想，用C语言实现了状态机可复用的模块化代码。

状态机 fsm.h 头文件代码如下：

#ifndef _FSM_H_
#define _FSM_H_
 
#include <stdint.h>
#include <stddef.h>
 
typedef struct FsmTable_s
{
    uint8_t event;                /* 触发事件 */
    uint8_t CurState;             /* 当前状态 */
    void (*eventActFun)(void *);  /* 动作函数 */
    uint8_t NextState;            /* 跳转状态 */
}FsmTable_T;
 
typedef struct FSM_s
{
    FsmTable_T *FsmTable;         /* 状态迁移表 */
    uint8_t curState;             /* 状态机当前状态 */
    uint8_t stuMaxNum;            /* 状态机状态迁移数量 */
}FSM_T;
 
/*********************************************************************************
使用方法：1.创建FSM_T对象；
          2.创建FsmTable_T表；
          3.调用FSM_Init()初始化；
          4.程序轮询FSM_EventHandle()运行状态机。
*********************************************************************************/
void FSM_Init(FSM_T *pFsm, FsmTable_T *pTable, uint8_t stuMaxNum, uint8_t curState);
void FSM_EventHandle(FSM_T *pFsm, uint8_t event, void *parm);
 
#endif

状态机 fsm.c 源文件代码如下：

#include "fsm.h"
 
/*==================================================================
* Function  : FSM_StateTransfer
* Description : 状态转换
* Input Para  : 
* Output Para : 
* Return Value: 
==================================================================*/
static void FSM_StateTransfer(FSM_T *pFsm, uint8_t state)
{
    pFsm->curState = state;
}
 
/*==================================================================
* Function  : FSM_EventHandle
* Description : 状态机处理函数
* Input Para  : pFsm状态机对象, event触发事件, parm动作执行参数
* Output Para : 
* Return Value: 
==================================================================*/
void FSM_EventHandle(FSM_T *pFsm, uint8_t event, void *parm)
{
    FsmTable_T *pAcTable = pFsm->FsmTable;
    void (*eventActFun)(void *) = NULL;
    uint8_t NextState;
    uint8_t CurState = pFsm->curState;
    uint8_t flag = 0;
      
    for (uint8_t i = 0; i < pFsm->stuMaxNum; i++)// 遍历状态表
    {
        if (event == pAcTable[i].event && CurState == pAcTable[i].CurState)
        {
            flag = 1;
            eventActFun = pAcTable[i].eventActFun;
            NextState = pAcTable[i].NextState;
            break;
        }
    }
    if (flag)
    {
        if (eventActFun != NULL)
        {
            eventActFun(parm);  // 执行相应动作
        }
        FSM_StateTransfer(pFsm, NextState); // 状态转换
    }
    else
    {
        // do nothing
    }
}
 
/*==================================================================
* Function  : FSM_Init
* Description : 状态机初始化
* Input Para  : pFsm状态机对象，pTable状态迁移表，stuMaxNum迁移表数量
*               curState当前状态
* Output Para : 
* Return Value: 
==================================================================*/
void FSM_Init(FSM_T *pFsm, FsmTable_T *pTable, uint8_t stuMaxNum, uint8_t curState)
{
    pFsm->FsmTable = pTable;
    pFsm->curState = curState;
    pFsm->stuMaxNum = stuMaxNum;
}

queue.h

#ifndef __QUEUE_H_
#define __QUEUE_H_

/*********************************************************************
 * @brief       队列类型定义
 *********************************************************************/
typedef struct
{
    volatile unsigned int   front;           // front为起始元素
    volatile unsigned int   rear;            // rear为最后一个元素
    volatile unsigned int   count;           // 元素个数
    unsigned int            element_size;    // 每个元素的字节数（这里的元素可以是任意类型的变量）
    unsigned int            element_num;     // 队列深度（元素最大个数，以元素的类型为基本单位，例如元素是结构体，那element_num就是这个结构体的数量）
    void                    *buf;            // 缓存区（大小为element_size * element_num）
}queue_type;

/*********************************************************************
 * @brief       队列初始化
 * @param[in]   queue: 队列指针
 * @param[in]   buf: 队列中缓存
 * @param[in]   element_size:队列每个元素的字节数
 * @param[in]   element_num: 队列深度（元素最大个数）
 * @return      None
 *********************************************************************/
void queue_create(queue_type *queue, void *buf, unsigned int element_size, unsigned int element_num);

/*********************************************************************
 * @brief       判断队列是否为空
 * @param[in]   queue: 队列指针
 * @return      1-TRUE or 0-FALSE
 *********************************************************************/
unsigned char queue_is_empty(queue_type *queue);

/*********************************************************************
 * @brief       判断队列是否已满
 * @param[in]   queue: 队列指针
 * @return      TRUE or FALSE
 *********************************************************************/
unsigned char queue_is_full(queue_type *queue);

/*********************************************************************
 * @brief       向队列添加一个元素
 * @param[in]   queue: 队列指针
 * @param[in]   value: 要添加的元素

*********************************************************************/
unsigned char queue_append_byte(queue_type *queue, void *value);

/*********************************************************************
 * @brief       向队列添加多个元素
 * @param[in]   queue: 队列指针
 * @param[in]   values: 要添加的元素指针
 * @param[in]   element_num: 要添加元素个数
 * @return      实际添加的元素个数
 *********************************************************************/
unsigned int queue_append_nbyte(queue_type *queue, void *values, unsigned int element_num);

/*********************************************************************
 * @brief       从队列读取一个元素
 * @param[in]   queue: 队列指针
 * @param[in]   value: 存放要读取的元素指针
 * @return      1-TRUE or 0-FALSE
 *********************************************************************/
unsigned char queue_delete_byte(queue_type *queue, void *value);

/*********************************************************************
 * @brief       从队列读取多个元素
 * @param[in]   queue: 队列指针
 * @param[out]  values: 存放要读取的元素指针
 * @param[in]   element_num: 要读取的元素个数
 * @return      实际读取的元素个数
 *********************************************************************/
unsigned int queue_delete_nbyte(queue_type *queue, void *values, unsigned int element_num);

/*********************************************************************
 * @brief       清空队列
 * @param[in]   queue: 队列指针
 * @return      None
 *********************************************************************/
void queue_clear(queue_type *queue);

#endif

queue.c

#include <string.h>
#include "queue.h"
#include <stdio.h>

/*********************************************************************
 * @brief       创建队列
 * @param[in]   queue: 队列指针
 * @param[in]   buf: 队列缓存（大小为element_size * element_num）
 * @param[in]   element_size: 队列每个元素的大小（这里的元素可以是任意类型的变量）
 * @param[in]   element_num: 队列最大元素个数（以元素的类型为基本单位，例如元素是一个结构体，那么element_num就是这个结构体的数量）
 * @return      None
 *********************************************************************/
void queue_create(queue_type *queue, void *buf, unsigned int element_size, unsigned int element_num)
{
    queue->buf = buf;
    queue->element_size = element_size;
    queue->element_num = element_num;
    queue->front = 0;
    queue->rear = 0;
    queue->count = 0;
}

/*********************************************************************
 * @brief       判断队列是否为空
 * @param[in]   queue: 队列指针
 * @return      1-TRUE or 0-FALSE
 *********************************************************************/
unsigned char queue_is_empty(queue_type *queue)
{
    return (queue->count == 0);
}

/*********************************************************************
 * @brief       判断队列是否已满
 * @param[in]   queue: 队列指针
 * @return      TRUE or FALSE
 *********************************************************************/
unsigned char queue_is_full(queue_type *queue)
{
    return (queue->count == queue->element_num);
}

/*********************************************************************
 * @brief       向队列添加一个元素
 * @param[in]   queue: 队列指针
 * @param[in]   value: 要添加的元素
 * @return      1-TRUE or 0-FALSE
 *********************************************************************/
unsigned char queue_append_byte(queue_type *queue, void *value)
{
    unsigned char *p;

    if (queue_is_full(queue))
    {
        return 0;
    }

    p = (unsigned char *)queue->buf;
    memcpy(p + queue->rear, (unsigned char *)value, queue->element_size);

    queue->rear += queue->element_size;
    if (queue->rear >= queue->element_size * queue->element_num)
    {
        queue->rear = 0;
    }
    queue->count ++;
    return 1;
}

/*********************************************************************
 * @brief       向队列添加多个元素
 * @param[in]   queue: 队列指针
 * @param[in]   values: 要添加的元素指针
 * @param[in]   element_num: 要添加的元素个数
 * @return      实际添加的元素个数
 *********************************************************************/
unsigned int queue_append_nbyte(queue_type *queue, void *values, unsigned int element_num)
{
    unsigned char *p;
    unsigned int cnt = 0;

    p = (unsigned char *)values;
    while(element_num --)
    {
        if (queue_append_byte(queue, p))
        {
            p += queue->element_size;
            cnt++;
        }
        else
        {
            break;
        }
    }
    return cnt;
}

/*********************************************************************
 * @brief       从队列读取一个元素
 * @param[in]   queue: 队列指针
 * @param[in]   value: 存放要读取的元素指针
 * @return      1-TRUE or 0-FALSE
 *********************************************************************/
unsigned char queue_delete_byte(queue_type *queue, void *value)
{
    unsigned char *p;
    if (queue_is_empty(queue))
    {
        return 0;
    }

    p = (unsigned char *)queue->buf;
    memcpy(value, p + queue->front, queue->element_size);

    queue->front += queue->element_size;
    if (queue->front >= queue->element_size * queue->element_num)
    {
        queue->front = 0;
    }
    queue->count --;
    return 1;
}

/*********************************************************************
 * @brief       从队列读取多个元素
 * @param[in]   queue: 队列指针
 * @param[out]  values: 存放要读取的元素指针
 * @param[in]   element_num: 要读取的元素长度
 * @return      实际读取的元素个数
 *********************************************************************/
unsigned int queue_delete_nbyte(queue_type *queue, void *values, unsigned int element_num)
{
    unsigned int cnt = 0;
    unsigned char *p;

    p = (unsigned char *)values;
    while(element_num--)
    {
        if (queue_delete_byte(queue, p))
        {
            p += queue->element_size;
            cnt++;
        }
        else
        {
            break;
        }
    }
    return cnt;
}

/*********************************************************************
 * @brief       清空队列
 * @param[in]   queue: 队列指针
 * @return      None
 *********************************************************************/
void queue_clear(queue_type *queue)
{
    queue->count = 0;
    queue->front = 0;
    queue->rear = 0;
}

2. 状态机模块使用

使用状态机结合消息队列的编程思想，实例代码如下：

/** @enum FSM_STATE_E
 *  @brief 状态机运行状态
 *  
 */
typedef enum
{
    RUNNING = 0x00, // 运行态
    FAULT,          // 故障态
}FSM_STATE_E;
 
/** @enum TRIG_EVENT_E
 *  @brief 状态机触发事件
 *  
 */
typedef enum
{       
    SENSOR_FAULT,       // 传感器故障事件
    SENSOR_RESUME,      // 传感器故障恢复事件
}TRIG_EVENT_E, *PTRIG_EVENT_E;
 
 
/** @struct MSG_EVENT_TRIG_T
 *  @brief 事件触发消息结构
 *  
 */
typedef struct
{
    uint8_t eDevPort;    			/* 事件触发传感器端口 */
    TRIG_EVENT_E eEventType;        /* 事件触发类型 */
    
}MSG_EVENT_TRIG_T, *PMSG_EVENT_TRIG_T;
 
/** @struct DEV_DET_T
 *  @brief  探测器
 *  
 */
typedef struct
{
    queue_type stEventQue;             /* 事件触发队列 */
    MSG_EVENT_TRIG_T eEventQueBuf[8];  /* 事件触发缓存 */
    
}DEV_DET_T, *PDEV_DET_T;
 
 
/* 创建监控探测器实例 */
static DEV_DET_T g_stDetIns;
 
 
/* 状态机变量 */
static FSM_T g_stFsm;
 
/* 动作函数 */
static void ActFun_FaultEvent(void *parm);
static void ActFun_FaultResumeEvent(void *parm);
 
/* 状态迁移表 */
static FsmTable_T g_stFsmTable[] = 
{
    /* 触发事件         初态            动作函数             次态  */	
	{SENSOR_FAULT,      RUNNING,     ActFun_FaultEvent,             FAULT},
	{SENSOR_RESUME,     FAULT,       ActFun_FaultResumeEvent,       RUNNING},
};
 
/* 计算状态迁移表长度 */
#define FSM_TABLE_MAX_NUM (sizeof(g_stFsmTable)/sizeof(FsmTable_T))
 
 
/*==================================================================
* Function  : APP_Init
* Description : 创建消息队列，初始化状态机
* Input Para  : 
* Output Para : 
* Return Value: 
==================================================================*/
void APP_Init(void)
{
    /* 创建事件触发队列 */
    queue_create(&g_stDetIns.stEventQue, (uint8_t *)g_stDetIns.eEventQueBuf, sizeof(MSG_EVENT_TRIG_T), 8);

    /* 初始化状态机 */
    FSM_Init(&g_stFsm, g_stFsmTable, FSM_TABLE_MAX_NUM, RUNNING);

}
 
/*==================================================================
* Function  : ActFun_FaultEvent
* Description : 触发故障事件动作函数
* Input Para  : LocalActiveStatus
* Output Para : 
* Return Value: 
==================================================================*/
static void ActFun_FaultEvent(void *parm)
{
	/* 执行故障相关的动作 */	
	printf("trigger fault happen\n");
}
 
/*==================================================================
* Function  : ActFun_FaultResumeEvent
* Description : 故障恢复事件动作函数
* Input Para  : 
* Output Para : 
* Return Value: 
==================================================================*/
static void ActFun_FaultResumeEvent(void *parm)
{
	/* 执行故障恢复相关的动作 */
	printf("trigger fault reset\n");
}
 
/*==================================================================
* Function  : FsmEventHandleTask
* Description : 在定时器中定时轮询，避免动作函数中含有长任务函数
* Input Para  : 
* Output Para : 
* Return Value: 
==================================================================*/
void FsmEventHandleTask(void)
{
    MSG_EVENT_TRIG_T p_TrigMsg;

    if(!queue_is_empty(&g_stDetIns.stEventQue))
    {
        /* 取出触发事件队列中的事件 */
        if(queue_delete_byte(&g_stDetIns.stEventQue, &p_TrigMsg))
        {
            /* 在其它模块中改变触发事件，即可完成相应动作的执行 */
            FSM_EventHandle(&g_stFsm, p_TrigMsg.eEventType, (void *)&p_TrigMsg.eDevPort);
        }
    }
}
 
/*==================================================================
* Function  : Elec_UpdateEvent
* Description : 更新触发事件
* Input Para  : 
* Output Para : 
* Return Value: 
==================================================================*/
void Elec_UpdateEvent(MSG_EVENT_TRIG_T stTrigEventMsg)
{
    /* 触发事件入队 */
    if (!queue_append_byte(&g_stDetIns.stEventQue, (uint8_t*)&stTrigEventMsg))
    {
        printf("ELEC: electrical fire detector tigger event entry queue fail!\r\n");
    }
}
 
/*==================================================================
* Function  : TestEvent
* Description : 测试事件函数
* Input Para  : 
* Output Para : 
* Return Value: 
==================================================================*/
void TestEvent1(void)
{
	MSG_EVENT_TRIG_T stTrigEventMsg;
	
	APP_Init();
	/* 触发故障事件 */
	stTrigEventMsg.eEventType = SENSOR_FAULT; 
	Elec_UpdateEvent(stTrigEventMsg);
}

void TestEvent2(void)
{
	MSG_EVENT_TRIG_T stTrigEventMsg;
	
	APP_Init();
	/* 触发故障事件 */
	stTrigEventMsg.eEventType = SENSOR_RESUME; 
	Elec_UpdateEvent(stTrigEventMsg);
}

输出结果如下

trigger fault happen
trigger fault reset

拓展

关于状态表使用拓展

FsmTable fsmtb[] = {
    /* 事件         当前状态        动作        下一个状态 */
    { E_IDLE,       S_IDLE,     idle_func,      S_IDLE },
    { E_BELL,       S_IDLE,     bell_func,      S_BELL }, 
    { E_DIAL,       S_IDLE,     dial_func,      S_DIAL },
    { E_TIME_OUT,   S_DIAL,     timeout_func,   S_TIMEOUT },
    { E_TIME_OUT,   S_BELL,     timeout_func,   S_TIMEOUT },
    { E_BUSY,       S_DIAL,     hangup_func,    S_HANGUP },
    { E_CONNECT,    S_DIAL,     talk_func,      S_TALK },
    { E_WHITE_LIST, S_BELL,     talk_func,      S_TALK }, 
    { E_BLACK_LIST, S_BELL,     hangup_func,    S_HANGUP },
    { E_FINISH,     S_TALK,     hangup_func,    S_HANGUP },
    { E_IDLE,       S_HANGUP,   idle_func,      S_IDLE },
    { E_IDLE,       S_TIMEOUT,  idle_func,      S_IDLE  }
};
路过的小熊~
关注
专栏目录
C语言高效有限状态机(FSM)详细设计说明书.docx
05-19
有限状态机是一种用来进行对象行为建模的工具，其作用主要是描述对象在它的生命周期内所经历的状态序列，以及如何响应来自外界的各种事件。在计算机科学中，有限状态机被广泛用于建模应用行为、硬件电路系统设计、软件工程，编译器、网络协议、和计算与语言的研究。
C语言_有限状态机（FSM）
aoyousihaiqiuqihuang的博客
09-04 7113
C语言_有限状态机（FSM） 基本介绍 许多小型或复杂的应用程序都使用有限状态机 (FSM)，C 语言中的有限状态机是嵌入式系统的流行设计模式之一，有限状态机使开发变得容易和顺利。 有很多设备使用事件基态，如咖啡机、自动售货机、POS 设备、门锁系统等。一些 POS 设备使用事件表，在事件表中使用事件处理程序注册事件，通过相关条件触发事件的执行。 本文中，使用C语言创建一个简易的ATM状态机。 ATM 机的状态可以通过即将发生的事件进行更改。ATM状态机包含以下几个状态： Idle State Card
C语言实现简单有限状态机(FSM)
认知 行动 坚持
04-13 8410
转载地址：https://www.jianshu.com/p/917c0fb8778b?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation 有限状态机（finite state machine）简称FSM，表示有限个状态及在这些状...
C语言实现有限状态机FSM
奥丁的博客
12-22 3699
FSM（finite state machine），它是一种协议，是一个数学概念，用于有限数量的子程序（状态）的变化，每个子程序进行一些处理并选择下一种状态（通常取决于下一段输入）； 它可以用作程序的控制，对于那些基于输入的在几个不同的可选动作中进行循环的程序尤为合适。 C语言中的状态机表达式通常使用函数指针数组的方式。 void （*state[MAX_STATES] ) ( )； ex
轻松入门C语言实现有限状态机FSM
一名热爱技术的工程师的博客。分享技术干货，记录美好生活。永远相信美好的事情即将发生。
12-14 1247
有限状态机是一种数学模型，用于描述系统在不同状态之间转换的行为。它可以看作是一个状态集合、转移集合和事件集合的组合。系统通过响应事件来改变当前状态，并根据当前状态来确定下一个可能的状态。在嵌入式系统中，有限状态机通常用于建模控制系统、通信协议、用户界面等方面。通过将系统的不同操作和行为抽象为状态，我们可以更好地组织和理解系统的逻辑。在这个例子中，我们定义了三种交通灯状态（红灯、黄灯、绿灯）和两种事件（定时器到期、按钮按下）。
C语言实现状态机（一）
热门推荐
qq_36969264的博客
05-03 1万+
状态机原理 状态机有4个要素： 现态：是指当前所处的状态。 条件：又称为“事件”，当一个条件被满足，将会触发一个动作，或者执行一次状态的迁移。 动作：条件满足后执行的动作。动作执行完毕后，可以迁移到新的状态，也可以仍旧保持原状态。动作不是必需的，当条件满足后，也可以不执行任何动作，直接迁移到新状态。 次态：条件满足后要迁往的新状态。“次态”是相对于“现态”而言的，“次态”一旦被激活，就转变成新的...
C语言实现状态机
坚持
08-11 2522
C语言实现状态机
C语言——简单状态机
m0_51582169的博客
06-28 2968
状态机：一般指有限状态机（英语：finite-state machine，缩写：FSM）又称有限状态自动机（英语：finite-state automaton，缩写：FSA），是表示有限个状态以及在这些状态之间的转移和动作等行为的数学计算模型。状态机中有几个术语：state(状态) 、transition(转移) 、action(动作) 、transition condition(转移条件) 。如下图，就定义了一个只有opened 和closed两种状态的状态机。当系统处于opened状态，在收到输入“关闭
设计模式--状态模式(C语言实现)
m0_38056437的博客
04-11 5678
原创亚索老哥embed linux share 模式动机 状态模式(状态机)是嵌入式开发中最重要、最核心的设计模式之一，毫不夸张的说，是否熟练掌握状态模式，很大程度上直接决定了嵌入式工程师的代码掌控能力。在嵌入式开发里面，几乎80%以上的程序都有状态模式(状态机)的影子。在一个思路清晰而且高效的程序中，必然有状态模式(状态机)身影浮现。但是很多嵌入式开发者只是掌握一些很基础的状态机编...
C语言实现有限状态机
12-22
有限状态机是一种数学概念，运用到程序中，可用于有限数量的状态的变化，每个子程序进行一些处理并选择下一种状态。 　基本的实现思路是用一张表保存所有可能的状态，并列出进入每个状态时可能执行的所有动作，...
C语言嵌入式状态机架构（含C源码）
05-29
在C语言中，实现状态机通常采用函数指针的方式。这是因为函数指针可以被视为指向执行特定任务的代码的指针，使得我们可以在运行时动态地调用不同的函数，对应于不同的状态行为。以下是一个简单的步骤，展示了如何...
状态机的C语言经典实现
12-08
本文将深入探讨有限状态机（FSM）的C语言实现，以及如何通过通用化代码来提高可读性、可移植性和调试效率。 首先，我们需要理解状态机的基本概念。状态机由一组状态和一些转换规则构成，每个状态对应系统的一种行为...
C语言中的状态机设计深入讲解
12-16
A switch语句提供了状态机最容易实现和最常见的版本之一。在这里，每个案例在switch语句成为一个状态，实现如下所示： switch (currentState) { case ST_IDLE: // do something in the idle state break; case ...
C语言FSM 有限状态机
最新发布
weixin_54376810的博客
03-31 545
C语言状态机模式
状态机编程
caojunhao123的专栏
11-04 916
有限状态机FSM思想广泛应用于硬件控制电路设计，也是软件上常用的一种处理方法(软件上称为FMM--有限消息机)。它把复杂的控制逻辑分解成有限个稳定状态，在每个状态上判断事件，变连续处理为离散数字处理，符合计算机的工作特点。同时，因为有限状态机具有有限个状态，所以可以在实际的工程上实现。但这并不意味着其只能进行有限次的处理，相反，有限状态机是闭环系统，有限无穷，可以用有限的状态，处理无穷的事务。  
用C语言实现有限状态自动机FSM
河西无名式
10-10 5620
摘要：状态机模式是一种行为模式，在《设计模式》这本书中对其有详细的描述，通过多态实现不同状态的调转行为的确是一种很好的方法，只可惜在嵌入式环境下，有时只能写纯C代码，并且还需要考虑代码的重入和多任务请求跳转等情形，因此实现起来着实需要一番考虑。本文主要为你实现一个简单的有限状态机，没有考虑代码的重入和多任务跳转，为以后复杂的状态机实现，打下基础。
C程序设计：状态机
weixin_42549534的博客
07-31 844
状态机是一种常用的编程模型，用于描述系统的状态和状态之间的转换规则。无论使用何种操作系统或编程框架，状态机都可以用来帮助设计和实现系统的逻辑。即使在使用 FreeRTOS 的情况下，如果系统的逻辑需要描述为多个状态和状态转换，那么状态机仍然是一种很有用的设计工具。在上面的例子中，有两个状态 S1 和 S2，输入有两个选项 A 和 B，输出有四个选项 O1、O2、O3 和 O4。根据当前状态和输入，状态机会根据表格的规则进行状态转移，并输出相应的结果。
FSM状态机示例代码
08-31
下面是一个简单的FSM状态机示例代码（使用Python编写）： ```python class State: def __init__(self, name): self.name = name def on_enter(self): pass def on_exit(self): pass def handle_event(self, event): pass class StateMachine: def __init__(self, initial_state): self.current_state = initial_state def transition_to(self, new_state): self.current_state.on_exit() self.current_state = new_state self.current_state.on_enter() def handle_event(self, event): self.current_state.handle_event(event) # 示例状态 class IdleState(State): def on_enter(self): print("进入空闲状态") def on_exit(self): print("退出空闲状态") def handle_event(self, event): if event == "start": print("开始任务") return "running" return self.name class RunningState(State): def on_enter(self): print("进入运行状态") def on_exit(self): print("退出运行状态") def handle_event(self, event): if event == "stop": print("停止任务") return "idle" return self.name # 创建状态机并设置初始状态为IdleState state_machine = StateMachine(IdleState()) # 处理事件 state_machine.handle_event("start") # 输出: 进入空闲状态 # 开始任务 state_machine.transition_to(RunningState()) # 输出: 退出空闲状态 # 进入运行状态 state_machine.handle_event("stop") # 输出: 停止任务 # 退出运行状态 # 进入空闲状态 ``` 以上示例代码展示了一个简单的状态机，其中包括两个状态，即"空闲"和"运行"。状态之间的切换由事件触发，例如"start"事件将从"空闲"状态切换到"运行"状态，"stop"事件将从"运行"状态切换回"空闲"状态。每个状态都有进入（on_enter）和退出（on_exit）方法，在切换到新状态时会调用这些方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值