其他串口利用printf函数输出文字
9 S' b& P( s, |8 T. e首先，你要想用printf函数的话需要配置串口的相关参数，也就是初始化，学过stm32的都清楚串口初始化的大概配置过程，这里我就不细讲了，重点讲一下printf函数，这个printf函数在MDK5里面好像是找不到的，看了网上很多教程，发现是在fputc这个函数里面修改串口的输出，而这个fput函数一般在usart.c文件里面，如下所示：
* R" I& _3 P4 p1 l
# c4 d) Y9 F/ h* r0 F9 {" j! p, e

1. //重定义fputc函数
   $ e' K- ^. Q4 |+ a' {* L7 S
2. int fputc(int ch, FILE *f)
   # R6 a4 |- x: A
3. {/*这个可以发送文字*/
   
4.         while((USART3->SR & 0X40) == 0); //循环发送,直到发送完毕,给串口3发送数据
   
5.         USART3->DR = (u8) ch;
   
6.         while((USART1->SR & 0X40) == 0); //循环发送,直到发送完毕,给串口1发送数据
   
7.         USART1->DR = (u8) ch;
   * S$ y% u: f4 }; U2 m0 ?
8.         return ch;
   ) ~  {! B$ i3 J8 \$ ?
9. }

复制代码

这里我设置这个printf函数同时输出到串口1和串口3，这个printf函数可以直接输出文字。有时候需要向串口发送文字信息这个printf函数很好用，不像其他函数只能一个一个发送出去。

stm32中u8 u16的格式后字符
' |+ y2 G8 j( J* Q" z8 L2 W) }. [u8是指数值0-255，定义u8输出格式是%d，同时也可以输出%c，比如得到一个字符是1，则输出用%c得到的是1，输出用%d得到是49
" }+ X5 z) U, c) h% A' |: Gu16是指数值0-65535
5 ^$ I* y7 J9 x5 w" u9 T$ G
' l7 e% Q: b, I2 Hstm32语音识别与播报检测温湿度
下面附上图片：
/ {  {6 o& C# Y$ \' I( n1 C
: ~" A9 j* A7 r" V

* A5 k% t9 V  o9 m; T- m: F/ j
温湿度的相关程序在原子哥的程序源码里面有，当然，在下面我也会附上我的程序：
串口1是与PC端进行通信的，串口2是与LD3320语音模块上面的51单片机进行通信，串口3是与MR628连接的
main.c

1. /*
   # k7 g0 j3 F& x
2. 接线定义:
   
3. MR628语音合成模块  语音识别模块LD3320是集成在51单片机STC11L08XE    DHT11温湿度传感器
   
4. 红线--5V               语音识别模块5V->stm32 5V                                         信号线->stm32的PB11
   ; t  t2 F' I* }4 h
5. 黄线--PB10                           语音识别模块GND->stm32 GND
     E/ H8 c- r' }6 h9 A
6. 黑线--GND                           语音识别模块TX->stm32 RX PA3
   
7.                                            语音识别模块RX->stm32 TX PA2                                                */                                                
   0 F3 x8 W$ A2 F8 Q- R
8. #include "led.h"
   . k+ |) ~6 K  j* U& l. F
9. #include "sys.h"
   6 U9 |/ `2 \4 X* ?; B& c: z
10. #include "delay.h"
    
11. #include "stdio.h"
    3 \3 L( L$ _( W* W# F  x
12. #include "usart.h"
    
13. #include "dht11.h"
    
14. 
    
15. int main(void)
    
16. {
    
17.         u8 m=0;                           
    - r- J3 ]. L) E5 b' @7 S% k
18.         u8 temperature;  //温度变量            
    ) F+ L' l# K  M0 {3 }
19.         u8 humidity;         //湿度变量
    
20.         short t=9999;        
    8 Z' L: l9 I  {4 L" o5 M
21.         u8 flag=0;                 //标记位
    
22.         u16 len2;
    
23.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
    0 h3 F0 m) U  ^2 C: `' y& i
24.         delay_init();
    ) S, h8 l  l6 }% s
25.         LED_Init();        
    & d- r2 k3 u7 v4 y+ [/ |. d
26.         uart_init(115200);
    + F& }5 Y( u9 s6 y" P/ w- ?
27.         My_USART2_Init(9600);
    / J& w' e' B3 Q; S% {! y1 c
28.         USART3_Init(9600);
    / C+ Q, w- k" b$ \6 B& _
29.         while(DHT11_Init())        //DHT11初始化        
    ! d' v0 y- u% A* y
30.         {delay_ms(200);}        
    
31.         printf("初始化成功");
    9 \( J  f2 g$ z
32.         while(1)
    # I, p5 k9 V+ p3 }3 \: P
33.         {
    1 R- Z% {9 Y' T( {  v
34.                 if(USART2_RX_STA&0x8000)
    3 @" Y9 k3 u: q( b7 M
35.                 {                                          
    
36.                         len2=USART2_RX_STA&0x3fff;//得到此次接收到的数据长度
    
37.                         for(t=0;t<len2;t++)
    . C+ [  l% e$ h. M' `, }: t( r9 z
38.                         {
    + w. e8 G5 a$ B6 Q  X2 W* R
39.                                 if(USART2_RX_BUF[0]=='0')//接收到51单片机发过来的信号0
    $ B8 X* t: X$ \6 J/ X. ]0 B6 P, }7 K
40.                                 {
    . o! x- L8 I0 `9 E7 P* X
41.                                         if(flag==0)
    0 v. ~; T7 M% R4 h' X9 Y
42.                                         {
    : B" K9 [' k4 G: k! ~
43.                                                 printf("<I>18");//播放提示音1
    
44.                                                 flag=1;
    
45.                                         }
    4 {, L/ Q4 E* l4 v. J) Q
46.                                         else
    4 D, G2 w- H: B2 G% _
47.                                         {
    
48.                                                 printf("<I>19");//播放提示音2
    ' r! {6 C: |; I
49.                                                 flag=0;
    
50.                                         }
    
51.                                 delay_ms(1000);
    9 ]* r2 z) e- w' w/ z
52.                                 printf("<G>你好,我是小杰\r\n");
    
53.                                 }
    
54.                                 if(USART2_RX_BUF[0]=='1')//接收到51单片机发过来的信号1
    
55.                                 {printf("<G>现在温度是%d十%d摄氏度\r\n",temperature/10,temperature%10);}
    0 V; n# q% L4 H. Q  J$ O
56.                                 if(USART2_RX_BUF[0]=='2')//接收到51单片机发过来的信号2
    * n8 t! p( `, d+ }! i
57.                                 {printf("<G>现在湿度是%d十%d\r\n",humidity/10,humidity%10);}
    . F; a2 r. f; }, r
58.                                 if(USART2_RX_BUF[0]=='3')//接收到51单片机发过来的信号3
    
59.                                 {printf("<G>好的!");
    - {+ r+ ^4 T! M) ~
60.                                 delay_ms(1000);
    
61.                                 printf("<M>1\r\n");}
    9 E! F. d4 o4 H& H6 k
62.                                 if(USART2_RX_BUF[0]=='4')//接收到51单片机发过来的信号4
    , ?# a  @2 ?* a" p# f6 }2 p
63.                                 {printf("<G>好的!");
    
64.                                 delay_ms(1000);
    6 H8 z- b- m2 H; n- ^) [1 v/ P
65.                                 printf("<M>2\r\n");}
    " D1 Y7 a) O& C9 o
66.                                 if(USART2_RX_BUF[0]=='5')//接收到51单片机发过来的信号5
    $ M  S5 H6 g' N; F3 ?/ s" v
67.                                 {printf("<G>好的!");
    + m' @1 ^0 V# D+ g6 O% l! P
68.                                 delay_ms(1000);
    
69.                                 printf("<M>0\r\n");}
    ; O, g9 a# {) h- [8 Y; ~/ K' c+ Y1 W
70.                         }
    
71.                         USART2_RX_STA=0;
    
72.                 }               
    
73.                 if(m%100==0)                        //每1s读取一次
    
74.                 {                                                                          
    
75.                         DHT11_Read_Data(&temperature,&humidity);        //读取温湿度值        
    
76.                 }
    
77.                 delay_ms(10);
    ' v/ M( M$ T9 z7 v: O% v( @6 Q
78.                 m++;
    7 q# W+ l- U" p0 W! [2 z& q
79.                 if(m==200)
    , s' f) a& v4 i- y* P; G
80.                 {
    0 V/ e: Y2 G$ B5 V8 R
81.                         m=0;
    , g& H- F' E: {) m
82.                         LED0=!LED0;
    
83.                 }        
    ( m* d" q: N4 _2 a
84.         }
    
85. }

复制代码

" ~8 x( a3 M* [! p2 Vusart.c
$ Z. {% u- i7 x" g, f) I9 I

1. #include "sys.h"
   ) S) x! [  }$ R' ~  l
2. #include "usart.h"
   
3. #include "timer.h"
   
4. 
   
5. #if 1
   
6. #pragma import(__use_no_semihosting)
   
7. //标准库需要的支持函数
   
8. struct __FILE
   
9. {
   
10.         int handle;
    3 b# z. G2 p( `: z: n: q
11. 
    
12. };
    " U* U) f! r) y7 Q0 Y
13. 
    
14. FILE __stdout;
    ! M% h1 J% K4 e- p, B  z3 a4 A2 [" v
15. //定义_sys_exit()以避免使用半主机模式
    - f; P* ]  v4 v& ]' E. t
16. void _sys_exit(int x)
    
17. {
    3 ]% g) V  p. c% @$ o. {6 H5 u
18.         x = x;
    3 |. O) t: \' |& Z* k  }& g$ d
19. }
    $ K1 ]1 u% K8 M
20. //重定义fputc函数
    - P; W% w" V. y' `
21. int fputc(int ch, FILE *f)
    ' g7 }$ c( @8 _  H+ \& j
22. {/*这个可以发送文字*/
    ' K  ^6 M8 j7 q. o! S7 s
23.         while((USART3->SR & 0X40) == 0); //循环发送,直到发送完毕,给串口3发送数据
    8 X7 C" ~/ N! X5 }! y/ _. O8 e
24.         USART3->DR = (u8) ch;
    
25.         while((USART1->SR & 0X40) == 0); //循环发送,直到发送完毕,给串口1发送数据
    
26.         USART1->DR = (u8) ch;
    , q# d, x7 N' G" n
27.         return ch;
    % t% a- u2 x5 r3 z* z! T' g
28. }
    
29. #endif
    
30. 
    
31. void USART3_SendData(u8 data)
    4 i' v7 [3 r% q
32. {
    
33.         while((USART3->SR & 0X40) == 0);
    
34.         USART3->DR = data;
    ( u! n1 E3 m" u9 m' Y
35. }
    
36. 
    & Y( T$ @4 i, e- }2 r
37. void USART3_SendString(u8 *DAT, u8 len)
    
38. {
    " k" \  a3 z% h
39.         u8 i;
    
40.         for(i = 0; i < len; i++)
    
41.         {
    
42.                 USART3_SendData(*DAT++);
    1 v; C$ L9 w' _# l# G
43.         }
    # X* a' Q% |# X+ @
44. }
    
45. 
    / I  D1 x, G) L; v+ w& S' \% F  \
46. 
    ' v" M4 Z. G" z! k) h0 t
47. 
    
48. #if EN_USART3_RX   //如果使能了接收,一般在.h文件里面定义这个变量为1，也就是一直都是使能的
    4 X2 d7 X/ b. Q$ _* \
49. u8 USART3_RX_BUF[USART3_REC_LEN];     //接收缓冲,最大USART3_REC_LEN个字节.
    3 M# v0 g* g9 ]. X% H* k( m6 o
50. //接收状态
    * W* @& i9 q' F3 F( }+ i3 A1 V0 T
51. //bit15，        接收完成标志
    
52. //bit14，        接收到0x0d
    
53. //bit13~0，        接收到的有效字节数目
    
54. u16 USART3_RX_STA = 0;     //接收状态标记
    9 I8 _& `5 `: i0 \& D" c% V& \# m
55. 
    4 T) C, N6 Q8 c5 E' W2 [
56. void USART3_Init(u32 bound)
    
57. {
    
58.         //GPIO端口设置
    ) B& e  c# ?6 z: n* k$ i, ]/ v) _6 O
59.         GPIO_InitTypeDef GPIO_InitStructure;
    ; M% m2 Q( H8 Q
60.         USART_InitTypeDef USART_InitStructure;
    
61.         NVIC_InitTypeDef NVIC_InitStructure;
    8 l* u# q8 u; K! M% b; _
62. 
    
63.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);        //使能USART3，GPIOB时钟
    ( p8 \* h1 U! i6 ]/ E) `
64.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
    ! p1 ?+ K( V5 v& G0 |- E  [/ s
65.         //USART3_TX   GPIOB.10
    & Z. {& r) l8 t& b2 X* p' d
66.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    . w+ v, e/ ?. z* ~) l" i; S
67.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    6 {( a6 H  `, W" d6 G5 P! i
68.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
    
69.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIO
    : ?$ _3 o* m4 h8 q, a* G6 k3 H
70. 
    8 L/ U& B: j2 B' k- C
71.         //USART3_RX          GPIOB.11初始化
    
72.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    
73.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    
74.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIO
    
75. 
    - M' [5 V1 V/ V& ^
76.         //USART3 NVIC 配置
    9 }: G7 \1 m* f. _( m( s$ ?
77.         NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
    
78.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3 ; //抢占优先级3
    - h! m' B# e. Y
79.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    
80.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    ; J6 [; r/ E7 ]  o' ?$ `
81.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    
82. 
    
83.         //USART 初始化设置
    
84. 
    
85.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
    . y0 ?& b1 j) A9 t: j
86.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    
87.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    
88.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    
89.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    
90.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
      o! E' ]! h. \- B' p/ u4 W
91. 
    + p) j: S5 c8 O4 E. d( S3 i# M
92.         USART_Init(USART3, &USART_InitStructure); //初始化串口3
    2 \2 A# j% ~3 Z4 p, e
93.         USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//开启串口接受中断
    4 a( N, Z8 @5 f( X7 B; Y
94.         USART_Cmd(USART3, ENABLE);                    //使能串口3
    0 n9 K) K9 ?( t( Q4 s
95. 
    
96.         TIM3_Int_Init(99, 7199);                //10ms中断
    7 E  B) l& o8 f  u; C/ T" n5 r
97.         USART3_RX_STA = 0;                //清零
    
98.         TIM_Cmd(TIM3, DISABLE);                        //关闭定时器3
    $ r# P1 J1 M6 T3 q
99. }
    
100. 
     
101. void USART3_IRQHandler(void)                        //串口3中断服务程序
     
102. {
     
103.         u8 Res;
     
104.         if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
     ; l8 S1 X) l3 O6 V6 G
105.         {
     . D$ F( Q' p& a  G
106.                 Res = USART_ReceiveData(USART3);        //读取接收到的数据
     
107.                 if((USART3_RX_STA & 0x8000) == 0) //接收未完成
     # V' W9 z" W; }) h
108.                 {
     
109.                         if(USART3_RX_STA < USART3_REC_LEN)        //还可以接收数据
     # e" b$ V- [0 {+ {# j
110.                         {
     
111.                                 TIM_SetCounter(TIM3, 0); //计数器清空                                          //计数器清空
     
112.                                 if(USART3_RX_STA == 0)                                 //使能定时器3的中断
     
113.                                 {
     
114.                                         TIM_Cmd(TIM3, ENABLE); //使能定时器3
     
115.                                 }
     
116.                                 USART3_RX_BUF[USART3_RX_STA++] = Res;        //记录接收到的值
     
117.                         }
     
118.                         else
     
119.                         {
     $ }5 i; `- D% V! U- W
120.                                 USART3_RX_STA |= 1 << 15;                                //强制标记接收完成
     1 @3 Q; j+ N9 A- N# w! a
121.                         }
     
122.                 }
     
123.         }
     
124. }
     
125. #endif
     
126. #if EN_USART1_RX   //如果使能了接收,一般在.h文件里面定义这个变量为1，也就是一直都是使能的
     ' o0 G# ^/ o. j, Q
127. //串口1中断服务程序
     9 v% G3 X& D; b
128. //注意,读取USARTx->SR能避免莫名其妙的错误           
     , l4 X* F! s7 J$ |& y, F5 x
129. u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
       D3 z7 ^, I: ]4 C& ^# ^2 f6 M2 e
130. //接收状态
     : D! y) U' N9 C$ B
131. //bit15，        接收完成标志
     # P0 C; E5 `" u/ G) b- c5 k
132. //bit14，        接收到0x0d
     $ j+ V0 Q6 `# i
133. //bit13~0，        接收到的有效字节数目
     3 z( K1 H& A0 B0 G  A( \# V
134. u16 USART_RX_STA=0;       //接收状态标记         
     ' @" }: u; A* }# Z+ S" l% B
135. 
     . V* g2 P: s3 M6 A6 Z; o
136. void uart_init(u32 bound){
     ) ~" r+ o3 F. M: c& ?; @  T8 V3 V
137.   //GPIO端口设置
     
138.   GPIO_InitTypeDef GPIO_InitStructure;
       ]; g7 Q; m# c! @; X
139.         USART_InitTypeDef USART_InitStructure;
     % y: W# S' ^6 p% l  c
140.         NVIC_InitTypeDef NVIC_InitStructure;
     
141.          
     
142.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
       a9 ~6 a2 ^# Q1 c6 _3 _
143. 
     ) l* X7 N! {0 s* i, W& l
144.         //USART1_TX   GPIOA.9
     
145.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
     
146.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
147.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
     
148.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
     
149. 
     
150.   //USART1_RX          GPIOA.10初始化
     # R8 s/ P2 v3 _3 C
151.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
     ) _0 ~5 e3 n" D# A) N
152.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
     $ C+ g6 [2 ~/ z/ }: b7 s5 f" q
153.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  
     1 t$ Z! @# j# i; a' J# o
154. 
     
155.   //Usart1 NVIC 配置
     6 X, o; y1 {# _
156.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
     
157.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
     
158.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;                //子优先级3
     ) @6 r2 J$ }* I8 a
159.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
     $ {3 j. a3 N! [% y5 T6 F% ?, x
160.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
     
161. 
     3 s2 P. q$ e7 U: K$ z
162.    //USART 初始化设置
     
163. 
     
164.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
     ' K% Q0 y: k4 Q) g" [" S4 P
165.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
     , K: V: a! T' o6 I4 J
166.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
     7 R; U, j# h; i/ h
167.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
     
168.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
     - p1 o/ v9 T* L; m( _: X
169.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
     
170. 
     , w  c( L* K1 K/ n
171.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
     
172.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
     1 g" g" F( B4 T0 B3 t( J. R& C# |$ u! f4 l
173.   USART_Cmd(USART1, ENABLE);                    //使能串口1
     
174. 
       ~9 N9 f& d3 G: u; i! {
175. }
     - Z8 |2 j/ ~* U) q7 J
176. 
     
177. void USART1_IRQHandler(void)                        //串口1中断服务程序
     8 G; o* |9 ]* Q0 q: n- ~$ D, v, d
178.         {
     
179.         u8 Res;
     + e3 d( B1 x2 I' U0 q
180. #if SYSTEM_SUPPORT_OS                 //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
     2 w6 a3 x- [. e5 _
181.         OSIntEnter();   
     * C0 P% Z  H; m1 ^& K$ G
182. #endif
     1 ]: i. @" q) M% o; G. J* H
183.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
     6 L2 k5 U/ R% _- G) [5 N2 k$ `
184.                 {
     8 s) w3 T9 A8 `- ]) b& i
185.                 Res =USART_ReceiveData(USART1);        //读取接收到的数据
     
186.                
     3 N) n/ @  J" P6 B- e% D0 u6 |
187.                 if((USART_RX_STA&0x8000)==0)//接收未完成
     
188.                         {
     
189.                         if(USART_RX_STA&0x4000)//接收到了0x0d
     
190.                                 {
     
191.                                 if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
     7 b7 `8 D# x: W# U. S( _4 l
192.                                 else USART_RX_STA|=0x8000;        //接收完成了
     
193.                                 }
     
194.                         else //还没收到0X0D
     ; t' \$ A2 r5 M5 W' ?5 |
195.                                 {        
     ' e) Z* X) y& E) _( q/ B
196.                                 if(Res==0x0d)USART_RX_STA|=0x4000;
     5 ^3 Y) e- |2 _2 P
197.                                 else
       o3 Q9 [! w& U% v
198.                                         {
     $ b+ n3 E, G$ C% u. d- ?  q
199.                                         USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
     * i$ ]! P$ s% D8 ^$ N; o
200.                                         USART_RX_STA++;
     & Y. t; _6 b5 ~
201.                                         if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收         
     & K8 J/ T/ Q' t, K
202.                                         }                 
     8 H$ X5 l( o% o1 g  B( V$ g
203.                                 }
     % V) i1 c+ P2 h  E3 I+ [
204.                         }                    
     
205.      }
     
206. #if SYSTEM_SUPPORT_OS         //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
     & _' E6 g$ p2 j0 C
207.         OSIntExit();                                                                                          
     
208. #endif
     
209. }
     
210. #if EN_USART2_RX   //如果使能了接收,一般在.h文件里面定义这个变量为1，也就是一直都是使能的
     
211. u8 USART2_RX_BUF[USART2_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.
     
212. u16 USART2_RX_STA = 0;                                 //接收状态标记         
     8 `: _8 T0 [$ I* \( Z4 u
213. void My_USART2_Init(u32 bound)
     7 H. p" ?1 c6 B9 F4 S3 W! B
214. {
     / T6 c+ O% f# z2 s# K3 l
215.         GPIO_InitTypeDef GPIO_InitStrue;
     
216.         USART_InitTypeDef USART_InitStrue;
     
217.         NVIC_InitTypeDef NVIC_InitStrue;
     
218.         
     
219.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
     
220.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);
     - p" w: v  o- b9 [# I
221.         
     . o  ~/ `: c, b' b* |5 [$ s
222.         GPIO_InitStrue.GPIO_Mode=GPIO_Mode_AF_PP;
     : T/ e! V0 ~9 p  x! y
223.         GPIO_InitStrue.GPIO_Pin=GPIO_Pin_2;
     
224.         GPIO_InitStrue.GPIO_Speed=GPIO_Speed_10MHz;
     
225.         GPIO_Init(GPIOA,&GPIO_InitStrue);
     
226.         
     0 x+ w9 V/ c3 t0 _
227.         GPIO_InitStrue.GPIO_Mode=GPIO_Mode_IN_FLOATING;
     
228.         GPIO_InitStrue.GPIO_Pin=GPIO_Pin_3;
     
229.         GPIO_InitStrue.GPIO_Speed=GPIO_Speed_10MHz;
     
230.         GPIO_Init(GPIOA,&GPIO_InitStrue);
     8 v3 x1 X. T4 U+ {
231.         
     ( W7 a7 b0 ]  u+ x5 E0 w6 w
232.         USART_InitStrue.USART_BaudRate=bound;
     
233.         USART_InitStrue.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
     $ Z1 [3 y' v5 x
234.         USART_InitStrue.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;
     4 O( \/ B# y4 \
235.         USART_InitStrue.USART_Parity=USART_Parity_No;
     0 z* g4 v, V7 T5 n, N6 l0 j+ B
236.         USART_InitStrue.USART_StopBits=USART_StopBits_1;
     : I: g! [! R! V9 r+ M" E: m* g. o! V
237.         USART_InitStrue.USART_WordLength=USART_WordLength_8b;
     
238.         USART_Init(USART2,&USART_InitStrue);
     9 l  N4 Q3 W( J
239.         
     
240.         USART_Cmd(USART2,ENABLE);
       H. m# X  U6 F& X7 z% [4 M
241.         
     5 K/ i6 q) M. _3 P5 }
242.         USART_ITConfig(USART2,USART_IT_RXNE,ENABLE);
     0 c! r1 e; B( V2 s; t& F; l
243.         
     . ]( P1 E, d) D- b" W, }% d- S
244.         NVIC_InitStrue.NVIC_IRQChannel=USART2_IRQn;
       d+ j5 t6 O6 x, d8 Q
245.         NVIC_InitStrue.NVIC_IRQChannelCmd=ENABLE;
     
246.         NVIC_InitStrue.NVIC_IRQChannelPreemptionPriority=1;
     ' r$ Y  a7 R8 U" v7 z3 Q
247.         NVIC_InitStrue.NVIC_IRQChannelSubPriority=1;
     
248.         NVIC_Init(&NVIC_InitStrue);
     : Y5 ^$ v: r7 m9 g( o1 o
249. }
     ; \7 ]- R5 Y. C
250. 
     
251. void USART2_IRQHandler(void)
     # I6 H! _* x5 |. p9 s3 R
252. {
     
253.         u8 Res;
     : `, O6 X0 S* }- I* ^- P1 k
254.                 if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
     , \+ t2 Y( j' t# L$ q+ f
255.                 {
     " e; W2 D4 R) K
256.                 Res =USART_ReceiveData(USART2);        //读取接收到的数据
     
257.                
     
258.                 if((USART2_RX_STA&0x8000)==0)//接收未完成
     
259.                         {
     6 h1 H  t5 P5 P, K
260.                         if(USART2_RX_STA&0x4000)//接收到了0x0d
     
261.                                 {
     ! @5 F8 ^2 Q2 F) b- t* D
262.                                 if(Res!=0x0a)USART2_RX_STA=0;//接收错误,重新开始
     
263.                                 else USART2_RX_STA|=0x8000;        //接收完成了
     9 \& [+ u4 {. |- c
264.                                 }
     
265.                         else //还没收到0X0D
     5 n) b; \" B6 `7 O. V% u8 e
266.                                 {        
     
267.                                 if(Res==0x0d)USART2_RX_STA|=0x4000;
     
268.                                 else
     9 |. B/ `2 R, |# `% V& _
269.                                         {
     ( Z/ C$ v# P7 c: o; h% N
270.                                         USART2_RX_BUF[USART2_RX_STA&0X3FFF]=Res ;
     
271.                                         USART2_RX_STA++;
     ; O& T3 f0 f# }. q  K) i5 M$ p  Q
272.                                         if(USART2_RX_STA>(USART2_REC_LEN-1))USART2_RX_STA=0;//接收数据错误,重新开始接收         
     
273.                                         }                 
     
274.                                 }
     + n1 f3 Y# o4 f8 j
275.                         }                    
     ( ~% R% ?6 p" C9 U0 o" Y
276.      }
     
277. }
     
278. #endif
     
279. #endif

复制代码

usart.h

1. #ifndef __USART_H
   
2. #define __USART_H
   6 k2 r% s8 m  d9 C: O1 c
3. #include "stdio.h"        
   
4. #include "sys.h"
   
5. 
   
6. #define USART_REC_LEN                          200          //定义最大接收字节数 200
   
7. #define EN_USART1_RX                         1                //使能（1）/禁止（0）串口1接收
   " C  |1 A) @7 W" _
8.                   
   
9. extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
   
10. extern u16 USART_RX_STA;                         //接收状态标记        
    9 `& i1 L; S# Q3 h* D/ j' h' w" H
11. 
    
12. void uart_init(u32 bound);
    9 N4 {0 l  ~$ f
13. 
    
14. #define USART2_REC_LEN                          200          //定义最大接收字节数 200
    : }3 b& i( q9 e
15. #define EN_USART2_RX                         1                //使能（1）/禁止（0）串口1接收
    
16. 
    6 |% d6 K# D+ r0 ~# \
17. extern u8  USART2_RX_BUF[USART2_REC_LEN]; //接收缓冲,最大USART2_REC_LEN个字节.末字节为换行符
    
18. extern u16 USART2_RX_STA;                         //接收状态标记        
    
19. 
    
20. void My_USART2_Init(u32 bound);
    
21. 
    ; Z& u8 w( w0 s; A
22. #define USART3_REC_LEN                          200          //定义最大接收字节数 200
    - b0 t& @- F" C& m5 l8 N9 [  ?
23. #define EN_USART3_RX                         1                //使能（1）/禁止（0）串口3接收
      V3 \1 g1 J, N& A
24.                   
    
25. extern u8  USART3_RX_BUF[USART3_REC_LEN]; //接收缓冲,最大USART3_REC_LEN个字节.末字节为换行符
    
26. extern u16 USART3_RX_STA;                                 //接收状态标记        
      X: B9 }: e( N3 d
27. 
      x6 F1 H# L8 f/ T( I8 |& S
28. void USART3_SendString(u8 *DAT,u8 len);
    ; d) }! u! ?2 a. Z1 {
29. void USART3_SendData(u8 data);
    7 y6 b, j  p- q) D! K& |
30. void USART3_Init(u32 bound);
    ) x7 j6 p. V+ Z* P+ s8 W! A$ ^6 N
31. 
    
32. #endif

复制代码

" N2 I5 g+ i9 _关于接线的话，我在main函数里面开头就已经写了。至于LD3320语音模块，他是集成在51单片机的，所以你要设置那些语音的口令以及收到口令后发送什么数据到stm32的串口2需要打开LD3320语音模块的程序，在最下面我将附上所有的程序以及资料，我个人认为里面讲得很清楚（对于LD3320语音模块以及MR628播报模块，里面相关教学视频也有）
虽然里面的51程序是MDK4的程序，但是我用MDK5打开了，所以各位如果要打开里面的51程序的话，需要用MDK5打开，因为MDK5编译后，MDK4是打不开的。
————————————————
版权声明：i土豆
  Z) q' {! x; a5 E9 w6 G; e