RTOS调度+LCD液晶显示模板，使用的是原子的探索者，只所以使用这个来做模板，是在为毕竟NUCLEO上的资源有限，比如FSMC就没法做。而要使用液晶，FSMC还是很有必要的。


$ @, b9 m! L0 G  y# X; U2 G看RTOS的资料看了一段时间，最近才勉强明白了一点，希望和大家一起讨论哈！
7 |& i- _+ @, X4 P
) c' l1 o! _' T; G& v% J高手请多包容，多指导！

: \1 n6 }- m" H1 ?
先看看效果图。
. A7 j2 V. @' O! a( R+ h
& n2 z$ u; i% }


) ]+ V( ~" l% n4 a: E
& c0 r, ^+ M: b

# D$ S& x( B4 i7 D完整的工程可以参考github.com/netlhx/stm32f407，里面的general文件夹包含一个通用的模板，LCD文件夹里将LCD和RTOS的使用结合在一起。

* P# R1 @* [! a% ^8 b后面准备将其它的模块功能添加进来，虽然以前基于NUCLEOF411做了一个模板，最近折腾原子的探索者，所以那一个就没有更新了。

几点说明：
0 m2 w) V3 K5 L! `1. 绘制文字的任务是一个守护者任务（GATEKEEPER TASK），这样输出就不会产生混乱。不过任务在输出实际内容时，每个像素点都带了各自输出的位置，所以如果不使用守护者任务来实现的话，应该也没有问题。这里之所以这样处理，是为了以后的统一处理。
2. 液晶驱动为ILI9341，分辨率为240X320.
3. 没有加注释，大部分代码都比较简单，以后再整理吧
2 u% @/ B$ H6 a: W- g, ^3 b

6 i3 _4 L5 }- r/ I/ `  T实例一 、添加一个日历任务
4 T/ }/ i5 E+ q9 o
1 F. I" b% u9 t, }框架已经搭好，使用RTOS的好处之一在于：每个任务就是一个模块，所以接下来看看如何添加一个日历模块，并在LCD上显示。

添加一个新任务，需要完成下列步骤：
1. 定义一个任务ID，用来对任务进行管理操作，如果不需要管理该任务，也可以跳过这步
2. 设定任务相关参数，如优先级、堆栈大小等
3. 创建任务
* E! q& G2 a) e* J1 Y4. 编写任务函数
- P+ W$ I9 d. c7 ?
  X2 i2 Q! k+ I* q在freertos.c文件中，添加如下


9 W+ c& Y5 \3 m$ ]
' \. d8 h/ t0 Z7 w
9 M" j% h( e9 @  z* [0 i/ j

% K0 ]6 U5 F" M  T6 V
8 W/ w* o8 c# U8 g
! [: X/ ~; l8 f9 O% a. a完整的任务代码：
& C$ |* A/ y6 p& o0 R

1. <p>void StartShowCalendarTask(void const *argument)
   $ L7 M* [- H4 m' Z; {6 R
2. {        
     R3 G$ ~5 n& f) m
3.         char calendarStr[30] = "";
   ; F- [# w3 E- ?7 T
4.         RCC_OscInitTypeDef RCC_OscInitStruct;
   
5.         RCC_PeriphCLKInitTypeDef RCC_PeriphCLKInitStruct;
   
6.                
   , U# [7 x( Q1 \- v6 Y; `
7.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE | RCC_OSCILLATORTYPE_LSI;
   
8.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
   . o; Q' X; R' A! W4 K; g8 K8 ~
9.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
   
10.         RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
    
11.         
    + X! h. G0 }0 @" b3 C  o! m
12.         HAL_RCC_OscConfig(&RCC_OscInitStruct);
    
13.         
    : R- W& L! i% p( j0 `' W2 J
14.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
    
15.         RCC_PeriphCLKInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
    $ m! F7 y4 i4 v3 W  I
16.         
    , Q" P% y1 `7 b) \; I
17.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    2 u6 n+ \( O* X) g9 Z
18.         
    ; X% E7 ~1 F$ o3 |6 L
19.         __HAL_RCC_RTC_ENABLE();
    & F& A( v$ Q7 P9 j3 `
20.         
    ! w. `, p% Y" c, B) s0 ^0 D) U
21.         RtcHandle.Instance = RTC;
    
22.         RtcHandle.Init.HourFormat = RTC_HOURFORMAT_24;
    1 t6 q/ |2 A4 C: w# X
23.   RtcHandle.Init.AsynchPrediv = 127;
    
24.   RtcHandle.Init.SynchPrediv = 255;
    
25.   RtcHandle.Init.OutPut = RTC_OUTPUT_DISABLE;
    
26.   RtcHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
    : \3 I+ \) Y: U1 ~1 v1 U6 Q$ k1 p! Q
27.   RtcHandle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
    
28.         
    ( H& i. C" z6 x& `2 T  h
29.         HAL_RTC_Init(&RtcHandle);
    
30.         
    
31.         if(HAL_RTCEx_BKUPRead(&RtcHandle, RTC_BKP_DR0) != 0x32F2)
    + s( N3 T" x3 D: K
32.   {  
    
33.     /* Configure RTC Calendar */
    ! I  N; G* d# ]3 U) Q1 ?
34.     RTC_CalendarConfig();
    
35.   }
    * ?' j1 u: V3 ?* v) z
36.         
    ! y1 `, o4 P3 p; C8 h4 N: c) m0 S
37.         for(;;)
    
38.         {
    2 ~  J! a- S- z% D% o$ T" ?
39.                 RTC_DateTypeDef sdatestructureget;
    
40.                 RTC_TimeTypeDef stimestructureget;
    
41.                
    ) u' N: y+ q- q; c* ]1 H
42.                 /* Get the RTC current Time */
    $ N/ F5 P3 F! Q) Y* s, M9 r
43.                 HAL_RTC_GetTime(&RtcHandle, &stimestructureget, RTC_FORMAT_BIN);
    
44.                 /* Get the RTC current Date */
    ( ^5 _3 R- ^( r: x+ O  |' S
45.                 HAL_RTC_GetDate(&RtcHandle, &sdatestructureget, RTC_FORMAT_BIN);
    ( X8 b" f) o; x2 `
46.                
    
47.                 /* Display time Format: hh:mm:ss */
    
48.                 sprintf((char*)calendarStr,"%02d:%02d:%02d   %02d-%02d-%04d",stimestructureget.Hours, stimestructureget.Minutes, stimestructureget.Seconds,
    . P4 ?3 A9 q3 l* o- t7 S
49.                         sdatestructureget.Month, sdatestructureget.Date, 2000 + sdatestructureget.Year);
    
50.                 ShowString(10, 60, calendarStr);
    
51.                
    6 e& q3 @0 s6 R' N- j
52.                 osDelay(100);
    " ~6 i' U6 f% e! o
53.         
    " b& w: a) I( n4 S8 y
54.                
    ( d/ a7 X' ~% {
55.         }
    
56.         
    
57. }
    
58. </p><p> </p><p> </p><p>这是任务运行实例效果，外观与没有使用RTOS并没有区别。</p><p> </p><p><img alt="" src="https://www.stmcu.org.cn/module/forum/forum.php?mod=image&aid=344633&size=300x300&key=ef30ab9e6f6ce7f2&nocache=yes&type=fixnone" border="0" aid="attachimg_344633">
    ; ^, ]) `5 M+ W. E
59. </p>

复制代码

; ^7 l2 A3 h' Z) o
$ l: n! ^2 \. d8 w2 K4 j; N) d0 g





+ C8 D1 d# v8 G$ \

( c( y; ~0 n. G7 b  h7 c+ g
1 Y' r0 F! l. s, ?( s# g  O

suzhe_518 发表于 2015-5-29 11:49
不错哦  能否提供些入门资料 谢谢

很不错的资料，E文版
/ W$ K) h' j- o& H$ L* N% Z2 z
rtos.pdf (1.33 MB, 下载次数: 6902)

2015-6-2 20:21 上传

点击文件名下载附件

实例二、加入红外解码，利用红外控制MCU

RTOS支持还是很不错的，加入RTOS之后，所有的任务都是一个独立的模块。

要控制MCU来完成一些任务，主要的方法一般是两个：串口通信、红外遥控。今天来加上红外遥控支持。
1 u0 P8 A0 H+ K2 g7 y0 ]+ _5 y
$ r$ v$ l( i) n: i板载红外支持的协议是NEC协议，所以加上相应的读取值并解码之后，就能得到输入控制码，利用控制码来完成相应的任务即可。
4 O3 C6 F$ x3 U* d" f
+ g/ ~" B% ]9 ^$ Q; x4 u% P先看一个逻辑分析仪抓到的信号
9 u# q0 n. P0 z4 j



7 E: O" {) Y0 y$ ^& X" W
7 E6 g# u4 k) n* F
7 M5 x* n6 h9 Q* k

% l/ e: h2 |: r  e$ o5 m2 M同上一个实例一样，使用任务来处理红外信息。同上一个实例不同的是，加入了中断控制，使用中断来处理编码信息。例程中用到了任务、信号量、队列、中断。上代码，慢慢看
0 s: L9 W3 k1 ^' V2 s
! R  [0 b6 P; W% f9 C( O
" o+ i. T1 N) p6 }

1. #include "FreeRTOS.h"
   
2. #include "task.h"
   
3. #include "cmsis_os.h"
   + F( J( C# M! M0 d" e+ i/ J
4. #include "stm32f4xx_hal.h"
   1 l  x# l  j/ k& M
5. #include "ili9341.h"
   * Z# d3 F9 {! E# C) ]5 @: d
6. #include "string.h"
   3 z' B5 `- B/ A
7. 
   $ U* c0 W6 n1 n% l1 \  P8 t: h
8. extern uint16_t foreColor;
   
9. 
   
10. TIM_HandleTypeDef htim1;
    . e. @- a, b7 Y' D, q; l* y
11. 
    
12. uint8_t irState;
    * a4 G1 }7 y; f2 D
13. uint32_t irData;
    # j4 p; Z% k1 }6 N8 X5 U
14. uint32_t icValue;
    
15. uint8_t irCount;
    
16. 
    
17. 
    
18. osThreadId defaultTaskHandle;
    
19. //osThreadId displayTaskHandle;
    
20. osThreadId drawCharTaskHandle;
    
21. 
    * r0 B5 y6 X1 e$ f
22. //task id
    
23. osThreadId showCalendarHandle;
    
24. osThreadId IrControlHandle;
    % W8 ~) ^* x7 l8 a/ P8 W
25. 
    ' Q8 V4 S# X7 f6 ~* q; ?1 r
26. RTC_HandleTypeDef RtcHandle;
    
27. 
    2 E! t% H. ]; q' `" I
28. //IR SEMAPHORE
    
29. osSemaphoreId irSemHandle;
    
30. 
    0 v# l& B4 t5 b6 v' n
31. static void ShowString(uint16_t x, uint16_t y, char *msg);
    / T6 R6 ?- ^* m9 m3 w$ q9 V
32. 
      i' P7 j. _" b9 b; f
33. 
    
34. //osMessageQId displayQueueHandle;
    
35. osMessageQId charQueueHandle;
    
36. 
    
37. 
    
38. //add your own task definitions
    
39. 
    ' m/ s$ n% k0 {
40. void StartDefaultTask(void const * argument);
    3 H5 I- |1 P" Q8 K( h9 Q/ a
41. //void StartDisplayTask(void const * argument);
    $ g# U4 Q8 j# L  V7 m# `
42. void StartDrawCharTask(void const *argument);
    " x! u& ]; m7 d8 B* _
43. void StartLedTask(void const *argument);
    
44. 
      Z: e& [# D( ~" N: R
45. void StartShowCalendarTask(void const *argument);
    ( ^. Q  Q8 o# B  p1 n& ~$ g2 z( V
46. void StartIrControlTask(void const *argument);
    
47. 
    + X6 J) i  z6 s5 w
48. static void ShowString(uint16_t x, uint16_t y, char *msg);
      e; w& `6 M  a  U
49. 
    # T' M; r/ c" i$ e( a& x
50. 
    3 ^; m2 {4 A; h* O  @1 u- P
51. void FREERTOS_Init(void);
    
52. static void RTC_CalendarConfig(void);
    
53. 
    / \) S8 `2 V) `% Z
54. 
    " [$ I! f4 v% i
55. void FREERTOS_Init(void)
    # C3 s6 ]" F3 H' b
56. {
    
57.         osMessageQDef(charQueue, 16, uint32_t);
    
58.         charQueueHandle = osMessageCreate(osMessageQ(charQueue), NULL);
    & c' b$ t! W7 p) g1 L  M2 l) G
59.         
    
60.         osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 128);
    
61.         defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);
    
62. 
    
63.         
    ' ~* u2 ]- \% s' |, }! M
64.         osThreadDef(drawCharTask, StartDrawCharTask, osPriorityAboveNormal, 0, 128);
    
65.         drawCharTaskHandle = osThreadCreate(osThread(drawCharTask), NULL);
    : s4 ?5 z9 c. |+ n7 c! a
66.         
    
67. 
    
68.         //create your own tasks
    
69.         
    " @/ y7 e5 S+ P: Q
70.         osSemaphoreDef(irSem);
    
71.         irSemHandle = osSemaphoreCreate(osSemaphore(irSem), 1);
    , `# B9 e; x; S( _$ Z% ~  M
72.         
      }; R3 y9 ?" ^
73.         osThreadDef(showCalendarTask, StartShowCalendarTask, osPriorityNormal, 0, 128);
    
74.         showCalendarHandle = osThreadCreate(osThread(showCalendarTask), NULL);
    9 ^8 b5 q+ n; r: j+ C6 h
75.         
    
76.         osThreadDef(IrControl, StartIrControlTask, osPriorityNormal, 0, 128);
    
77.         IrControlHandle = osThreadCreate(osThread(IrControl), NULL);
    
78.         
    
79. 
    4 L% g4 M3 m- o& r  o
80. 
    
81. }
    
82. 
    ; j/ t, L9 i9 |7 g) l
83. 
    
84. void StartDefaultTask(void const * argument)
    / c% g/ g1 ~% R% D7 A
85. {
    
86.         for(;;)
    
87.         {
    6 i" ^( w6 b( q9 U9 Q$ p1 A& e
88.         
    
89.     osDelay(1);
    ; c$ J7 F  C/ A+ z
90.   }
    
91.   
    
92. }
    
93. 
    4 J1 t0 I, i6 L6 H, c
94. //your own task implementetions
    , {' D/ k3 L, i( o! m# m; ~* z. d
95. 
    - [9 K( G$ \: w
96. 
    # Y+ O. l1 @) d' P
97. 
    
98. void StartDrawCharTask(void const * argument)
    5 E, e! |0 }5 Q3 ?
99. {
    * |/ ~, M, w/ ^# D0 F6 }
100.         osEvent event;
     
101.         CharTypeDef ch;
     - M. t% F4 [; d
102.         
     
103.         for(;;)
     
104.         {
     
105.                
     6 \! `  X$ k/ r
106.                 event = osMessageGet(charQueueHandle, osWaitForever);
     
107.                 ch.data = event.value.v;
     
108.                 lcd_DrawCharEn(ch.charInfo.x, ch.charInfo.y, ch.charInfo.ch, foreColor);
     
109.                
     1 G7 S+ c$ B+ K2 A/ ~  v( m
110.         }
     # b, [/ A" g% w6 B+ m3 |
111.         
     8 L- _' |- ]# u* L0 c6 U
112.         
     1 x, B% v. I8 E8 o
113. }
     
114. 
     
115. 
     ) M* I0 h' D; l0 y
116. 
     
117. static void ShowString(uint16_t x, uint16_t y, char *msg)
     
118. {
     
119.         
     4 q! N9 h8 Q# U
120.         uint16_t len = strlen(msg);
     3 c' Y5 J& T" m
121.         uint32_t info;
     6 }9 j3 p9 R: v8 r) U
122.         
     $ Y* s) }, F6 n( w
123.         for(uint16_t i = 0; i < len; i ++)
     / c& _+ e+ Q3 t5 w4 D4 e, V
124.         {
     
125.                 info = 0;
     6 h. y: m1 y/ H$ W( c; N: ]3 G
126.                 info |= x << 24;
     
127.                 info |= y << 16;
     
128.                 info |= msg[i];
     
129.                
     
130.                 osMessagePut(charQueueHandle, info, osWaitForever);
     / ?+ M0 T/ a4 p5 O  Y0 z" u6 F
131.                
     / G# |+ L: J$ p; G! w" b
132.                 x += 8;
     
133.         }
     % B: @! t: m; a3 z" @
134.         
     
135.         
     
136. }
     " J4 e% q7 W, w) F
137. 
     $ I" b( {. L4 y
138. void StartShowCalendarTask(void const *argument)
     
139. {        
     0 y* _; v* \; e2 ]: j
140.         char calendarStr[30] = "";
     ' r( T! s7 @5 J/ a6 s3 r- o
141.         RCC_OscInitTypeDef RCC_OscInitStruct;
     
142.         RCC_PeriphCLKInitTypeDef RCC_PeriphCLKInitStruct;
     : R/ J+ y, q8 q- j" Z
143.                
     
144.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
     
145.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
     ' a1 {$ Z8 j% l0 P- \
146.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
     ( C$ i8 M) n4 }: O( b" K! Z3 {& t' e
147.         RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
     
148.         
     
149.         HAL_RCC_OscConfig(&RCC_OscInitStruct);
     * T- I2 }. r& i4 m9 Q5 M$ {+ K
150.         
     
151.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
     
152.         RCC_PeriphCLKInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
     ! o8 g6 F% `. j0 f' f( m4 x
153.         
     
154.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
     
155.         
     7 L* R8 _0 r# k( h2 t
156.         __HAL_RCC_RTC_ENABLE();
     
157.         
     
158.         RtcHandle.Instance = RTC;
     
159.         RtcHandle.Init.HourFormat = RTC_HOURFORMAT_24;
     $ y5 p  }! o  m: L
160.   RtcHandle.Init.AsynchPrediv = 127;
     
161.   RtcHandle.Init.SynchPrediv = 255;
     2 y/ [+ d. O7 \, d
162.   RtcHandle.Init.OutPut = RTC_OUTPUT_DISABLE;
     + `+ y* L4 M7 m. N
163.   RtcHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
     1 r' a3 F" M7 V) Q  F
164.   RtcHandle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
     9 G) I" b9 ]7 P3 X) n; P6 u
165.         
     
166.         HAL_RTC_Init(&RtcHandle);
     0 d! B; j6 N/ c: l
167.         
     
168.         if(HAL_RTCEx_BKUPRead(&RtcHandle, RTC_BKP_DR0) != 0x32F3)
     3 r! @3 o2 \/ l0 Z; B
169.   {  
     
170.     /* Configure RTC Calendar */
       u( m5 A' p2 `# ^) Q! y
171.     RTC_CalendarConfig();
     , D* {1 m0 P6 b5 ?0 Q( ~
172.   }
     
173.         
     ) _& N( }0 G8 Y  }, k! y
174.         for(;;)
     , r9 o5 D3 i' u* X2 I2 c
175.         {
     9 S, ~! ^( [5 h  @+ }" T" M, E
176.                 RTC_DateTypeDef sdatestructureget;
     
177.                 RTC_TimeTypeDef stimestructureget;
     
178.                
     
179.                 /* Get the RTC current Time */
     
180.                 HAL_RTC_GetTime(&RtcHandle, &stimestructureget, RTC_FORMAT_BIN);
     
181.                 /* Get the RTC current Date */
     2 V7 Q+ r$ M' `- k3 i/ h& f
182.                 HAL_RTC_GetDate(&RtcHandle, &sdatestructureget, RTC_FORMAT_BIN);
     : c: z2 y: d" N' g' v" C1 ?
183.                
     6 ]/ A4 ^' p. X# D3 `$ _
184.                 /* Display time Format: hh:mm:ss */
     . J1 {! p% B- H$ O: M
185.                 sprintf((char*)calendarStr,"%02d:%02d:%02d   %02d-%02d-%04d",stimestructureget.Hours, stimestructureget.Minutes, stimestructureget.Seconds,
     
186.                         sdatestructureget.Month, sdatestructureget.Date, 2000 + sdatestructureget.Year);
     
187.                 ShowString(10, 60, calendarStr);
     & S% j5 V" j. i) x. q* I' ]
188.                
     
189.                 osDelay(100);
     
190.         
     8 K0 X6 ]# M  I  [
191.                
     
192.         }
     7 a- |' M0 y2 T, N$ @$ a
193.         
     
194. }
     6 B- K1 v! z. n' ~
195. 
     
196. 
     1 \+ u# C0 m7 a* d
197. 
     % i" p% k( n) x: U: P. L. ^; ?- w
198. static void RTC_CalendarConfig(void)
     
199. {
     
200.   RTC_DateTypeDef sdatestructure;
     
201.   RTC_TimeTypeDef stimestructure;
     $ F8 c  b# @: ^5 s
202. 
     
203.   /*##-1- Configure the Date #################################################*/
     5 i( F' h+ X$ g. q$ L- I$ N6 m3 C
204.   
     1 p# j% n* a8 M5 B3 A3 W
205.   sdatestructure.Year = 0x15;
     / A8 B( N4 s& p- Z0 S, O! j: W
206.   sdatestructure.Month = RTC_MONTH_MAY;
     
207.   sdatestructure.Date = 0x28;
     ( R! H4 p& L+ [
208.   sdatestructure.WeekDay = RTC_WEEKDAY_THURSDAY;
     
209.   
     
210.   if(HAL_RTC_SetDate(&RtcHandle,&sdatestructure,RTC_FORMAT_BCD) != HAL_OK)
     ! b* c9 @& Z0 z) v; D* @& y
211.   {
     
212.     /* Error */
     3 Z+ e" K6 E4 b6 z
213.     //Error_Handler();
     
214.   }
     - J# A* q, Y, T8 z7 j; L* C
215.   
     . v: n. N! F! R. O: T6 y7 I
216.   /*##-2- Configure the Time #################################################*/
     ; y! s7 u# R0 B: o2 J7 l
217.   /* Set Time: 02:00:00 */
     ' \" @& {6 l8 x. ]) g0 @4 F. x
218.   stimestructure.Hours = 0x21;
     
219.   stimestructure.Minutes = 0x38;
     , Y; T! G5 D0 S
220.   stimestructure.Seconds = 0x00;
     / Y4 V* i: `0 s+ {
221.   stimestructure.TimeFormat = RTC_HOURFORMAT12_AM;
     ! Z4 u0 }/ S, Q& \1 P
222.   stimestructure.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
     5 G. P" \2 x( t, Y' a% K2 @3 e# ]
223.   stimestructure.StoreOperation = RTC_STOREOPERATION_RESET;
     7 Z/ M6 G* m0 \: o, E7 D
224.   
     + {$ I: H+ v9 A) S" M; _  p
225.   if(HAL_RTC_SetTime(&RtcHandle,&stimestructure,RTC_FORMAT_BCD) != HAL_OK)
     
226.   {
     
227.     /* Error */
     ) a% {9 k4 Q: z& l. U9 X
228.     //Error_Handler();
     
229.   }
     4 L1 r4 k& Z2 V9 @/ Y  V  k
230.   
     
231.   /*##-3- Writes a data in a RTC Backup data Register0 #######################*/
     8 l( V* Y9 D0 \3 G# h
232.   HAL_RTCEx_BKUPWrite(&RtcHandle,RTC_BKP_DR0,0x32F3);  
     7 W1 ?1 i( W4 y' g
233. }
     6 W0 V4 @$ A7 e" L1 a1 N
234. 
     
235. 
     % R- i- Z2 m" {8 S- Y5 Z- U
236. void StartIrControlTask(void const *argument)
     9 `3 W2 N1 ~+ v% K% H
237. {
     
238.   TIM_MasterConfigTypeDef sMasterConfig;
     
239.   TIM_IC_InitTypeDef sConfigIC;
     
240.         
     0 D3 t/ V5 W0 ^! s
241.         GPIO_InitTypeDef GPIO_InitStruct;
     
242.         char irMsg[30] = "";
     
243.         
     1 @% c6 f- F5 v$ R! q" T
244.         __GPIOA_CLK_ENABLE();
     
245.         
     
246.         __TIM1_CLK_ENABLE();
     
247.         
     
248.         GPIO_InitStruct.Pin = GPIO_PIN_8;
     
249.         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
     
250.         GPIO_InitStruct.Pull = GPIO_PULLUP;
     7 h6 i3 n# T& X% `2 i5 S8 a" {
251.         GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
     7 B0 u7 S% F# S- v* X
252.         GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
     $ V1 n, h5 a& }! _& V( j; R1 ^* H
253.         
     7 R: L2 _! h  o3 r: q1 Z
254.         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
     5 ~3 b  p0 B2 ?. K1 Z5 @
255. 
     
256.         /* Peripheral interrupt init*/
     2 w6 d! X+ o! G1 x5 `$ W
257.         HAL_NVIC_SetPriority(TIM1_CC_IRQn, 5, 0);
     . q3 B7 b- U5 [/ ~; \
258.         HAL_NVIC_EnableIRQ(TIM1_CC_IRQn);
     3 ~, {- [, H+ ^. s; G$ _: e
259.         HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 5, 0);
     
260.         HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);
     ! c% [- q8 y# ]. L+ Z  P/ C! }
261.         
     2 o* b% l% M6 S- h; @/ @
262.   htim1.Instance = TIM1;
     ' N* n$ j. K9 G- z. \4 [  K
263.   htim1.Init.Prescaler = 167;
     + j2 Z- Z9 _3 P
264.   htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
     , w+ r& o1 G4 N# K5 y
265.   htim1.Init.Period = 9999;
     , ]& `4 @  Q& u, c5 S5 _" U
266.   htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
     
267.   htim1.Init.RepetitionCounter = 0;
     + C) y: h% V" \/ s- u5 j
268.         
     5 B1 P" H7 b. x$ N5 f* r
269. //        sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
     
270. //  HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig);
     4 n" O; l2 j* b. Z$ f/ `
271. 
     + I. d5 D6 b+ j# p/ R
272.   HAL_TIM_IC_Init(&htim1);
     7 e/ }* K! H- ?/ G$ B
273. 
     8 T( E/ g4 K+ ^5 o& l0 I$ A
274.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
     / r7 i4 _9 E) l/ e) i
275.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
     " R" }# n3 k. G5 ^- p* y( |# {
276.   HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig);
     
277. 
     * W4 G8 ]: C/ |; R5 R9 n: f; R
278.   sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
     * b: }* o, X+ D3 n- B
279.   sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
     
280.   sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
     
281.   sConfigIC.ICFilter = 3;
     
282.   HAL_TIM_IC_ConfigChannel(&htim1, &sConfigIC, TIM_CHANNEL_1);        
     ) r: b! Z7 [9 \, P) k& P* a9 F
283.         
     ! a6 x: y2 `, i. F& H- c1 N7 i
284. 
     & O, G8 F( O- J+ n* a0 G7 H' r
285.         HAL_TIM_Base_Start_IT(&htim1);
       R& g7 ?8 G. M/ u) j# e7 P
286.         HAL_TIM_IC_Start_IT(&htim1, TIM_CHANNEL_1);
     
287.         
     8 B1 f' b1 n0 d8 t
288.         osSemaphoreWait(irSemHandle, 0);
     
289.         
     
290.         for(;;)
     
291.         {
     
292.                 osSemaphoreWait(irSemHandle, osWaitForever);
     
293.                
     " ?/ D& u" o5 x2 Z0 I
294.                 sprintf(irMsg, "Key Code: %4u    ", 0xFF & (irData >> 8));
     ( w+ J4 Z  q" K6 ]  q- i
295.                
     
296.                 ShowString(10, 90, irMsg);
     6 A# k) |- F7 Y) a) V
297.                
     + \2 h$ y' A" U  r: p. B
298.                
     + ?+ g1 H: m  p# }0 D9 H
299.         }
     . a. T) N+ Y6 p/ a6 _. }
300. }
     
301. 
     
302. 
     " w; v1 {. h# W
303. 
     ' e9 [8 v$ ~" M# q
304. void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
     
305. {
     
306. 
     
307.         if(__HAL_TIM_GET_ITSTATUS(&htim1, TIM_IT_CC1) == SET)
     
308.         {
     6 E1 v" {1 l; T3 ?9 u! V3 s0 y$ R
309.                 if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == GPIO_PIN_SET)
     
310.                 {
     
311.         
     - F' C9 g: t, {/ m) D" P6 v: n& S
312.                         __HAL_TIM_SET_CAPTUREPOLARITY(&htim1, TIM_CHANNEL_1, TIM_INPUTCHANNELPOLARITY_FALLING);
     
313.                         TIM1->CNT = 0;
     
314.                         irState |= 0x10;
     
315.                         
     2 _3 s) \- ]) L- M; B7 K1 U% n2 V
316.                 }
     
317.                 else
     4 N! C2 L. v/ K) F: `
318.                 {
     
319.                         icValue = HAL_TIM_ReadCapturedValue(&htim1, TIM_CHANNEL_1);
     
320. 
     4 Z2 ]; R" x3 v7 R  q+ d
321.                         __HAL_TIM_SET_CAPTUREPOLARITY(&htim1, TIM_CHANNEL_1, TIM_INPUTCHANNELPOLARITY_RISING);
     ) A; U; L+ V. \5 i
322.                         
     
323.                         if(irState & 0x10)
     9 B  B6 c  _% h, l
324.                         {
       T: U/ Q; V" ~8 P) }
325.                                 if(irState & 0x80)
     
326.                                 {
     
327.                                        
     6 N' s8 q$ G8 n1 O" N+ S9 `* D
328.                                        
     8 k3 D. b% k; }" `1 f  n9 U2 m
329.                                         if(icValue > 300 && icValue < 800)
     
330.                                         {
     
331.                                                 irData <<= 1;
     * F! v+ n/ t0 Z) F
332.                                                 irData |= 0;
     1 x% u- M. J8 R6 j4 X+ r$ z. K
333.                                                 
     
334.                                         }
     
335.                                         else if(icValue > 1400 && icValue < 1800)
     ; g- X( o+ z; e( r1 J
336.                                         {
     % q+ E' g8 j* C: _( n( G: A
337.                                                 irData <<= 1;
     
338.                                                 irData |= 1;
     
339.                                         }
     
340.                                         else if(icValue > 2200 && icValue < 2600)
     
341.                                         {
     
342.                                                 irCount ++;
     9 z  A' D4 f  ~6 v
343.                                                 irState &= 0xF0;
     
344.                                         }
     
345.                                 }
     
346.                                 else if(icValue > 4200 && icValue < 4700)
     
347.                                 {
     
348.                                         irState |= 1 << 7;
     2 A, D4 r) U! B/ Q! Q
349.                                         irCount = 0;
     
350.                                        
     
351.                                 }
     5 J+ w& @! g; o7 S4 K
352.                                 
     3 h9 M8 C& w) m
353.                         }
     
354.                         irState &= ~(1 << 4);
     
355.                 }
       H8 S3 a6 L7 M0 W. j
356.                
     
357.         }
     ! g8 U( F$ v: ^  P) h2 [/ h
358.         
     
359.         
     6 w- P* x/ r1 l
360. }
       \( A; E* K2 N- i( u# a, K$ [9 i
361. 
     
362. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
     
363. {
     
364.         if(__HAL_TIM_GET_ITSTATUS(&htim1, TIM_IT_UPDATE) == SET)
     ! ~/ A. M8 m+ ^, ?+ S2 v- D
365.         {
     " |0 q1 y. ]# e5 \4 ^
366.                 if(irState & 0x80)
     
367.                 {
     
368.                         irState &= ~0x10;
     9 h' O5 d: \7 w" S$ t+ T3 u5 ~
369.                         if((irState & 0x0F) == 0)
     
370.                         {
     
371.                                 irState |= 1 << 6;
     # r1 z$ k: Q% q8 y& G
372.                                 osSemaphoreRelease(irSemHandle);
     
373.                                 
     
374.                         }
     " A) F8 O+ O% X
375.                         
     : }  v0 d$ N% y+ P! y
376.                         if((irState & 0x0F) < 14)
     5 O/ T7 u3 s( N3 g$ ?+ j$ Y3 h" g
377.                                 irState ++;
     
378.                         else
     
379.                         {
     % E9 Q4 n0 H' v0 N+ q+ m
380.                                 irState &=  ~(1 << 7);
     4 f  u/ @& W8 O3 I  D% c5 r8 f& T
381.                                 irState &= 0xF0;
     
382.                                 
     1 j! I* U" p6 A0 k. M
383.                         }
     3 `+ `  o' T) @$ b1 W& u; r
384.                         
     * e. W1 L+ d* Q9 l1 t2 c' d! }* f
385.                 }
     - X& J" k9 @7 l
386.                
     
387.                
     
388.         }
     8 _0 T. Y1 s" c. ^. X
389.         
     
390.         
     
391. }
     
392. 
     
393. 
     
394. 
     7 w3 |1 {" X- U9 v( j
395. 
     

复制代码

1. <p> </p>

复制代码

3 }) G5 g) w. ?3 {7 x$ \- r

qiu-368230 发表于 2015-5-30 18:09
厉害，我是在FREERTOS和MQX之间纠结呢，以后ST没有库函数了，不知道还要不要用，想选个系统，没确定用哪 ...

( z: ~- H9 R3 O$ b# O" ]FREERTOS就不错，免费、简单

占楼备注

占楼备注

恩恩，不错

挺好                  

谢谢分享

占楼这么多，感觉要出大事了

沐紫 发表于 2015-5-29 10:49
占楼这么多，感觉要出大事了

在模板上添加一些任务，体验RTOS的魅力

自己画的板子么？FREERTOS？期待后续教程

不错哦  能否提供些入门资料 谢谢  suzhe1020@163.com

学习学习

学习学习

qiu-368230 发表于 2015-5-29 11:29
# [. I% ~( K6 z; A自己画的板子么？FREERTOS？期待后续教程

准备折腾几个例程

suzhe_518 发表于 2015-5-29 11:49
8 x( h3 D9 l/ T- ^9 ]不错哦  能否提供些入门资料 谢谢

! S* I9 |0 m& A& Z0 R% _8 S官网上有的