FreeRtos的引入
FreeRTOS是一个操作系统内核，提供操作系统最重要的特性：任务调度操作系统允许多个任务同时运行，这个叫做多任务。实际上，一个处理器核心在某一时刻只能运行一个任务。 操作系统中任务调度器的责任就是决定在某一时刻究竟运行哪个任务， 任务调度在各个任务之间的切换非常快！
" |0 B, ^' M; j8 O& [; V  V/ c! o像 FreeRTOS 这种传统的 RTOS 类操作系统是由用户给每个任务分配一个任务优先级， 任务调度器就可以根据此优先级来决定下一刻应该运行哪个任务
3 h2 J5 t1 ^  N0 `" C; Y, G
4 f& |" d/ q- J; _# P单片机引入RTOS，可以将各个功能模块分别设计为单独的任务，每个任务都是一个死循环，就好比有多个人在同时干活，这样CPU的利用率就提高了，并且可以处理一些并行逻辑。
$ S+ i( [6 m" h0 Y% T& T单片机只有一个CPU（核），那怎么让多个人同时干活呢？其实每个子任务虽然都是死循环，但并不是每个子任务一直都在执行，每个子任务在执行期间，可能需要延时，也可能需要等另一个任务的数据到来，所有，在某个任务在等待的时候，CPU就可以停止此任务，然后切换到其它任务执行，这样看起来就是多个人在同时干活了
9 K& O) ~9 \5 z! I3 w7 n


& S/ y2 R6 I% E; z6 C3 f) H想了解更多FreeRtos的知识需要的小伙伴可以去我专栏里面看哦，有基础实验测试，自己可以试试从移值开始，这个工程的话都是移值好了FreeRtos 直接用就行了。
5 _3 C6 ^0 D% ~5 }8 ~. B1 i
3 |: `  t9 K0 x一、题目说明



二、功能说明
( T! p- \8 D# T  v% I! k
& Z, p6 L0 G5 Z' o2 f( K; C3 t- P0 E使用说明：
1.按键模式 也是上电默认的功能 在该功能下
" n7 F8 s/ [' F. n& d' W0 S; LPB6 直接用来控制灯的亮灭 第一次按下开灯 再次按下关灯
PB7 PB8 用来进行灯的亮度等级调节 一个变亮 一个变暗
PB9 按下后为定时模式 默认为定时5s时间到后会关闭灯光 并通过蜂鸣器进行5次提示
) V& w- ?5 ?0 M6 O  {6 z4 \在定时模式的时候 PB6 PB7则为进行时间的调节  按键模式下为亮度的调节（PB6 PB7为两种功能的控制）
- s1 v% {; {  X6 c- L1 f8 _6 [9 R& }
2 E) \0 s% u+ y, h4 g/ X2、光敏模式：在该模式下灯光可以跟随环境的变化而自动调节
% C$ V/ g3 u' X  z! g; t
3、红外模式： 通过检测距离来进行灯光的控制
2 ?  d  C8 [2 N( K
& T7 o& t- Y/ _) i/ w4、定时模式：到一定时间后自动关闭灯光 并以蜂鸣器实行进行提示
5、实时检测当前电压
6、超时波测距模式：也是通过距离的检测来控制灯光（该功能屏蔽了）
$ T) K4 ~3 w0 g$ M8 c. P注意：按键是没有模式切换的只有按键 和定时可以控制所有进行其他模式切换时是以蓝牙控制
( u0 Y4 P% X7 k7 V: Y) s" s5 i通过手机来控制的，语音同样可以进行模式切换和亮度控制
( J: v/ L# _3 M2 \% j
简单的焊接了一个方便调试
  d0 H9 i/ V9 e: u5 Y& k3 A0 g" g

5 R* @7 c* v* X
由于在进行OLED显示时刷新有点问题，所以将各模式下数据通过蓝牙发送到手机上了，以两种形式进行显示，实时电压值在手机上会一直打印 ，其他显示只有在进行相应功能切换时才打印
% |7 A7 y7 W. X- s0 S/ t5 L# j
% D5 B  P% q9 u7 F5 P+ A7 l

三、硬件部分
: z' u- L! A& N! G0 o' I
# `) u" N, I1 E6 k0 L' \& C, }" W( {

1.stm32f103c8t6
# `6 {% E, [) V
# D; e, B- m4 ], G$ P

2.oled显示屏

6 Z) D8 z6 H. O( E2 J

: @: N6 d% ]: ^6 b4 b- ~3.su-03t语音模块
* A. c# t+ ^7 p. {


4.红外模块

) r) W+ m  X6 O- o, _

0 \$ t5 [5 n( X- d- y5 x3 u5.超声波模块



4 @, m2 L2 [7 \  O4 o* N& U6.光敏模块



/ @3 h8 e6 c4 O9 X7.蓝牙模块



8.蜂鸣器



/ J3 |- f$ S+ ?5 Q) I四、硬件接线

2 t1 {$ G  h' g; [% d1.PB6 PB7 PB8 PB9 接四个按键
2.oled PB13--CLK  PB14--DIN
; C8 q5 H4 p# f3.光敏 A0---PA4
1 A" K0 {- C3 b  v5 h0 _4.LED -- PB5
5.超声波 Trig--PB10  ECHO--PB11
- e* R1 }  o' b4 U5 a6.蜂鸣器 -- PC14
2 Z) H9 \( D( `( M7 y" r7.红外模块--PB4
5 n/ v8 A4 d( b  m8.电压 ---PA5
/ M5 G9 X4 z% ?5 `1 R9.蓝牙-- TX-PA3 RX--PA2  
10.语音 TX-PA10 RX--PA9

9 _& h6 f2 M: U& s: R五、软件部分

下面代码为主函数内容
4 r: b7 D  U2 {+ c

1. /*=============================基于FreeRtos的智能台灯======================
   
2. 
   
3. @Author;小殷童鞋
   
4. @Date:2022-11-25
   
5. 
   
6. ===========================================================================*/
   
7. 
   8 k% i" M! T/ P0 L# X
8. /**********************************引脚接线**********************************
   
9. 按键 PB6 PB7 PB8 PB9
   5 k- o; }1 N# i5 q* v6 k" L% V# t
10. OLED GND VCC  PB13-CLK PB14-DIN
    
11. 光敏 PA4
    + P7 _& |: L, d1 r9 a
12. LED PB5
    5 @" b/ T+ C6 ?, |# G/ ?
13. 超声波 gnd vcc  Trig--PB10 Echo--PB11
    
14. 蜂鸣器  PC14
    ; j7 h# T- N6 l' T, o2 g
15. 蓝牙  TX--PA3(PA10)   RX--PA2(PA9)  
    . A9 g1 R* v% k$ V# }0 m3 W
16. 红外模块 PB4
    
17. 电压  一端接PA5  一端接电源正极
    ) H7 j( D- y" A) N& f0 m9 C6 a
18. ******************************************************************************/
    
19. 
    4 _/ a9 R) S( T/ A3 O+ a* M# ?0 S
20. 
    * y' q" s4 e0 M  ]' Y, G
21. /*=====================================功能说明=================================
    
22. 1.默认界面显示按键模式  PB6 直接开关灯  PB7 PB8进行亮度调高调低  PB9为定时模式
    8 M# A% @, H8 ^# h6 i( P
23. 按下PB9后 PB7 PB8的功能变为进行时间的加减  （这里PB7 PB8按键有两种功能）
    4 z% a$ L7 L! n+ Z" J
24. 2.光敏模式  界面只显示光敏界面
    ! ]$ S* j3 x! \' c
25. 3.定时模式  显示时间 到时自动熄灭
    : f/ p8 W0 g% h* w% u
26. 4.红外距模式  
    ! `2 H  P  u1 ?7 O
27. 5.实时电压显示
    
28. 注意：蓝牙和语音与其他模式互不影响
    
29. ================================================================================*/
    4 `5 H* D' i; X
30. 
    
31. #include "sys.h"
    3 s- ~& n* j7 q) c& j8 V
32. #include "delay.h"
    , @' ]4 @) N5 p$ M6 ^2 Q, [& k
33. #include "usart.h"
    % t! u$ O: o  j  X# C, C3 E
34. #include "led.h"
    
35. #include "FreeRTOS.h"
    / m, H  s; L! }. i  w$ {
36. #include "task.h"
    
37. #include "key.h"
    
38. #include "semphr.h"
    9 B8 e3 l3 i9 y0 s. s* ~
39. #include "string.h"
    
40. #include "HC_SR04.h"
    
41. #include "beep.h"
    % ^2 ^6 {; H% Q2 v0 J; }
42. #include "timer.h"
    7 ^# t; W+ A6 n  ^  x0 }* y  @0 L
43. #include "ldr.h"
    # l8 i) `* O2 {' ~% a
44. #include "infrared.h"
    % S7 o+ @1 j' b' ?! g. n
45. #include "oled.h"
    
46. #include "adc1.h"
    ' Q( _  Z# z$ K1 K* z
47. 
    - v0 u2 I- f6 w7 G/ N4 y3 k: u9 {
48. 
    
49. 
    
50. /*================单独功能调试时只改变下面宏开关的值即可代码不动==================*/
    ' ~. K: q8 ?) g: P6 V9 R6 B
51. //开关宏定义   1打开  0关闭
    
52. 
    
53. #define   USART_START           1
    + b2 o* K0 O+ T. X  W1 Q* P& S
54. #define   CLOCK_START           1
    
55. #define   CSB_START             0           //超声波检测时有问题 暂时没用
    
56. #define   LDR_START             1
    & ~( @, Q: e3 i& @6 ?- a7 v
57. #define   KEY_START             1
    
58. #define   INFRARED_START        1
    2 H* F' z$ d& ~0 u% D
59. #define   INTERFACE_START       1
    
60. 
    
61. /*=================================任务宏定义====================================*/
    
62. 
    
63. //任务优先级
    3 g; }# @% o9 s5 E2 s% P, k
64. #define START_TASK_PRIO                1
    ( ?8 a. m7 Q1 Z: _, W
65. //任务堆栈大小        
    
66. #define START_STK_SIZE                 512  
    ! b( [- y5 y. r0 {( N- x
67. //任务句柄
    " }/ x  c9 o6 I/ C, G" W; V% n) W2 z$ Q
68. TaskHandle_t StartTask_Handler;
    
69. //任务函数
    , V- c2 o) S8 m
70. void start_task(void *pvParameters);
    
71. 
    
72. 
    
73. //按键任务
    
74. //任务优先级
    
75. #define BUTTON_TASK_PRIO                5
    
76. //任务堆栈大小        
    % N5 P! W! D/ V  K. c  }; a9 E" m
77. #define BUTTON_STK_SIZE                 128  
    
78. //任务句柄
    + U0 p. }' P, n( v: N! G# J
79. TaskHandle_t BUTTONTask_Handler;
    # K5 c' [. m0 m7 h# r
80. //任务函数
    
81. void button_task(void *pvParameters);
    * b( f7 O9 u+ @  v
82. 
    
83. 
    : j  x5 p$ R8 j% D
84. 
    
85. 
    
86. 
    6 p$ s  }! Y5 T% ]9 ?- ^$ T( y) R
87. //超声波任务
    " J+ B- I0 ^6 B4 v, I/ V" A) k- q
88. //任务优先级
    
89. #define CSB_TASK_PRIO                5
    
90. //任务堆栈大小        
    + e  k, b& [/ k% k0 A6 o* B, }0 L
91. #define CSB_STK_SIZE                 100  
    
92. //任务句柄
    / d2 T* k* c5 X4 \" V
93. TaskHandle_t CSBTask_Handler;
    
94. //任务函数
    
95. void csb_task(void *pvParameters);
    
96. 
    4 n" G4 O" t. B6 u% @5 q/ N6 C# ?
97. 
    5 v5 y5 I7 {3 j& _
98. 
    
99. 
    : u+ l/ `( A/ X* `
100. //串口数据处理任务
     
101. //任务优先级
     
102. #define USART_TASK_PRIO                6
     
103. //任务堆栈大小        
     ' |* D) V( {" Q/ H7 Y
104. #define USART_STK_SIZE                 128  
     
105. //任务句柄
     ( }$ N5 N; ~1 w. [6 b% Q
106. TaskHandle_t USARTTask_Handler;
     
107. //任务函数
     
108. void usart_task(void *pvParameters);
     , G: {* e& Q$ P
109. 
     
110. 
     ) _; i4 ~- P4 Y8 z/ [
111. 
     . s8 N, z# }( ^3 q5 w6 M$ Y
112. //定时任务
     
113. //任务优先级
     : Z6 G( [& t& \% X* n0 k
114. #define CLOCK_TASK_PRIO                4
     3 S7 @) d3 O4 U
115. //任务堆栈大小        
     
116. #define  CLOCK_STK_SIZE                 50  
     
117. //任务句柄
     : [& z3 I" W/ q& V* ^
118. TaskHandle_t  CLOCKTask_Handler;
     , a" s9 z) ~/ @1 W+ \8 I
119. //任务函数
     ' y1 i: ^1 }. |2 \
120. void clock_task(void *pvParameters);
     ) i+ j- G) I9 Z; }8 x
121. 
     
122. 
     
123. 
     
124. //光敏任务
     
125. //任务优先级
     9 b" X& o- y* V1 t1 K
126. #define LDR_TASK_PRIO                2
     
127. //任务堆栈大小        
       E' d; l% w' t0 s$ ]
128. #define  LDR_STK_SIZE                 50  
     
129. //任务句柄
     
130. TaskHandle_t LDRTask_Handler;
     ; H2 v5 R1 s" P4 f& |% k, l
131. //任务函数
     
132. void ldr_task(void *pvParameters);
     
133. 
     : J4 f  `  m/ ~) b* o
134. 
     
135. 
     
136. 
     9 r0 c- m+ e6 g# o) C0 u* S2 M+ Y  d4 a
137. //红外任务
     
138. //任务优先级
     
139. #define INFARED_TASK_PRIO                4
     
140. //任务堆栈大小        
     * ?8 S. l9 B8 l/ Y7 n
141. #define  INFARED_STK_SIZE                 50  
     - o( y5 D' T6 I7 C0 n9 X
142. //任务句柄
     
143. TaskHandle_t INFAREDTask_Handler;
     & O- y. D# Z' t/ [1 Q, h
144. //任务函数
     ( ^+ [1 o/ c2 }
145. void  infrared_task(void *pvParameters);
     
146. 
     : k& l0 u3 {. W; a, B# n+ a
147. 
     7 _  Z7 j1 _" E0 h; o, H' s4 H
148. 
     
149. //界面显示任务
     
150. //任务优先级
     
151. #define INTERFACE_TASK_PRIO                3
     . X: ^7 }, R* r& T$ ]. l7 A* S9 v
152. //任务堆栈大小        
     
153. #define  INTERFACE_STK_SIZE                 50  
     
154. //任务句柄
     
155. TaskHandle_t INTERFACETask_Handler;
     ; G$ |+ u3 X$ B, s+ ?+ S8 W
156. //任务函数
     ( T4 W' @' @* l# |1 W) h: }
157. void  interface_task(void *pvParameters);
     
158. 
     2 u( v0 r* ]% q
159. 
     5 w. y; o6 z3 x% q
160. 
     8 S/ x4 o- T, h6 N7 e# S
161. 
     
162. 
     ) j# v$ l  g. p2 h, N# `
163. 
     
164. //========================================变量定义================================*/
     
165. 
       y5 |) N0 e8 G9 u0 B3 m1 D0 r) i
166. #define Dis      50                    //实时距离小于DIS的时候灯打开
     - ]  }* {& ^$ H1 d7 a
167. #define Set_Dis  20                    //距离预设  可根据实际情况进行修改
     8 ~/ M3 Q9 R. a& r" b. J8 k% B
168. unsigned char Usart1_cmd = 0;           //用来接收蓝牙和语音的指令
     - R7 }/ `. f3 y5 [$ N
169. unsigned int current_duty = 0;        //当前占空比 默认关闭
     1 C" M  B1 T/ K( e* e, j- J9 U
170. unsigned char clock_start = 0;            //功能模式
     7 X" r$ j& Z, ]0 @6 `
171. unsigned char sec;                      //秒
     % P0 r& q& j  k- O5 q0 g( A- z
172. unsigned char min;                      //分
     
173. unsigned char hour;                     //时
     , H; X5 P$ W, h: C  F
174. unsigned int count,clock_flag = 0;      //计数变量   时间到标志
     9 Q- p# @  T: b, Q
175. unsigned int set_time = 5;              //默认为5s
     ; R0 N: E( N0 }) O
176. unsigned char time[6];                  //存储时间转换后的值
     # W9 I; J0 p# J/ M& x* u9 S, {
177. unsigned char adcx; //光敏值 0-100
     # I7 F/ `; `+ M& p- [9 L5 s: E
178. unsigned char work_mode = 1,send_flag = 1; //模式变量  发送到蓝牙的标志
     $ _" H- C' k) O( Q# C
179. float voltage = 0.0;                     //电压
     6 p* ~3 j% a: _0 w/ C- Y6 a
180. char str[24];                           //存储信息字符串的形式显示
     
181. void Buzzer_Voice(void);                //蜂鸣器提示声音
     & Y0 F6 d6 P, i) J9 C
182. void Init_interface(void);              //初始化界面
     # ]" N6 M7 j; A# X& Y7 K9 J
183. void Time_Display(void);                 //定时显示界面
     
184. void KEY_Display(void);                  //按键显示界面
     8 P7 T$ h' |3 a: U' j4 r- r" h. K
185. void Infrared_Display(void);             //红外显示界面
     
186. void LDR_Display(void);                  //光敏界面
     $ F6 b) |- W+ y
187. void VoltageDisplay(void);               //电压显示
     
188. 
     
189. 
     
190. /*==================================功能界面显示函数===============================*/
     
191. //初始化界面
     0 z- j. e, f" L* [9 y! h* [$ D- N
192. void Init_interface(void)
     : Z, Y6 U+ I1 ?* M: t! O
193. {
     
194.                 OLED_ShowCHinese(6,0,0);//智
     ( W/ n! v8 F8 k1 C8 ^( S8 c4 i
195.                 OLED_ShowCHinese(26,0,1);//能
     8 b$ H0 T/ T+ j! d0 b
196.                 OLED_ShowCHinese(46,0,2);//台
     8 L4 P' [% |- ^7 c. Q4 }
197.                 OLED_ShowCHinese(66,0,3);//灯
     % H9 D% h+ B3 u# M8 k& d2 O" y
198.                 OLED_ShowCHinese(86,0,4);//系
     
199.                 OLED_ShowCHinese(106,0,5);//统         
     
200.                 OLED_ShowNum(6,4,2022,4,16);
     
201.                 OLED_ShowCHinese_TWO(40,4,0);//年
     : F  S# o8 _9 C2 v" W7 H
202.                 OLED_ShowNum(60,4,11,2,16);
     
203.                 OLED_ShowCHinese_TWO(74,4,1);//月
     2 D/ k) @4 c. C9 ~
204.                 OLED_ShowNum(92,4,17,2,16);
     ' a4 f1 v# a: L& H4 z
205.                 OLED_ShowCHinese_TWO(108,4,2);//日
     & i4 W- o3 W# z0 z5 q
206. }
     : f7 V# O' P9 r' z1 u* r- T: U
207. 
     ; M/ D! N4 [1 R, j4 U, x1 u
208. //定时模式显示定时的时间
     $ u& i7 Y1 E; j; K$ R  P( {
209. void Time_Display(void)
     9 b3 a1 @4 [" B6 Z: R% `
210. {
     
211. 
     + p/ L. T/ _4 h& I+ L
212.          OLED_ShowCHinese(26,0,12);//定
     
213.          OLED_ShowCHinese(46,0,13);//时
     
214.          OLED_ShowCHinese(66,0,14);//模
     
215.          OLED_ShowCHinese(86,0,15);//式
     4 q( X9 S* c: b' u; J/ v6 `# n. Z
216.          OLED_ShowNum(30,3,time[0],2,4);
     # |: x8 \7 Z' D8 ?9 q7 U& B  E
217.          OLED_ShowNum(38,3,time[1],2,4);
     ) Q0 {8 {- b7 B9 i3 N
218.          OLED_ShowChar(46,3,':',4);
     3 J% \  J$ M& Y6 ~' ?
219.          OLED_ShowNum(52,3,time[2],2,4);
     / g& I% s+ F3 J' k3 D4 A  i
220.          OLED_ShowNum(60,3,time[3],2,4);
     
221.          OLED_ShowChar(68,3,':',4);
     / R% a! |, }! A/ I+ X
222.          OLED_ShowNum(74,3,time[4],2,4);
     # r- U4 E% H( Y$ g
223.          OLED_ShowNum(82,3,time[5],2,4);        
     9 ]1 a3 F4 h2 f( U: @
224.    //电压显示
     % I% x0 l, j7 ~- U
225.          OLED_ShowString(10,6,(unsigned char *)str,8);
     
226. }
     ) e1 C! n5 p( U8 u/ ?
227. 
     . b: J! i: H* O- y" @6 E4 S
228. //按键模式
     ! L  w9 F  R7 y8 u7 X
229. void KEY_Display(void)
     
230. {
     9 D) i: x) A1 O+ F$ i
231.          OLED_ShowCHinese(26,3,10);//按
     2 J$ \( }6 i- p* b0 o5 u* H
232.          OLED_ShowCHinese(46,3,11);//键
     
233.          OLED_ShowCHinese(66,3,14);//模
     * {+ l0 C) Q! ]& K7 }
234.          OLED_ShowCHinese(86,3,15);//式
     
235.           //电压显示
     
236.          OLED_ShowString(10,6,(unsigned char *)str,8);
     & I( g7 w1 z5 U: L
237. }
     4 d7 d* A4 @- V# {
238. 
     . V/ u7 u% h1 ?3 V
239. //光敏模式模式
     
240. void LDR_Display(void)
     / Y2 z. O2 y$ C2 [- _  ]( z
241. {
     
242.          OLED_ShowCHinese(26,3,6);//光
     2 m% ~+ |4 |  ?5 m' ?
243.          OLED_ShowCHinese(46,3,7);//敏
     
244.          OLED_ShowCHinese(66,3,14);//模
     
245.          OLED_ShowCHinese(86,3,15);//式
     
246.           //电压显示
     ; K0 V7 I! g( t" n0 A6 _5 F' ^3 h
247.          OLED_ShowString(10,6,(unsigned char *)str,8);
     5 U7 R7 o" f, X% r: \* B3 D
248. }
     ) P% B4 p; g" L5 t% z5 o6 }" z) L
249. 
     
250. //红外模式
     / }3 K( X2 p& v& B9 R+ r" `
251. void Infrared_Display(void)
     
252. {
     + c4 p3 ]0 R/ o
253.          OLED_ShowCHinese(26,3,8);//红
     ' G$ F% t- {. k/ N6 o
254.          OLED_ShowCHinese(46,3,9);//外
     ! V4 n# P+ h% J* d5 R
255.          OLED_ShowCHinese(66,3,14);//模
     2 O+ ~4 ?# g( w1 ^; o+ S# A
256.          OLED_ShowCHinese(86,3,15);//式
     , D, b- }* ^) _& c: G+ b
257.           //电压显示
     
258.          OLED_ShowString(10,6,(unsigned char *)str,8);
     
259. }
     * D  r7 d$ ?! l/ M5 ]4 W
260. 
     
261. 
     5 ?5 {- h7 y2 r' G0 v) k9 V
262. //电压显示
     $ A( M4 M9 D7 N( U5 k1 [( Q8 ]
263. void VoltageDisplay(void)
     
264. {
     
265. //         OLED_ShowCHinese(26,5,20);//当
     / f4 n# v/ v+ U: Y/ N( T5 R
266. //         OLED_ShowCHinese(46,5,21);//前
     1 m% a# O4 g8 g- o
267. //         OLED_ShowCHinese(66,5,22);//电
     
268. //         OLED_ShowCHinese(86,5,23);//压
     
269.           OLED_ShowString(10,6,(unsigned char *)str,8);
     
270. }
     ) c4 R' h! ^/ B7 b$ Z+ G
271. 
     
272. 
     3 b" s0 K" E' ~6 N/ _
273. 
     - `- p7 w' S2 z( q$ z
274. /*=====================================主函数及功能函数================================*/
     % z, ]; B9 l! S5 d3 B
275. 
     
276. int main(void)
     7 Z& `) I/ v* N5 F
277. {
     4 K6 g- v: }4 A* T/ t( O
278.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4         
     : ~) e3 [& A3 l. D  y) X
279.         
     
280.         delay_init();                                                  //延时函数初始化         
     " ]- w) p  X7 ]! ~, m5 i2 Q
281.         Init_Usart();                                                 //初始化串口
     ! v4 x/ b4 k: N+ v
282.         LED_Init();                                                               //初始化LED
     
283.         KEY_GPIO_INIT();               //按键初始化
     
284.         HC_SR04_init();                //超声波初始化
     - u. k) O2 m3 P# \6 ]
285.         init_timer4_exti();            //定时器中断
     8 `5 M9 d4 P% e6 d; ?; O
286.         Buzzer_GPIO_Init();            //蜂鸣器初始化
     
287.         Lsens_Init();                  //光敏初始化
     
288.         Infrared_Init();               //红外初始化
     
289.         Power_init();                  //ADC1初始化  测电压
     ; r( z: K" J; k& `4 x
290.         OLED_Init();                                     //初始化OLED  
     
291.         OLED_Clear(0);        
     
292.         TIM3_PWM_Init(100-1,7200-1);        //pwm控制初始化 1hkz  计数到100为10ms         
     " {7 ]& }; G( d* f# u# X3 q, W1 L
293.         Init_interface();                                                  //初始化界面只显示一次
     6 z) ?. E! x: G$ i, N
294.         delay_ms(1000);        
     
295. 
     
296.         //printf("----------------测试---------------\r\n");
     & K5 s. c3 C$ E* h8 `& H
297.          
     9 Q2 S3 |" q% h5 F: p1 p" w1 t. V3 O
298.         //创建开始任务
     
299.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
     : E2 C& G& p" I% X# N3 n" q
300.                 (const char*    )"start_task",          //任务名称
     # X$ ~& X" p; H. h% l0 e- O$ ?- X
301.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
     
302.                 (void*          )NULL,                  //传递给任务函数的参数
     . [* \4 E- t0 B' M/ y7 u
303.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
     
304.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
     / F# q+ g& k* S0 L6 d$ W
305.     vTaskStartScheduler();          //开启任务调度
     ) e- f* Q% G+ K1 z6 D4 E9 _7 \* j
306. }
     / Z& K+ B0 {/ \8 h5 N1 u: A
307. 
     . F) m  T7 U8 B4 {" N- J
308. //开始任务任务函数
     
309. void start_task(void *pvParameters)
     
310. {
     
311.     taskENTER_CRITICAL();           //进入临界区
     1 R  ~- |2 U! R+ q8 |
312.         
     
313. 
     
314. #if KEY_START
     - m" [5 \$ {% s, Z7 k/ w
315.     //创建按键任务
     2 r" }+ F" u8 ?+ d) N, d
316.     xTaskCreate((TaskFunction_t )button_task,            
     
317.                 (const char*    )"button_task",           
     ! D7 t: g4 y1 G
318.                 (uint16_t       )BUTTON_STK_SIZE,
     
319.                 (void*          )NULL,                                
     
320.                 (UBaseType_t    )BUTTON_TASK_PRIO,        
     
321.                 (TaskHandle_t*  )&BUTTONTask_Handler);     
     4 k0 ^' Y" \& J
322. #endif
     
323.         
     5 {7 T0 q$ I  e9 G
324. #if CSB_START
     
325.         
     
326.                 //创建超声波任务
     
327.                 xTaskCreate((TaskFunction_t )csb_task,     
     
328.                 (const char*    )"csb_task",   
     
329.                 (uint16_t       )CSB_STK_SIZE,
     8 n! @8 U1 M* P6 @; T; V
330.                 (void*          )NULL,
     
331.                 (UBaseType_t    )CSB_TASK_PRIO,
     
332.                 (TaskHandle_t*  )&CSBTask_Handler);   
     
333. #endif
     * L1 ?  i' B8 T6 p$ N7 r5 x
334. 
     6 h2 M% e4 g2 `
335. 
     # J% \- H( T- I9 I" H+ Y
336. 
     
337. #if USART_START
     
338.                                                                
     * J' j: V  Y+ r& U: V8 X& }
339.                         //创建串口处理任务
     
340.                 xTaskCreate((TaskFunction_t )usart_task,     
     : J. k8 u' j8 A. f/ ^# n
341.                 (const char*    )"usart_task",   
     $ J3 K# r8 y7 r) [* G' E
342.                 (uint16_t       )USART_STK_SIZE,
     
343.                 (void*          )NULL,
     1 S0 u& ?9 y- h0 @/ D4 H" N
344.                 (UBaseType_t    )USART_TASK_PRIO,
     
345.                 (TaskHandle_t*  )&USARTTask_Handler);  
     2 }1 [: W5 r) L, [; C4 f2 h2 [
346. #endif
     
347.                                                                
     + @& \/ T1 h; Y/ l
348. #if CLOCK_START                                                        
     6 l, q7 v' [4 e! B4 {" ?
349.                 //创建定时处理任务
     
350.                 xTaskCreate((TaskFunction_t )clock_task,     
     
351.                 (const char*    )"clock_task",   
     # H) a: O. u3 i% y7 O
352.                 (uint16_t       )CLOCK_STK_SIZE,
     
353.                 (void*          )NULL,
     5 ?! {3 j& m% T+ D: q
354.                 (UBaseType_t    )CLOCK_TASK_PRIO,
     
355.                 (TaskHandle_t*  )&CLOCKTask_Handler);  
     
356. #endif
     / Z5 u& M4 Y* h, p$ d! T2 R* v# X+ B* G
357. 
     : g' \9 K+ I: O  {- [
358. #if LDR_START                                                                 
     
359.                                 //创建光敏处理任务
     
360.                 xTaskCreate((TaskFunction_t )ldr_task,     
     
361.                 (const char*    )"ldr_task",   
     
362.                 (uint16_t       )LDR_STK_SIZE,
     . b. H0 |% \! Q( C% T
363.                 (void*          )NULL,
     
364.                 (UBaseType_t    )LDR_TASK_PRIO,
     
365.                 (TaskHandle_t*  )&LDRTask_Handler);  
     
366. #endif
     
367. 
       {  Z/ N1 C5 A2 Q" g% |* d
368. 
     + G7 v6 ~5 q* N3 W
369. #if INFRARED_START                                                                 
     ; P  u  z+ x2 [5 ?3 ]' `5 @
370.                                 //创建光敏处理任务
     
371.                 xTaskCreate((TaskFunction_t )infrared_task,     
     3 A4 H; t( |* k/ k# ]  @
372.                 (const char*    )"infrared_task",   
     1 S# U; _2 V4 n/ u& \, L; W
373.                 (uint16_t       )INFARED_STK_SIZE,
     % j$ E4 f: \0 B! Q  g& W
374.                 (void*          )NULL,
     1 Q* M- a' i, Z( Y% H8 ^$ q# ?) Q
375.                 (UBaseType_t    )INFARED_TASK_PRIO,
     
376.                 (TaskHandle_t*  )&INFAREDTask_Handler);  
     
377. #endif
     7 [; q2 A# R1 F2 s& Z9 P  _4 C
378. 
     $ `# J- f" e1 ^
379. 
     3 K, c1 [9 Q8 w, f: M, x2 R
380. #if INTERFACE_START                                                                 
     * ~. \  B, A4 x& x! a, Q6 U
381.                                 //创建界面现实处理任务
     
382.                 xTaskCreate((TaskFunction_t )interface_task,     
     & X- W  v/ ]4 e2 W+ }
383.                 (const char*    )"interface_task",   
     
384.                 (uint16_t       )INTERFACE_STK_SIZE,
     8 m8 l$ H1 P* _' z" I
385.                 (void*          )NULL,
     
386.                 (UBaseType_t    )INTERFACE_TASK_PRIO,
     ' o, I7 b6 N" @
387.                 (TaskHandle_t*  )&INTERFACETask_Handler);  
     
388. #endif
     9 _9 @* @* P6 r0 g8 Y0 [9 Z) G* T
389. 
     " [, D5 v) H# |4 _4 q
390.     vTaskDelete(StartTask_Handler); //删除开始任务
     + m% v1 q5 O! d
391.     taskEXIT_CRITICAL();            //退出临界区
     
392. }
     
393. 
     
394. 
     
395. 
     
396. //按键声响声音  m每次按下按键会有一声按键声响
     
397. void Buzzer_Voice(void)
     - m' T  `9 B* v) d) \+ k
398. {
     ' A7 w6 L& U. T% O9 p! ^9 s
399.                   Buzzer_ON();
     ! V2 R* e+ B- ?/ {3 |  i3 f1 {0 V
400.                         delay_ms(200);
     ; T! a; T% m7 @) J4 x" @- w
401.                   Buzzer_OFF();                        
     ( O) L2 N* n1 m0 P  k" t
402.             delay_ms(200);
     
403. }
     ; F- v9 w) h1 {% J! k+ j& G
404. 
     
405. 
     $ f% ?; o$ Z" e7 [" d
406. #if KEY_START
     8 n( y. @4 k( |5 c& T1 `, K; W' Z
407. //按键任务函数
     ; r: X8 G% y! \5 c1 G; J+ d
408. void button_task(void *pvParameters)
     
409. {
     - u$ q/ P4 G  {) v
410.         u8 key = 0;
     ' y4 z9 T; z. _6 n. n/ E; p0 R
411.         static u8 flag = 0;
     
412.         while(1)
     
413.     {
     
414.                         if(work_mode == 1)
     
415.                         {
     
416.                                  //需要进行调试的时候可将其打开串口观察是否运行
     : V! j% p* e) h# m
417.                         //        printf("==================按键模式==================\r\n");
     
418.                                 key = KEY_Scan();
     
419.                                 //进行定时模式
     & `: W4 _6 m, D2 i; t3 |7 F
420.                                 if(key == KEY0_Value)  //PB9  KEY0_Value
     
421.                                 {
     
422.                                                 Buzzer_Voice();            //按键提示音
     
423.                                                 clock_start = 1;// 开始计时
     - z$ j  e, l9 R% j# D. e) r
424.                                                 hour = 0,min = 0,sec = 0;  //每次都从0开始
     " ~1 n1 l( f$ Z4 q5 I5 k& b
425.                                                 
     " U# ^7 }5 K' ?8 g
426.                                 }
     ' @3 i: R( c6 `  C4 E
427.                                 
     ! U0 f# U1 j) W
428.                                 //clock_start 为0 时表示进行灯光占空比的控制 为1时为时间的控制
     
429.                                 if(clock_start == 0)
     
430.                                 {
     
431.                                                 //亮度调高
     
432.                                          if(key == KEY1_Value)
       s  _& {: ^* B
433.                                                 {
     . f) }+ y9 \+ R; j* B
434.                                                          Buzzer_Voice();            //按键提示音
     
435.                                                         //调整亮度 变量
     4 X7 J% P  T! t  q; [, A$ [
436.                                                         current_duty += 20;                     //可根据实际效果进行修改
     / W' L! X- x. B% b9 X6 N7 E- @
437.                                                         printf("current_duty = %d\r\n",current_duty);
     4 E" V% m5 C: A/ D
438.                                                         //printf("this is key1 = %d\r\n",key);  //需要进行按键检测调试时可将其打开                                       
     
439.                                                 }               
     
440.                                                 //亮度调低
     
441.                                                 else if(key == KEY2_Value)
     
442.                                                 {
     4 P( b0 T$ H1 Z; V/ G# e1 J
443.                                                         Buzzer_Voice();            //按键提示音
     
444.                                                         //调整亮度  变暗
     
445.                                                         current_duty -= 20;
     
446.                                                         printf("current_duty = %d\r\n",current_duty);
     # n3 q4 }  g6 n$ N
447.                                                         //printf("this is key2 = %d\r\n",key);  //需要进行按键检测调试时可将其打开
     $ c+ W' W0 N1 ?$ T/ F$ J) ^
448.                                                         
     
449.                                                 }               
     : K7 M; i; L. `% Q% T( X% N
450.                                         }
     
451.                                 
     
452.                                 
     & F  L# K5 n/ V5 E6 U& I
453.                                 else if(clock_start == 1)
     
454.                                 {
     6 e7 T% x8 z8 f1 O9 l, w) j
455.                                         if(key == KEY1_Value)
     # y/ N# _# `6 p
456.                                                 {
     
457.                                                          Buzzer_Voice();            //按键提示音
     
458.                                                         //调整时间  ++
     
459.                                                         set_time += 5;                     //可根据实际效果进行修改
     " K' ^3 D! M2 K! Z  ^4 n: y* K
460.                                                         //printf("this is key1 = %d\r\n",key);  //需要进行按键检测调试时可将其打开                                       
     
461.                                                 }               
     
462.                                                 //亮度调低
     
463.                                                 else if(key == KEY2_Value)
     1 h3 @' s  K7 O8 Y2 g1 a
464.                                                 {
     
465.                                                         Buzzer_Voice();            //按键提示音
     
466.                                                         //时间 --
     
467.                                                         set_time -= 5;
     * \# J3 Q' s6 }3 a
468.                                                         //printf("this is key2 = %d\r\n",key);  //需要进行按键检测调试时可将其打开
     $ }! m8 ]1 Y1 M& Y+ I8 L% L1 z! m
469.                                                 }               
     
470.                                 }
     ' S7 C/ Y3 J( v7 T& ^" C
471.                         
     
472.                                        
     # |' p' }+ p/ j# V
473.                                        
     
474.                                                 //直接控制LED的亮灭 第一次按下亮 再次按下熄灭
     
475.                                          if(key == KEY3_Value)
     & m! H9 B1 e4 d  P5 H  R8 y6 V
476.                                                 {
       J! b) x( W& n8 P5 i9 ^
477.                                                         Buzzer_Voice();            //按键提示音
     7 |( v& L  o( B6 j5 {' y( {4 v6 H
478.                                                         if(flag == 0)
     
479.                                                         {
     # u1 s- `) P9 s% E: ^8 H2 z
480.                                                                 flag = 1;
     
481.                                                                 current_duty = 100;   //占空比最大亮
     ! ?7 l2 B( ~; ]# {% e. m6 X0 Z
482.                                                         }
     ' E5 d- y" s- {( d& X% q: Z: Y. X9 a
483.                                                         else if(flag == 1)
     ; W* a4 V$ }8 C) P4 u* k5 r7 |* x
484.                                                         {
     7 w) I# e8 N/ B. N* ~; \& i8 {+ G
485.                                                                  flag = 0;
       n  ?. i( z, s. L& h9 e
486.                                                                  current_duty = 0;    //占空比最小 熄灭
     0 S! F# s! e9 h  F2 C3 t
487.                                                         }
     9 F1 }, m+ t% A
488.                                                         printf("current_duty = %d\r\n",current_duty);
     9 B8 y# L( Q( V! x2 b
489.                                                         //printf("this is key2 = %d\r\n",key);  //需要进行按键检测调试时可将其打开                                
     ' ?1 L8 g) f9 N7 L0 }# ^
490.                                                 }
     
491.                                         }
     
492.                                        
     ! z1 s8 n8 D& Z2 d
493.       vTaskDelay(120);
     . U1 T( b: O3 u$ w" m, t/ c
494.     }
     ! a/ ]3 p+ [: W3 `+ {
495. }   
     8 U7 @# r; B" U  F
496. #endif
     % g, o9 X3 K) m
497. 
     , q+ Q9 T4 m# e! t$ \) n: a
498. 
     
499. #if LDR_START         
     
500. //光敏任务函数
     
501. void ldr_task(void *pvParameters)
     
502. {
     
503.                 while(1)
       i9 l) l; _0 g2 M0 G2 ~5 l
504.                 {
     
505.                         if(work_mode ==2)
     
506.                         {
     
507.                                  //需要进行调试的时候可将其打开串口观察是否运行
     ( K2 @$ h7 ]" X; S7 }* b
508.                                 //printf("==================光敏模式==================\r\n");
     & a* j- E' S1 _9 V$ A" V
509.                                 adcx = Lsens_Get_Val();
     7 d, b9 p7 ]$ Y# f# j' h, L" p
510.                                 //根据光敏强度自动调节灯光的亮度  这里分为5个等级
     8 o; H( d# D& T1 l$ V* A
511.                                 if(adcx > 0  && adcx < 20 )
     : ~# h# n2 @( N5 N3 A
512.                                 {
     
513.                                         current_duty = 100;
     
514.                                        
     
515.                                 }
     
516.                                 else if(adcx >= 20 && adcx < 40)
     ) q! P8 S1 I- F$ U
517.                                 {
     
518.                                         current_duty = 80;
     ! g4 W: X4 g) S8 Y/ W7 q# L
519.                                 }
     ! K- T, J7 r& R/ J" x7 X2 \
520.                                 else if(adcx >= 40 && adcx < 60)
     
521.                                 {
     
522.                                         current_duty = 60;
     
523.                                 }
     
524.                                 else if(adcx >= 60 && adcx < 80)
     
525.                                 {
     
526.                                         current_duty = 40;
     % \$ `7 c% r% W" k, f+ K  ?
527.                                 }
       d: n5 s% P- s5 V! I/ ^
528.                                 else if(adcx >= 80 && adcx < 100)
     
529.                                 {
     2 H2 {% }2 {, F8 \$ `- G! Z) H
530.                                         current_duty = 20;
     ! g% ~2 L+ n0 b* I% I
531.                                 }
     
532.                                 TIM_SetCompare2(TIM3,current_duty);
     
533.                                 printf("adcx = %d\r\n",adcx);
     ) T2 J$ @- F; q# ^
534.                         }
     
535.                          vTaskDelay(40);
     ) z$ I1 R" j& u% }7 k/ b
536.                 }
     # o$ u# P4 [* K, X# f0 S: @3 w2 }3 b
537. }
     6 L* q7 ~! O4 u8 i. x
538. #endif
     
539. 
     
540. 
     
541. 
     
542. #if CSB_START
     
543. //超声波任务函数
     
544. void csb_task(void *pvParameters)
     ) p: D7 Z: m# n, |( ^7 E5 Y
545. {
     
546.         float distance = 0;
     
547.         unsigned char i = 0;
     
548.         while(1)
     : d5 W( G* z5 x4 p
549.     {
     9 F2 E3 |& X# ?+ f, h4 c
550.                                 if(work_mode == 5)
       c$ I- b1 S  @2 ^' g+ J7 Z
551.                                 {
     * b3 Z. g% c) [* l8 w7 M* b
552.                                  distance = Get_HS_Length_Value();
     
553.                                  if(distance < Set_Dis)   //SSet_Dis 宏定义可自己更改数值
     
554.                                  {
     ) g" O9 X0 b! l7 o( C2 ?( \
555.                                          for(i = 0;i<5;i++)
     
556.                                          {
     
557.                                                  Buzzer_Voice();       //报警声响
     
558.                                          }               
     
559.                                  }
     
560.                                  
     # C$ \$ S1 T3 h, f3 B. N
561.                                  //处于开灯的范围
     
562.                                  if(distance < Dis)
     2 R+ g; O, [0 G
563.                                  {
     
564.                                          current_duty = 100;
     ( q9 Q9 ~: g4 D& o% H% E
565.                                         }
     
566.                                   printf("distance = %.2f\r\n",distance);  //进行串口调试的时候将其打开
     
567.                                 }
     
568.                                 vTaskDelay(80);
     
569.     }
     
570. }   
     
571. #endif
     
572. 
     6 c; \& E. ]  t7 Q+ M' c, O: N* y
573. 
     * ~: a  ]# K; y, J( Y
574. #if USART_START
       a- @1 z+ _2 b) k2 g6 a
575. 
     ( d- I2 b* t' A  ?( `' o
576. //串口功能接收函数
       l1 F( o! H0 U* K4 f$ N5 a
577. 
     / g; e1 j. U/ {$ b7 ]
578. //注意下面 cmd_temp 后面的十六进制可根据自己的指令来更改
     4 P2 f1 r( f: s) [( S
579. 
     , h9 D2 P& W  F5 _! h  f. z
580. void usart_task(void *pvParameters)
     6 h+ C* ]+ B9 q. S: ^5 H
581. {
     , W: V8 d! Q8 c! |" v) y
582.          unsigned char cmd_temp = 0;
     ' g! B& {/ n( b2 T- b/ @; A2 S2 \
583.                 while(1)
     
584.                 {
     
585.                         //后面的命令有根据自己来进行调节最后写十六进制
     % ~! C$ U! V7 m# I# A& _; I
586.                         cmd_temp = Usart1_cmd;
     ) _8 h$ U0 ~! z5 A& q! g! _
587.                         Usart1_cmd = 0;   //清除
     
588.                
     
589.                         if(cmd_temp == 0x01)   //板载LED PC13
     ' Z& e8 D" W( Y' y. r# {
590.                         {
     & m; P; w# p9 x. s2 f* |
591.                                 LED = 0;             //PC13 打开
     1 V1 F4 O/ i& A. i; j; F( E- W
592.                         }
     
593.                         else if(cmd_temp == 0x02)
       J+ ^4 g# i& {5 _! \
594.                         {
     
595.                                 LED = 1;             //PC13 关闭
       v& i2 H- W' _2 ~, y
596.                                 
     + Q$ t& V$ x& |4 V. w2 N
597.                         }               
     ; ^2 u0 ~! }9 e9 d8 ]+ D: }& Y
598.                         
       H  K; h: v7 t2 k5 _% r
599.                         /*==========================下面指令是控制我们用的LED (PWM控制)===========================*/
     
600.                         else if(cmd_temp == 0x03)     //直接打开 最亮 占空比百分百
     
601.                         {
     $ e) K- g* T1 e2 y
602.                                  current_duty = 100;
     
603.                         }
     $ z, ?# z/ ]4 f5 a6 F- }: g
604.                         else if(cmd_temp == 0x04)     //直接关闭 最暗  占空比最小 0
     
605.                         {
     5 F% X/ h" I3 [- j3 y" i6 X
606.                                  current_duty = 0;
     
607.                         }
     
608.                         else if(cmd_temp == 0x05)    //占空比控制 加加
     : e* F- @' O/ w. S; e" E1 Q
609.                         {
     , v5 h; R* [, }& e, ?
610.                                  current_duty += 20;       //这里的数字可根据实际效果写大或者写小
     6 b: I( B5 B  ^
611.                         }
     
612.                         else if(cmd_temp == 0x06)     //占空比控制 --
     
613.                         {
     1 H4 d' k& R- E7 x3 d: A: H+ o+ t
614.                                 current_duty -= 20;        //这里的数字可根据实际效果写大或者写小
     
615.                         }
     
616.                         
     " S: r+ L. X3 }. {- \# n" H) Y
617.                         
     # `$ d$ H, k" ?; v& J) R5 N4 X2 l9 g- \
618.                         //==========================模式切换命令============================
     2 E; C0 t- Z0 T- N9 w
619.                         else if(cmd_temp == 0xea)
     ; f8 ]. b3 @/ H5 @* Y
620.                         {
     
621.                                  work_mode = 1;   //按键模式               
     
622.                                  send_flag = 1;
     
623.                         }
     
624.                         else if(cmd_temp == 0xeb)
     
625.                         {                        
     # g9 {# F0 D2 j8 n
626.                                 work_mode = 2;   //光敏模式
     
627.                                 send_flag = 2;
     1 v4 S( G& \& e  N5 }
628.                         }
     3 l' x) c- t3 L& ?7 H* v
629.                         //在时间设置模式下才能进行时间的修改
     6 o- o5 |' C9 K( q- o/ G2 q
630.                         else if(cmd_temp == 0xec)
     - I( Q( }' v' d4 P1 a+ v$ n) B
631.                         {
     0 ]) O9 G% Q* p* c) N0 E- U
632.                                 work_mode = 3;
     
633.                                 send_flag = 3;
     
634.                                 clock_start = 1;// 开始计时
     
635.                                 hour = 0,min = 0,sec = 0;  //每次都从0开始
     , _* P& r+ n* R( e; c% u) r! H! a
636.                                 //时间增加 每次加5s  可自己修改数值
     
637.                         }
     
638.                         //红外
       ?- m! Z8 r( q3 N5 c& p
639.                         else if(cmd_temp == 0xed)
     
640.                         {
     ! }* h$ r: }; q; @& Z& f
641.          work_mode = 4;
     $ `6 o( o( g$ x# M5 L
642.                                  send_flag = 4;
     & `8 g( s( R2 ~8 G( N
643.                                 
     
644.                         }
     9 d8 z/ ?4 x8 w2 u3 `* Q
645.                         //超声波
     ! A6 k2 B; E/ ~; l3 e1 ?  {
646.                         else if(cmd_temp == 0xff)
     
647.                         {
     
648.          work_mode = 5;
     
649.                                  send_flag = 5;
     
650.                                 
     6 J2 L. \& o" G/ |* Y1 ?
651.                         }
     
652. 
     + G. y* {( {/ r' J9 d% J7 I
653.                         else if(cmd_temp == 0x07)     
     
654.                         {
     
655.                                  set_time += 5;
     / N! t* g0 i. _# w# a, N
656.                                 //        printf("set_time = %d\r\n",set_time);
     
657.                         }
     & Z( ?+ I8 H' [
658.                                 
     $ Z! N- Z2 |0 U6 O) p# [
659.                         //时间--每次-5s  可自己修改数值
     
660.                         else if(cmd_temp == 0x08)  
     
661.                         {
     
662.                                 set_time -= 5;
     5 g1 h3 \3 G' D! a+ M
663.                         //        printf("set_time = %d\r\n",set_time);
     
664.                         }
     
665.                         TIM_SetCompare2(TIM3,current_duty);
     
666.                         printf("current_duty = %d\r\n",current_duty);
     - U1 k, W/ z$ u' z. c
667.                         vTaskDelay(120);
     
668.         }
     
669. }
     
670. #endif
     : D! b8 G8 S9 l/ m
671. 
     
672. #if CLOCK_START
     4 f$ t6 F/ w6 ?
673. //定时任务函数
     
674. void clock_task(void *pvParameters)
     
675. {
     ; G8 P5 n2 m, n" g
676.         unsigned char i = 0;
     
677.         while(1)
     
678.         {
     5 J/ P2 G/ f6 \5 K6 r
679.         
     5 d! P$ i& u  n; g1 O
680.                         //定时时间到了 灯自动熄灭 蜂鸣器给个提示音
     1 c* i) a+ f: S8 g$ ^& A
681.                         if(clock_flag == 1)
     
682.                         {
     
683.                                          //需要进行调试的时候可将其打开串口观察是否运行
     $ n) a2 t" Q* u
684.                                         //printf("==================定时模式==================\r\n");
     ( K6 h' F! H" z. G
685.                                         printf("==============时间到了==============\r\n");
     ' K  C& Q, S  N7 ?. k  w
686.                                   USART_Send_String(USART2,"time over");
     6 M7 A& O' ?. l( @8 j5 a
687.                                   clock_flag = 0;   //重新置0  等待下一次
     
688.                                         current_duty = 0;
     
689.                                         for(i = 0;i< 5;i++)
     0 G7 N7 x, I& e; q. W
690.                                         {
     # W4 |# Q$ i) S  j8 w8 @
691.                                                 Buzzer_Voice();
     
692.                                         }
     
693.                                        
     
694.                         }
     
695.                          vTaskDelay(50);
     ) k1 g% t2 P. `9 ~  B
696.     }
     
697. }   
     6 I8 ^1 n2 V, x2 i7 c" k+ z% v: I
698. 
     
699. #endif
     
700. 
     8 W! h+ j0 b, l. h; p5 O5 p. B1 r
701. 
     * L- x9 X4 y+ j
702. #if INFRARED_START
     # a5 }; o$ I4 l# l4 r& s
703. //红外人体感应功能测试
     ! X8 k7 g7 ~1 d6 X7 I
704. //感应到人体输出高电平，离开感应区域输出低电平
     
705. void infrared_task(void *pvParameters)
     , \% v! L' A4 S- G$ I! n4 Z
706. {
     
707.         
     ! [3 W$ p3 E; v0 [) R7 P
708.         while(1)
     
709.         {
     & {) A* U7 B. @3 Y( D, F
710.                         //定时时间到了 灯自动熄灭 蜂鸣器给个提示音
     + p9 y/ r4 f( ~; N
711.                         if(work_mode == 4)
     9 g8 L2 A1 r$ B
712.                         {
     ; ~, N3 u& Z: w4 S
713.                                  //需要进行调试的时候可将其打开串口观察是否运行
     
714.                                 //printf("==================红外模式==================\r\n");
     
715.                                 if(Read_STATE() == RESET)  //检测到人了 开灯
     8 }( H# c5 y) H: P2 m+ ^
716.                                 {
     
717.                                         current_duty = 100;
     8 w2 C2 ~, j7 _& s" O
718.                                 }
     
719.                                 else
     
720.                                 {
     
721.                                         current_duty = 0;
     
722.                                 }
     
723.                                 
     
724.                         }
     4 p+ E' u. B! V* Z0 j8 R
725.                         TIM_SetCompare2(TIM3,current_duty);        
     
726.                          vTaskDelay(50);
     
727.     }
     
728. }
     % C! Q" e' \$ _- x  k# `
729. 
     ( z. f) H2 T- x  F. v1 K
730. #endif
     
731. 
     
732. 
     
733. #if INTERFACE_START
     : c" M! N2 N% e/ ^. l# K
734. 
     
735. 
     + g. n' @* |* `* D- R& i
736. //下面发送到蓝牙放的数据可根据自己需求 也可以屏蔽掉
     9 q; P. w4 x7 H; }& q( Z
737. void interface_task(void *pvParameters)
     
738. {
     
739.         static unsigned char temp_mode = 1;
     
740.         while(1)
     / z; e. ]( R6 v* n7 E8 g
741.         {
     + }) U3 D4 ?" X6 D6 y! b
742.                         if(temp_mode != work_mode)
     
743.                         {
     & j5 i) f3 h, e7 m
744.                                 OLED_Clear(0);
     ! X0 N4 t1 c1 N
745.                                 temp_mode = work_mode;
     9 V7 I+ n& p# O  y/ _: _. S" t
746.                         }
     ; }, `+ r$ h* L4 @0 q% q
747.                         if(work_mode == 1)
     
748.                         {
     
749.                                 //按键模式
     
750.                                 KEY_Display();
     
751.                                 if(send_flag ==1)
     ) x# n/ q5 x- E
752.                                 {
     
753.                                         send_flag = 0;
     
754.                                   USART_Send_String(USART2,"========按键模式=======\r\n");
     
755.                                 }
     
756.                         }
     - |' o' ]; E  a. S
757.                         else if(work_mode == 2)
     4 I9 Q; \" U- K9 P6 s# j- ~
758.                         {
     
759.                                  //光敏模式
     ' ?: i" ]7 j& M3 q& i' U' w$ P" B
760.                                  LDR_Display();
     6 e6 l$ ^2 Q5 E- C: e, Z
761.                                 if(send_flag == 2)
     ( P" O' R' B% \+ o# ^7 m
762.                                 {
     
763.                                         send_flag = 0;
     
764.                                         USART_Send_String(USART2,"========光敏模式=======\r\n");
     
765.                                 }
     8 E7 T. N" f6 z' z9 e2 g; j3 P" ^
766.                         }
     ( t5 I( L9 Q! l  K' O
767.                         else if(work_mode == 3)
     * N: `4 f. h; D  M  K
768.                         {
     
769.                                 //定时模式
     
770.                                 Time_Display();
     " i% Z+ b" ~4 Q" o) J* I  R
771.                                 if(send_flag == 3)
     ) S! A$ k+ G3 M9 [% F$ \
772.                                 {
     
773.                                         send_flag = 0;
     & y2 y! _) i& l
774.                                   USART_Send_String(USART2,"========定时模式=======\r\n");
     
775.                                 }
     
776.                         }
     ( X8 y* ?; H! N' ~* Q
777.                         else if(work_mode == 4)
     
778.                         {
     
779.                                 //红外模式
     : N5 p6 C1 C0 z+ Y4 b" v4 ]* ?' j
780.                                 Infrared_Display();
     
781.                                 if(send_flag == 4)
     & f; I) Y! C4 b
782.                                 {
     
783.                                         send_flag = 0;
     
784.                                         USART_Send_String(USART2,"========红外模式=======\r\n");
     " j! A/ `5 N, Z; r) Y8 _) Q1 G
785.                                 }               
     % k2 I; \" h2 {* J
786.                         }        
     9 v. u. A7 G0 B4 a
787.                          vTaskDelay(200);
     / @/ p! R9 e) q1 W
788.     }
     
789. }
     
790. 
     ' j- u; {/ ^5 a: R0 q
791. #endif
     7 j+ H' Q0 B3 B5 f2 U; \
792. 
     
793. /*-------------------------------串口中断服务函数-------------------------*/
     8 |0 I- |) N& _& {
794. //串口1接收  PA9 PA10   语音模块
     ( m+ _8 N. h, p- a+ Q. ~
795. void USART1_IRQHandler(void)
     $ g( n9 h5 M! v& r0 U& e6 Y5 c
796. {
     % v6 z) ~# h0 F4 b0 h* q
797.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //接收中断
     
798.         {
     
799.                 Usart1_cmd = USART_ReceiveData(USART1);
     
800.                 USART_SendData(USART1,Usart1_cmd);
     
801.                 USART_ClearFlag(USART1, USART_FLAG_RXNE);
     
802.         }
     9 Q8 P' h. Y1 f8 o
803. }
     
804. 
     
805. 
     * X1 |8 [5 T. n3 I; ~
806. //l蓝牙 RX-  PA2  TX-PA3
     ' {5 d0 _/ q  N9 f  I: _! v- p
807. void USART2_IRQHandler(void)
     * A8 _- J: ?' Q$ ?' A% G
808. {
     
809.     if(USART_GetITStatus(USART2,USART_IT_RXNE) != RESET)
     8 v7 b$ O" V! r2 L+ `! \- y! C
810.     {
     
811.        Usart1_cmd = USART_ReceiveData(USART2);                                
     
812.                          USART_ClearFlag(USART2, USART_FLAG_RXNE);
     2 \$ u9 [8 C8 a3 p# B
813.     }
     
814. }
     
815. 
     6 Z. y& `# w0 K6 P8 K/ Y+ O
816. 
     % S; Q% H6 p2 ^- O
817. 
     ! ^& _5 b" O) e; _  G9 V
818. 
     
819. 
       P0 r2 i  m5 H" l& G" O
820. void TIM3_IRQHandler(void)   //TIM3中断
     
821. {
     6 y3 [$ ]* P; e% ~
822.         static unsigned int volt_t = 0;          //控制电压检测时间 2s检测一下电压
     
823.         char str_t[24];                          //发送时间到蓝牙
     
824.         if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)  //检查TIM3更新中断发生与否
     ) z! E3 s6 [/ ?; P9 K$ [
825.                 {
     1 |8 d9 j0 p4 Z
826.                                 TIM_ClearITPendingBit(TIM3, TIM_IT_Update  );  //清除TIMx更新中断标志  //10ms
     4 X5 W' ]4 f0 q, s0 X. h$ p
827.                                 volt_t++;
     
828.                         if(volt_t == 200)
     6 k" k" J& a; G5 X5 {6 H! w
829.                         {
     ( q5 P  K  C8 q; N# ]4 [
830.                                 volt_t = 0;   //计数清零
     
831.                                 voltage = Power_Get_VBAT();
     - ^" |& }( b, A9 i5 ]
832.                                 sprintf(str,"volt:%.2f\r\n",voltage);
     
833.                                 USART_Send_String(USART2,str);
     
834.                                 //printf("voltage = %.2f\r\n",voltage);  //需要用串口进行观察时将其打开
     
835.                         }
     
836.                           if(clock_start == 1)  //定时模式 开始进行计时
     
837.                                 {
     4 f6 s3 Q; [% {; p. L
838.                                         count++;
     
839.                                         if(count == 100)
     
840.                                         {
     
841.                                                 count = 0;
     
842.                                        
     
843.                                                 sec++;
     
844.                                                 if(sec == 60)
     
845.                                                 {
     7 v# Y6 m& ^" T
846.                                                         sec = 0;
     5 q/ P4 ]8 B6 u; i
847.                                                         min++;
     
848.                                                         if(min== 60)
     
849.                                                         {
     , z0 X. `4 x. J4 c1 Y- e% W
850.                                                                 min = 0;
     
851.                                                                 hour++;
     
852.                                                                 if(hour == 24)
     ! \% l, U# \  ]7 s
853.                                                                 {
     
854.                                                                         hour = 0;
     7 O9 x: ]0 O4 \
855.                                                                 }
     
856.                                                         }
     
857.                                                 }
     + `% b& Z$ l0 C5 r5 N8 f& V
858.                                         sprintf(str_t,"%02d:%02d:%02d\r\n",hour,min,sec);
     
859.                                         USART_Send_String(USART2,str_t);
     0 J. @" S: g- T) [  l0 a
860.                                         //        printf("%2d:%2d:%2d\r\n",hour,min,sec);
     
861.                                         }
     
862.                                         time[0] = hour/10; //获取小时的十位
       u% y2 N* T3 m7 E
863.                                         time[1] = hour%10;//获取小时的个位
     $ p: J5 V( X$ |8 q7 ]) l
864.                                         time[2] = min/10; //获取分钟的十位
     + C% v" w+ a  C' B1 N" i
865.                                         time[3] = min%10;//获取分钟的个位
     : }) K* ^! V  D. A
866.                                         time[4] = sec/10; //获取秒的十位
     ' h" o2 |3 v7 ~8 l3 h( c6 ?9 z) ^2 ?
867.                                         time[5] = sec%10; //获取秒的个位
     & X# X+ ^. i* B+ D7 ?% R
868.                                         if(hour *24 + min *60 + sec == set_time)   //计时时间与我们设定的时间相等
     8 i+ B! L, F# @9 X7 B8 t
869.                                         {
     + d9 I6 }! {6 r# {& _9 U
870.                                                  clock_flag = 1;           //标志置1
     2 q* E& w: w0 `
871.                                                   clock_start = 0;          //停止计时                                
     % \+ e" T& Z& [# j0 O$ W9 w( K
872.                                         }        
     
873.                                        
     2 Z( D7 E* H5 _5 K8 f! {
874.                                 }
     
875.                         }
     
876. }

复制代码

: N! X0 Q. o) i9 E- n9 ?# X8 q————————————————
8 {3 k3 r* `; y, S: j) [. R版权声明：@slow-walker
; v4 {" u) C2 _6 o/ D( h
' a$ i; Y* Y* |" W3 ~