《K64进阶笔记》节选-嵌入式系统软件的典型开发框架(4)

suyong_yq

嵌入式系统软件的典型开发框架

• 基本的超循环结构
• 使用中断的前后台结构
• 完全依赖中断的事件驱动系统
• 状态机驱动系统——玩转按键
• 总结
  

4. 状态机驱动系统


4.1 程序结构

状态机驱动系统是在前后台系统的基础之上，显式指定了一组专用状态标志描述系统当前所处的状态，从而根据状态进入对应的程序执行流程的系统结构。同样是基于前后台系统，“事件驱动系统”将响应事件与处理事件的过程都放在中断服务程序中执行，而通常情况下，“状态机驱动系统”的中断服务程序只是用来改变状态标志的值，即维护“状态机”的状态，而对事件的处理过程则交由后台运行在超循环中的“调度器”根据“状态机”的状态进行分派。


图4

“事件驱动系统”和“状态机驱动系统”都是对前后台系统的具体应用，在前后台系统的基础之上增加了不同设计应用程序的约束条件。“事件驱动系统”强化了前台程序，侧重于对外部事件的响应。“状态机驱动系统”是在后台程序中的超循环进行了强化，这样就可以由CPU主导，完成更加复杂的处理流程。而相对于基本的前后台系统设计，每个子任务的设计思路变得更加清晰：在前台沟通外部事件同状态机交互，更新状态机的状态；在后台根据状态机的状态执行处理。

由于基于状态机的程序结构对硬件依赖小，同时又将复杂的程序结构划分成了一个个相对独立的任务，很容易地将复杂的功能分解成多个独立的功能，使得整个功能易于实现。因此，有很多协议栈在实现时，都选择使用状态机模型搭建框架结构。最典型的就是RTOS，任务调度器就是一个状态机解析器。

4.2 样例程序

这里通过设计一个机械按键的检测程序来说明状态机设计结构的用法。

在这个案例中，封装了一个按键组件“Key”。在应用按键时，程序使用定时器周期扫描按键引脚的输入电平，形成按键输入逻辑电平的采样流，采样波形中包含“按键抖动”。可以由按键组件实时地处理按键采样的波形，通过延时滤波器过滤掉“按键抖动”，然后由状态机实时地识别按键的按下、短按弹起、长按、连击、长按弹起等事件，最后交由超循环响应按键事件。

在这个案例中，分别在延时滤波器、检测按键事件及在超循环中对按键事件的处理上分别都用到了状态机的设计方法。

【延时滤波器】

使用延时滤波器对按键引脚采样流进行预处理，是为了过滤掉“按键抖动”，从而简化后续按键事件的检测
。
“延时滤波”使用的是比较“保守”的状态判决策略：只有当输入信号稳定在另一个状态足够长时间后，才进行状态跃迁，否则保持原状态。
在“延时滤波器”的状态机中，有三种状态：当前稳定状态、下一个可能的稳定状态和无效状态，它们在获得新的信号输入之后进行切换。通过代码清单可以说明其中的变化过程。

1. typedef struct
   
2. {
   
3.     /* 用户配置属性 */
   
4.     uint32_t FilterCountMax; /* 滤波计数，只有当输出值保持足够长时间之后才发生变化 */
   
5.     /* 内部统计信息 */
   
6.     uint32_t StableValue; /* 当前输出值 */
   
7.     uint32_t NextValue; /* 检测最新的输出值，只有当输出值保持足够长时间后才切换此值 */
   
8.     uint32_t AccCounterForNextValue; /* 新值保持的时间 */
   
9. } Filter_Handler_T;
   
10. 
    
11. void Filter_Init(Filter_Handler_T *handler, uint32_t initValue, uint32_t filterCount)
    
12. {
    
13.     assert(NULL != handler);
    
14.     /* 保存用户属性. */
    
15.     handler->FilterCountMax = filterCount-1U;
    
16.     /* 初始化统计信息. */
    
17.     handler->StableValue = initValue;
    
18.     handler->NextValue = initValue;
    
19.     handler->AccCounterForNextValue = 1U;
    
20. }
    
21. 
    
22. uint32_t Filter_GetFiltedOutput(Filter_Handler_T *handler, uint32_t curUnfiltedValue)
    
23. {
    
24.     if (curUnfiltedValue != handler->StableValue)
    
25.     {
    
26.         if (curUnfiltedValue != handler->NextValue)
    
27.         {
    
28.             handler->NextValue = curUnfiltedValue;
    
29.             handler->AccCounterForNextValue = 1U;
    
30.         }
    
31.         else
    
32.         {
    
33.             if (handler->AccCounterForNextValue < handler->FilterCountMax)
    
34.             {
    
35.                 handler->AccCounterForNextValue++;
    
36.             }
    
37.             else
    
38.             {
    
39.                 handler->StableValue = handler->NextValue;
    
40.             }
    
41.         }
    
42.     }
    
43.     return handler->StableValue;
    
44. }
    

复制代码

【检测按键事件】

为了满足检测按键事件的需求，需要首先定义出按键的静态状态模式，只有在按键的静态状态之间相互切换时，才会产生事件。具体的，这里首先对按键的事件模式进行描述，如下：
- 按下事件 - 按键从未按下状态到按下状态转换的过程。
- 短按弹起事件 - 按键从按下状态返回到未按下状态，在按下状态保持事件未达到长按事件需要的时间长度。
- 首次长按事件 - 在首次切换到按下状态后（按下事件），连续保持一段时间，达到长按事件需要的时间长度。
- 连击事件 - 在长按事件发生后，继续保持按下状态，继续保持了一段时间。连击事件是长按事件的一个细分的事件。
- 长按弹起事件 - 在长按事件（包括连击事件）发生后，按键弹起。
通过对按键事件的明确定义，可以确定需要检测到按键输入流的几种稳定的状态模式，包括：按下状态、未按下状态、长按状态、连击状态。状态之前切换的过程发生事件。特别地，在连击状态下，为了产生变化以触发事件的发生，将连击状态分为连击A和连击B，这两个连击状态相互切换也可以产生连续的连击事件。状态及状态变化产生的事件如图5所示。



图5

1. typedef enum
   
2. {
   
3.     eKey_State_UnPressed = 0,      /*!< 未按下状态 */
   
4.     eKey_State_FirstPressedDown,   /*!< 进入长按状态之前的按下状态 */
   
5.     eKey_State_InLongPressedDownA, /*!< 长按A状态 */
   
6.     eKey_State_InLongPressedDownB, /*!< 长按B状态 */
   
7. } Key_State_T;
   
8. 
   
9. typedef enum
   
10. {
    
11.     eKey_Event_Nothing = 0,
    
12.     eKey_Event_PressedDownEdge,         /*!< 按下事件 */
    
13.     eKey_Event_PressedDownLongFirst,    /*!< 首次检测到长按事件 */
    
14.     eKey_Event_PressedDownLongContinue, /*!< 长按状态下的连击事件 */
    
15.     eKey_Event_PressedUpEdgeShort,      /*!< 短按弹起事件 */
    
16.     eKey_Event_PressedUpEdgeLong,       /*!< 长按弹起事件 */
    
17. } Key_Event_T;
    
18. 
    
19. /* Keep all the static variable and information for each key. */
    
20. typedef struct
    
21. {
    
22.     /* State. */
    
23.     Key_State_T PreState;
    
24.     Key_State_T CurState;
    
25. 
    
26.     /* Attr. */
    
27.     uint32_t PressedDownLongMaxFirst; /* To detect the start of long pressed. */
    
28.     uint32_t PressedDownLongMaxContinue;  /* To detect the continue long pressed. */
    
29. 
    
30.     /* Condition. */
    
31.     uint32_t PressedDownCounter; /* Count for the period that keeping the key pressed. */
    
32.     uint32_t PressedDownStepCounter;
    
33. 
    
34. } Key_Handler_T;
    
35. 
    
36. Key_State_T Key_GetState(Key_Handler_T *handler, bool isKeyDown)
    
37. {
    
38.     /* 保存之前的状态 */
    
39.     if (handler->PreState != handler->CurState)
    
40.     {
    
41.         handler->PreState = handler->CurState;
    
42.     }
    
43.     /* 查看最新状况，进行状态切换 */
    
44.     switch (handler->CurState)
    
45.     {
    
46.         case eKey_State_UnPressed:
    
47.             /*
    
48.             在按键未按下的情况下，可能转换到的状态只有两个：
    
49.             - 在检测到按键按下的情况下，转入最初的按下状态；
    
50.             - 在未检测到按键按下的情况下，继续保持未按下的状态。
    
51.             进行一次判断后等待下次按键信号再次进行判断。
    
52.             */
    
53.             if (isKeyDown) /* 在没有按下的情况下检测到按键被按下，转入按下状态。 */
    
54.             {
    
55.                 handler->CurState = eKey_State_FirstPressedDown;
    
56.                 handler->PressedDownCounter++; /* 启动按下计数器。 */
    
57.             }
    
58.             break;
    
59.         case eKey_State_FirstPressedDown:
    
60.             /*
    
61.             在按键最初被按下的状态下，下一个状态可能有三个：
    
62.             - 在检测到按键继续按下并且保持一段足够长的时间之后，可以转换到长按状态；
    
63.             - 在检测到按键继续按下但是并未达到长按事件需要的时间前，保持现状；
    
64.             - 在任何情况下检测到按键弹起，总是还原到未按下状态。
    
65.             */
    
66.             if (isKeyDown) /* 在最初的按下之后继续坚持按下，有机会发展为长按事件。 */
    
67.             {
    
68.                 handler->PressedDownCounter++;
    
69.                 if (handler->PressedDownCounter >= handler->PressedDownLongMaxFirst)
    
70.                 {
    
71.                     handler->CurState = eKey_State_InLongPressedDownA;
    
72.                     handler->PressedDownCounter = 0U; /* 此时计数器转为每个连击事件计数。 */
    
73.                     handler->PressedDownStepCounter++; /* 连击事件计数器开始计数。 */
    
74.                 }
    
75.                 /*
    
76.                 else
    
77.                 {
    
78.                     // 在检测到按键继续按下，但是并未达长按事件切换点时，保持现状。
    
79.                 }
    
80.                 */
    
81.             }
    
82.             else /* 在第一次按下之后没持续多久就按键弹起了？ */
    
83.             {
    
84.                 handler->CurState = eKey_State_UnPressed; /* 切换为弹起状态。 */
    
85.                 handler->PressedDownCounter = 0U; /* 清空按键按下计数器。*/
    
86.                 handler->PressedDownStepCounter = 0U;
    
87.             }
    
88.             break;
    
89.         case eKey_State_InLongPressedDownA:
    
90.             /*
    
91.             在进入长按状态后，实际上只能等着还原回未按下状态或者保持现状了，但实际上为了检测长按过程中的连击过程，必须在长按过程中产生状态切换。为此，这里设计了在长按过程中的A状态和B状态，即使同样在长按过程中，仍然可以A状态和B状态之间相互切换，在切换的时刻产生连击事件。此时，在长按A状态
    
92.             下可以转入的下一状态从两个变成了三个：
    
93.             - 在检测到按键继续按下并保持一段足够长的时间后，达到连击切换点，可以转换到长按B状态；
    
94.             - 在检测到按键继续按下但是并未达到下一个连击切换点时，保持现状；
    
95.             - 在任何情况下检测到按键弹起，总是还原到未按下状态。
    
96.             */
    
97.             if (isKeyDown) /* 在连击状态下的按下之后继续坚持按下，有机会发展为另一个连击事件。 */
    
98.             {
    
99.                 handler->PressedDownCounter++;
    
100.                 if (handler->PressedDownCounter >= handler->PressedDownLongMaxContinue)
     
101.                 {
     
102.                     // 检测到按键继续按下并保持一段足够长的时间后，达到连击切换点，可以转换到长按B状态
     
103.                     handler->CurState = eKey_State_InLongPressedDownB;
     
104.                     handler->PressedDownCounter = 0U; /* 此时计数器转为每个连击事件计数。 */
     
105.                     handler->PressedDownStepCounter++; /* 连击事件计数器开始计数。 */
     
106.                 }
     
107.                 /*
     
108.                 else
     
109.                 {
     
110.                 // 在检测到按键继续按下，但是并未达到下一个连击切换点时，保持现状。
     
111.                 }
     
112.                 */
     
113.             }
     
114.             else /* 在任何情况下检测到按键弹起，总是还原到未按下状态。 */
     
115.             {
     
116.                 handler->CurState = eKey_State_UnPressed; /* 切换为弹起状态。 */
     
117.                 handler->PressedDownCounter = 0U; /* 清空按键按下计数器。*/
     
118.                 handler->PressedDownStepCounter = 0U;
     
119.             }
     
120.             break;
     
121.         /*
     
122.         长按B状态同长按A状态在实际上是一个状态，只是在达到连击切换点时相互切换，所以长按A状态和长按B
     
123.         状态除了相互切换成为彼此的下一个状态之外，一切的判断过程都是完全相同的。
     
124.         */
     
125.         case eKey_State_InLongPressedDownB:
     
126.             if (isKeyDown) /* 在连击状态下的按下之后继续坚持按下，有机会发展为另一个连击事件。 */
     
127.             {
     
128.                 handler->PressedDownCounter++;
     
129.                 if (handler->PressedDownCounter >= handler->PressedDownLongMaxContinue)
     
130.                 {
     
131.                     handler->CurState = eKey_State_InLongPressedDownA;
     
132.                     handler->PressedDownCounter = 0U; /* 此时计数器转为每个连击事件计数。 */
     
133.                     handler->PressedDownStepCounter++; /* 连击事件计数器开始计数。 */
     
134.                 }
     
135.                 /*
     
136.                 else
     
137.                 {
     
138.                     // 在检测到按键继续按下，但是并未达到下一个连击切换点时，保持现状。
     
139.                 }
     
140.                 */
     
141.             }
     
142.             else /* 在任何情况下检测到按键弹起，总是还原到未按下状态。 */
     
143.             {
     
144.                 handler->CurState = eKey_State_UnPressed; /* 切换为弹起状态。 */
     
145.                 handler->PressedDownCounter = 0U; /* 清空按键按下计数器。*/
     
146.                 handler->PressedDownStepCounter = 0U;
     
147.             }
     
148.             break;
     
149.         default:
     
150.             break;
     
151.     }
     
152.     return handler->CurState;
     
153. }
     
154. 
     
155. /* 在状态的切换过程中提取事件 */
     
156. Key_Event_T Key_GetEvent(Key_Handler_T *handler)
     
157. {
     
158.     Key_Event_T retEvent = eKey_Event_Nothing;
     
159. 
     
160.     if (handler->PreState == handler->CurState)
     
161.     {
     
162.         retEvent = eKey_Event_Nothing;
     
163.     }
     
164.     else if ((eKey_State_UnPressed == handler->PreState)
     
165.          && (eKey_State_FirstPressedDown == handler->CurState))
     
166.     {
     
167.         retEvent = eKey_Event_PressedDownEdge;
     
168.     }
     
169.     else if ((eKey_State_FirstPressedDown == handler->PreState)
     
170.          && (eKey_State_InLongPressedDownA == handler->CurState))
     
171.     {
     
172.         retEvent = eKey_Event_PressedDownLongFirst;
     
173.     }
     
174.     else if ( ((eKey_State_InLongPressedDownA == handler->PreState)
     
175.             && (eKey_State_InLongPressedDownB == handler->CurState))
     
176.          || ((eKey_State_InLongPressedDownB == handler->PreState)
     
177.             && (eKey_State_InLongPressedDownA == handler->CurState)) )
     
178.     {
     
179.         retEvent = eKey_Event_PressedDownLongContinue;
     
180.     }
     
181.     else if ( (    (eKey_State_InLongPressedDownB == handler->PreState)
     
182.                 || (eKey_State_InLongPressedDownA == handler->PreState) )
     
183.          && (eKey_State_UnPressed == handler->CurState) )
     
184.     {
     
185.         retEvent = eKey_Event_PressedUpEdgeLong;
     
186.     }
     
187.     else if ((eKey_State_FirstPressedDown == handler->PreState)
     
188.           && (eKey_State_UnPressed == handler->CurState))
     
189.     {
     
190.         retEvent = eKey_Event_PressedUpEdgeShort;
     
191.     }
     
192.     return retEvent;
     
193. }
     

复制代码

【响应按键事件】

按键输入信号使用延时滤波器进行预处理，然后送入按键事件检测状态机中，分析按键事件等，都是实时处理的过程，而对按键事件进行响应属于用户行为，执行时间可能会比较长，执行逻辑也可能比较复杂，所以通常被安排在超循环中。

1. while (1)
   
2. {
   
3.     /* 获得按键事件并处理. */
   
4.     if (!RBUF_IsEmpty(gRingBufHandler))
   
5.     {
   
6.         switch (RBUF_GetDataOut(gRingBufHandler))
   
7.         {
   
8.         case eKey_Event_PressedDownEdge:
   
9.             printf("1:eKey_Event_PressedDownEdge\r\n");
   
10.             break;
    
11.         case eKey_Event_PressedDownLongFirst:
    
12.             printf("2:eKey_Event_PressedDownLongFirst\r\n");
    
13.             break;
    
14.         case eKey_Event_PressedDownLongContinue:
    
15.             printf("3:eKey_Event_PressedDownLongContinue\r\n");
    
16.             break;
    
17.         case eKey_Event_PressedUpEdgeShort:
    
18.             printf("4:eKey_Event_PressedUpEdgeShort\r\n");
    
19.             break;
    
20.         case eKey_Event_PressedUpEdgeLong:
    
21.             printf("5:eKey_Event_PressedUpEdgeLong\r\n");
    
22.             break;
    
23.         default:
    
24.             break;
    
25.         }
    
26.     }
    
27. }
    

复制代码

这里使用了一个循环队列，由扫描按键的定时器中断服务程序将按键事件传递给超循环，是为了避免事件丢失。一般来说，扫描按键的定时器周期是非常短的，若是简单使用通常方法通过全局变量传递数据，一旦按键事件产生并传递给超循环，那么超循环就必须响应并处理完成，若是在接下来连续两次扫描到按键事件之时超循环仍在处理上次按键的事件，表示按键事件的全局变量在保存了第一次事件后，在未得到响应时就会被第二次按键事件冲掉。这样，在超循环处理最早的按键事件时，接下来的第一次按键事件就会被第二次按键事件冲掉，从而产生丢失按键事件的情况。如果超循环中对按键事件的进行处理时间特别长，那么丢失按键的情况也会进一步恶化。因此，在按键的样例程序中使用了循环队列实现了一个按键事件的FIFO，按键事件被缓存在FIFO中，由超循环逐个取出进行处理，确保了不会出现丢失按键事件的情况。

运行使用了延时滤波器和按键状态机的样例程序“Key_StateMachineQueue”，操作渡鸦K64开发板上的KEY1按键，可以通过上位机的串口终端观察到对按键事件的检测情况。


图6

阅读全文

jackten

谢谢分享               

cldym

谢谢分享