开源最简状态机框架

youkebing

我们写状态机时，其实还是很烦的，我觉得PT在这个方面是最直观的，但在一些特定领域并不合适。QP也是大家比较推崇的，但是感觉有点大（至少我觉得），刚好逛github碰到一个叫SM的库，据说是模仿QP的，看起来感觉不错，就改写了一点，我在windows下写了个demo，我觉得在arm下也应该是一样的，大家不妨一起探讨，研究！

youkebing

原作者地址
https://github.com/leijian001/sm
源码

负西弱

Mark,有讲解就更好了

youkebing

负西弱 发表于 2016-5-1 22:44
Mark,有讲解就更好了

我改写的那个非常简单，就几行代码(ssm.c),觉得有问题，可以直接提问。我们一起探讨。

maimaige

mark 一下 状态机

youkebing

maimaige 发表于 2016-5-1 22:58
mark 一下 状态机

光mark不行啊，如果能一起探讨就最好了 压缩包里面包含一个demo和可执行文件，可以非常容易测试。我过几天再写一个简单的arm测试例子。

maimaige

youkebing 发表于 2016-5-1 23:05
光mark不行啊，如果能一起探讨就最好了 压缩包里面包含一个demo和可执行文件，可以非常容易测试。 ...

好啊，我还想找人指导一下，消息处理，协议处理的，框架呢，一般是串口方面的控制协议

youkebing

maimaige 发表于 2016-5-1 23:12
好啊，我还想找人指导一下，消息处理，协议处理的，框架呢，一般是串口方面的控制协议 ...

指导谈不上,大家起探讨

yikuang

先收下，谢谢！

yuntian

晚上下来研究下

kenson

先了解一下再问

youkebing

大家可以先想一些场景，我来按照这个场景写一些简单demo，当然要比较简单，有一定的代表性。或者用其他模式写起来不太顺手的。

what007

收藏了，谢谢。

fchen2

定时器超时消息如何处理？

youkebing

fchen2 发表于 2016-5-2 17:20
定时器超时消息如何处理？

定时器超时不再这个框架内，
最简单的方式是实现一个定时节拍，而后设定自己要延时的节拍数，在那个节拍处理器中不停的减，为0时，给框架发一个消息。

bj232

先收下，谢谢！

笑笑我笑了

用switch-case写最简单，但是难维护啊。

youkebing

笑笑我笑了 发表于 2016-5-3 11:10
用switch-case写最简单，但是难维护啊。

你看看我这个，是不是还可以？

笑笑我笑了

youkebing 发表于 2016-5-3 12:13
你看看我这个，是不是还可以？

够简洁，但是状态不能嵌套啊。

youkebing

笑笑我笑了 发表于 2016-5-3 12:21
够简洁，但是状态不能嵌套啊。

呵呵，太复杂可能就失去意义了，一般我也不喜欢过于庞大的框架

sgweilong

下载了，研究研究
写好程序不容易

笑笑我笑了

youkebing 发表于 2016-5-3 12:41
呵呵，太复杂可能就失去意义了，一般我也不喜欢过于庞大的框架

框架复杂呢，应用可能会简单，但是框架简单呢，应用会复杂。
怎么取舍，看你自己啦。

youkebing

笑笑我笑了 发表于 2016-5-3 12:52
框架复杂呢，应用可能会简单，但是框架简单呢，应用会复杂。
怎么取舍，看你自己啦。
...

每个人看法不一样，所以也要有取舍，如果更复杂的话，其实直接上os，但是许多时候，我们不需要那么大。那么这个时候，可能一个简单的框架更合适

EngKing

思路都差不多

youkebing

EngKing 发表于 2016-5-3 13:01
思路都差不多

请发表高见，有没有类似的也发表出来，大家一起交流啊

我是一个大白菜

谢谢分享，mark状态机

huangqi412

给楼主顶下

RAMILE

看不动，求LZ写一个定时炸弹demo，洗衣机也行

xuxi2009

很简练的一个

wt3333

最近正在研究状态机  谢谢分享

youkebing

RAMILE 发表于 2016-5-4 10:11
看不动，求LZ写一个定时炸弹demo，洗衣机也行

不知道你的定时是啥样的?你写个定时的简单需求呢？

笑笑我笑了

youkebing 发表于 2016-5-4 12:09
不知道你的定时是啥样的?你写个定时的简单需求呢？

void TIMER_IRQ(void)
{
        me->tick--;
}

STATE1
{
        switch(evt)
        {
                case xx:
                        if(me->tick == xxx)
                                xxxx
                        break;

                default:
                        break;
        }
}

youkebing

笑笑我笑了 发表于 2016-5-4 12:34
void TIMER_IRQ(void)
{
        me->tick--;

你这个代码好难懂，似乎就一个状态，一个状态还叫状态机吗？麻烦些个详细的需求呢？

262619890

youkebing 发表于 2016-5-4 12:49
你这个代码好难懂，似乎就一个状态，一个状态还叫状态机吗？麻烦些个详细的需求呢？ ...

事件+时间片轮转

308594151

mark一下

showgu

之前用过不少pt，感觉挺好，也没出过什么问题，不知道这个怎么样，下载看看，谢谢楼主。

wlmwwx

谢谢，收藏了，以后研究一下。

cyberkyg

mark              .

watcherone

看了一下，里面的超状态什么意思啊。没弄懂

klxx68

下下来，学习一下

youkebing

watcherone 发表于 2016-5-6 10:14
看了一下，里面的超状态什么意思啊。没弄懂

你说的什么抄状态？我不知道你说的是哪一块

watcherone

HSM中的SM_RET_SUPER,/*!< event passed to superstate to handle */

youkebing

因为这是参照QP的，所以有些定义是没有用的，简化的，忽略掉就可以,看好原理就可以了

watcherone

自己新手，基础不够。就结合QP-nano源码对这个框架做了一个详细的注释。希望大家有用，可能有点错误。但是整体还是正确的

youkebing

watcherone 发表于 2016-5-6 12:19
自己新手，基础不够。就结合QP-nano源码对这个框架做了一个详细的注释。希望大家有用，可能有点错误。但是 ...

呵呵，大家一起学习，我没有全部看，我只找了一点最简单的看了下

richie550

下了，慢慢看

wswh2o

标签：状态机

自由飞儿

收藏备用

sxgtc

还有此等好东西，收藏了~

ywlzh

楼主，我很好奇，你那个文件夹里的.exe是怎么生成的,这个可执行文件太给力了。我好像意识到了它背后的力量

youkebing

ywlzh 发表于 2016-5-14 11:11
楼主，我很好奇，你那个文件夹里的.exe是怎么生成的,这个可执行文件太给力了。我好像意识到了它背后的力量 ...

一点也不好奇啊，那个是gcc编译的

BigWolf

收藏学习。                 

guolun

支持状态机的嵌套吗？

zhenghe

来个更简单的，只给接口，怎么用，自己琢磨吧，很简单。

1. /*******************************************************************************
   
2. *  Copyright(C)2016 by Dreistein<mcu_shilei@hotmail.com>                     *
   
3. *                                                                            *
   
4. *  This program is free software; you can redistribute it and/or modify it   *
   
5. *  under the terms of the GNU Lesser General Public License as published     *
   
6. *  by the Free Software Foundation; either version 3 of the License, or      *
   
7. *  (at your option) any later version.                                       *
   
8. *                                                                            *
   
9. *  This program is distributed in the hope that it will be useful, but       *
   
10. *  WITHOUT ANY WARRANTY; without even the implied warranty of                *
    
11. *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU          *
    
12. *  General Public License for more details.                                  *
    
13. *                                                                            *
    
14. *  You should have received a copy of the GNU Lesser General Public License  *
    
15. *  along with this program; if not, see http://www.gnu.org/licenses/.        *
    
16. *******************************************************************************/
    
17. 
    
18. //! \note do not move this pre-processor statement to other places
    
19. #define __EVENT_FSM_C__
    
20. 
    
21. /*============================ INCLUDES ======================================*/
    
22. #include ".\app_cfg.h"
    
23. 
    
24. /*============================ MACROS ========================================*/
    
25. /*============================ MACROFIED FUNCTIONS ===========================*/
    
26. /*============================ TYPES =========================================*/
    
27. typedef uint8_t (fn_state_t)(void *pArg);
    
28. typedef fn_state_t *event_fsm_stack_t;
    
29. 
    
30. typedef struct {
    
31.     event_fsm_stack_t *pStack;
    
32.     uint8_t     chStackSize;
    
33.     uint8_t     chSP;
    
34.     uint8_t     chCurrentSP;
    
35. } event_fsm_tcb_t;
    
36. 
    
37. /*============================ PROTOTYPES ====================================*/
    
38. /*============================ LOCAL VARIABLES ===============================*/
    
39. /*============================ GLOBAL VARIABLES ==============================*/
    
40. /*============================ IMPLEMENTATION ================================*/
    
41. bool event_fsm_init(event_fsm_tcb_t *ptTCB,
    
42.                     event_fsm_stack_t *pStack,
    
43.                     uint8_t chStackSize,
    
44.                     fn_state_t *pInitState)
    
45. {
    
46.     ptTCB->pStack       = pStack;
    
47.     ptTCB->chStackSize  = chStackSize;
    
48.     ptTCB->chSP         = 0;
    
49.     ptTCB->chCurrentSP  = 0;
    
50.     ptTCB->pStack[0]    = pInitState;
    
51. 
    
52.     return true;
    
53. }
    
54. 
    
55. bool event_fsm_transfer_to(event_fsm_tcb_t *ptTCB, fn_state_t *pState)
    
56. {
    
57.     ptTCB->chSP = ptTCB->chCurrentSP;
    
58.     ptTCB->pStack[ptTCB->chCurrentSP] = pState;
    
59.    
    
60.     return true;
    
61. }
    
62. 
    
63. bool event_fsm_transfer_to_end(event_fsm_tcb_t *ptTCB)
    
64. {
    
65.     ptTCB->chSP = ptTCB->chCurrentSP;
    
66.     ptTCB->pStack[ptTCB->chCurrentSP] = NULL;
    
67. 
    
68.     if (ptTCB->chSP) {
    
69.         ptTCB->chSP--;
    
70.     } else {
    
71.         //! event fsm run complete.
    
72.     }
    
73.    
    
74.     return true;
    
75. }
    
76. 
    
77. bool event_fsm_to_current_Level(event_fsm_tcb_t *ptTCB)
    
78. {
    
79.     ptTCB->chSP = ptTCB->chCurrentSP;
    
80.     return true;
    
81. }
    
82. 
    
83. bool event_fsm_transfer_to_uper(event_fsm_tcb_t *ptTCB, fn_state_t *pState)
    
84. {
    
85.     if (ptTCB->chStackSize == (ptTCB->chSP + 1)) {
    
86.         return false;
    
87.     }
    
88. 
    
89.     ptTCB->chSP++;
    
90.     ptTCB->pStack[ptTCB->chSP] = pState;
    
91.    
    
92.     return true;
    
93. }
    
94. 
    
95. //! internal use only.
    
96. bool event_fsm_current_level_decrease(event_fsm_tcb_t *ptTCB)
    
97. {
    
98.     if (ptTCB->chCurrentSP) {
    
99.         ptTCB->chCurrentSP--;
    
100.         return true;
     
101.     } else {
     
102.         return false;
     
103.     }
     
104. }
     
105. 
     
106. bool event_fsm_transfer_to_lower(event_fsm_tcb_t *ptTCB, fn_state_t *pState)
     
107. {
     
108.     if (!event_fsm_current_level_decrease(ptTCB)) {
     
109.         return false;
     
110.     }
     
111. 
     
112.     return event_fsm_transfer_to(ptTCB, pState);
     
113. }
     
114. 
     
115. fn_state_t *event_fsm_get_current_state(event_fsm_tcb_t *ptTCB)
     
116. {
     
117.     return ptTCB->pStack[ptTCB->chCurrentSP];
     
118. }
     
119. 
     
120. fn_state_t *event_fsm_get_state(event_fsm_tcb_t *ptTCB)
     
121. {
     
122.     ptTCB->chCurrentSP = ptTCB->chSP;
     
123.     return ptTCB->pStack[ptTCB->chSP];
     
124. }
     
125. 
     
126. 
     
127. /* EOF */
     

复制代码

用在DTU上，AT指令的处理。

youkebing

zhenghe 发表于 2016-5-14 14:13
来个更简单的，只给接口，怎么用，自己琢磨吧，很简单。

用在DTU上，AT指令的处理。 ...

似乎没有我那个简单

youkebing

guolun 发表于 2016-5-14 14:05
支持状态机的嵌套吗？

这个是很简单的，不支持嵌套，当然，你可以修改，

zhenghe

youkebing 发表于 2016-5-14 14:50
似乎没有我那个简单

你只做了fsm，我只做了hsm，人家都做了好吧。原理都那样，不同实现罢了。

youkebing

zhenghe 发表于 2016-5-14 15:12
你只做了fsm，我只做了hsm，人家都做了好吧。原理都那样，不同实现罢了。 ...

好吧，我错了

lushanlq

fsm  hsm  是有限状态机吗？能否详细说明一下？

chunyu

好东西 下载下来学习

creep

感谢分享，下载学习!

tianyime

现在我都是用switch写。。

youkebing

tianyime 发表于 2016-5-17 08:47
现在我都是用switch写。。

这个由很多方法，我这个仅仅是一个例子，switch当然是可以得。

308594151

mark一下

altim_li

学习一下，不错。

chencc8

有事件框架么，还是说只是状态机框架。只是状态机的话将QP里的qfsm弄出来就是了。

leiyitan

看来除了switch，我需要花点时间学习一下了

HalenYU

支持创新

end2000

学习。简单的状态机。

a7458969

赶脚是一坨shit，这样封装和重新写有什么区别。

bigwei

谢谢分享 下来看看

成就与价值

这个可以有，搞来研究学习下

xxzzhy

还可以，学习下下

xf331785508

压缩包不利于直观看代码探讨，我先把你的代码贴出来。再探讨。

1. //ssm.c
   
2. #include "ssm.h"
   
3. 
   
4. ssm_event_t ssm_reserved_event[] = {
   
5.     { SSM_EMPTY_SIG, 0 },
   
6.     { SSM_ENTRY_SIG, 0 },
   
7.     { SSM_EXIT_SIG,  0 },
   
8.     { SSM_INIT_SIG,  0 },
   
9.     { SSM_USER_SIG,  0 },
   
10. };
    
11. 
    
12. static ssm_ret_t null_state_handler(ssm_t *fsm, ssm_event_t const *e) {
    
13.     return SSM_EMPTY_SIG;
    
14. }
    
15. 
    
16. void fsm_ctor(ssm_t *me, ssm_state_handler_t init) {
    
17.     me->state = null_state_handler;
    
18.     me->temp  = init;
    
19.     fsm_dispatch(me, &ssm_reserved_event[1]);
    
20. }
    
21. 
    
22. void fsm_dispatch(ssm_t *me, ssm_event_t *e) {
    
23.     ssm_ret_t ret;
    
24. 
    
25.     ret = (me->temp)(me, e);
    
26.     if (SSM_RET_TRAN == ret) {
    
27.         SSM_EXIT(me, me->state);
    
28.         SSM_ENTRY(me, me->temp);
    
29.         me->state = me->temp;
    
30.     }
    
31. }
    

复制代码

1. //ssm.h
   
2. 
   
3. #ifndef __SM_H__
   
4. #define __SM_H__
   
5. 
   
6. #ifdef __cplusplus
   
7. extern "C" {
   
8. #endif
   
9. 
   
10. 
    
11. typedef int ssm_sig_t;
    
12. 
    
13. /**
    
14. * @bref 状态机事件
    
15. */
    
16. typedef struct ssm_event_s {
    
17.     ssm_sig_t sig;
    
18.     void *event;
    
19. } ssm_event_t;
    
20. 
    
21. /**
    
22. * @bref 状态处理函数返回值, 指示事件被怎么处理了
    
23. */
    
24. typedef unsigned char ssm_ret_t;
    
25. 
    
26. //struct ssm_fsm_s;
    
27. typedef struct ssm_s ssm_t;
    
28. typedef ssm_ret_t (*ssm_state_handler_t)(ssm_t *fsm, ssm_event_t const *e);
    
29. 
    
30. /**
    
31. * @bref 状态机
    
32. */
    
33. struct ssm_s {
    
34.     ssm_state_handler_t state;
    
35.     ssm_state_handler_t temp;
    
36. };
    
37. 
    
38. /**
    
39. * @bref 状态机返回值
    
40. *
    
41. */
    
42. enum {
    
43.     SSM_RET_HANDLED,
    
44.     SSM_RET_IGNORE,
    
45.     SSM_RET_UNHANDLED,
    
46. 
    
47.     SSM_RET_TRAN,
    
48.     SSM_RET_SUPER,
    
49. };
    
50. #define SSM_RET_CAST(x)  ( (ssm_ret_t)(x) )
    
51. 
    
52. #define SSM_HANDLED()        SSM_RET_CAST(SSM_RET_HANDLED)
    
53. #define SSM_IGNORE()         SSM_RET_CAST(SSM_RET_IGNORE)
    
54. #define SSM_UNHANDLED()      SSM_RET_CAST(SSM_RET_UNHANDLED)
    
55. 
    
56. #define SSM_TRAN(me, target) \
    
57.             ((me)->temp = (target), SSM_RET_CAST(SSM_RET_TRAN))
    
58. #define SSM_SUPER(me, super) \
    
59.             ((me)->temp = (super), SSM_RET_CAST(SSM_RET_SUPER))
    
60. 
    
61. #define SSM_SIG(e) (e->sig)
    
62. 
    
63. enum ssm_reserved_sig {
    
64.     SSM_EMPTY_SIG = -5,
    
65.     SSM_ENTRY_SIG = -4,
    
66.     SSM_EXIT_SIG  = -3,
    
67.     SSM_INIT_SIG  = -2,
    
68.     SSM_USER_SIG  = -1,
    
69. };
    
70. extern ssm_event_t ssm_reserved_event[];
    
71. #define SSM_TRIG(me, state, sig)     ((state)(me, &ssm_reserved_event[5 + (sig)]))
    
72. #define SSM_ENTRY(me, state)         SSM_TRIG(me, state, SSM_ENTRY_SIG)
    
73. #define SSM_EXIT(me, state)      SSM_TRIG(me, state, SSM_EXIT_SIG)
    
74. 
    
75. void fsm_ctor(ssm_t *me, ssm_state_handler_t init);
    
76. void fsm_dispatch(ssm_t *me, ssm_event_t *e);
    
77. 
    
78. #ifdef __cplusplus
    
79. }
    
80. #endif
    
81. 
    
82. #endif
    

复制代码

1. //main.c
   
2. 
   
3. #include "ssm.h"
   
4. #include <windows.h>
   
5. #include <stdio.h>
   
6. 
   
7. #define SSM_TIMEOUT_SIG  0
   
8. static ssm_ret_t off_state_handler(ssm_t *fsm, ssm_event_t const *e);
   
9. static ssm_ret_t on_state_handler(ssm_t *fsm, ssm_event_t const *e);
   
10. 
    
11. static ssm_ret_t off_state_handler(ssm_t *fsm, ssm_event_t const *e) {
    
12.     ssm_ret_t status;
    
13. 
    
14.     switch (SSM_SIG(e)) {
    
15.         case SSM_ENTRY_SIG: {
    
16.             printf("close led\r\n");
    
17.             status = SSM_HANDLED();
    
18.             break;
    
19.         }
    
20.         case SSM_TIMEOUT_SIG: {
    
21.             printf("off time ev\r\n");
    
22.             status = SSM_TRAN(fsm, &on_state_handler);
    
23.             break;
    
24.         }
    
25.         default: {
    
26.             status = SSM_HANDLED();
    
27.             break;
    
28.         }
    
29.     }
    
30.     return status;
    
31. }
    
32. static ssm_ret_t on_state_handler(ssm_t *fsm, ssm_event_t const *e) {
    
33.     ssm_ret_t status;
    
34. 
    
35.     switch (SSM_SIG(e)) {
    
36.         case SSM_ENTRY_SIG: {
    
37.             printf("open led\r\n");
    
38.             status = SSM_HANDLED();
    
39.             break;
    
40.         }
    
41.         case SSM_TIMEOUT_SIG: {
    
42.             printf("on time ev\r\n");
    
43.             status = SSM_TRAN(fsm, &off_state_handler);
    
44.             break;
    
45.         }
    
46.         default: {
    
47.             status = SSM_HANDLED();
    
48.             break;
    
49.         }
    
50.     }
    
51.     return status;
    
52. }
    
53. int main(int argc, char **argv) {
    
54.     ssm_event_t ev = {SSM_TIMEOUT_SIG, 0};
    
55.     ssm_t me;
    
56. 
    
57.     fsm_ctor(&me, off_state_handler);
    
58. 
    
59.     while (1) {
    
60.         Sleep(1000);
    
61.         fsm_dispatch(&me, &ev);
    
62.     }
    
63.     return 0;
    
64. }

复制代码

xf331785508

代码看了一下，指针利用非常轻熟。  
1.但这样的状态机缺少异步事件处理，还有就是单一状态下事件的时间可能远远大于TIMEOUT的值，造成其它事件直接死等。
2.适合于处理简单事务，单一状态处理函数中可做的事务越简单，耗时越小，整体状态循环就快。
3.代码的偶合性太高了，如果事件状态超过10个，20个，50个的时候，状态迁移就需要表来维护了，代码的后期维护难度将直线上升，非常困难。

我简单列一下我的观点：
1.将所要实现的功能分解成任务，各任务下再划分出不同状态，状态表要全局的；
2.状各任务配备一份状态控制表，每一状态完成后检查是否需要跳转任务状态；
3.设定定时器，处理异步事务，中断事务。

youkebing

谢谢你的建议

jorry

学习一下！谢谢

end2000

这个最简状态机框架可以这样用：
- 定义一个FSM，再定义这个FSM的一个通用消息变量Evt，把FSM+Evt封装起来，这样就得到一个AO，然后程序里可以有多个AO，它们互相通过发送消息进行协作。
- 每个AO再增加一个定时器消息变量EvtTimer，可以实现延时动作。

由于消息变量Evt可以看成是长度为1的队列，所以AO可能丢失消息。但如果把Evt扩展为长度大于1的队列，就又回到QPN的完整设计。

所以，简单的项目可以用这个框架，实际工程里建议直接用QPN框架，它基本功能都齐了。

ericw2012

学习学习。。。。

gaowh

很不错的东西，状态机在嵌入式简直是无敌的存在。

guolun

这个状态机也做过产品，就是事件的生成和派送繁琐。用QPN较省事。

propor123

非常不错。

pchf005

好好学习天天向上