! K6 Q+ J7 G: F7 q$ n
; W7 u, f( z0 B0 e1 T2 i特别说明：完整STemWin的1-60期教程和配套实例下载地址：链接

第28章 STemWin多任务设计（模拟器）

/ R# E: i& \& ^  Z; t

    本期教程主要是跟大家讲一下STemWin多任务的设计，官方手册对于这部分内容在开头的时候讲的非常好，本期教程主要是把这部分内容给大家做个介绍，并在模拟器上跑一下多任务。

    28. 1  单任务系统（超级循环）

    28. 2 多任务系统：一个任务调用emWin

    28. 3 多任务系统：多个任务调用emWin

    28. 4 官方推荐运行方式

    28. 5 运行多任务（模拟器）

    28. 6 总结

28.1 单任务系统（超级循环）

    STemWin可以配置为不使用RTOS，这时就是整个程序在一个超循环中运行。通常，软件的所有组件都进行周期性调用。因为未使用实时内核，所以软件的实时部分必须使用中断。此类型系统主要用于小型系统，或者实时操作特性无关紧要时。平时大家写裸机程序的时候基本都是下面这种方式：

1. void main (void)
   
2. {
   / d- V8 z% y! s
3.      /* 初始化硬件 */
   
4. HARDWARE_Init();
   , t' z: A% ]3 ]7 i, m* {0 f
5. 
   
6. /* 初始化软件组件 */
   0 _% d& K& L0 ~$ q
7. XXX_Init();
   
8. YYY_Init();
   
9. 
   2 J  U+ q5 |  C1 W6 I- }
10. /* 超级循环: 规则的调用所以软件组件*/
    ! N* Q7 ]! I. P
11. while (1)
    
12. {
    % f8 @. }0 A6 m1 l
13. /* Exec all compontents of the software */
      h" N' @: O8 A; M1 n* m
14. XXX_Exec();
    
15. YYY_Exec();
    9 P; @2 X5 ~1 D# A
16. }
    
17. }

复制代码

加入了STemWin的初始化函数后就是下面这样：

1. void main (void)
   
2. {
   
3.      /* 初始化硬件 */
   - H5 s) _" R% t# w2 h! W- |
4. HARDWARE_Init();
   9 m% O( `2 [+ C7 r
5. 
   0 R' D( {2 `6 \0 o
6. /* 初始化软件组件 */
   
7. XXX_Init();
   
8. YYY_Init();
   
9. GUI_Init();  //初始化emWin
   6 o# |) ]0 D7 \: I
10. 
    " ?5 y+ w" Z7 [9 v6 Z+ e* i- N! L
11. /* 超级循环: 规则的调用所以软件组件*/
    
12. while (1)
    
13. {
    
14. /* Exec all compontents of the software */
    ! V. U' x- C+ J; M
15. XXX_Exec();
    ; x4 ]/ ]& H0 x4 m4 u% k8 |  h
16. YYY_Exec();
    
17. GUI_Exec(); //调用刷新函数
    ) Q4 ?! S( I' Q. K& R1 J
18. }
    . h7 z1 X* W9 L% m3 n
19. }

复制代码

    关于emWin的使用没有实际的限定。照例，需要在调用GUI_Init()之后才能使用该软件。之后，任何API函数都可使用。如果使用了窗口管理器的回调机制，则必须定期调用emWin更新函数。这通常通过从超循环内调用GUI_Exec()来完成。各种模块化函数，如GUI_Delay()和GUI_ExecDialog()不应在循环中使用，因为它们会阻断其它软件模块。可使用不支持多任务(#define GUI_OS 0)的默认配置；不需要内核接口例程。

l 优点

    因为未使用实时内核 （->较小的ROM大小，仅一个堆栈->用于堆栈的RAM较少），所以不存在使用RTOS中的抢先/同步问题。

l 缺点

    超循环类型程序的大小如果超出某个值，会变得很难维护。实时特性较差，因为一个软件组件无法被任何其它组件中断 （只能通过中断）。这意味着一个软件组件的反应时间取决于系统中所有其它组件的执行时间。

28.2 多任务系统：一个任务调用emWin

    使用了实时内核(RTOS)。用户程序分成不同部分，在不同的任务中执行，这些任务通常具有不同的优先级。通常，实时关键任务 （需要一定的反应时间）将具有最高优先级。一个单任务用于用户界面，它调用emWin函数。此任务在系统中通常具有最低优先级，或至少是最低优先级任务中的一个（一些统计任务或简单的空闲时间处理可能具有更低的优先级）。中断可以但不是必须用于软件的实时部分。

    如果使用了窗口管理器的回调机制，则必须从调用emWin的任务定期调用emWin更新函数（通常为GUI_Exec()、GUI_Delay()）。 由 于emWin仅由一个任务调用，所以对于emWin而言，它与在单任务系统中的使用是相同的。可使用不支持多任务(#define GUI_OS 0)的默认配置；不需要内核接口例程。可使用任何实时内核，商用的或专用的。

l 优点

    该系统的实时特性非常优秀。任务的实时特性仅受以较高优先级运行的任务的影响。这意味着对在低优先级任务中运行的程序组件的更改完全不会影响实时特性。如果从低优先级任务执行用户界面，则意味着用户界面的更改不影响实时特性。因此，使用这种系统可轻松将软件的不同组件分配给开发团队的不同成员，成员彼此间可以高度独立地工作。

l 缺点

    用户需要拥有实时内核(RTOS)，这需要资金并会耗费ROM和RAM（用于堆栈）。此外，还必须考虑任务的同步，以及如何将信息从一个任务传输到另一个任务。

28.3 多任务系统：多个任务调用emWin

    使用了实时内核(RTOS)。用户程序分成不同部分，在不同任务中执行，这些任务通常具有不同的优先级。通常，实时关键任务 （需要一定的反应时间）将具有最高优先级。多个任务用于用户界面，调用emWin函数。这些任务在系统中通常具有低优先级，所以它们不影响系统的实时特性。中断可以但不是必须用于软件的实时部分。

    如果使用了窗口管理器的回调机制，则必须从调用emWin的一个或多个任务定期调用emWin更新函数 （通常为GUI_Exec()、GUI_Delay()）。不可使用不支持多任务(#define GUI_OS 0)的默认配置。配置需要启用多任务支持并定义从中调用emWin的任务的最大数目 （摘自GUIConf.h）：

         #define GUI_OS 1 // Enable multitasking support

        #define GUI_MAX_TASK 5 // Max. number of tasks that may call emWin

内核接口例程是必需的，并需要与正在使用的内核匹配。可使用任何实时内核，商用的或专用的。

l 优点

    该系统的实时特性非常优秀。任务的实时特性仅受以较高优先级运行的任务的影响。这意味着对在低优先级任务中运行的程序组件的更改完全不会影响实时特性。如果从低优先级任务执行用户界面，则意味着用户界面的更改不影响实时特性。因此，使用这种系统可轻松将软件的不同组件分配给开发团队的不同成员，成员彼此间可以高度独立地工作。

l 缺点

    用户必须拥有实时内核(RTOS)，这需要资金并会耗费部分ROM和RAM（用于堆栈）。此外，还必须考虑任务的同步，以及如何将信息从一个任务传输到另一个任务。

28.4 官方推荐运行方式

    上面介绍了三种STemWin的运行方式，下面介绍下官方推荐的运行方式：

l 仅从一个任务调用emWin更新函数（即GUI_Exec()、GUI_Delay()），这有助于保持程序结构清晰。如果在您的系统中有足够的RAM，则指定一个任务 （具有最低优先级）来更新emWin。如下面示例所示，此任务将不断调用GUI_Exec()，且不进行任何其它操作。

l 保持实时任务 （它们确定I/O、接口、网络等方面的系统特性）与调用emWin的任务分开，这有助于确保最佳的实时性能。

l 如果可能，仅为用户界面使用一个任务，这有助于保持程序结构简单并简化调试工作。（当然，这不是必须的，而且可能在一些系统中不适合。）

官方推荐的这几点比较的笼统，后面我会在教程中再跟大家详细讲解。

28.5 运行多任务（模拟器）

    这个例子在模拟器中的位置：

    实际运行效果如下：

下面把相关的代码跟大家解释下：

1. #ifndef SKIP_TEST
   : N. O: W6 l) E0 Y2 B, E9 x
2. #include <stddef.h>
   
3. #include "GUI.h"
   
4. #include "FRAMEWIN.h"
   
5. 
   
6. #if GUI_OS == 0
   / t9 L# M. \- `( r$ F
7.   #error Multitasking sample requires task awareness (#define GUI_OS 1)
   
8. #endif
   
9. 
   
10. /*******************************************************************
    + Y8 M' L8 f# n, R, A4 H
11. *
      G7 d8 h) G  t+ C
12. *       Define how to create a task and start multitasking
    
13. *
    
14. ********************************************************************
    ' d' P" {) d; V
15. */
    
16. #ifndef WIN32
    0 `6 O4 L; U( y; X7 `# m! ^
17.   #include "RTOS.h"    /* Definitions for embOS */
    " }6 ]2 E. ~; S/ _$ x7 @7 k0 v
18.   #define CREATE_TASK(pTCB, pName, pFunc, Priority, pStack)  OS_CREATETASK(pTCB, pName, pFunc, Priority, pStack)
    
19.   #define START_MT()  OS_Terminate(0)
    
20.   #define Delay(t)    OS_Delay(t)
    $ S& [: F, k' c: l& [
21. #else
    % {8 V5 f  [# {$ c; z& g+ o$ h- Y
22.   #include "SIM.h"     /* Definitions for the Win32 simulation */
    / j* Q6 H# b& E; K- C
23.   #define CREATE_TASK(pTCB, pName, pFunc, Priority, pStack)   SIM_CreateTask(pName, pFunc)
    ; }" p9 J( K: ^6 m  p* W* r
24.   #define START_MT()  SIM_Start()
    4 C8 n" ^8 C. u/ N( i# j3 d
25.   #define Delay(t)    SIM_Delay(t)
    
26. #endif
    9 F8 D0 q8 B9 ^% u: v7 J
27. 
    1 h1 {" t2 e7 V
28. /*******************************************************************
    
29. *
    
30. *       Static data
    
31. *
    " m' H0 l, S% M" g4 X! o
32. ********************************************************************
    
33. */
    
34. #ifndef WIN32
    
35.   //
    
36.   // Stacks
    
37.   //
    
38.   static OS_STACKPTR int Stack_0[600];
    
39.   static OS_STACKPTR int Stack_1[600];
    9 P7 b. _7 e) T2 F- l$ O
40.   static OS_STACKPTR int Stack_2[600];
    : F+ y; q) W( r1 y, [, `# u
41.   static OS_TASK aTCB[3];               // Task control blocks
    3 z/ K. d2 l8 J# k0 O  _
42. #endif
    
43. 
    
44. /*******************************************************************
    
45. *
    
46. *       Static code
    + J5 o! B" U% w
47. *
    ' Z4 _- W! h2 K1 ^9 R
48. ********************************************************************
    
49. */
    " Q' ^, p5 p* }4 ?* Z; J3 J* y: |) ~
50. /*******************************************************************
    
51. *
    
52. *       _cbCallbackT0
    8 X2 y$ w: \8 n9 _. y& m: H
53. */
    
54. static int XPos;
    
55. static const char aText[] = "Moving text...";
    & L% b, W. P/ ]" M2 J. r+ h
56. 
    
57. static void _cbCallbackT0(WM_MESSAGE * pMsg) {（1）
    
58.   switch (pMsg->MsgId) {
    
59.   case WM_PAINT:
    
60.     //
    
61.     // Handle the paint message
    5 N; I# q7 z0 z) q% n( d( u% c$ T
62.     //
    
63.     GUI_SetBkColor(GUI_RED);
    & I0 ]$ J+ B8 v# ?" h! R
64.     GUI_SetColor(GUI_BLACK);
    & X+ N' e+ B& R8 d  N( o
65.     GUI_SetFont(&GUI_FontComic24B_ASCII);
    
66.     GUI_Clear();
    
67.     GUI_DispStringAt(aText, XPos, 0);
    5 W6 Z7 S2 Z2 G" J5 S9 V# q
68.     break;
    - J& P2 x% u  C3 E4 J2 B
69.   default:
    
70.     WM_DefaultProc(pMsg);
    % U6 s+ R4 ]( v3 p2 X" s/ ?( q
71.   }
    
72. }
    ! F  U  ^8 k0 P! [1 O
73. 
    
74. /*******************************************************************
    1 J# a3 w  c1 i2 k9 N
75. *
    ( Q! A) l& O  [/ P
76. *       _cbCallbackT1
    
77. */
    5 ^4 f( n0 Y  u1 b; P  o' [
78. static void _cbCallbackT1(WM_MESSAGE * pMsg) {（2）
    # }: m/ ]: |, U6 u. ?5 }$ t( Y' a
79.   WM_HWIN hWin = (FRAMEWIN_Handle)(pMsg->hWin);
    
80.   switch (pMsg->MsgId) {
    
81.   case WM_PAINT:
    
82.     //
    
83.     // Handle the paint message
    
84.     //
    ' [3 g4 w* f7 l) g; R
85.     GUI_SetBkColor(GUI_BLUE);
    
86.     GUI_SetColor(GUI_WHITE);
    + X3 Z% F# y3 m) O9 O) D
87.     GUI_SetFont(&GUI_FontComic24B_ASCII);
    
88.     GUI_SetTextAlign(GUI_TA_HCENTER | GUI_TA_VCENTER);
    , ]2 ]+ p9 {" u" V2 J; L+ \
89.     GUI_Clear();
    
90.     GUI_DispStringHCenterAt("Moving window...",
    ' }* j5 \5 ^. _- L" B( G; b
91.                             WM_GetWindowSizeX(hWin) / 2,
    
92.                             WM_GetWindowSizeY(hWin) / 2);
    % r* j9 e  {* V2 K: V) h, P- k$ X
93.     break;
    5 b3 N% P4 u4 M$ U/ @
94.   default:
    
95.     WM_DefaultProc(pMsg);
    , y' ]. h" r- U' k& q) V
96.   }
    
97. }
    $ m6 M, [* o" p/ F& y
98. 
    $ P( G5 W& L5 l9 g7 v) U& X6 z
99. /*******************************************************************
    
100. *
     
101. *       _cbBackgroundWin
     / u/ R) @2 l, |4 b8 ^
102. */
     1 l  y3 p1 d- a# I# C
103. static void _cbBackgroundWin(WM_MESSAGE* pMsg) {（3）
     
104.   switch (pMsg->MsgId) {
     ' c7 h4 r. y7 d( r' E+ u
105.   case WM_PAINT:
       o6 O' ~5 G: H- I" G
106.     //
     
107.     // Handle only the paint message
     
108.     //
     ) `* O$ {9 t; i# A" g/ Q
109.     GUI_SetBkColor(0x00CC00);
     
110.     GUI_Clear();
     
111.     GUI_SetFont(&GUI_Font24_ASCII);
     
112.     GUI_DispStringHCenterAt("emWin - multitasking demo\n", 160, 5);
     
113.     GUI_SetFont(&GUI_Font13_1);
     6 A; E/ Z8 L7 l2 [. K: f, T
114.     GUI_DispStringAt("Scrolling text and moving windows without flickering", 5, 35);
     
115.   default:
     - h0 U4 k" L% K4 w1 r' q+ H
116.     WM_DefaultProc(pMsg);
     # K4 [  w& K2 O. q+ [: m
117.   }
     4 Y" T. ?4 M- }+ z6 N4 ?3 b
118. }
     9 h" ]/ J+ V& Y$ o1 Z% t
119. 
     
120. /*******************************************************************
     
121. *
     8 C9 u# w" D( M7 o" b
122. *       _Task_0
     4 y3 [. ]& [/ k0 b* [6 Q
123. */
     7 L1 \* k& j1 X9 `0 M
124. static void _Task_0(void) {（4）
     $ ^% w! e! b9 U$ K5 N
125.   //
     
126.   // Create frame window
     
127.   //
     
128.   FRAMEWIN_Handle hFrameWin = FRAMEWIN_Create("Task 0",  NULL, WM_CF_SHOW | WM_CF_STAYONTOP,  0, 70, 200, 40);
     
129.   //
     7 W( P9 u$ g/ d
130.   // Create child window
     
131.   //
     
132.   WM_HWIN         hChildWin = WM_CreateWindowAsChild(0, 0, 0, 0, WM_GetClientWindow(hFrameWin),
     
133.                                                      WM_CF_SHOW | WM_CF_MEMDEV,  _cbCallbackT0, 0);
     
134.   FRAMEWIN_SetActive(hFrameWin, 0);
     " h4 R% X7 t$ y: W2 W6 A1 S6 X
135.   //
     . l8 T  G+ I# Q
136.   // Make sure the right window is active...
     
137.   //
     ( b4 x) [" e- v& b: U. f
138.   WM_SelectWindow(hChildWin);
     
139.   //
     
140.   // ...and the right font is selected
     ! ?! W% v# }" p; a/ l. T
141.   //
     
142.   GUI_SetFont(&GUI_FontComic24B_ASCII);
     4 x- m# m6 `. S4 R% C- d5 K; p
143.   while(1) {
     
144.     GUI_RECT Rect;
     7 f; q, }+ q/ X9 @4 i  x5 \
145.     int XLen;
     
146. 
     
147.     XLen = GUI_GetStringDistX(aText);       // Get the length of the string
     ! h' d* l' g- D5 C, I4 i
148.     WM_GetClientRect(&Rect);                // Get the size of the window
     
149.     //
     # @* s/ o" ^, x4 v
150.     // Show moving text
     + t6 u% c% Y. ^& [3 Q& ?
151.     //
     
152.     for (XPos = 0; XPos < (Rect.x1 - Rect.x0) - XLen; XPos++) {
     " |, [, G/ L* C% X
153.       WM_InvalidateWindow(hChildWin);
     9 q7 W) Z9 z0 l$ f
154.       Delay(50);
     , d. y! {+ [3 U4 [6 [* s
155.     }
     
156.     for (; XPos >= 0; XPos--) {
     
157.       WM_InvalidateWindow(hChildWin);
     
158.       Delay(100);
     
159.     }
     
160.   }
     ' I& P, B3 r6 P# r
161. }
     $ j8 d0 n8 y; {" U! B: y
162. 
     % q, j9 q8 ^: l5 S# k7 V
163. /*******************************************************************
     / M8 A" p4 ~, a6 d
164. *
     ! F: y  f4 k' x: e
165. *       _Task_1
     3 }' `( V8 ~* S2 u6 c% ?
166. */
     
167. static void _Task_1(void) {（5）
     
168.   //
     
169.   // Create frame window
     
170.   //
     
171.   FRAMEWIN_Handle hFrameWin = FRAMEWIN_Create("Task 1", NULL, WM_CF_SHOW | WM_CF_STAYONTOP,
     
172.                                               20, 170, 200, 40);
     , S( n% @5 p! \. p; o
173.   //
     
174.   // Create child window
     
175.   //
     ( ^! ?4 Q2 J' s3 W1 v9 U( y
176.   WM_HWIN hChildWin = WM_CreateWindowAsChild(0, 0, 0, 0, WM_GetClientWindow(hFrameWin), WM_CF_SHOW | WM_CF_MEMDEV,
     
177.                                              _cbCallbackT1, 0);
     
178.   FRAMEWIN_SetActive(hFrameWin, 0);
     
179.   while(1) {
     
180.     int i;
     1 h- [5 Z# R5 K/ c1 E
181.     int nx = 80;
     
182.     int ny = 90;
     6 A6 e: ]; H- [# {" {: v- e% f
183.     //
     2 i6 {7 n( D( A  q" R) v  \
184.     // Move window continously
     8 f3 C$ I( b5 N! y- ?/ t/ N/ Y) O
185.     //
     
186.     for (i = 0; i < ny; i++) {
     4 |0 \6 o. O# l" W8 y  N: o3 _
187.       WM_MoveWindow(hFrameWin, 0, -2);
     & a+ a0 |  W- M) b
188.       Delay(50);
     % P/ }  i* r5 U8 r
189.     }
     
190.     for (i = 0; i < nx; i++) {
     " z7 z- x7 o6 Y# V, z$ b
191.       WM_MoveWindow(hFrameWin, 2, 0);
     7 j) O# I# P; V8 Q+ I
192.       Delay(50);
     $ h7 u. K8 ]3 G/ L# G$ F
193.     }
     , ~! u; `+ e% u& r8 n  {; H
194.     for (i = 0; i < ny; i++) {
     5 y* j" M# k9 Q
195.       WM_MoveWindow(hFrameWin, 0, 2);
     5 {8 r/ Q, J. `1 o' N# W' [9 r
196.       Delay(50);
     ; s8 l6 {, E$ T0 p: w0 |" l
197.     }
     , |, I4 U0 }+ [) B
198.     for (i = 0; i < nx; i++) {
     
199.       WM_MoveWindow(hFrameWin, -2, 0);
     
200.       Delay(50);
     ' l8 U- _2 e/ R# N' l5 [6 g, \* P0 N
201.     }
     
202.   }
     2 ]& `$ w% J% e. q; \
203. }
     . G* p* K0 x' }* G5 l
204. 
     5 L2 \' y. N) U) K) ]: C$ d
205. /*******************************************************************
     
206. *
     
207. *       _GUI_Task
     
208. *
     
209. * This task does the background processing.
     
210. * The MainTask job is to update invalid windows, but other things such as
       Q4 w% K( W( c1 r- O/ ?5 Q
211. * evaluating mouse or touch input may also be done.
     
212. */
     
213. static void _GUI_Task(void) {（6）
     
214.   while(1) {
     
215.     GUI_Exec();           // Do the background work ... Update windows etc.)
     
216.     GUI_X_ExecIdle();     // Nothing left to do for the moment ... Idle processing
     ; B3 u$ ?- r7 o
217.   }
     8 k; ~+ d! m+ n4 }7 s% ]
218. }
     
219. 
     ( X- P5 o+ H. z& v! a3 L
220. 
     / v" S" Z6 }7 ^5 C0 L# {/ x. w
221. /*********************************************************************
     " R3 b/ o; [- `: @1 A
222. *
     
223. *       Public code
     1 T- Q  K( _- D, k
224. *
     . \5 R3 w& S3 P
225. **********************************************************************
     
226. */
     
227. /*********************************************************************
     
228. *
     
229. *       MainTask
     
230. */
     
231. void MainTask(void) {
     6 M* h( w. c) G& Y
232.   //
     
233.   // Init GUI
     / N) X) i1 Z' \  J1 B
234.   //
     
235.   GUI_Init();
       t% F7 z9 b# S2 p, Q
236.   WM_SetCreateFlags(WM_CF_MEMDEV);              // Use memory devices on all windows to avoid flicker
     
237.   WM_SetCallback(WM_HBKWIN, _cbBackgroundWin);  // Set callback for background window
     + k7 S& x3 e& Q; G
238.   //
     + I9 |9 t0 e+ [& Q7 w' L, ^( U
239.   // Create tasks
     
240.   //
     - B4 v3 M% N# T* F+ o# `! E/ d
241.   CREATE_TASK(&aTCB[0], "Task_0",   _Task_0,   80, Stack_0);（7）
     % ^# F4 g4 E& _7 D
242.   CREATE_TASK(&aTCB[1], "Task_1",   _Task_1,   60, Stack_1);
     
243.   CREATE_TASK(&aTCB[2], "GUI_TASK", _GUI_Task,  1, Stack_2);
     ! \/ `* n  w- a, O9 v5 V
244.   //
     
245.   // Start multitasking
     
246.   //
       u( y; M8 t4 ~9 H" A
247.   START_MT();
     4 \; r6 z( i! _  I% ?. y( }/ p
248. }
     
249. 
     . h+ u+ K4 W0 k- {8 e
250. #endif

复制代码

跟大家讲这个DEMO，主要是想让大家对emWin的多任务框架有个了解，对于初学者可以不必了解主要是实现了什么功能。但必须得知道这个多任务实现的框架。

1. 任务0所创建窗口的回调函数。

2. 任务1所创建窗口的回调函数。

3. 桌面窗口的回调函数。

4. 任务0所跑的具体函数

5. 任务1所跑的具体函数。

6. 这个任务专门用emWin的刷新。

7. 创建三个任务。

28.6 总结

    本期教程就跟大家讲这么多，大家要认真的学习一下本期教程开头对emWin多种运行方式的介绍。

好教程  沙发！

这么好的资料，学习一下

学习了，感谢大神分享！

好资料，收藏了哈