【转】3-单片机的非OS的事件驱动

3-单片机的非OS的事件驱动

Part 1　　前言

　　很多单片机项目恐怕都是没有操作系统的前后台结构，就是main函数里用while无限循环各种任务，中断处理紧急任务。这种结构最简单，上手很容易，可是当项目比较大时，这种结构就不那么适合了，编写代码前你必须非常小心的设计各个模块和全局变量，否则最终会使整个代码结构杂乱无序，不利于维护，而且往往会因为修改了某部分代码而莫名其妙的影响到其他功能，而使调试陷入困境。
　　改变其中局面的最有效措施当然是引入嵌入式操作系统，但是大多数的操作系统都是付费的（特别是商业项目）。我们熟悉的uc-os/II如果你应用于非商业项目它是免费的，而应用于商业项目的话则要付费，而且价格不菲。
　　我们也可以自己编写一套嵌入式OS，这当然最好了。可要编写一套完整的OS并非易事，而且当项目并不是非常复杂的话也不需要一个完整的os支持。我们只要用到OS最基本的任务调度和上下文切换就够了。正是基于这样的想法，最近的一个项目中我就尝试采用事件驱动的思想重新构建了代码架构，实际使用的效果还不错，在这里做个总结。
　　本质上新架构仍然是前后台结构，只不过原来的函数直接调用改成通过指向函数的指针来调用。实际上这也是嵌入式OS任务调度的一个核心。C语言中可以定义指向函数的指针：
　　void (*handle)(void);
　　这里的handle就是一个指向函数的指针，我们只要将某函数的函数名赋给该指针，就能通过实现函数的调用了：

1 void func1(void)
2 {
3      // Code
4 }
5 
6 handle = func1;
7 (*handle)(); // 实现func1的调用

　　有了这个函数调用新方法，我们就可以想办法将某个事件与某个函数关联，实现所谓的事件驱动。例如，按键1按下就是一个事件，func1响应按键1按下事件。但是，如果是单纯的调用方法替代又有什么意义呢？这又怎么会是事件驱动呢？关键就在于使用函数指针调用方法可以使模块和模块之间的耦合度将到最低。一个例子来说明这个问题，一个按键检测模块用于检测按键，一个电源模块处理按键1动作。
　　传统的前后台处理方法：
main.c

 1 void main()
 2 {
 3     ...
 4     while(1)
 5     {
 6         ...
 7         keyScan();
 8         if(flagKeyPress)
 9         {
10             keyHandle(); // 检测到按键就设置flagKeyPress标志，进入处理函数
11         }
12     }
13 }

key.c

1 void keyHandle(void)
2 {
3     switch (_keyName) // 存放按键值的全局变量
4     {
5         ...
6         case KEY1: pwrOpen(); break;
7         case KEY2: pwrClose(); break;
8     }
9 }

power.c

1 void pwrOpen(void)
2 {
3     ...
4 }
5 
6 void pwrClose(void)
7 {
8     ...
9 }

　　这样的结构的缺点在哪里呢？
　　1. key代码中直接涉及到power代码的函数，如果power代码里的函数变更，将引起key代码的变更
　　2. 一个按键值对应一个处理函数，如果要增加响应处理函数就要再次修改key代码
　　3. 当项目越来越大时，引入的全局变量会越来越多，占用过多的内存
很显然key模块与其他模块的耦合程度太高了，修改其他模块的代码都势必去修改key代码。理想的状态是key模块只负责检测按键，并触发一个按键事件，至于这个按键被哪个模块处理，它压根不需要知道，大大减少模块之间的耦合度，也减少出错的几率。这不正好是事件驱动的思想吗？
　　接下来，该如何实现呢？

Part 2　　事件驱动的实现

　　需要一个事件队列：
　　u16 _event[MAX_EVENT_QUEUE];
　　它是一个循环队列，保存事件编号，我们可以用一个16位数为各种事件编号，可以定义65535个事件足够使用了。
　　一个处理函数队列：

1 typedef struct 
2 {
3     u16 event; // 事件编号
4     void (*handle)(void); // 处理函数
5 }handleType;
6 
7 handleType _handle[MAX_HANDLE_QUEUE];

　　它实际是一个数组，每个元素保存事件编号和对应的处理函数指针。
　　一个驱动函数：

 1 void eventProc(void)
 2 {
 3     u16 event;
 4     u8 i;
 5 
 6     if((_eventHead!=_eventTail) || _eventFull) // 事件队列里有事件时才处理
 7     {
 8         event = _eq[_eventHead];
 9         _event [_eventHead++] = 0; // 清除事件
10 
11         if(_eventHead>= MAX_EVENT_QUEUE)
12         {
13             _eventHead= 0; // 循环队列
14         }
15         
16          // 依次比较，执行与事件编号相对应的函数
17         for(i=0; i<_handleTail; i++)
18         {
19             if(_handle[i].event == event)
20             {
21                 (*_handle[i].handle)();
22             }
23         }
24     }
25 }

　　main函数可以精简成这样：

1 void main(void)
2 {
3     ...
4     while(1)
5     {
6         eventProc();
7     }
8 }

　　这样代码的缺陷是需要为处理函数队列分配一个非常大的内存空间，项目越复杂分配的空间越大，显然不可取。需要做个变通，减少内存空间的使用量。

Part3　　改进与变通

　　这样代码的缺陷是需要为处理函数队列分配一个非常大的内存空间，项目越复杂分配的空间越大，显然不可取。需要做个变通，减少内存空间的使用量。

1 typedef struct 
2 {
3     void (*handle)(u16 event); // 仅保存模块总的散转函数
4 }handleType;
5 
6 handleType _handle[MAX_HANDLE_QUEUE];

　　修改驱动函数：

 1 void eventProc(void)
 2 {
 3     u16 event;
 4     u8 i;
 5 
 6     if((_eventHead!=_eventTail) || _eventFull) // 事件队列里有事件时才处理
 7     {
 8         ...
 9         
10         for(i=0; i<_handleTail; i++)
11         {
12             (*_handle[i].handle)(event); // 将事件编号传递给模块散转函数
13         }
14     }
15 }

　　把散转处理交回给各模块，例如power模块的散转函数：

1 void pwrEventHandle(u16 event)
2 {
3     switch (event)
4     {
5         ...
6         case EVENT_KEY1_PRESS: pwrOpen(); break;
7         ...
8     }
9 }

　　在power模块的初始化函数中，将该散转函数加入到处理函数队列中：

1  // 该函数在系统初始化时调用
2 void pwrInit(void)
3 {
4     ...
5     addEventListener(pwrEventHandle);
6     ...
7 }

　　addEventListener定义如下：

 1 void addEventListener(void (*pFunc)(u16 event))
 2 {
 3     if(!_handleFull)
 4     {
 5         _handle[_handleTail].handle = pFunc;
 6         _handleTail++;
 7 
 8         if(_handleTail>= MAX_HANDLE_QUEUE)
 9         {
10             _handleFull= TRUE;
11         }
12     }
13 }

 　　每个模块都定义各自的散转处理，然后在初始化的时候将该函数存入处理事件队列中，即能实现事件处理又不会占用很多的内存空间。
　　加入到事件队列需要封装成统一的函数dispatchEven，由各模块直接调用。例如，key模块就可以dispatchEvent(EVENT_KEY1_PRESS)来触发一个事件

 1 void dispatchEvent(u16 event)
 2 {
 3     u8 i;
 4     bool canDispatch;
 5 
 6     canDispatch = TRUE;
 7 
 8     if(!_eventFull)
 9     {
10         // 为了避免同一事件被多次加入到事件队列中
11         for(i=_eventHead; i!=_eventTail;)
12         {
13             if(_event[i] == event)
14             {
15                 canDispatch = FALSE;
16                 break;
17             }
18 
19             i++;
20             if(i >= MAX_EVENT_QUEUE)
21             {
22                 i = 0;
23             }
24         }
25 
26         if(canDispatch)
27        {
28             _event[_eventTail++] = event;
29 
30             if(_eventTail>= MAX_EVENT_QUEUE)
31             {
32                 _eventTail= 0;
33             }
34             if(_eventTail== _eventHead)
35             {
36                 _eventFull = TRUE;
37             }
38         }
39     }
40 }

part 4　　深一步：针对与时间相关的事件

 　　对于与时间相关的事件（循环事件和延时处理事件）需要做进一步处理。
 　　首先要设定系统Tick，可以用一个定时器来生成，例如配置一个定时器，每10ms中断一次。
 　　注：tick一般指os的kernel计时单位，用于处理定时、延时事件之类。一般使用硬件定时器中断处理tick事件
 　　定义一个时间事件队列：

1 typedef struct
2 {
3     u8 type;   // 事件类别，循环事件还是延时事件
4     u16 event; // 触发的事件编号
5     u16 timer;   // 延时或周期时间计数器
6     u16 timerBackup; // 用于周期事件的时间计数备份
7 }timerEventType;
8 
9 timerEventType _timerEvent[MAX_TIMER_EVENT_Q];

 　　在定时器Tick中断中将时间事件转换成系统事件：

 1 void SysTickHandler(void)
 2 {
 3     ...
 4     for(i=0; i<_timerEventTail; i++)
 5     {
 6         _timerEvent[i].timer--;
 7         if(_timerEvent[i].timer == 0)
 8         {
 9             dispatchEvent(_timerEvent[i].event);// 事件触发器
10 
11             if(_timerEvent[i].type == CYCLE_EVENT)
12             {
13                 // 循环事件，重新计数
14                 _timerEvent[i].timer = _timerEvent[i].timerBackup;
15             }
16             else
17             {
18                 // 延时事件，触发后删除
19                 delTimerEvent(_timerEvent[i].event);
20             }
21         }
22     }
23 }

　　将增加和删除时间事件封装成函数，便以调用：

 1 void addTimerEvent(u8 type, u16 event, u16 timer)
 2 {
 3      _timerEvent[_timerEventTail].type = type;
 4      _timerEvent[_timerEventTail].event = event;
 5      _timerEvent[_timerEventTail].timer = timer; // 时间单位是系统Tick间隔时间
 6      _timerEvent[_timerEventTail].timerBackup = timer; // 延时事件并不使用
 7      _timerEventTail++;
 8 }
 9 
10 void delTimerEvent(u16 event)
11 {
12     ...
13     for(i=0; i<_timerEventTail; i++)
14     {
15         if(_timerEvent[i].event == event)
16         {
17             for(j=i; j<_timerEventTail; j++)
18             {
19                 _timerEvent[j] = _timerEvent[j+1];
20             }
21 
22             _timerEventFull= FALSE;
23             _timerEventTail--;
24         }
25     }
26 }

 　　对于延时处理，用事件驱动的方法并不理想，因为这可能需要将一段完整的代码拆成两个函数，破坏了代码的完整性。解决的方法需要采用OS的上下文切换，这就涉及到程序堆栈问题，用纯C代码不容易实现。

 

——【感谢】资料来源于https://wenku.baidu.com/view/5465391d10a6f524ccbf8591.html 

posted on 2017-08-27 17:27  Engraver  阅读(2800)  评论(0)  编辑  收藏  举报

导航