C语言实现状态机

已于 2023-08-14 14:57:25 修改
阅读量2.7k 收藏 37
点赞数 11
分类专栏： 嵌入式 文章标签： c语言 算法 单片机
于 2023-08-11 18:14:44 首次发布
原文链接：https://blog.csdn.net/qq_36969264/article/details/122365696
版权

前言

对于之前的一篇博客《C语言实现状态机》（链接：https://blog.csdn.net/qq_36969264/article/details/105865099?spm=1001.2014.3001.5501），看网友的留言，似乎对pFsm->stNextState 和 EVENT_MAP_END的比较有一些误解。
这里需要解释一下，当时这么写是为了省事，但后面看这么写确实很容易让人误解，所以这篇文章的目的是为了修改掉这个容易让人误解的地方，同时对该状态机做了一些优化。

一、实现状态机的基本函数

1、定义相关结构体

typedef void (*STATE_ACTION)(void);	
typedef struct ACTION_MAP
{
	uint8_t 		stStateID;
	STATE_ACTION 	EnterAct;	
	STATE_ACTION 	RunningAct;	
	STATE_ACTION 	ExitAct;
}ACTION_MAP_t; /* 动作action表描述 */
typedef struct EVENT_MAP
{
	uint8_t	stEventID;
	uint8_t stCurState;
	uint8_t stNextState;
}EVENT_MAP_t; /* 事件event表描述 */
typedef struct FSM
{
	uint8_t u8Flag; 			/* 状态切换标志位,1表示要进行状态切换 */
	uint8_t u8EventSum;			/* 事件event总数 */
	uint8_t u8ActSum;			/* 动作action总数 */
	uint8_t stCurState;
	uint8_t stNextState;
	ACTION_MAP_t *pActionMap;
	EVENT_MAP_t *pEventMap;
}FSM_t; /* 状态机控制结构 */

注：状态机控制结构FSM_t的元素u8Flag用于替代pFsm->stNextState 和 EVENT_MAP_END的比较，以实现相同的功能。

2、状态机初始化函数

初始化函数主要目的是为了将状态机与事件表、动作表关联起来。

void fsm_init(FSM_t* pFsm,EVENT_MAP_t* pEventMap,ACTION_MAP_t *pActionMap,
	uint8_t u8EventSum,uint8_t u8ActSum,uint8_t curState)
{
	pFsm->u8Flag = 0;
	pFsm->stNextState = 0;
	pFsm->u8EventSum = u8EventSum;
	pFsm->u8ActSum = u8ActSum;
	pFsm->stCurState = curState;
	pFsm->pEventMap = pEventMap;
	pFsm->pActionMap = pActionMap;
}

3、状态机转换函数

该函数的主要功能是通过查找事件表，以确定是否要进行状态切换，如果需要进行状态切换，则将标志位u8Flag 置1。

void fsm_state_transfer(FSM_t* pFsm, uint8_t stEventID)
{
	uint8_t i = 0;
	for(i=0; i<pFsm->u8EventSum; i++)
	{
		if((stEventID == pFsm->pEventMap[i].stEventID) 
			&& (pFsm->stCurState == pFsm->pEventMap[i].stCurState))
		{
			pFsm->stNextState = pFsm->pEventMap[i].stNextState;
			pFsm->u8Flag = 1;	
			return;
		}
	}	
}

4、状态机动作执行函数

该函数为此状态机的精髓所在，一般的状态机在状态切换时只执行一次动作，或者周期执行同一动作。
而此状态机则在状态切换时执行当前动作的退出函数（一次），即ExitAct函数，实际应用当中可对该状态的一些变量进行清0，或者打印相关调试信息等；同时还会执行下一个状态的进入函数（一次），即EnterAct函数，实际应用当中可以对该状态的变量进行初始化等操作。在状态切换完成后，还会周期执行RunningAct函数。
这里的ExitAct函数和EnterAct函数类似于C++的构造函数和析构函数。

uint8_t get_action_sum(FSM_t* pFsm,uint8_t u8ID)
{
	int i = 0;
	for(i=0; i<pFsm->u8ActSum; i++)
	{
		if(u8ID == pFsm->pActionMap[i].stStateID)
			return i;
	}
	return -1;
}

void action_perfrom(FSM_t* pFsm)
{
	uint8_t u8CurID = -1, u8NextID = -1;
	
	if(0 != pFsm->u8Flag)	/* 标志位不为0表示要进行状态切换 */
	{
		u8CurID = get_action_sum(pFsm,pFsm->stCurState);
		u8NextID = get_action_sum(pFsm,pFsm->stNextState);
		
		if((-1 != u8CurID) && (-1 != u8NextID))
		{
			pFsm->pActionMap[u8CurID].ExitAct();	/* 执行当前状态的退出动作 */
			pFsm->pActionMap[u8NextID].EnterAct(); /* 执行下一个状态的进入动作 */
		}
		else
		{
			pFsm->u8Flag = 0;								/* 清标志位 */
			printf("State transition failed! curState = %d, nextState = %d\n",pFsm->stCurState,pFsm->stNextState);
			return;
		}
	
		pFsm->stCurState = pFsm->stNextState;			/* 当前状态切换 */
		pFsm->stNextState = -1;
		pFsm->u8Flag = 0;								/* 清标志位 */
	}
	else
	{
		u8CurID = get_action_sum(pFsm,pFsm->stCurState);
		if(-1 != u8CurID)
			pFsm->pActionMap[u8CurID].RunningAct();/* 标志位为0不进行状态切换，执行当前状态的do动作 */
	}	
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

二、如何使用状态机

这里还是使用之前的博客里状态机流程图为例：

在这里插入图片描述

1、以流程图为标准定义事件表

数组eventMap就是对以上流程图的全部描述：

#define EVENT1 0
#define EVENT2 1
#define EVENT3 2
#define EVENT4 3
#define EVENT5 4
EVENT_MAP_t eventMap[] = 
{
	{EVENT1,	STATE1,	STATE2},
	{EVENT2,	STATE2,	STATE3},	
	{EVENT3,	STATE3,	STATE4},
	{EVENT4,	STATE4,	STATE1},
	{EVENT5,	STATE1,	STATE4},	
};

2、定义动作表

#define STATE1 0
#define STATE2 1
#define STATE3 2
#define STATE4 3
ACTION_MAP_t actionMap[] = 
{
	{STATE1,	state1_entry,	state1_do,	state1_exit},
	{STATE2,	state2_entry,	state2_do,	state2_exit},
	{STATE3,	state3_entry,	state3_do,	state3_exit},
	{STATE4,	state4_entry,	state4_do,	state4_exit},
};

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

3、实现动作函数

这里的每个函数的内容可以根据实际情况进行填充。


void state1_entry(void)
{
	printf("state1_entry\n");
}
void state1_do(void)
{
	printf("state1_do\n");
}
void state1_exit(void)
{
	printf("state1_exit\n");
}
void state2_entry(void)
{
	printf("state2_entry\n");
}
void state2_do(void)
{
	printf("state2_do\n");
}
void state2_exit(void)
{
	printf("state2_exit\n");
}
void state3_entry(void)
{
	printf("state3_entry\n");
}
void state3_do(void)
{
	printf("state3_do\n");
}
void state3_exit(void)
{
	printf("state3_exit\n");
}
void state4_entry(void)
{
	printf("state4_entry\n");
}
void state4_do(void)
{
	printf("state4_do\n");
}
void state4_exit(void)
{
	printf("state4_exit\n");
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

4、实现表获取函数

/* 获取动作表 */
ACTION_MAP_t* get_action_map(uint8_t *total)
{
	*total = sizeof(actionMap)/sizeof(ACTION_MAP_t);
	return actionMap;
}
/* 获取事件表 */
EVENT_MAP_t* get_event_map(uint8_t *total)
{
	*total = sizeof(eventMap)/sizeof(EVENT_MAP_t);
	return eventMap;
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

5、测试

int main(void)
{
	int i = 0;		
	uint8_t u8ActNum = 0, u8EventNum = 0;
	FSM_t stFsm;	/* 定义状态机 */
	ACTION_MAP_t* stActMap;
	EVENT_MAP_t* stEventMap;
	stActMap = get_action_map(&u8ActNum);
	stEventMap = get_event_map(&u8EventNum);
	fsm_init(&stFsm,stEventMap,stActMap,u8EventNum,u8ActNum,STATE1);
	while(1)
	{
		sleep(1);
		printf("i = %d\n",i++);
		action_perfrom(&stFsm);
		/* 利用i产生EVENT1~EVENT5 */
		if(1 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT1);
		}
		if(3 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT2);
		}	
		if(5 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT3);
		}
		if(7 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT4);
		}	
		if(9 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT5);
		}
	}
	return 0;
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

调试信息如下：
在这里插入图片描述

三、附上代码

fsm.c

#include <stdio.h>
#include "fsm.h"
void fsm_init(FSM_t* pFsm,EVENT_MAP_t* pEventMap,ACTION_MAP_t *pActionMap,
	uint8_t u8EventSum,uint8_t u8ActSum,uint8_t curState)
{
	pFsm->u8Flag = 0;
	pFsm->stNextState = 0;
	pFsm->u8EventSum = u8EventSum;
	pFsm->u8ActSum = u8ActSum;
	pFsm->stCurState = curState;
	pFsm->pEventMap = pEventMap;
	pFsm->pActionMap = pActionMap;
}
void fsm_state_transfer(FSM_t* pFsm, uint8_t stEventID)
{
	uint8_t i = 0;
	for(i=0; i<pFsm->u8EventSum; i++)
	{
		if((stEventID == pFsm->pEventMap[i].stEventID) 
			&& (pFsm->stCurState == pFsm->pEventMap[i].stCurState))
		{
			pFsm->stNextState = pFsm->pEventMap[i].stNextState;
			pFsm->u8Flag = 1;
			return;
		}
	}	
}
uint8_t get_action_sum(FSM_t* pFsm,uint8_t u8ID)
{
	int i = 0;
	for(i=0; i<pFsm->u8ActSum; i++)
	{
		if(u8ID == pFsm->pActionMap[i].stStateID)
			return i;
	}
	return -1;
}
void action_perfrom(FSM_t* pFsm)
{
	uint8_t u8CurID = -1, u8NextID = -1;
	if(0 != pFsm->u8Flag)	/* 标志位不为0表示要进行状态切换 */
	{
		u8CurID = get_action_sum(pFsm,pFsm->stCurState);
		u8NextID = get_action_sum(pFsm,pFsm->stNextState);
		if((-1 != u8CurID) && (-1 != u8NextID))
		{
			pFsm->pActionMap[u8CurID].ExitAct();	/* 执行当前状态的退出动作 */
			pFsm->pActionMap[u8NextID].EnterAct(); /* 执行下一个状态的进入动作 */
		}
		else
		{
			pFsm->u8Flag = 0;								/* 清标志位 */
			printf("State transition failed! curState = %d, nextState = %d\n",pFsm->stCurState,pFsm->stNextState);
			return;
		}
		pFsm->stCurState = pFsm->stNextState;			/* 当前状态切换 */
		pFsm->stNextState = -1;
		pFsm->u8Flag = 0;								/* 清标志位 */
	}
	else
	{
		u8CurID = get_action_sum(pFsm,pFsm->stCurState);
		if(-1 != u8CurID)
			pFsm->pActionMap[u8CurID].RunningAct();/* 标志位为0不进行状态切换，执行当前状态的do动作 */
	}	
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77

fsm.h

#ifndef FSM_H
#define FSM_H
#include "common.h"
typedef void (*STATE_ACTION)(void);	
typedef struct ACTION_MAP
{
	uint8_t 		stStateID;
	STATE_ACTION 	EnterAct;	
	STATE_ACTION 	RunningAct;	
	STATE_ACTION 	ExitAct;
}ACTION_MAP_t; /* 动作action表描述 */
typedef struct EVENT_MAP
{
	uint8_t	stEventID;
	uint8_t stCurState;
	uint8_t stNextState;
}EVENT_MAP_t; /* 事件event表描述 */
typedef struct FSM
{
	uint8_t u8Flag; 			/* 状态切换标志位,1表示要进行状态切换 */
	uint8_t u8EventSum;			/* 事件event总数 */
	uint8_t u8ActSum;			/* 动作action总数 */
	uint8_t stCurState;
	uint8_t stNextState;
	ACTION_MAP_t *pActionMap;
	EVENT_MAP_t *pEventMap;
}FSM_t; /* 状态机控制结构 */
void fsm_init(FSM_t* pFsm,EVENT_MAP_t* pEventMap,ACTION_MAP_t *pActionMap,
	uint8_t u8EventSum,uint8_t u8ActSum,uint8_t curState);
void fsm_state_transfer(FSM_t* pFsm, uint8_t stEventID);
void action_perfrom(FSM_t* pFsm);
#endif

action.c

#include <stdio.h>
#include "action.h"
void state1_entry(void);
void state1_do(void);
void state1_exit(void);
void state2_entry(void);
void state2_do(void);
void state2_exit(void);
void state3_entry(void);
void state3_do(void);
void state3_exit(void);
void state4_entry(void);
void state4_do(void);
void state4_exit(void);
ACTION_MAP_t actionMap[] = 
{
	{STATE1,	state1_entry,	state1_do,	state1_exit},
	{STATE2,	state2_entry,	state2_do,	state2_exit},
	{STATE3,	state3_entry,	state3_do,	state3_exit},
	{STATE4,	state4_entry,	state4_do,	state4_exit},
};
void state1_entry(void)
{
	printf("state1_entry\n");
}
void state1_do(void)
{
	printf("state1_do\n");
}
void state1_exit(void)
{
	printf("state1_exit\n");
}
void state2_entry(void)
{
	printf("state2_entry\n");
}
void state2_do(void)
{
	printf("state2_do\n");
}
void state2_exit(void)
{
	printf("state2_exit\n");
}
void state3_entry(void)
{
	printf("state3_entry\n");
}
void state3_do(void)
{
	printf("state3_do\n");
}
void state3_exit(void)
{
	printf("state3_exit\n");
}
void state4_entry(void)
{
	printf("state4_entry\n");
}
void state4_do(void)
{
	printf("state4_do\n");
}
void state4_exit(void)
{
	printf("state4_exit\n");
}
ACTION_MAP_t* get_action_map(uint8_t *total)
{
	*total = sizeof(actionMap)/sizeof(ACTION_MAP_t);
	return actionMap;
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81

action.h

#ifndef ACTION_H
#define ACTION_H
#include "common.h"
#include "fsm.h"
#define STATE1 0
#define STATE2 1
#define STATE3 2
#define STATE4 3
ACTION_MAP_t* get_action_map(uint8_t *total);
#endif

event.c

#include "event.h"
EVENT_MAP_t eventMap[] = 
{
	{EVENT1,	STATE1,	STATE2},
	{EVENT2,	STATE2,	STATE3},	
	{EVENT3,	STATE3,	STATE4},
	{EVENT4,	STATE4,	STATE1},
	{EVENT5,	STATE1,	STATE4},	
};
EVENT_MAP_t* get_event_map(uint8_t *total)
{
	*total = sizeof(eventMap)/sizeof(EVENT_MAP_t);
	return eventMap;
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

event.h

#ifndef EVENT_H
#define EVENT_H
#include "fsm.h"
#include "common.h"
#include "action.h"
#define EVENT1 0
#define EVENT2 1
#define EVENT3 2
#define EVENT4 3
#define EVENT5 4
EVENT_MAP_t* get_event_map(uint8_t* total);
#endif

common.h

#ifndef COMMON_H
#define COMMON_H
typedef  unsigned char uint8_t;
#endif

main.c

int main(void)
{
	int i = 0;		
	uint8_t u8ActNum = 0, u8EventNum = 0;
	FSM_t stFsm;	/* 定义状态机 */
	ACTION_MAP_t* stActMap;
	EVENT_MAP_t* stEventMap;
	stActMap = get_action_map(&u8ActNum);
	stEventMap = get_event_map(&u8EventNum);
	fsm_init(&stFsm,stEventMap,stActMap,u8EventNum,u8ActNum,STATE1);
	while(1)
	{
		sleep(1);
		printf("i = %d\n",i++);
		action_perfrom(&stFsm);
		/* 利用i产生EVENT1~EVENT5 */
		if(1 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT1);
		}
		if(3 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT2);
		}
		if(5 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT3);
		}
		if(7 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT4);
		}	
		if(9 == (i%10))
		{
			fsm_state_transfer(&stFsm,EVENT5);
		}
	}
	return 0;
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

Makefile

objects = fsm.o action.o event.o
main:*.o
	cc -o $@ $^
*.o:*.c 
	cc -c $^
clean:
	rm *.o -rf
	rm main -rf
duozh
关注
专栏目录
【编程之美】函数指针方法实现简单状态机(附代码)
李肖遥的专栏
10-14 1811
关注、星标公众号，直达精彩内容ID：技术让梦想更伟大作者：李肖遥之前写过一篇状态机的实用文章，很多朋友说有几个地方有点难度不易理解，今天给大家换种简单写法，使用函数指针的方法实现状态机。...
状态机思路在单片机程序设计中的应用
anchor_mt的专栏
01-06 1698
<br /><br />状态机思路在单片机程序设计中的应用<br />状态机的概念<br />状态机是软件编程中的一个重要概念。比这个概念更重要的是对它的灵活应用。在一个思路清晰而且高效的程序中，必然有状态机的身影浮现。<br /><br />比如说一个按键命令解析程序，就可以被看做状态机：本来在A状态下，触发一个按键后切换到了B状态；再触发另一个键后切换到C状态，或者返回到A状态。这就是最简单的按键状态机例子。实际的按键解析程序会比这更复杂些，但这不影响我们对状态机的认识。<br /><br />进一步看
学习FSM状态机的C语言实现
最新发布
tianjiahe的数字空间
09-25 523
学习状态机编程 C语言实现案列
C语言实现的状态机
06-29
C状态机，switch-case版；C状态机，查表法。
C语言编写的状态机源代码，包括四种典型实现方式
08-12
C语言编写的状态机源代码，包括四种典型实现方式。 状态机编程的经典参考资料。
C语言实现有限状态机
蓬篙人的专栏
09-16 7217
以下是转载内容：☆─────────────────────────传说中的分隔符───────────────────────────────────────☆ 来源1：http://www.cnblogs.com/swingboat/archive/2005/07/27/201488.html【转载1】有限状态机的实现  有限状态机（Finite State Machine
C语言实现状态机（一）
热门推荐
qq_36969264的博客
05-03 1万+
状态机原理 状态机有4个要素： 现态：是指当前所处的状态。 条件：又称为“事件”，当一个条件被满足，将会触发一个动作，或者执行一次状态的迁移。 动作：条件满足后执行的动作。动作执行完毕后，可以迁移到新的状态，也可以仍旧保持原状态。动作不是必需的，当条件满足后，也可以不执行任何动作，直接迁移到新状态。 次态：条件满足后要迁往的新状态。“次态”是相对于“现态”而言的，“次态”一旦被激活，就转变成新的...
c语言实现状态机.zip
02-28
以下是对C语言实现状态机相关知识点的详细说明： 1. **状态机基础概念**： 状态机是一个抽象的概念，它描述了一个实体在不同时间可能处于的不同状态以及这些状态之间的转换。状态机可以分为有限状态机（FSM）和...
C语言嵌入式状态机架构（含C源码）
05-29
在C语言中，实现状态机通常采用函数指针的方式。这是因为函数指针可以被视为指向执行特定任务的代码的指针，使得我们可以在运行时动态地调用不同的函数，对应于不同的状态行为。以下是一个简单的步骤，展示了如何...
C语言实现状态机解析单词
11-15
C++的多态，本质上和在C语言当中的函数指针一样，通过一种手段，调用不同的函数，实现对同一事物实现不同的处理方式。最近在写一个单词解析的练习题，刚好是使用了函数指针来达到隔离变化，降低耦合的目的，本文将是...
C语言状态机
08-14
C语言 状态机 初学必备！
基于C语言实现的嵌入式电机状态机（含源码）
05-29
前言 背景 内外事件 事件数据 状态转变 状态机模块 电机实例 外部事件 州数 状态函数 状态图 状态机对象 过渡图 新的状态机步骤 状态引擎 生成事件 不使用堆 离心机测试实例 多线程安全
c语言switch用法状态机,「编程之美」用C语言实现状态机(超实用)
weixin_35971306的博客
05-20 885
关于状态机，基础的知识点可以自行理解，讲解的很多，这里主要是想写一个有限状态机FSM通用的写法，目的在于更好理解，移植，节省代码阅读与调试时间，体现出编程之美。传统的实现方案if...else : 搞一大堆if else, 一个函数写很长很长......swich...case : 也搞一大堆一个函数写很长很长......先来看看最近做的一个项目，无线通信协议实现的状态机是什么样子的：有三种类型的...
C语言实现状态机：详解与示例代码
PixelLoom的博客
10-03 1059
在上面的示例代码中，我们定义了三个状态：IDLE（空闲状态）、RUNNING（运行状态）和FINISH（完成状态）。通过定义状态和状态之间的转换条件，并使用条件语句进行状态切换，我们可以有效地处理复杂的逻辑流程。通常，我们会使用枚举类型来定义状态，并使用条件语句（如switch语句）来处理状态之间的转换。每个状态代表系统或程序在某一时刻的行为或状态，而状态之间的转换代表了不同条件下状态的变化。我们可以根据具体的需求定义更多的状态和状态之间的转换条件，以实现更加复杂的程序逻辑。
状态机----C语言实现
weixin_42404595的博客
09-01 4178
状态机（C语言实现状态机）
设计模式--状态模式(C语言实现)
m0_38056437的博客
04-11 5731
原创亚索老哥embed linux share 模式动机 状态模式(状态机)是嵌入式开发中最重要、最核心的设计模式之一，毫不夸张的说，是否熟练掌握状态模式，很大程度上直接决定了嵌入式工程师的代码掌控能力。在嵌入式开发里面，几乎80%以上的程序都有状态模式(状态机)的影子。在一个思路清晰而且高效的程序中，必然有状态模式(状态机)身影浮现。但是很多嵌入式开发者只是掌握一些很基础的状态机编...
C语言实现状态机的四种方法解析
以下是四种使用C语言实现状态机的方法： 1. **switch/case或if/else**：这是最基础的实现方式，通过条件语句来决定状态间的转换。对于小型状态机而言，这种方式直观易懂，但随着状态数量增加，代码将变得难以维护。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值