嵌入式中狀態機的設置
狀態機在嵌入式軟件中隨處可見，可能你會說狀態機有什么難的，不就是switch 嗎？
switch僅僅是最基礎的一個點，關于狀態機的更多操作，或許你都沒有見過，下面分享幾種實現方法。
狀態機基本術語
現態：是指當前所處的狀態。
條件：又稱為“事件”，當一個條件被滿足，將會觸發一個動作，或者執行一次狀態的遷移。
動作：條件滿足后執行的動作。動作執行完畢后，可以遷移到新的狀態，也可以仍舊保持原狀態。動作不是必需的，當條件滿足后，也可以不執行任何動作，直接遷移到新狀態。
次態：條件滿足后要遷往的新狀態。“次態”是相對于“現態”而言的，“次態”一旦被激活，就轉變成新的“現態”了。
傳統有限狀態機FSM
如圖，是一個定時計數器，計數器存在兩種狀態，一種為設置狀態，一種為計時狀態
設置狀態
“+” “-” 按鍵對初始倒計時進行設置
當計數值設置完成，點擊確認鍵啟動計時 ，即切換到計時狀態
計時狀態
按下“+” “-” 會進行密碼的輸入“+”表示1 ,“-”表示輸入0 ，密碼共有4位
確認鍵：只有輸入的密碼等于默認密碼，按確認鍵才能停止計時，否則計時直接到零，并執行相關操作
嵌套switch
/***************************************
1.列出所有的狀態
***************************************/
typedefenum{
SETTING,
TIMING
}STATE_TYPE;
/***************************************
2.列出所有的事件
***************************************/
typedefenum{
UP_EVT,
DOWN_EVT,
ARM_EVT,
TICK_EVT
}EVENT_TYPE;
/***************************************
3.定義和狀態機相關結構
***************************************/
structbomb
{
uint8_tstate;
uint8_ttimeout;
uint8_tcode;
uint8_tdefuse_code;
}bomb1;
/***************************************
4.初始化狀態機
***************************************/
voidbomb1_init(void)
{
bomb1.state=SETTING;
bomb1.defuse_code=6;//0110
}
/***************************************
5.狀態機事件派發
***************************************/
voidbomb1_fsm_dispatch(EVENT_TYPEevt,void*param)
{
switch(bomb1.state)
{
caseSETTING:
{
switch(evt)
{
caseUP_EVT://"+"按鍵按下事件
if(bomb1.timeout0)--bomb1.timeout;
bsp_display(bomb1.timeout);
break;
caseARM_EVT://"確認"按鍵按下事件
bomb1.state=TIMING;
bomb1.code=0;
break;
}
}break;
caseTIMING:
{
switch(evt)
{
caseUP_EVT://"+"按鍵按下事件
bomb1.code=(bomb1.code<<1)?|0x01;
??????????????break;
??????????????case?DOWN_EVT:??//?"-"???按鍵按下事件
??????????????????bomb1.code?=?(bomb1.code?<<1);?
??????????????break;
??????????????case?ARM_EVT:???//?"確認"?按鍵按下事件
??????????????????if(bomb1.code?==?bomb1.defuse_code){
??????????????????????bomb1.state?=?SETTING;
??????????????????}
??????????????????else{
????????????????????bsp_display("bomb!")
??????????????????}
??????????????break;
??????????????case?TICK_EVT:
??????????????????if(bomb1.timeout)
??????????????????{
??????????????????????--bomb1.timeout;
??????????????????????bsp_display(bomb1.timeout);
??????????????????}
??????????????????if(bomb1.timeout?==?0)
??????????????????{
??????????????????????bsp_display("bomb!")
??????????????????}
??????????????break;
??????????}???
??????}break;
??}
}
優點:簡單，代碼閱讀連貫，容易理解
缺點
當狀態或事件增多時，代碼狀態函數需要經常改動，狀態事件處理函數會代碼量會不斷增加
狀態機沒有進行封裝，移植性差。
沒有實現狀態的進入和退出的操作。進入和退出在狀態機中尤為重要。進入事件：只會在剛進入時觸發一次，主要作用是對狀態進行必要的初始化。退出事件：只會在狀態切換時觸發一次 ，主要的作用是清除狀態產生的中間參數，為下次進入提供干凈環境
狀態表
二維狀態轉換表
狀態機可以分為狀態和事件 ，狀態的躍遷都是受事件驅動的，因此可以通過一個二維表格來表示狀態的躍遷。
僅當(code == defuse_code) 時才發生到setting 的轉換。
/*1.列出所有的狀態*/
enum
{
SETTING,
TIMING,
MAX_STATE
};
/*2.列出所有的事件*/
enum
{
UP_EVT,
DOWN_EVT,
ARM_EVT,
TICK_EVT,
MAX_EVT
};
/*3.定義狀態表*/
typedefvoid(*fp_state)(EVT_TYPEevt,void*param);
staticconstfp_statebomb2_table[MAX_STATE][MAX_EVENT]=
{
{setting_UP,setting_DOWN,setting_ARM,null},
{setting_UP,setting_DOWN,setting_ARM,timing_TICK}
};
structbomb_t
{
constfp_stateconst*state_table;/*theState-Table*/
uint8_tstate;/*thecurrentactivestate*/
uint8_ttimeout;
uint8_tcode;
uint8_tdefuse_code;
};
structbombbomb2=
{
.state_table=bomb2_table;
}
voidbomb2_init(void)
{
bomb2.defuse_code=6;//0110
bomb2.state=SETTING;
}
voidbomb2_dispatch(EVT_TYPEevt,void*param)
{
fp_states=NULL;
if(evt>MAX_EVT)
{
LOG("EVTtypeerror!");
return;
}
s=bomb2.state_table[bomb2.state*MAX_EVT+evt];
if(s!=NULL)
{
s(evt,param);
}
}
/*列出所有的狀態對應的事件處理函數*/
voidsetting_UP(EVT_TYPEevt,void*param)
{
if(bomb1.timeout
缺點：函數粒度太小是最明顯的一個缺點，一個狀態和一個事件就會產生一個函數，當狀態和事件較多時，處理函數將增加很快，在閱讀代碼時，邏輯分散。沒有實現進入退出動作。
一維狀態轉換表
實現原理：
typedefvoid(*fp_action)(EVT_TYPEevt,void*param);
/*轉換表基礎結構*/
structtran_evt_t
{
EVT_TYPEevt;
uint8_tnext_state;
};
/*狀態的描述*/
structfsm_state_t
{
fp_actionenter_action;//進入動作
fp_actionexit_action;//退出動作
fp_actionaction;
tran_evt_t*tran;//轉換表
uint8_ttran_nb;//轉換表的大小
constchar*name;
}
/*狀態表本體*/
#defineARRAY(x)x,sizeof(x)/sizeof(x[0])
conststructfsm_state_tstate_table[]=
{
{setting_enter,setting_exit,setting_action,ARRAY(set_tran_evt),"setting"},
{timing_enter,timing_exit,timing_action,ARRAY(time_tran_evt),"timing"}
};
/*構建一個狀態機*/
structfsm
{
conststructstate_t*state_table;/*theState-Table*/
uint8_tcur_state;/*thecurrentactivestate*/
uint8_ttimeout;
uint8_tcode;
uint8_tdefuse_code;
}bomb3;
/*初始化狀態機*/
voidbomb3_init(void)
{
bomb3.state_table=state_table;//指向狀態表
bomb3.cur_state=setting;
bomb3.defuse_code=8;//1000
}
/*狀態機事件派發*/
voidfsm_dispatch(EVT_TYPEevt,void*param)
{
tran_evt_t*p_tran=NULL;
/*獲取當前狀態的轉換表*/
p_tran=bomb3.state_table[bomb3.cur_state]->tran;
/*判斷所有可能的轉換是否與當前觸發的事件匹配*/
for(uint8_ti=0;ievt==evt)//事件會觸發轉換
{
if(NULL!=bomb3.state_table[bomb3.cur_state].exit_action){
bomb3.state_table[bomb3.cur_state].exit_action(NULL);//執行退出動作
}
if(bomb3.state_table[_tran[i]->next_state].enter_action){
bomb3.state_table[_tran[i]->next_state].enter_action(NULL);//執行進入動作
}
/*更新當前狀態*/
bomb3.cur_state=p_tran[i]->next_state;
}
else
{
bomb3.state_table[bomb3.cur_state].action(evt,param);
}
}
}
/*************************************************************************
setting狀態相關
************************************************************************/
voidsetting_enter(EVT_TYPEevt,void*param)
{
}
voidsetting_exit(EVT_TYPEevt,void*param)
{
}
voidsetting_action(EVT_TYPEevt,void*param)
{
}
tran_evt_tset_tran_evt[]=
{
{ARM,timing},
}
/*timing狀態相關*/
優點
各個狀態面向用戶相對獨立，增加事件和狀態不需要去修改先前已存在的狀態事件函數。
實現了狀態的進入和退出
容易根據狀態躍遷圖來設計 （狀態躍遷圖列出了每個狀態的躍遷可能，也就是這里的轉換表）
實現靈活，可實現復雜邏輯，如上一次狀態，增加監護條件來減少事件的數量。可實現非完全事件驅動
缺點
函數粒度較小（比二維小且增長慢），可以看到，每一個狀態需要至少3個函數，還需要列出所有的轉換關系。
QP嵌入式實時框架
事件驅動型編程
好萊塢原則：和傳統的順序式編程方法例如“超級循環”，或傳統的RTOS 的任務不同。絕大多數的現代事件驅動型系統根據好萊塢原則被構造（Don’t call me; I’ll call you.）
面向對象
類和單一繼承
工具
QM ：一個通過UML類圖來描述狀態機的軟件，并且可以自動生成C代碼
QS軟件追蹤工具
QEP實現有限狀態機Fsm
/*qevent.h----------------------------------------------------------------*/
typedefstructQEventTag
{
QSignalsig;
uint8_tdynamic_;
}QEvent;
/*qep.h-------------------------------------------------------------------*/
typedefuint8_tQState;/*statusreturnedfromastate-handlerfunction*/
typedefQState(*QStateHandler)(void*me,QEventconst*e);/*argumentlist*/
typedefstructQFsmTag/*FiniteStateMachine*/
{
QStateHandlerstate;/*currentactivestate*/
}QFsm;
#defineQFsm_ctor(me_,initial_)((me_)->state=(initial_))
voidQFsm_init(QFsm*me,QEventconst*e);
voidQFsm_dispatch(QFsm*me,QEventconst*e);
#defineQ_RET_HANDLED((QState)0)
#defineQ_RET_IGNORED((QState)1)
#defineQ_RET_TRAN((QState)2)
#defineQ_HANDLED()(Q_RET_HANDLED)
#defineQ_IGNORED()(Q_RET_IGNORED)
#defineQ_TRAN(target_)(((QFsm*)me)->state=(QStateHandler)(target_),Q_RET_TRAN)
enumQReservedSignals
{
Q_ENTRY_SIG=1,
Q_EXIT_SIG,
Q_INIT_SIG,
Q_USER_SIG
};
/*fileqfsm_ini.c---------------------------------------------------------*/
#include"qep_port.h"/*theportoftheQEPeventprocessor*/
#include"qassert.h"/*embeddedsystems-friendlyassertions*/
voidQFsm_init(QFsm*me,QEventconst*e)
{
(*me->state)(me,e);/*executethetop-mostinitialtransition*/
/*enterthetarget*/
(void)(*me->state)(me,&QEP_reservedEvt_[Q_ENTRY_SIG]);
}
/*fileqfsm_dis.c---------------------------------------------------------*/
voidQFsm_dispatch(QFsm*me,QEventconst*e)
{
QStateHandlers=me->state;/*savethecurrentstate*/
QStater=(*s)(me,e);/*calltheeventhandler*/
if(r==Q_RET_TRAN)/*transitiontaken?*/
{
(void)(*s)(me,&QEP_reservedEvt_[Q_EXIT_SIG]);/*exitthesource*/
(void)(*me->state)(me,&QEP_reservedEvt_[Q_ENTRY_SIG]);/*entertarget*/
}
}
實現上面定時器例子
#include"qep_port.h"/*theportoftheQEPeventprocessor*/
#include"bsp.h"/*boardsupportpackage*/
enumBombSignals/*allsignalsfortheBombFSM*/
{
UP_SIG=Q_USER_SIG,
DOWN_SIG,
ARM_SIG,
TICK_SIG
};
typedefstructTickEvtTag
{
QEventsuper;/*derivefromtheQEventstructure*/
uint8_tfine_time;/*thefine1/10scounter*/
}TickEvt;
typedefstructBomb4Tag
{
QFsmsuper;/*derivefromQFsm*/
uint8_ttimeout;/*numberofsecondstillexplosion*/
uint8_tcode;/*currentlyenteredcodetodisarmthebomb*/
uint8_tdefuse;/*secretdefusecodetodisarmthebomb*/
}Bomb4;
voidBomb4_ctor(Bomb4*me,uint8_tdefuse);
QStateBomb4_initial(Bomb4*me,QEventconst*e);
QStateBomb4_setting(Bomb4*me,QEventconst*e);
QStateBomb4_timing(Bomb4*me,QEventconst*e);
/*--------------------------------------------------------------------------*/
/*theinitialvalueofthetimeout*/
#defineINIT_TIMEOUT10
/*..........................................................................*/
voidBomb4_ctor(Bomb4*me,uint8_tdefuse){
QFsm_ctor_(&me->super,(QStateHandler)&Bomb4_initial);
me->defuse=defuse;/*thedefusecodeisassignedatinstantiation*/
}
/*..........................................................................*/
QStateBomb4_initial(Bomb4*me,QEventconst*e){
(void)e;
me->timeout=INIT_TIMEOUT;
returnQ_TRAN(&Bomb4_setting);
}
/*..........................................................................*/
QStateBomb4_setting(Bomb4*me,QEventconst*e){
switch(e->sig){
caseUP_SIG:{
if(me->timeouttimeout;
BSP_display(me->timeout);
}
returnQ_HANDLED();
}
caseDOWN_SIG:{
if(me->timeout>1){
--me->timeout;
BSP_display(me->timeout);
}
returnQ_HANDLED();
}
caseARM_SIG:{
returnQ_TRAN(&Bomb4_timing);/*transitionto"timing"*/
}
}
returnQ_IGNORED();
}
/*..........................................................................*/
voidBomb4_timing(Bomb4*me,QEventconst*e){
switch(e->sig){
caseQ_ENTRY_SIG:{
me->code=0;/*clearthedefusecode*/
returnQ_HANDLED();
}
caseUP_SIG:{
me->code<<=?1;
????????????me->code|=1;
returnQ_HANDLED();
}
caseDOWN_SIG:{
me->code<<=?1;
????????????return?Q_HANDLED();
????????}
????????case?ARM_SIG:?{
????????????if?(me->code==me->defuse){
returnQ_TRAN(&Bomb4_setting);
}
returnQ_HANDLED();
}
caseTICK_SIG:{
if(((TickEvtconst*)e)->fine_time==0){
--me->timeout;
BSP_display(me->timeout);
if(me->timeout==0){
BSP_boom();/*destroythebomb*/
}
}
returnQ_HANDLED();
}
}
returnQ_IGNORED();
}
優點
采用面向對象的設計方法，很好的移植性
實現了進入退出動作
合適的粒度，且事件的粒度可控
狀態切換時通過改變指針，效率高
可擴展成為層次狀態機
缺點
對事件的定義以及事件粒度的控制是設計的最大難點，如串口接收到一幀數據，這些變量的更新單獨作為某個事件，還是串口收到數據作為一個事件。再或者顯示屏，如果使用此種編程方式，如何設計事件。
QP 實現層次狀態機
初始化層次狀態機的實現：在初始化時，用戶所選取的狀態永遠是最底層的狀態，如上圖，我們在計算器開機后，應該進入的是開始狀態，這就涉及到一個問題，由最初top（頂狀態）到begin 是有一條狀態切換路徑的，當我們設置狀態為begin如何搜索這條路徑成為關鍵（知道了路徑才能正確的進入begin,要執行路徑中過渡狀態的進入和退出事件）
voidQHsm_init(QHsm*me,QEventconst*e)
{
Q_ALLEGE((*me->state)(me,e)==Q_RET_TRAN);
t=(QStateHandler)&QHsm_top;/*HSMstartsinthetopstate*/
do{/*drillintothetarget...*/
QStateHandlerpath[QEP_MAX_NEST_DEPTH_];
int8_tip=(int8_t)0;/*transitionentrypathindex*/
path[0]=me->state;/*這里的狀態為begin*/
/*通過執行空信號，從底層狀態找到頂狀態的路徑*/
(void)QEP_TRIG_(me->state,QEP_EMPTY_SIG_);
while(me->state!=t){
path[++ip]=me->state;
(void)QEP_TRIG_(me->state,QEP_EMPTY_SIG_);
}
/*切換為begin*/
me->state=path[0];/*restorethetargetoftheinitialtran.*/
/*鉆到最底層的狀態，執行路徑中的所有進入事件*/
Q_ASSERT(ip=(int8_t)0);
t=path[0];/*currentstatebecomesthenewsource*/
}while(QEP_TRIG_(t,Q_INIT_SIG)==Q_RET_TRAN);
me->state=t;
}
狀態切換
/*.................................................................*/
QStateresult(Calc*me,QEventconst*e)
{
switch(e->sig)
{you
caseENTER_SIG:{
break;
}
caseEXIT_SIG:{
break;
}
caseC_SIG:
{
printf("clear");
returnQ_HANDLED();
}
caseB_SIG:
{
returnQ_TRAN(&begin);
}
}
returnQ_SUPER(&reday);
}
/*.ready為result和begin的超狀態................................................*/
QStateready(Calc*me,QEventconst*e)
{
switch(e->sig)
{
caseENTER_SIG:{
break;
}
caseEXIT_SIG:{
break;
}
caseOPER_SIG:
{
returnQ_TRAN(&opEntered);
}
}
returnQ_SUPER(&on);
}
voidQHsm_dispatch(QHsm*me,QEventconst*e)
{
QStateHandlerpath[QEP_MAX_NEST_DEPTH_];
QStateHandlers;
QStateHandlert;
QStater;
t=me->state;/*savethecurrentstate*/
do{/*processtheeventhierarchically...*/
s=me->state;
r=(*s)(me,e);/*invokestatehandlers*/
}while(r==Q_RET_SUPER);//當前狀態不能處理事件，直到找到能處理事件的狀態
if(r==Q_RET_TRAN){/*transitiontaken?*/
int8_tip=(int8_t)(-1);/*transitionentrypathindex*/
int8_tiq;/*helpertransitionentrypathindex*/
path[0]=me->state;/*savethetargetofthetransition*/
path[1]=t;
while(t!=s){/*exitcurrentstatetotransitionsources...*/
if(QEP_TRIG_(t,Q_EXIT_SIG)==Q_RET_HANDLED){/*exithandled?*/
(void)QEP_TRIG_(t,QEP_EMPTY_SIG_);/*findsuperstateoft*/
}
t=me->state;/*me->stateholdsthesuperstate*/
}
...
}
me->state=t;/*setnewstateorrestorethecurrentstate*/
}
t=path[0];/*targetofthetransition*/
if(s==t){/*(a)checksource==target(transitiontoself)*/
QEP_EXIT_(s)/*exitthesource*/
ip=(int8_t)0;/*enterthetarget*/
}
else{
(void)QEP_TRIG_(t,QEP_EMPTY_SIG_);/*superstateoftarget*/
t=me->state;
if(s==t){/*(b)checksource==target->super*/
ip=(int8_t)0;/*enterthetarget*/
}
else{
(void)QEP_TRIG_(s,QEP_EMPTY_SIG_);/*superstateofsrc*/
/*(c)checksource->super==target->super*/
if(me->state==t){
QEP_EXIT_(s)/*exitthesource*/
ip=(int8_t)0;/*enterthetarget*/
}
else{
/*(d)checksource->super==target*/
if(me->state==path[0]){
QEP_EXIT_(s)/*exitthesource*/
}
else{/*(e)checkrestofsource==target->super->super..
*andstoretheentrypathalongtheway*/
....
QP實時框架的組成
內存管理
使用內存池，對于低性能mcu，內存極為有限，引入內存管理主要是整個架構中，是以事件作為主要的任務通信手段，且事件是帶參數的，可能相同類型的事件會多次觸發，而事件處理完成后，需要清除事件，無法使用靜態的事件，因此是有必要為不同事件創建內存池的。對于不同塊大小的內存池，需要考慮的是每個塊的起始地址對齊問題。在進行內存池初始化時，我們是根據blocksize+header大小來進行劃分內存池的。假設一個2字節的結構，如果以2來進行劃分，假設mcu 4字節對齊，那么將有一半的結構起始地址無法對齊，這時需要為每個塊預留空間，保證每個塊的對齊。
事件隊列
每一個活動對象維護一個事件隊列，事件都是由基礎事件派生的，不同類型的事件只需要將其基礎事件成員添加到活動對象的隊列中即可，最終在取出的時候通過一個強制轉換便能獲得附加的參數。
事件派發
直接事件發送QActive_postLIFO()
發行訂閱事件發送豎軸表示信號（為事件的基類）活動對象支持64個優先級，每一個活動對象要求擁有唯一優先級通過優先級的bit位來表示某個事件被哪些活動對象訂閱，并在事件觸發后根據優先級為活動對象派發事件。
代碼風格
審核編輯：彭靜
聲明：本文內容及配圖由入駐作者撰寫或者入駐合作網站授權轉載。文章觀點僅代表作者本人，不代表電子發燒友網立場。文章及其配圖僅供工程師學習之用，如有內容侵權或者其他違規問題，請聯系本站處理。
舉報投訴
-
嵌入式
+關注
關注
5198文章
20442瀏覽量
333975 -
軟件
+關注
關注
69文章
5332瀏覽量
91575 -
計數器
+關注
關注
32文章
2315瀏覽量
98170
原文標題：嵌入式中狀態機的幾種騷操作
文章出處：【微信號：strongerHuang，微信公眾號：strongerHuang】歡迎添加關注！文章轉載請注明出處。
發布評論請先 登錄
相關推薦
熱點推薦
嵌入式狀態機的幾種大牛才懂的操作
狀態機在嵌入式軟件中隨處可見，可能你會說狀態機有什么難的，不就是 switch 嗎？ switch僅僅是最基礎的一個點，關于狀態機的更多操作
發表于 11-17 10:41
?2032次閱讀
嵌入式軟件開發中常用的狀態機編程實現
在嵌入式軟件開發中，狀態機編程是一個十分重要的編程思想，它也是嵌入式開發中一個常用的編程框架。掌握了狀態機編程思想，可以更加邏輯清晰的實現復
發表于 09-06 10:25
?3274次閱讀
嵌入式之狀態機編程的概念是什么
干貨 | 嵌入式之狀態機編程干貨篇文章描述了基本的狀態機編程概念，感覺還可以。如果在搭上事件驅動框架，就可以寫一個簡單的RTOS了，這個OS可以作為一種不可剝奪型內核。...
發表于 12-22 06:25
LSM6DSOX嵌入式有限狀態機的使用和配置的信息
本文檔旨在提供有關 ST 的 LSM6DSOX 嵌入式有限狀態機的使用和配置的信息。LSM6DSOX 可配置為由用戶定義的運動模式激活中斷信號生成。為此，最多可以為運動檢測獨立編程 16 組嵌入式有限
發表于 09-06 06:36
ISM330DHCX嵌入式有限狀態機的使用和配置信息
本文檔旨在提供有關 ST 的 ISM330DHCX嵌入式有限狀態機的使用和配置的信息。ISM330DHCX 可配置為由用戶定義的運動模式激活中斷信號生成。為此，最多可以為運動檢測獨立編程 16 組嵌入式有限
發表于 09-08 08:00
嵌入式軟件中狀態機的抽象與實現
文中提出了 在嵌入式軟件中把狀態機作為一個獨立模塊從控制模塊中抽象出來的思想 , 描述了 抽象出來的狀態機模塊 。 并介紹了 如何將這種
發表于 03-22 15:47
?1次下載
有限狀態機在嵌入式系統中的實現及應用
如何使嵌入式軟件代碼更加可靠 增強程序的可維護性 一直以來都是嵌入式程序員追 求的目標。論述了有限狀態機的原理和其實現方法;采用狀態機方法編寫了一個按鍵掃描程序介紹了
發表于 03-22 15:40
?1次下載
基于事件驅動的有限狀態機介紹
EFSM(event finite state machine，事件驅動型有限狀態機)，是一個基于事件驅動的有限狀態機，主要應用于嵌入式設備的軟件系統中。
嵌入式狀態機的設計與實現
嵌入式狀態機是一種常用的軟件設計模式，它能夠提高代碼的可讀性和可維護性。狀態機是一個抽象的概念，它描述了一個系統或者組件的不同狀態以及在不同狀態
工商網監
評論