基于FreeRtos温湿度采集+蓝牙
本次分享的是基于FreeRtos的温湿度采集并且将所采集的数据通过蓝牙每隔1s发送到手机一次。
" M7 U4 o6 u" J3 t7 V/ {
5 [# O( P1 U9 a硬件说明

& f2 g' Z# D& L- Y' Y使用的是DHT11温湿度模块，蓝牙使用的是HC-05，具体的使用方法就不做介绍了。

2 c6 Y; u% E) V6 r

( L8 c3 s! j$ \
& n8 Q5 P8 v5 s/ T下面直接进入主题
$ c0 h) w  {& X8 o- Y- {% L1 N0 |# j
) ~2 G, Y# S- Z7 iusart.h //这个头文件里面宏定义了三个串口 可根据自己需求进行使用

1. #ifndef __USART_H
   
2. #define __USART_H
   
3. #include "stdio.h"        
   
4. #include "sys.h"
   
5. 
   5 v' b# \) r5 g% M# @
6. #define USART_REC_LEN                          200          //定义最大接收字节数 200
   " \9 b: M: o- b/ d4 o  J% ?. A' V5 [
7. #define EN_USART1_RX                         1                //使能（1）/禁止（0）串口1接收
   & ]- u, E% |! P( E
8. #define EN_USART2_RX                         1                //使能（1）/禁止（0）串口1接收
   
9. #define EN_USART3_RX                         0          //使能（1）/禁止（0）串口1接收
   ' S9 ]: z! K) {. t
10. 
    7 \5 K: e! e4 u1 b" G) V
11. 
    ! @7 ~; Q6 n' o6 Q
12. #define  DEBUG_USARTx                   USART1
    $ Y8 U8 o7 p( z& Q2 P9 Y, r
13. //串口1
    
14. #define USART1_GPIO_PORT      GPIOA
    
15. #define USART1_GPIO_CLK       RCC_APB2Periph_GPIOA
    " \) B( L9 G+ p+ f2 ]
16. #define USART1_TX_GPIO_PIN    GPIO_Pin_9
    
17. #define USART1_RX_GPIO_PIN    GPIO_Pin_10
    
18. //串口2
    , z! L+ i( K' [
19. #define USART2_GPIO_PORT      GPIOA
    7 W* V. N% Q% ^  a' K$ Z' y
20. #define USART2_GPIO_CLK       RCC_APB2Periph_GPIOA
    
21. #define USART2_TX_GPIO_PIN    GPIO_Pin_2
    3 o: u0 m( k" i6 Q% @
22. #define USART2_RX_GPIO_PIN    GPIO_Pin_3
    
23. 
    
24. 
    
25. //串口3
    2 E$ q5 _4 f& Q
26. #define USART3_GPIO_PORT      GPIOB
    
27. #define USART3_GPIO_CLK       RCC_APB2Periph_GPIOB
    ! @4 z/ `( E" M" x
28. #define USART3_TX_GPIO_PIN    GPIO_Pin_10
    
29. #define USART3_RX_GPIO_PIN    GPIO_Pin_11
    
30. #define USART3_RX_EN                         1                                        //0,不接收;1,接收.
    ( N' U! w& a) F: f
31. #define USART3_MAX_RECV_LEN                600                                        //最大接收缓存字节数
    
32. extern vu16 USART3_RX_STA;                                                   //接收数据状态
    # K3 Q7 M% C# y
33. extern u8  USART3_RX_BUF[USART3_MAX_RECV_LEN];                 //接收缓冲,最大USART3_MAX_RECV_LEN字节
    ; n0 S. C1 U; w5 d& R3 V
34. 
    
35.                   
    * q: Q9 {1 _) b) m" g
36. extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    9 D9 C" G$ ]& l
37. extern u16 USART_RX_STA;                         //接收状态标记        
    4 Q- W6 Z. @! T
38. //如果想串口中断接收，请不要注释以下宏定义
    7 q/ W, z3 d5 ^( w. _1 U
39. void uart_init(u32 bound);
    
40. void usart_init2(u32 bound);
    
41. void usart_init3(u32 bound);
    # K& K' q. u# S% z- E8 m1 ^: _
42. void u3_printf(char* fmt,...) ;
    
43. void USART_Send_Byte(USART_TypeDef* USARTx, uint16_t Data);
    * ]+ w- B1 `6 j: S
44. void USART_Send_String(USART_TypeDef* USARTx, char *str);
    8 C  Q# p# d, F9 t$ {0 s8 F
45. #endif

复制代码

) |+ N% g( ~! u! u+ N2 musart.c
5 S0 P0 B  j/ `- z3 n. S
" E' T) c; M9 E2 m

1. #include "sys.h"
   
2. #include "usart.h"         
   # C7 a8 V% }/ V2 Z
3. #include "stdarg.h"        
   7 P6 G2 y: C2 h3 j/ Y4 `
4. #include "string.h"
   $ D/ @; [: K, D- c7 r5 P
5. //         
   
6. //如果使用ucos,则包括下面的头文件即可.
   / |: t% X2 ^2 ^7 _4 H$ g
7. #if SYSTEM_SUPPORT_OS
   - ~0 }2 l, G  J, |8 w8 q
8. #include "FreeRTOS.h"                                        //FreeRTOS使用                  
   
9. #endif
   
10. 
    
11. 
    ! {/ N% J8 R. u( h
12. #if 1
    
13. #pragma import(__use_no_semihosting)            
    / E; L" x- t3 p( X" G
14. //标准库需要的支持函数                 
    : f# T9 `$ q- T2 U# T% z
15. struct __FILE
    
16. {
    
17.         int handle;
    
18. 
    
19. };
    
20. 
    
21. FILE __stdout;      
    
22. //定义_sys_exit()以避免使用半主机模式   
    5 R1 A1 U" k  ]  m
23. void _sys_exit(int x)
    0 H. h3 J' S$ S* @- h- _
24. {
    
25.         x = x;
    # q. W% x) u9 r0 g
26. }
    
27. //重定义fputc函数
    , _; k1 J" Z! k0 G. ?6 N3 ^! u0 Z
28. int fputc(int ch, FILE *f)
    
29. {      
    
30.         while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
      z2 K: Q0 a) O' T  W: Y6 ?
31.     USART1->DR = (u8) ch;      
    ' _9 z- O$ b) J
32.         return ch;
    
33. }
    2 [+ A0 k. Q' R* G
34. #endif
    
35. 
    
36. /*使用microLib的方法*/
    
37. /*
    3 p; ~. ]  m) T, @% Z$ ]7 m7 r
38. int fputc(int ch, FILE *f)
    : H9 ?" @) a. [4 y* @: x
39. {
    
40.         USART_SendData(USART1, (uint8_t) ch);
    
41. 
    
42.         while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET) {}        
    
43. 
    $ u% S6 ~* _7 Z# I( R# c# G9 P- y
44.     return ch;
      ?# d3 ~5 z6 M* B! L$ a6 c
45. }
    
46. int GetKey (void)  {
    
47. 
    
48.     while (!(USART1->SR & USART_FLAG_RXNE));
    0 ~1 x+ \# a' o$ ~$ J. f* L. |
49. 
    
50.     return ((int)(USART1->DR & 0x1FF));
    
51. }
    " c; D( n$ x: {1 }' R
52. */
    $ k9 @0 H% ~6 y0 J0 ^% f
53. 
    & `; v: S3 ]/ ~+ H: z: c
54. 
    - ?3 e# ^( `& R  m3 m: m
55. 
    
56. /*===============================================================================================*/
    $ b0 l, m3 w% _  t$ i- M7 R% u
57. u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
    # j% o" ~, q9 G7 p% a# {7 ~
58. //接收状态
    9 Z6 `3 X# B" f. D9 a6 ?
59. //bit15，        接收完成标志
    
60. //bit14，        接收到0x0d
    ) F9 X# o+ V6 K
61. //bit13~0，        接收到的有效字节数目
    7 f& y" t$ t' v$ h! t
62. u16 USART_RX_STA=0;       //接收状态标记        
    ; ]# `6 p! p# N# Q: [. A
63. /*================================================================================================*/
    % N3 Q' K3 K5 [! T0 p/ M
64. 
    
65. 
    ; M6 g$ N  ]4 ?, e; f) t  ^8 a1 e8 M; _
66. #if EN_USART1_RX   //如果使能了接收
    
67. //串口1中断服务程序
    
68. //注意,读取USARTx->SR能避免莫名其妙的错误           
    # A) \7 V$ S1 r
69. 
    
70. 
    
71. void uart_init(u32 bound){
    
72.         //GPIO端口设置
    + R+ Q! c: Q$ W% t/ o
73.         GPIO_InitTypeDef GPIO_InitStructure;
    
74.         USART_InitTypeDef USART_InitStructure;
    
75.         NVIC_InitTypeDef NVIC_InitStructure;
    3 b/ R3 }/ \5 ]2 N1 j& n
76.          
    % _0 Q3 {; l. f2 y' W, `5 l
77.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
    
78. 
    * @' r7 `% w6 H" F( J7 B. Y
79.         //USART1_TX   GPIOA.9
    
80.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    
81.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
82.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
    
83.         GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
    ) M* K1 y/ _: i! a. k. O
84. 
    * i, K" ^3 e4 z/ m7 T
85.         //USART1_RX          GPIOA.10初始化
    . s" m* Q  V" p
86.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    8 R/ t7 `1 v$ x) ~' r
87.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    8 _& F) ~7 C0 F  H- N" h
88.         GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  
    9 o% }, A/ l0 h; D, ^6 X) t% ]
89. 
    
90.         //Usart1 NVIC 配置
    
91.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
92.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=4 ;//抢占优先级3
    
93.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                //子优先级3
    
94.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    
95.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    
96. 
    7 b) l1 k# _# p6 s. P
97.         //USART 初始化设置
    
98. 
    
99.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
    
100.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
     + ^7 H0 n0 ^# _; j! q9 w
101.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
     ) O7 s! E4 L9 S# b
102.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
     6 [+ X8 G9 {9 G3 C* u, W: O
103.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
     
104.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
     $ l5 b/ D5 {0 m- Y/ j) L. v4 g
105. 
     
106.         USART_Init(USART1, &USART_InitStructure); //初始化串口1
     
107.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
     
108.         USART_Cmd(USART1, ENABLE);                    //使能串口1
     
109. }
       `. A; K) L# A9 E* x) B
110. 
     $ B# [# M# y. W* f4 _8 n
111. void USART1_IRQHandler(void)                        //串口1中断服务程序
     
112. {
     . f' L) F9 D4 ^/ w0 i
113.         u8 Res;
     
114. 
     
115.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
     
116.                 {
     . N% g/ [5 |5 _7 e6 f
117.                 Res =USART_ReceiveData(USART1);        //读取接收到的数据
     
118.                
     
119.                 if((USART_RX_STA&0x8000)==0)//接收未完成
     # p1 x. [* q2 m5 T  a$ @# k
120.                         {
     " ]7 R0 z; z/ U+ _, Z! J+ v
121.                         if(USART_RX_STA&0x4000)//接收到了0x0d
     ' ~# v2 ^6 d9 [& v% o
122.                                 {
     
123.                                 if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
     
124.                                 else USART_RX_STA|=0x8000;        //接收完成了
     ) ~  @# q2 K3 P/ m+ W& n
125.                                 }
     8 U* ~; U2 n2 t9 E& L
126.                         else //还没收到0X0D
     
127.                                 {        
     
128.                                 if(Res==0x0d)USART_RX_STA|=0x4000;
     
129.                                 else
     
130.                                         {
     
131.                                         USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
     
132.                                         USART_RX_STA++;
     + `$ Z2 c8 H- U8 [1 a4 F1 m
133.                                         if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收         
     
134.                                         }                 
       y4 E% w0 }, t5 T$ x
135.                                 }
     + ^( j/ b7 ?1 W# u( W, `; H
136.                         }                    
     ) j2 y; v% _3 c" @  H
137.      }
     ! b# h1 X5 p% ]) i  o& g/ D
138. }
     & ^. @7 }0 Q3 v2 F
139. #endif        
     3 y) V6 t; F# s" r3 J
140. 
     
141. /*=======================================================串口二===========================================*/
     
142. 
     3 N( x* Y/ h: x
143. #if  EN_USART2_RX
     , L8 g, c7 i. e/ ?
144. 
     + X$ ~" A0 _" h  p+ G+ J2 k
145. void usart_init2(u32 bound)
     ' M: V& {' {4 T. u1 w; [
146. {
     - u7 |5 X; p2 h! F3 s
147.     GPIO_InitTypeDef GPIO_Init_Structure;                            //定义GPIO结构体
     ) h6 Q7 ?( c  d
148.     USART_InitTypeDef USART_Init_Structure;                          //定义串口结构体
     / u5 x4 f' `3 P0 m& X6 k  T: c
149.                 NVIC_InitTypeDef  NVIC_Init_Structure;                                                                                                                //定义中断结构体
     4 t' X0 [1 y/ N2 E, b1 Y
150.                 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
     4 `, w  ?! o9 E# X3 E  I# f
151.         
     
152.     RCC_APB2PeriphClockCmd(USART2_GPIO_CLK,  ENABLE);                 //开启GPIOA时钟
     : o* C/ R' Y- `$ l  R
153.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,  ENABLE);            //开启APB2总线复用时钟
     6 z' j$ t4 S) M' O; E7 b$ Q1 n* b* S
154.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,  ENABLE);          //开启USART1时钟
     0 ]1 f! }4 C  Z+ x* Z
155. 
     , p1 b% b7 p' y" }
156.     //配置PA2 TX
     
157.     GPIO_Init_Structure.GPIO_Mode  = GPIO_Mode_AF_PP;                //复用推挽
     % a; K. j9 J5 m8 d9 ?; `9 q
158.     GPIO_Init_Structure.GPIO_Pin   = USART2_TX_GPIO_PIN;
     " W! Q( n% w6 a9 \+ [! O( R# F2 h
159.     GPIO_Init_Structure.GPIO_Speed = GPIO_Speed_10MHz;
     
160. 
     $ K. C( p; P$ k" d, w+ ~4 [# O
161.     GPIO_Init( USART2_GPIO_PORT, &GPIO_Init_Structure);
     
162. 
     6 J$ }2 ^2 S7 M2 X* i6 _8 G3 w
163.     //配置PA3 RX
     ' I) j! Z* G. Q" t0 ~. ~8 J
164.     GPIO_Init_Structure.GPIO_Mode  = GPIO_Mode_IN_FLOATING;                //复用推挽
     # V! A" q, E( ^( a1 L9 z
165.     GPIO_Init_Structure.GPIO_Pin   = USART2_RX_GPIO_PIN;
     " ?3 z& x8 C1 ^% K6 `" ~2 r9 `
166.     GPIO_Init( USART2_GPIO_PORT, &GPIO_Init_Structure);
     . G+ H& }6 i2 Z: {
167.         
     . y7 n7 c9 Q3 y" n) K0 G; u
168.     USART_ITConfig(USART2,USART_IT_RXNE,ENABLE);        
     6 ?5 B; g7 M$ o3 c. m
169.     USART_Init_Structure.USART_BaudRate = bound;                                          //波特率设置为115200
     ' o2 S. z3 e( S  x# X/ ?
170.     USART_Init_Structure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;       //硬件流控制为无
     & @7 D2 m& n& m) k) a
171.     USART_Init_Structure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;                       //模式设为收和发
     7 |( Q( \5 j1 B' J; Z. ^$ i
172.     USART_Init_Structure.USART_Parity = USART_Parity_No;                                   //无校验位
     ; W" D' O) l# H9 M+ v4 N
173.     USART_Init_Structure.USART_StopBits = USART_StopBits_1;                                //一位停止位
     . c# F. q& P1 ^; x" i: O) W
174.     USART_Init_Structure.USART_WordLength = USART_WordLength_8b;                           //字长为8位  
     
175.     USART_Init(USART2, &USART_Init_Structure);  
     ( x, s3 g# b  w% g8 s
176.     USART_Cmd(USART2, ENABLE);
     " H" h/ t* g+ I9 m% M
177.                
     
178.                 //中断结构体配置
     
179.                 NVIC_Init_Structure.NVIC_IRQChannel                         =   USART2_IRQn;
     
180.                 NVIC_Init_Structure.NVIC_IRQChannelCmd           =   ENABLE;
     5 X4 D9 g/ S: ^
181.                 NVIC_Init_Structure.NVIC_IRQChannelPreemptionPriority  =  5;
     5 T* j* o$ W3 e, c& g2 e
182.                 NVIC_Init_Structure.NVIC_IRQChannelSubPriority         =  0;
     
183.                 NVIC_Init(&NVIC_Init_Structure);
     
184.                
     
185.                
     
186. }
     
187. 
     5 y$ O' b: d3 E6 ?5 {% G
188. 
     ; K8 f. y, O2 V6 t7 R5 ~& b
189. void USART2_IRQHandler(void)                        //串口1中断服务程序
     
190. {
     / x& X9 a0 ^8 o
191.         u8 Res;
     
192. 
     " W; S' H2 j+ v9 B7 [/ p: u
193.         if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
     ' g1 }: `! p  l1 l* C
194.                 {
     / z" q. i8 a1 h1 e( q4 j
195.                 Res =USART_ReceiveData(USART2);        //读取接收到的数据
     ) g) W. F& a& a6 F1 J6 B7 X
196.                
     
197.                 if((USART_RX_STA&0x8000)==0)//接收未完成
     
198.                         {
     
199.                         if(USART_RX_STA&0x4000)//接收到了0x0d
     ( K2 z! e8 u$ P' H* m! M
200.                                 {
     
201.                                 if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
     6 U- X5 P3 c! A. h" H9 n: F
202.                                 else USART_RX_STA|=0x8000;        //接收完成了
     
203.                                 }
     ; s0 A. Z7 q1 |1 n; V" |- y* E& ~
204.                         else //还没收到0X0D
     6 U! f5 m3 s1 E* X2 P2 v$ ?7 X( ^! a
205.                                 {        
     
206.                                 if(Res==0x0d)USART_RX_STA|=0x4000;
     ) _, x0 w$ U* s& R
207.                                 else
     . ?1 e" V8 X; P5 i- F* D
208.                                         {
     
209.                                         USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
     2 d# B8 D! \8 w) C4 Z' ]
210.                                         USART_RX_STA++;
     
211.                                         if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收         
     
212.                                         }                 
     
213.                                 }
     
214.                         }                    
     - h5 i2 @, {4 }% F- A4 S
215.      }
     " X8 G- z  c& `/ S! q! f& @: T
216. }
     0 L" k+ _- w. U7 g2 R1 o
217. 
     ; h" |1 E7 b4 t- E! P( {5 C# f
218. #endif
     
219. 
     
220. 
     
221. 
     
222. /*==================================================串口三============================================== */
     9 S: h) _9 |! H& G( |4 h5 s# C: n
223. 
     
224. #if  EN_USART3_RX
       ?1 i/ w! ~/ I$ \  r' O0 l  B! f
225. 
     
226.          
     6 p. P" h! q) s4 t( }
227. u8  USART3_RX_BUF[USART3_MAX_RECV_LEN];
     # W4 u% g2 A- P7 p& t) \
228. //接收到的数据状态
     
229. //[15]:0,没有接收到数据;1,接收到了一批数据.
     
230. //[14:0]:接收到的数据长度
     
231. vu16 USART3_RX_STA=0;
     " h2 o4 K+ K: K4 \
232. 
     1 `  I9 s$ g# x; \8 N" m( z' O
233. 
     
234. void usart_init3(u32 bound)
     ' \$ ^& y  P& q. z9 h7 T
235. {
     
236.     GPIO_InitTypeDef GPIO_Init_Structure;                            //定义GPIO结构体
     
237.     USART_InitTypeDef USART_Init_Structure;                          //定义串口结构体
     
238.           NVIC_InitTypeDef  NVIC_Init_Structure;                                                                                                                //定义中断结构
     
239.         
     
240.     RCC_APB2PeriphClockCmd(USART3_GPIO_CLK,  ENABLE);                 //开启GPIOA时钟
     3 X4 i1 M+ o) H* m5 k4 Z4 Z
241.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,  ENABLE);            //开启APB2总线复用时钟
     
242.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,  ENABLE);          //开启USART1时钟
     
243. 
     
244.     //配置PB10 TX
     & A. g* c: m! C
245.     GPIO_Init_Structure.GPIO_Mode  = GPIO_Mode_AF_PP;                //复用推挽
     
246.     GPIO_Init_Structure.GPIO_Pin   = USART3_TX_GPIO_PIN;
     8 T1 d  r& X: K0 K+ ~" {
247.     GPIO_Init_Structure.GPIO_Speed = GPIO_Speed_10MHz;
     
248.     GPIO_Init( USART3_GPIO_PORT, &GPIO_Init_Structure);
     4 t/ n0 y7 r* L# v8 B2 M5 Z1 k
249. 
     
250.     //配置PB11 RX
     ' n" Y4 |; C" T3 ^3 s
251.     GPIO_Init_Structure.GPIO_Mode  = GPIO_Mode_IN_FLOATING;                //复用推挽
     , o8 f: `8 Z$ [& F1 ^% V3 H: g1 R
252.     GPIO_Init_Structure.GPIO_Pin   = USART3_RX_GPIO_PIN;
     
253.     GPIO_Init( USART3_GPIO_PORT, &GPIO_Init_Structure);
     
254.         
     
255.     USART_ITConfig(USART3,USART_IT_RXNE,ENABLE);        
     ) m1 E. m: r6 R- |$ u6 b
256.     USART_Init_Structure.USART_BaudRate = bound;                                          //波特率设置为115200
     
257.     USART_Init_Structure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;       //硬件流控制为无
     
258.     USART_Init_Structure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;                       //模式设为收和发
     6 ~) B# h6 ?0 Z# w3 ^2 U
259.     USART_Init_Structure.USART_Parity = USART_Parity_No;                                   //无校验位
     9 {1 N0 C' K3 @7 o. r
260.     USART_Init_Structure.USART_StopBits = USART_StopBits_1;                                //一位停止位
     
261.     USART_Init_Structure.USART_WordLength = USART_WordLength_8b;                           //字长为8位   
     
262.     USART_Init(USART3, &USART_Init_Structure);   
     ! F8 M2 r. E6 r
263.     USART_Cmd(USART3, ENABLE);
     
264.                
     
265.                 //中断结构体配置
     $ o6 w2 K% x& Z& W, Y$ [) [
266.                 NVIC_Init_Structure.NVIC_IRQChannel                         =   USART3_IRQn;
     4 V5 Y. R2 B( ?# w5 y
267.                 NVIC_Init_Structure.NVIC_IRQChannelCmd           =   ENABLE;
     : c5 L( Q& H7 N4 ?
268.                 NVIC_Init_Structure.NVIC_IRQChannelPreemptionPriority  =  6;
     
269.                 NVIC_Init_Structure.NVIC_IRQChannelSubPriority         =  0;
     
270.                 NVIC_Init(&NVIC_Init_Structure);
     $ E# E! h$ P4 Z9 C" H% E
271. }
     ; z1 V8 S1 T6 F- D+ O5 ]
272. 
     
273. 
     
274. 
     ) \$ n4 _+ l0 Y' C; i( M( G% @" p
275. 
     
276. void USART3_IRQHandler(void)                        //串口1中断服务程序
     
277. {
     
278.         u8 Res;
     
279. 
     ( d7 l9 ~! d! y& s+ {6 F* U
280.         if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
     
281.                 {
     
282.                                 Res =USART_ReceiveData(USART3);        
     7 @  j6 m" B1 Z( L. \( P4 \2 X
283.                                 USART_SendData(DEBUG_USARTx,Res);    //这里是把ESP8266发送到串口3的消息发送到电脑端串口调试助手，便于调试
     
284.                         
     ! |; c4 f2 {8 I
285.                                 if(Res != 'A')                     //以‘A’为结束位，收到‘A’表示一次接收消息完成
     
286.                                         {
     
287.                                                 if((USART3_RX_STA&(1<<15))==0)//接收完的一批数据,还没有被处理,则不再接收其他数据
     " t  V8 Z# n! l
288.                                                 {
     
289.                                                                 USART3_RX_BUF[USART3_RX_STA++]=Res;        //记录接收到的值         
     ) s, e! R% m( v, a+ i; P
290.                                                 }
     
291.                                                 else
     
292.                                                 {
     
293.                                                         USART3_RX_STA|=1<<15;                                //没有收到结束符‘A’，收到的字节数>=0x80,强制标记接收完成
     
294.                                                 }
     ( r" G* X( L- {7 v. i( f
295.                                                 
     " M, G& n. B( E3 W0 f
296.                                         }
       c+ S" e, c. q5 b& Z: |  r0 H) |6 a
297.                                        
     ) N. L4 B  ?( X& ]7 r  o
298.                                         else
       Y/ S# A0 X$ J" s8 o
299.                                         {
     * E# v: @4 ^# H  N" I
300.                                                 USART3_RX_STA|=1<<15;                                //接收消息完成
     
301.                                         }
       ~& ?1 h  o; T4 Q2 t5 ^
302.         
     
303.         }
     " ?5 k/ l/ J" y# U8 C
304.                                 
     
305. }
     
306. 
     2 w6 N- N/ V5 @* @
307. void u3_printf(char* fmt,...)  
     
308. {  
     
309.         u16 i,j;
     9 [: d2 Z5 b) L7 J2 {# ?  U
310.         va_list ap;
     
311.         va_start(ap,fmt);
     ( f9 M) w( Y- `+ T( U& l
312.         vsprintf((char*)USART_RX_BUF,fmt,ap);
     
313.         va_end(ap);
     
314.         i=strlen((const char*)USART_RX_BUF);                //此次发送数据的长度
     ; X7 X% Q0 Q0 J& k  @/ ]- ~8 t) |
315.         for(j=0;j<i;j++)                                                        //循环发送数据
     
316.         {
     
317.           while(USART_GetFlagStatus(USART3,USART_FLAG_TC)==RESET); //循环发送,直到发送完毕   
     $ s( Z6 y% g; y! U6 p
318.                 USART_SendData(USART3,USART_RX_BUF[j]);
     - B+ m* y/ y4 C+ V+ r; j" o; w7 Y
319.         }
     
320. }
     
321. 
     
322. #endif
     6 M3 y" n8 Z4 s1 b/ Q
323. 
     
324. 
     % `8 {9 J0 i; E( G0 H
325. 
     ; r5 c: m6 K2 T* _
326. /*=============================通过发送函数==============================*/
     
327. /**
     . V* _! y6 @8 \) ^( f" j2 i
328. * 功能：串口写字节函数
     0 V0 O$ H. Q* @  D4 y
329. * 参数1：USARTx ：串口号
     
330. * 参数2：Data   ：需写入的字节
     1 j9 P7 F/ Q9 w! V' W
331. * 返回值：None
     
332. */
     # s! Z& S2 S' b. `2 Q5 G; g: q
333. void USART_Send_Byte(USART_TypeDef* USARTx, uint16_t Data)
     
334. {
     + {' s& j) ~( I
335.     USART_SendData(USARTx, Data);
     # j; A2 [3 T, Z+ X
336.     while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE)==RESET);
     
337. }
     + b7 h" @* g; s0 I: v
338. /**
     " t$ I9 H2 g+ k3 `0 P+ N
339. * 功能：串口写字符串函数
     # v: Z( \; o" p- B0 ^3 @
340. * 参数1：USARTx ：串口号
     
341. * 参数2：str    ：需写入的字符串
     / w' C2 ?' ?. I4 g" F2 e, J5 I
342. * 返回值：None
     & C# _4 a4 H5 U' @" n
343. */
     
344. void USART_Send_String(USART_TypeDef* USARTx, char *str)
     
345. {
     
346.     uint16_t i=0;
     ( Y/ B# U! |# D1 K. q
347.     do
     7 e9 o! {  o+ x3 N. [; b# b$ z6 [
348.     {
     
349.         USART_Send_Byte(USARTx,  *(str+i));
     
350.         i++;
     # D" [1 K7 r- s' O0 U8 A
351.     }
     * m; z9 R* N$ k. D" W9 x) D! N* U
352.     while(*(str + i) != '\0');
     
353. 
     ' M6 h* ?' T4 z) ?/ X) m: \4 m
354.     while(USART_GetFlagStatus(USARTx, USART_FLAG_TC)==RESET);
     , d0 I' O% X7 |5 |
355. }

复制代码

; u! q0 D; E- Fmain.c

1 i  H, S% i4 [$ u

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   $ Z( T: I4 O& @; A
5. #include "FreeRTOS.h"
   " F" B& |, w  `8 c
6. #include "task.h"
   
7. #include "key.h"
   4 p& s0 k4 X' K) z/ V( L$ F
8. #include "string.h"
   
9. #include "dht11.h"
   
10. 
    # E# i$ x6 e# i; h
11. /*========================FreeRtos读取温湿度=======================
    + C/ ?( z1 c5 n  F3 G+ M& L
12. *Author:小殷同学
    
13. 
    9 r( {* r' r6 E5 ~" Y$ R
14. *Date:2022-5
    ; L& S- s1 H+ X7 I
15. 
    " Y. Z- d1 ]& g& i" @
16. *Description: 通过蓝牙将获取的温湿度数据每隔一秒发送一次到手机
    
17. ==================================================================*/
    4 O/ B, n. ~5 N5 p: h+ }& X
18. 
    5 w6 i7 x! g' x4 k
19. 
    
20. 
    1 m; U* T% i6 M: s8 h. G- |6 C
21. //任务优先级
    1 @( d( w; Y, R0 N# E. g
22. #define START_TASK_PRIO                1
    2 i) y8 t4 U* H
23. //任务堆栈大小        
    ) s& r% q% j) U( R9 f8 h; c$ \% q
24. #define START_STK_SIZE                 250  
    
25. //任务句柄
    
26. TaskHandle_t StartTask_Handler;
    % g! d# h( V  _& _
27. //任务函数
    4 l4 U% w  ]+ }" X, a. L5 r2 \2 F  h! p
28. void start_task(void *pvParameters);
    
29. 
    
30. //任务优先级
    7 C9 D9 W: i, v. `/ u
31. #define LED0_TASK_PRIO                2
    
32. //任务堆栈大小        
    
33. #define LED0_STK_SIZE                 50  
    
34. //任务句柄
    / `. _! f+ W4 T
35. TaskHandle_t LED0Task_Handler;
    
36. //任务函数
    
37. void led0_task(void *pvParameters);
    9 Y* d" M( T1 e: M5 r
38. 
    % R4 G! d, N" H+ I+ K$ w
39. //任务优先级
    
40. #define UsartControal_TASK_PRIO                3
    + F& C5 ?5 x& e4 o- U
41. //任务堆栈大小        
    9 E6 l% K. ?2 \, R0 O0 M/ Q
42. #define UsartControal_STK_SIZE                 120  
    7 N& ?' c, _0 N' t; {
43. //任务句柄
    
44. TaskHandle_t UsartControalTask_Handler;
    
45. //任务函数
    
46. void UsartControal_task(void *pvParameters);
    * r8 C% v, _' b
47. 
    
48. 
    : m! N9 @2 W. I* Z8 H/ H; G: H
49. 
    
50. int main(void)
    - G6 Z- r# l) q9 f
51. {
    
52.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4         
    
53.         delay_init();                                            //延时函数初始化         
    ' g- R' c2 x$ Z, ~4 Q5 u; B6 X# B# j) f) q
54.         uart_init(115200);                                        //初始化串口
    
55.         usart_init2(9600);          //蓝牙使用
    3 U" U) y1 T1 l7 |" c
56. 
    
57.         LED_Init();                                                          //初始化LED
    
58.         
    
59.         
    3 t/ D9 j! O1 V, t+ w
60.         printf("初始化完成Start Test\n");
    
61.          
    * d7 `+ j7 f* f/ _+ G0 g3 g8 b
62.         //创建开始任务
    
63.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    $ H$ d0 d& j3 z0 D8 c3 S8 p
64.                 (const char*    )"start_task",          //任务名称
    
65.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    1 A, k/ E- `' Q$ O" @. N2 ^
66.                 (void*          )NULL,                  //传递给任务函数的参数
    
67.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    2 {$ o9 r$ t. W5 u5 P/ f* n
68.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    1 ~! j  `% E- d/ K
69.     vTaskStartScheduler();          //开启任务调度
    
70. }
    
71. 
      ~& q" C% w9 {' f& _
72. 
    # _  D! ]+ F6 t5 O
73. //开始任务任务函数
    
74. void start_task(void *pvParameters)
    2 q4 z5 j  ^  Z. v% P3 k
75. {
    & |8 z6 w, X  i4 E. A1 o* H$ i
76.     taskENTER_CRITICAL();           //进入临界区
    7 z0 }6 J% h( \. H. H: G
77.     //创建LED0任务
    
78.     xTaskCreate((TaskFunction_t )led0_task,            
    
79.                 (const char*    )"led0_task",           
    & b2 G" ^1 j' t3 m( U. F0 w! o/ b
80.                 (uint16_t       )LED0_STK_SIZE,
    
81.                 (void*          )NULL,                                
    
82.                 (UBaseType_t    )LED0_TASK_PRIO,        
    
83.                 (TaskHandle_t*  )&LED0Task_Handler);   
    / y5 ^- q0 T5 R- j
84.     //蓝牙串口控制
    
85.     xTaskCreate((TaskFunction_t )UsartControal_task,     
    
86.                 (const char*    )"UsartControal_task",   
    / X- C+ W5 k$ y: Q6 k
87.                 (uint16_t       )UsartControal_STK_SIZE,
    # v: J/ n3 l# A; ^# B% R# f
88.                 (void*          )NULL,
    
89.                 (UBaseType_t    )UsartControal_TASK_PRIO,
    ; q' p" S$ L! E/ r  j5 {& R
90.                 (TaskHandle_t*  )&UsartControalTask_Handler);  
    
91. 
    
92.     vTaskDelete(StartTask_Handler); //删除开始任务
    
93.     taskEXIT_CRITICAL();            //退出临界区
    
94. }
    
95. 
    
96. //LED0任务函数
    + z! N& N5 \' r# W! S+ K
97. 
    
98. void led0_task(void *pvParameters)
    
99. {
    
100.         while(1)
     ' J( [1 B  J: _4 H
101.         {
     
102.                 LED0 = ~LED0;
     
103.                 vTaskDelay(1000);
     9 \) H( L$ N- o4 u% X
104.                 printf("led0_task  Running\r\n");
     ' C1 F8 C0 G7 X0 q! H& v
105.         }
     # f* J- k- j8 ^% O* D
106. }
     # d" A3 j* e- c8 Q$ z% B
107. 
     
108. 
     2 q! x5 R) P: a% W2 N
109. 
     
110. //温湿度数据读取 将获取的数据每隔1s通过蓝牙发送到手机
     ( [( l9 ]" {( X! o$ i" n! N
111. void UsartControal_task(void *pvParameters)
     . I7 q( L+ o- x1 K: e# f
112. {
     
113.                 uint16_t i;
     ! C0 @/ B  E2 E& M1 ~4 r5 [9 }! j
114.                 uint8_t k;
     . I  ]6 b' s2 t2 x1 K
115.                 uint8_t kk;
     
116.                 uint8_t kkk;
     6 T) c( w) L0 i3 q
117.           uint8_t Temp_Buffer[20];  //发送数据缓存
     ( ^  }' j% W$ f: ~( c: h
118.                 while(1)
     
119.                         {
     
120.                                 
     
121.                                 DHT11_UpdateData(); //读取温湿度
     
122.                                 i =  Rxbuff[0]+ Rxbuff[1]+Rxbuff[2]+ Rxbuff[3];
     + b; G; i6 e/ D5 o% m
123.                                 if(Rxbuff[4] ==i)   //进行效验判断
     + I$ y% j& ]# @& L6 J
124.                                 {
     # b/ f1 I5 L3 F; o- p! u5 ^
125.                                         k=Rxbuff[2];
     / N% O# E1 z- ~" z
126.                                         kk=Rxbuff[0];
     
127.                                         kkk=Rxbuff[3];
     
128.                                         sprintf((char *)Temp_Buffer,"当前温度为:%d 当前湿度为:%d\r\n",k,kk);
     % d- M' [" [& i: e
129.                                         USART_Send_String(USART2,(char *)Temp_Buffer);
     1 c. \/ F. I/ V1 r+ w& i  z
130.                                 }
     
131.                                 memset(Temp_Buffer,0,sizeof(Temp_Buffer)); //清空缓存
     
132.                                 delay_ms(1000);
     
133.                                 
     * [4 B+ Z7 [, t% Q3 z8 o
134.                
     
135.                         }
     
136.                                 
     5 o& @6 P  I5 s9 c0 u. F) u
137. }

复制代码

实验结果
  w* ]% \* X; @- H8 |1 o
2 W  R, I4 W+ E' r

- j% }6 Y& P! _/ B, B' t2 y! n————————————————
版权声明：@slow-walker
: i9 Z2 Y0 R& _+ L" M/ w# R" b
( x6 [% q, S( W- _7 W
0 h$ x( z7 o3 p. A6 q# i, @