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

2 ~5 K$ q4 F9 ]* m
看RTOS的资料看了一段时间，最近才勉强明白了一点，希望和大家一起讨论哈！

高手请多包容，多指导！


先看看效果图。


9 @& t1 b, r) ?& H
: e! m3 c. H+ |( C  C% d" c
  Y% x( x2 ~  l7 G/ a) M6 w
$ n* Q" l* W: C( ^5 a# m2 K
# T) H, C: c/ u  B5 O0 y( \4 T' U0 R
1 V* \# p# X  L完整的工程可以参考github.com/netlhx/stm32f407，里面的general文件夹包含一个通用的模板，LCD文件夹里将LCD和RTOS的使用结合在一起。

后面准备将其它的模块功能添加进来，虽然以前基于NUCLEOF411做了一个模板，最近折腾原子的探索者，所以那一个就没有更新了。

几点说明：
1. 绘制文字的任务是一个守护者任务（GATEKEEPER TASK），这样输出就不会产生混乱。不过任务在输出实际内容时，每个像素点都带了各自输出的位置，所以如果不使用守护者任务来实现的话，应该也没有问题。这里之所以这样处理，是为了以后的统一处理。
2 W/ f% |5 p. k" J; c4 s6 J7 c: N( i2. 液晶驱动为ILI9341，分辨率为240X320.
3. 没有加注释，大部分代码都比较简单，以后再整理吧

# @! y, w4 G/ A+ L8 Z3 X# B
实例一 、添加一个日历任务

( @9 L" R- D1 _! j2 @- R框架已经搭好，使用RTOS的好处之一在于：每个任务就是一个模块，所以接下来看看如何添加一个日历模块，并在LCD上显示。
2 g  e9 \8 b9 X! K( j8 g
. a4 J2 t2 l6 b3 s添加一个新任务，需要完成下列步骤：
1. 定义一个任务ID，用来对任务进行管理操作，如果不需要管理该任务，也可以跳过这步
2. 设定任务相关参数，如优先级、堆栈大小等
3. 创建任务
4. 编写任务函数

' F- D. L+ s; S, R在freertos.c文件中，添加如下
, n6 D- N. T1 F! h' f/ j0 o

2 T: ~$ D3 Y+ A3 i, P5 }



, J$ }1 k, l4 s  l/ z) B+ f& P; E

3 I  q* }, q; t% F2 Q0 ^完整的任务代码：
% s* ~% A; s4 i; s# _- ^( X

1. <p>void StartShowCalendarTask(void const *argument)
   
2. {        
   
3.         char calendarStr[30] = "";
   
4.         RCC_OscInitTypeDef RCC_OscInitStruct;
   
5.         RCC_PeriphCLKInitTypeDef RCC_PeriphCLKInitStruct;
   
6.                
   ) r. z% a( v) q  n7 o5 r
7.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE | RCC_OSCILLATORTYPE_LSI;
   0 W# t* h/ z8 {  t1 q( @6 d: x
8.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
   
9.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
   - q4 A8 W/ O; L) c& C; y
10.         RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
    ( E6 A: i5 Z) J" p# C" F
11.         
    9 [3 f; C/ O" }( ^
12.         HAL_RCC_OscConfig(&RCC_OscInitStruct);
    
13.         
    ) ^! E4 ^9 N) k" j, a
14.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
    
15.         RCC_PeriphCLKInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
    
16.         
    . u, F5 B8 P; R" L# K
17.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    
18.         
    
19.         __HAL_RCC_RTC_ENABLE();
    9 G. W: b2 u) P! M# p7 F8 k
20.         
    ( A! @" g1 j2 z9 I0 C! ]
21.         RtcHandle.Instance = RTC;
    
22.         RtcHandle.Init.HourFormat = RTC_HOURFORMAT_24;
    8 N9 o4 s) A  G9 E3 B0 ]$ G& I
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;
    
27.   RtcHandle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
    : g6 o0 k5 N. O& T% j
28.         
    5 S: i! s( ~+ F& C4 \' n
29.         HAL_RTC_Init(&RtcHandle);
    
30.         
    . p/ V! A1 [. ~3 h6 n9 P
31.         if(HAL_RTCEx_BKUPRead(&RtcHandle, RTC_BKP_DR0) != 0x32F2)
    
32.   {  
    
33.     /* Configure RTC Calendar */
    8 ^# |6 w9 ?/ |' J' d+ W
34.     RTC_CalendarConfig();
    
35.   }
    
36.         
    
37.         for(;;)
    : w6 c1 z4 J: O1 X: f
38.         {
    " |4 F" V- D9 v
39.                 RTC_DateTypeDef sdatestructureget;
    2 W4 A1 Y- j1 @: Z7 R- z
40.                 RTC_TimeTypeDef stimestructureget;
    % Q! [, z7 d4 R7 B& |
41.                
    7 E1 z( v  {/ V& W0 R' V
42.                 /* Get the RTC current Time */
    # h- {8 L. M: |9 M# g
43.                 HAL_RTC_GetTime(&RtcHandle, &stimestructureget, RTC_FORMAT_BIN);
    
44.                 /* Get the RTC current Date */
    , c0 E* p* j5 K+ T' p1 I
45.                 HAL_RTC_GetDate(&RtcHandle, &sdatestructureget, RTC_FORMAT_BIN);
    
46.                
    8 u0 ~  t2 R8 V5 s+ X
47.                 /* Display time Format: hh:mm:ss */
    3 Y0 a' _  j7 M6 U+ C  `
48.                 sprintf((char*)calendarStr,"%02d:%02d:%02d   %02d-%02d-%04d",stimestructureget.Hours, stimestructureget.Minutes, stimestructureget.Seconds,
    3 w8 c8 m1 k# z" L( w6 H3 d
49.                         sdatestructureget.Month, sdatestructureget.Date, 2000 + sdatestructureget.Year);
    
50.                 ShowString(10, 60, calendarStr);
    / K. @8 R$ w; I  w$ S( ?: a! P5 F
51.                
    ' L9 W( o' z2 B# e1 F
52.                 osDelay(100);
    * J2 F  F/ T  h- H. a
53.         
    
54.                
    ( q, f  Z! U% j1 s8 V0 G
55.         }
    5 g' C7 Q3 t; c2 U2 f
56.         
    
57. }
    . |& n# {5 e  ]: B$ Q8 w$ j
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">
      I4 Z; d0 w6 V8 D9 H, z
59. </p>

复制代码

. `/ ?" w* J/ V+ s+ V9 J
. b5 w; E' @" s9 L# |# y9 S, V
- H+ l( M5 {7 L! J  m2 ]2 n( S- q+ `
7 ]$ ^* C/ {9 z$ ]2 G1 P
6 L( r, p( a# n/ C5 I5 h
# e  w+ u2 S& f) F8 `# M' S2 h


. G. z9 i; D: D2 t

$ @% `4 p- M# X0 ~( Z$ m: T

  Q- r  m6 _/ X5 v  l  @

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

% a; P8 S4 M6 b' l; d很不错的资料，E文版
& Z; y) f$ A4 v/ H% @
rtos.pdf (1.33 MB, 下载次数: 6902)

2015-6-2 20:21 上传

点击文件名下载附件
. j7 Y" B/ Z, u) ^5 l0 I5 e

  L; |3 X6 Y9 j# t0 }$ j实例二、加入红外解码，利用红外控制MCU

# t( u5 z% Y$ ~2 z% J$ [RTOS支持还是很不错的，加入RTOS之后，所有的任务都是一个独立的模块。

要控制MCU来完成一些任务，主要的方法一般是两个：串口通信、红外遥控。今天来加上红外遥控支持。

5 b1 X* l. o: g' S' R( q板载红外支持的协议是NEC协议，所以加上相应的读取值并解码之后，就能得到输入控制码，利用控制码来完成相应的任务即可。

; P+ E; V" {. h! z$ `1 y先看一个逻辑分析仪抓到的信号
1 [: Y9 g. D1 I



! ~% z, `" S4 V! L
% r5 C/ L  ~3 S4 [) p( ]


同上一个实例一样，使用任务来处理红外信息。同上一个实例不同的是，加入了中断控制，使用中断来处理编码信息。例程中用到了任务、信号量、队列、中断。上代码，慢慢看


' E% }: y5 t8 W& a- }4 ]$ y6 h

1. #include "FreeRTOS.h"
   7 B' {- ]9 {1 C( m: d, c
2. #include "task.h"
   9 H, F1 p& C8 E: O" Z
3. #include "cmsis_os.h"
   
4. #include "stm32f4xx_hal.h"
   3 F. `) e5 X, c
5. #include "ili9341.h"
   
6. #include "string.h"
   9 U( N5 U3 y) T: M! p
7. 
   - f, j3 W0 z  w2 o9 v% R
8. extern uint16_t foreColor;
   - D1 z9 C( \6 H) v
9. 
   
10. TIM_HandleTypeDef htim1;
    5 _+ l- F% I9 w: [
11. 
    $ w# Q0 k/ O3 v! ^) i* E3 W+ W4 i
12. uint8_t irState;
    
13. uint32_t irData;
    , i, b- \5 f- \/ T: ~
14. uint32_t icValue;
    % O* S( @2 `8 Y- @7 g7 V3 I4 N: s
15. uint8_t irCount;
    
16. 
    
17. 
    ( U- [3 C& @, E' Q* Y, J
18. osThreadId defaultTaskHandle;
    
19. //osThreadId displayTaskHandle;
    
20. osThreadId drawCharTaskHandle;
    
21. 
    4 U- T+ r+ w* j4 W" Y
22. //task id
    8 c4 }+ c4 m: Y( q5 _
23. osThreadId showCalendarHandle;
    
24. osThreadId IrControlHandle;
    , o# b0 p1 J# ?: E. ?9 p
25. 
    
26. RTC_HandleTypeDef RtcHandle;
    
27. 
    
28. //IR SEMAPHORE
    ! T3 Q& D: j; D7 d" I
29. osSemaphoreId irSemHandle;
    
30. 
    
31. static void ShowString(uint16_t x, uint16_t y, char *msg);
    
32. 
    6 _& \1 s' z0 t. P7 q8 T
33. 
    ( t, T$ p& w8 N( o8 }# r. K
34. //osMessageQId displayQueueHandle;
    % @+ Q& U+ u! O6 b, s& }
35. osMessageQId charQueueHandle;
    
36. 
    , A. h( U" o1 M: r
37. 
    
38. //add your own task definitions
    
39. 
    # X- T- W; E7 e& j5 t' W
40. void StartDefaultTask(void const * argument);
    " w' b# ~1 g7 v; E
41. //void StartDisplayTask(void const * argument);
    
42. void StartDrawCharTask(void const *argument);
    4 r5 e! m1 @! B, r8 U+ u' h( ^+ K0 n
43. void StartLedTask(void const *argument);
    1 [5 T% x- _) J3 A4 j
44. 
    
45. void StartShowCalendarTask(void const *argument);
    
46. void StartIrControlTask(void const *argument);
    
47. 
    
48. static void ShowString(uint16_t x, uint16_t y, char *msg);
    
49. 
    
50. 
    
51. void FREERTOS_Init(void);
    & x! X2 n' u$ r: w' N
52. static void RTC_CalendarConfig(void);
    
53. 
    5 a6 l1 t1 h/ L1 Q
54. 
    * Q7 d: c/ z% a& V; B1 G
55. void FREERTOS_Init(void)
    / ~& Y& `  K2 U' L0 \
56. {
    
57.         osMessageQDef(charQueue, 16, uint32_t);
    $ `& o( h+ O- n! Z* N
58.         charQueueHandle = osMessageCreate(osMessageQ(charQueue), NULL);
    6 E- V# a1 @) }
59.         
    - s6 u1 A8 o/ `* l; m3 M3 k
60.         osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 128);
    " |" I1 G0 w* Z: T3 W
61.         defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);
    
62. 
    & A4 \8 M+ m1 y/ u' h# h
63.         
    
64.         osThreadDef(drawCharTask, StartDrawCharTask, osPriorityAboveNormal, 0, 128);
    ! D  Q+ U* ^+ l2 u( ~
65.         drawCharTaskHandle = osThreadCreate(osThread(drawCharTask), NULL);
    
66.         
    
67. 
    , G0 O1 ]) u2 r0 b
68.         //create your own tasks
    ; {# U9 t; ~. v! c& @6 W+ Z: Q
69.         
    ( Q" `( C/ }( G' H) J
70.         osSemaphoreDef(irSem);
    0 v+ k6 ~# V4 k% O7 _/ j1 f
71.         irSemHandle = osSemaphoreCreate(osSemaphore(irSem), 1);
    2 m* H9 i% d  F# ?
72.         
    . C4 B5 w: e* k3 a
73.         osThreadDef(showCalendarTask, StartShowCalendarTask, osPriorityNormal, 0, 128);
    8 m5 a1 E; R: e# Y2 _
74.         showCalendarHandle = osThreadCreate(osThread(showCalendarTask), NULL);
    
75.         
    
76.         osThreadDef(IrControl, StartIrControlTask, osPriorityNormal, 0, 128);
    
77.         IrControlHandle = osThreadCreate(osThread(IrControl), NULL);
    
78.         
    ) c1 N: X- @4 Z; K- p- s# a
79. 
    + T, `+ J' p' t' g( K
80. 
    , J2 F2 y! j* I& m4 g6 f3 e
81. }
    
82. 
    & y7 J' t4 c& r8 j
83. 
    9 T  }" Q) a& t2 a# I  ]7 T
84. void StartDefaultTask(void const * argument)
    6 C; \/ f9 [2 K) t
85. {
    
86.         for(;;)
    3 Y) @9 O: S' s- e6 Z5 _
87.         {
    - Q" p& t  d$ H6 U  D6 u4 ~8 k
88.         
    
89.     osDelay(1);
    . S; E" P4 Y( v& [0 r
90.   }
    
91.   
    
92. }
    
93. 
    5 e  R( h3 H  J5 M3 S9 R$ k# Y
94. //your own task implementetions
    
95. 
    8 ^* N" Z* d6 z; {* v
96. 
    2 x6 J  _: L9 k% I1 A
97. 
    + `* R' v: B' r. F6 O' k
98. void StartDrawCharTask(void const * argument)
    . C, [& h( N+ K& y6 O
99. {
    1 w% D  X$ Z! X$ W
100.         osEvent event;
     
101.         CharTypeDef ch;
     5 O( ~8 E' W, E7 q# v6 u" G$ M* C. P
102.         
     
103.         for(;;)
     6 |6 A+ a  R* v/ L* d0 E
104.         {
     
105.                
     
106.                 event = osMessageGet(charQueueHandle, osWaitForever);
     
107.                 ch.data = event.value.v;
     
108.                 lcd_DrawCharEn(ch.charInfo.x, ch.charInfo.y, ch.charInfo.ch, foreColor);
     - u/ y: I- H9 ]6 W
109.                
     
110.         }
     
111.         
     
112.         
     , Q1 ^; Z% Q5 o5 \+ Z- L( G
113. }
     
114. 
     
115. 
     , g( Z# L: k; V! E# v2 ]. m4 K9 `
116. 
     
117. static void ShowString(uint16_t x, uint16_t y, char *msg)
     
118. {
     
119.         
     + t: I: n# D; Y; Q
120.         uint16_t len = strlen(msg);
     ! i: X1 N' G2 O# [, c, s
121.         uint32_t info;
     
122.         
     
123.         for(uint16_t i = 0; i < len; i ++)
     3 \9 b7 M' b$ Y: R  d
124.         {
     " G, [6 o  x) B9 M& s
125.                 info = 0;
     
126.                 info |= x << 24;
     
127.                 info |= y << 16;
     
128.                 info |= msg[i];
     8 n% Q' c1 o! Z  }4 Z5 \2 f! @
129.                
     
130.                 osMessagePut(charQueueHandle, info, osWaitForever);
     " @3 d3 m' u* t. H- H4 b
131.                
     3 s7 x2 Y) X. y) W" F
132.                 x += 8;
     
133.         }
     / i* P4 z* M7 M2 ^0 x
134.         
     , _( I9 h& _+ h0 W" [
135.         
     
136. }
     
137. 
     3 E. N$ @4 u% M& {! b* z
138. void StartShowCalendarTask(void const *argument)
     8 x& W" f# @  d, c$ z
139. {        
     
140.         char calendarStr[30] = "";
     
141.         RCC_OscInitTypeDef RCC_OscInitStruct;
     
142.         RCC_PeriphCLKInitTypeDef RCC_PeriphCLKInitStruct;
     6 Y  `' ]" ^3 I" x2 n
143.                
     
144.         RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
     4 u" I6 n( y) W1 h1 }
145.         RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
     $ Q% ^/ ?+ B/ ^& u* @
146.         RCC_OscInitStruct.LSEState = RCC_LSE_ON;
     + h; P) I  J7 L9 D( P
147.         RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
     
148.         
     & Q9 ?, O. `1 w; {
149.         HAL_RCC_OscConfig(&RCC_OscInitStruct);
     ! j/ l5 r7 f: S' ?* v4 E  B/ S
150.         
     5 L8 c$ T8 l1 s; K* L5 l/ t) k# B% [
151.         RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
     ' r. N& ?2 n" y9 R% J: t
152.         RCC_PeriphCLKInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
     / {( C5 |  i  B6 q
153.         
     1 k: X, Y0 A  @
154.         HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
     
155.         
     % @/ t$ r' v* L! s3 {$ W
156.         __HAL_RCC_RTC_ENABLE();
     
157.         
     
158.         RtcHandle.Instance = RTC;
     
159.         RtcHandle.Init.HourFormat = RTC_HOURFORMAT_24;
     8 B# H3 t0 K: ~: ^( `
160.   RtcHandle.Init.AsynchPrediv = 127;
     
161.   RtcHandle.Init.SynchPrediv = 255;
     
162.   RtcHandle.Init.OutPut = RTC_OUTPUT_DISABLE;
     $ a* P3 Q$ ?8 D
163.   RtcHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
     / r3 k2 I5 D6 A( H2 v) ~/ ~
164.   RtcHandle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
     1 D( {$ v2 q4 k+ s1 L! z
165.         
     
166.         HAL_RTC_Init(&RtcHandle);
     
167.         
     : L. H4 q  U  ?) y
168.         if(HAL_RTCEx_BKUPRead(&RtcHandle, RTC_BKP_DR0) != 0x32F3)
     1 b) V3 V+ }0 q0 m; u8 ~) R2 k
169.   {  
     
170.     /* Configure RTC Calendar */
     
171.     RTC_CalendarConfig();
     
172.   }
     ( Q4 E* z% f. X' N. H  m* z
173.         
     
174.         for(;;)
     + o. E: H# t3 Q. n5 ?
175.         {
     
176.                 RTC_DateTypeDef sdatestructureget;
     
177.                 RTC_TimeTypeDef stimestructureget;
     1 d3 Z# q8 A1 R* _/ X9 @% b
178.                
     
179.                 /* Get the RTC current Time */
     
180.                 HAL_RTC_GetTime(&RtcHandle, &stimestructureget, RTC_FORMAT_BIN);
     
181.                 /* Get the RTC current Date */
     
182.                 HAL_RTC_GetDate(&RtcHandle, &sdatestructureget, RTC_FORMAT_BIN);
     
183.                
     
184.                 /* Display time Format: hh:mm:ss */
     0 g3 t2 x& T% o7 r- `
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);
     
188.                
     ' Z/ s9 O  S/ ?0 f
189.                 osDelay(100);
     
190.         
     
191.                
     ; ~3 P; w+ z& t' i: T
192.         }
     ; w( n; o9 z' O( l% x5 O
193.         
     
194. }
     
195. 
     
196. 
     ! y/ X6 G/ J" O/ W
197. 
     
198. static void RTC_CalendarConfig(void)
     
199. {
     
200.   RTC_DateTypeDef sdatestructure;
     $ x1 U4 Q6 u- ^( g. M
201.   RTC_TimeTypeDef stimestructure;
     ( L6 R, e6 r) T- ^
202. 
     " w8 P* U" P4 b. g* ?
203.   /*##-1- Configure the Date #################################################*/
     
204.   
     4 ]- {0 Y8 `6 e  G! }4 j! N5 g2 C& ?
205.   sdatestructure.Year = 0x15;
     9 W! `$ @4 ^5 I# _% O4 {& A: a
206.   sdatestructure.Month = RTC_MONTH_MAY;
     
207.   sdatestructure.Date = 0x28;
     ( C! _. g9 R& ]5 f1 B
208.   sdatestructure.WeekDay = RTC_WEEKDAY_THURSDAY;
     
209.   
     
210.   if(HAL_RTC_SetDate(&RtcHandle,&sdatestructure,RTC_FORMAT_BCD) != HAL_OK)
       ^3 o' S/ Z2 l7 A0 I$ u' H
211.   {
     . A& G: @, [2 \! w$ N% t/ g
212.     /* Error */
     ) \4 }: g6 [6 `) }4 o7 e
213.     //Error_Handler();
     & P3 p9 ?: `9 o, @- g8 o  S
214.   }
     
215.   
     % P7 E/ I) U! f: j) U* J- x& P
216.   /*##-2- Configure the Time #################################################*/
     
217.   /* Set Time: 02:00:00 */
     7 o$ B: Z- |0 T8 l$ \0 l7 ?
218.   stimestructure.Hours = 0x21;
     
219.   stimestructure.Minutes = 0x38;
     
220.   stimestructure.Seconds = 0x00;
     
221.   stimestructure.TimeFormat = RTC_HOURFORMAT12_AM;
     4 ]$ s* i$ E  I/ U; Y
222.   stimestructure.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
     
223.   stimestructure.StoreOperation = RTC_STOREOPERATION_RESET;
     
224.   
     
225.   if(HAL_RTC_SetTime(&RtcHandle,&stimestructure,RTC_FORMAT_BCD) != HAL_OK)
     
226.   {
     
227.     /* Error */
     
228.     //Error_Handler();
     
229.   }
     
230.   
     
231.   /*##-3- Writes a data in a RTC Backup data Register0 #######################*/
     
232.   HAL_RTCEx_BKUPWrite(&RtcHandle,RTC_BKP_DR0,0x32F3);  
     
233. }
     
234. 
     ' V  k1 h) n5 L$ J# c
235. 
     
236. void StartIrControlTask(void const *argument)
     
237. {
     
238.   TIM_MasterConfigTypeDef sMasterConfig;
     
239.   TIM_IC_InitTypeDef sConfigIC;
     
240.         
     
241.         GPIO_InitTypeDef GPIO_InitStruct;
     
242.         char irMsg[30] = "";
     8 ~5 b5 W7 Q0 t& D2 b
243.         
       X) O: P4 k6 p- w1 o. G
244.         __GPIOA_CLK_ENABLE();
     7 N, {, S4 h' L
245.         
     * h* ?5 E& T  Q. `' p4 o
246.         __TIM1_CLK_ENABLE();
     % E  h8 |. p: _/ F1 n* F, B  A5 \
247.         
     
248.         GPIO_InitStruct.Pin = GPIO_PIN_8;
     & U% L3 h) I: o! ~
249.         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
     
250.         GPIO_InitStruct.Pull = GPIO_PULLUP;
     
251.         GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
     : b( n, |& l" k
252.         GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
     
253.         
     : R; }" q" b# K
254.         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
     / R# h* Q1 z+ G  _! {
255. 
     
256.         /* Peripheral interrupt init*/
     + k1 F6 H" {1 P6 h% W2 p
257.         HAL_NVIC_SetPriority(TIM1_CC_IRQn, 5, 0);
     
258.         HAL_NVIC_EnableIRQ(TIM1_CC_IRQn);
     1 w# w7 B2 a0 N  y4 {9 }3 e
259.         HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 5, 0);
     0 s8 D! f6 u1 G% e9 M
260.         HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);
     
261.         
     
262.   htim1.Instance = TIM1;
       _2 v  r; {% y
263.   htim1.Init.Prescaler = 167;
     1 P+ E4 S+ \7 H6 t  d9 ~$ \
264.   htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
     ; u0 P& X0 [' E+ D, j( N, P
265.   htim1.Init.Period = 9999;
     $ H  e) f+ T9 X  P
266.   htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
     0 E' o, T# J& h5 ]/ `" {
267.   htim1.Init.RepetitionCounter = 0;
     
268.         
     9 [! M6 u3 W' B/ K
269. //        sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
     - ?/ @; [+ e, g) X" e. P$ ]( p
270. //  HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig);
     ' H5 {3 r" p% T3 N& z; j9 Z/ N5 J' Z4 C
271. 
     
272.   HAL_TIM_IC_Init(&htim1);
     0 H( R8 W: @% K7 O
273. 
     * w5 ]1 w1 K/ u$ U  C" a  [
274.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
     
275.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
     
276.   HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig);
     
277. 
     
278.   sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
     
279.   sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
     $ h% u! W  Q: w9 P/ ^2 S
280.   sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
     ' E7 [4 P6 d& ?. m& y: g
281.   sConfigIC.ICFilter = 3;
     ' w! N  D5 S$ E4 I
282.   HAL_TIM_IC_ConfigChannel(&htim1, &sConfigIC, TIM_CHANNEL_1);        
     5 e: c8 \- E; Y6 A- F0 O
283.         
     % J. P6 A& k% v& \1 ?7 a4 r, F( C
284. 
     # c$ p5 C2 g& q  s1 f  C3 e
285.         HAL_TIM_Base_Start_IT(&htim1);
     
286.         HAL_TIM_IC_Start_IT(&htim1, TIM_CHANNEL_1);
     ; K) A5 p' `+ B. @" r( }% S
287.         
     
288.         osSemaphoreWait(irSemHandle, 0);
     1 r3 R, l$ S8 B$ M0 B9 a  G5 l
289.         
     
290.         for(;;)
     
291.         {
     " y2 I8 c$ Y( {& o7 N! k
292.                 osSemaphoreWait(irSemHandle, osWaitForever);
     . c  H& b) U& ]9 n  C; ^( d
293.                
     
294.                 sprintf(irMsg, "Key Code: %4u    ", 0xFF & (irData >> 8));
     * @, N9 ^8 j. t  C
295.                
     
296.                 ShowString(10, 90, irMsg);
     
297.                
     6 R. c0 K" q& l9 [# Y4 h! s
298.                
     0 N' e$ ~0 l0 s. T% y( P# b
299.         }
       X6 {( f( E0 x8 Q5 O; [
300. }
     % i2 S; ^: P1 W$ W& j3 d& l
301. 
     3 p0 \2 D2 G7 X
302. 
     
303. 
     
304. void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
     
305. {
     + s0 j8 y: M! x6 q; z
306. 
     ' V- N2 J% S/ m3 O# Y4 d
307.         if(__HAL_TIM_GET_ITSTATUS(&htim1, TIM_IT_CC1) == SET)
     2 _# o) J/ f3 _8 [6 j. K/ X
308.         {
     
309.                 if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == GPIO_PIN_SET)
     % Y' T( [4 ]6 p& ^) J# @2 H
310.                 {
       a1 }5 Q- s( [' i) F+ m) ~
311.         
     ! w+ F6 x; n3 x3 C
312.                         __HAL_TIM_SET_CAPTUREPOLARITY(&htim1, TIM_CHANNEL_1, TIM_INPUTCHANNELPOLARITY_FALLING);
     
313.                         TIM1->CNT = 0;
     ( H, t2 y- c: @! V0 i( y' ]1 e9 @
314.                         irState |= 0x10;
     8 W3 c! W, s3 x& v7 `# z/ k
315.                         
     / W0 C% a! m4 Q: H, o: ^
316.                 }
     
317.                 else
     
318.                 {
       T) ]$ t- s0 T- q7 G& ^7 @
319.                         icValue = HAL_TIM_ReadCapturedValue(&htim1, TIM_CHANNEL_1);
     
320. 
     * b, p0 Z' O  O5 a, y
321.                         __HAL_TIM_SET_CAPTUREPOLARITY(&htim1, TIM_CHANNEL_1, TIM_INPUTCHANNELPOLARITY_RISING);
     
322.                         
     
323.                         if(irState & 0x10)
     / M" i8 e  F  P/ w1 T
324.                         {
     
325.                                 if(irState & 0x80)
     
326.                                 {
     
327.                                        
     & |$ _( ], h! k
328.                                        
     + I4 T. c/ R6 P8 `# i
329.                                         if(icValue > 300 && icValue < 800)
     
330.                                         {
     
331.                                                 irData <<= 1;
     - {: j9 _8 n& w$ C0 F; j( S) \
332.                                                 irData |= 0;
     
333.                                                 
     
334.                                         }
     
335.                                         else if(icValue > 1400 && icValue < 1800)
     
336.                                         {
     7 B" s5 C4 K6 @
337.                                                 irData <<= 1;
     
338.                                                 irData |= 1;
     % p1 t2 O$ X, {7 y2 B
339.                                         }
     
340.                                         else if(icValue > 2200 && icValue < 2600)
     
341.                                         {
     
342.                                                 irCount ++;
     , B0 _) }$ K* E2 Q4 ?
343.                                                 irState &= 0xF0;
     + v$ M  D: l- h, m1 N- E1 z
344.                                         }
     8 S" I) z5 G. ?* W/ X1 m, ^
345.                                 }
     
346.                                 else if(icValue > 4200 && icValue < 4700)
     
347.                                 {
     6 `' E6 q, y6 X( a
348.                                         irState |= 1 << 7;
     $ ?1 |) N6 ~0 c: `4 U6 u
349.                                         irCount = 0;
     - b5 V& f; e0 w3 {# @
350.                                        
     
351.                                 }
     & B0 ~1 N: Z$ \& \
352.                                 
     ( ?) e) O9 P! l
353.                         }
     / ^/ n' t2 P" g6 W1 d
354.                         irState &= ~(1 << 4);
     7 _- Y+ h, J4 A2 }( U! P6 l( P
355.                 }
     $ o* w* F  x6 K1 i8 |9 S  s( I# q
356.                
     % Z, l3 N+ k9 U: V$ ]$ t$ I
357.         }
     
358.         
     $ D# c1 M7 Y9 \" T7 h8 S
359.         
     
360. }
       M& `0 o  _) q1 U
361. 
     
362. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
     
363. {
     / J+ @' F! R, R3 i
364.         if(__HAL_TIM_GET_ITSTATUS(&htim1, TIM_IT_UPDATE) == SET)
     
365.         {
       R' h4 W/ _3 T7 N
366.                 if(irState & 0x80)
     
367.                 {
     " D8 m5 T0 d( ^$ q8 F" a
368.                         irState &= ~0x10;
     
369.                         if((irState & 0x0F) == 0)
     
370.                         {
     
371.                                 irState |= 1 << 6;
     1 o" h0 l) P, t
372.                                 osSemaphoreRelease(irSemHandle);
     6 c5 U7 [. G1 Q
373.                                 
     3 K, v/ h  w  f4 [6 u) x
374.                         }
     
375.                         
     9 b" n* c9 g& M- }. G' x& q
376.                         if((irState & 0x0F) < 14)
     
377.                                 irState ++;
     
378.                         else
     
379.                         {
     
380.                                 irState &=  ~(1 << 7);
     ( Q6 J2 J3 ]* z
381.                                 irState &= 0xF0;
     
382.                                 
     
383.                         }
     
384.                         
     
385.                 }
     & G3 y  N) B# \2 ]! _3 J
386.                
     
387.                
     4 `4 _' v* W+ Z' }% ]& J
388.         }
     ( x8 X. D4 |( r* _
389.         
     8 n7 A) r1 E" }) R+ U4 W& d, ]' o
390.         
     
391. }
     1 {. L* T  f1 B) c
392. 
     
393. 
     
394. 
     ) I9 m4 _0 s4 P/ A$ {
395. 
     , o0 k. g# U' F7 i

复制代码

1. <p> </p>

复制代码

4 G9 }* ~. n7 a- b

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

FREERTOS就不错，免费、简单

占楼备注

占楼备注

恩恩，不错

挺好                  

谢谢分享

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

沐紫 发表于 2015-5-29 10:49
$ [, k. ~& o; f1 P+ A: Y* C& B2 J占楼这么多，感觉要出大事了

' E, G, L( [8 }5 ^在模板上添加一些任务，体验RTOS的魅力

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

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

学习学习

学习学习

qiu-368230 发表于 2015-5-29 11:29
自己画的板子么？FREERTOS？期待后续教程

准备折腾几个例程

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

- T' q! O; {+ v% |# Z' V官网上有的