最近在做多节点无线通信，用到STM32 USART多机串行通信。

记录下多机串行通信配置要点。

下面是我封装的会用到的函数：

1. // .h
     Q$ |9 ]. d7 S& @) M" |- _
2. #ifndef _MULTIUSART_H
   
3. #define _MULTIUSART_H
   
4. #include "sys.h"
   3 e; E; x+ e! H
5. #include "stm32f10x_usart.h"
   0 H, T; h' l7 P  A2 y
6. 
   5 _/ L3 m+ [  E
7. /*
   8 U( d5 a, ?* y7 H: G
8.     USART_SR状态寄存器
   $ i5 \6 I, j& ]
9.     USART_DR数据寄存器
   0 n9 }  R5 ~3 ?) _8 g! z- P
10.     USART_BRR波特率寄存器
      `& ^: ]5 K" V) c2 f
11.    
    
12.     TXD-PA9
    & R1 W5 A) N& _/ f; P
13.     RXD-PA10
    
14. */
    " J6 i1 N0 A$ h, f3 K$ k* C' d0 E2 R
15. 
    , @9 V# g6 a1 p; y3 I4 w/ n
16. #define USART_REC_LEN              60      
    : }' T1 L* L* G9 w! x1 h- I
17. #define EN_USART1_RX             1        //使能（1）/禁止（0）串口1接收
    
18.          
    5 K( ]( ]0 ?7 n7 b) e5 c! |! n
19. extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    
20. extern u16 USART_RX_STA;                 //接收状态标记   
    
21. 
    
22. extern void USART_InitEx(u32 bound);
    
23. extern void USART_SendDataEx(USART_TypeDef* USARTx, uint16_t Data);
      P' _0 x! ^  u$ v
24. extern void USART_SendAddr(USART_TypeDef* USARTx, uint16_t Addr);
    
25. 
    
26. 
    * h1 p4 G/ N9 ]% x7 i  b7 T! W. l
27. #endif

复制代码

1. // .c
   - B& w! l9 N0 j" w2 m$ Y' O( g
2. #include "MultiUSART.h"
   
3. 
   
4. 
   
5. 
   ; ^' u  c/ A/ ~4 g$ z
6. //串口1中断服务程序
   % y9 B  \8 o, V: w! T/ j8 s9 [
7. //注意,读取USARTx->SR能避免莫名其妙的错误      
   
8. u8 USART_RX_BUF[USART_REC_LEN] = "";     //接收缓冲,最大USART_REC_LEN个字节.
   7 T. `1 m5 E3 [* y+ |
9. //接收状态
   
10. //bit15，    接收完成标志
    + r. F1 B, F3 v* j
11. //bit14，    接收到0x0d
    
12. //bit13~0，    接收到的有效字节数目
    ' e( z" _: t2 @7 D/ y
13. u16 USART_RX_STA=0;       //接收状态标记      
    
14. 
    
15. 
    
16. 
    
17. void USART_InitEx(u32 bound)
    . D* Q  s3 Y( F2 J
18. {
    - P# |0 X! y7 {0 G% M* H9 k2 E
19.     GPIO_InitTypeDef GPIO_InitStructure;
    # X& z( M) i- k
20.     USART_InitTypeDef USART_InitStructure;
    
21.     NVIC_InitTypeDef NVIC_InitStructure;
    
22.      
    . U. K/ \& e2 h$ Y0 r# b
23.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);    //使能USART1，GPIOA时钟
    # f2 T8 g7 t$ `5 a1 |9 w5 B( R
24.      USART_DeInit(USART1);                                      //复位串口1
    " y) Y1 c6 H7 G" F
25.    
    - q6 Z- m% X( x" G3 Q9 l" O
26.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;         
    
27.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
28.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;            //复用推挽输出
    
29.     GPIO_Init(GPIOA, &GPIO_InitStructure);            
    ! o3 O1 Y0 c( v# D
30.    
      c3 O) v0 M- X3 @
31.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    
32.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;    //浮空输入
    
33.     GPIO_Init(GPIOA, &GPIO_InitStructure);         
    
34. 
    
35.    //Usart1 NVIC 配置
    
36.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    ' U8 P1 B4 u9 _2 l
37.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
    4 a# B9 @. g1 ]! B0 l( u4 }
38.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;        //子优先级3
    # n/ M$ Z! ~+ z
39.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;            //IRQ通道使能
    
40.     NVIC_Init(&NVIC_InitStructure);   
    3 n$ c7 s. }. i& u- J
41.   
    
42.    //USART 初始化设置
    
43.     USART_InitStructure.USART_BaudRate = bound;
    ' ]/ I! i$ s; i3 \. I2 P/ x9 q
44.     USART_InitStructure.USART_WordLength = USART_WordLength_9b;
    
45.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
    * t# i% s5 |7 |5 p1 o
46.     USART_InitStructure.USART_Parity = USART_Parity_No;        
    . j' k7 h4 D, Q" J. @( ?
47.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    * X3 f. N- K* L4 X2 I) }
48.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;   
    1 O) d: S% B* C9 w! \9 z, ^/ {+ w6 Q
49. 
    5 @7 h' m$ X) ~% b, \+ m8 B
50.     USART_Init(USART1, &USART_InitStructure);         //初始化串口
    1 e( i( [% T: b$ a4 L
51.     USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);    //开启中断   接收中断
    , J3 h! ^4 i! M, R
52.     USART_Cmd(USART1, ENABLE);                        //使能串口
    
53.    
    
54.    
    + j9 A( H9 V) |! V7 A7 t9 ^
55.     USART_SetAddress(USART1, 0x01);                    //设置USART1节点地址
    
56.     //USART_WakeUpConfig(USART1, USART_WakeUp_AddressMark);//地址标记唤醒
    
57.    
    
58.     //USART_ReceiverWakeUpCmd(USART1,ENABLE);
    
59. }
    2 K- W; n2 A( h2 _
60. 
    % ?) u$ i  E& B2 U: z- P
61. 
    
62. void USART_SendDataEx(USART_TypeDef* USARTx, uint16_t Data)
    
63. {
    ! A, |; ?$ d6 K  S# t$ P
64.     /* Check the parameters */
    
65.     assert_param(IS_USART_ALL_PERIPH(USARTx));
    
66.     assert_param(IS_USART_DATA(Data));
    
67.    
    4 n# ~; M5 B) m3 [- n; `6 I4 I# k
68.     /* Transmit Data */
    0 l5 z: M, k& f5 }8 O+ ]
69.     USARTx->DR = (Data & (uint16_t)0x01FF);
    
70.    
    
71.     //等待发送缓冲区空
    
72.     //或   等待发送结束
    ' w, }( d. d5 ~! Y' s: ]
73.     //while((USART1->SR&0X40)==0);
    
74.     while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET){};
    
75. }
    
76. 
    
77. void USART_SendAddr(USART_TypeDef* USARTx, uint16_t Addr)
    
78. {
    
79.     /* Check the parameters */
    
80.     assert_param(IS_USART_ALL_PERIPH(USARTx));
    
81.    
    
82.     // 9位字长， 最高位为1，低四位为地址
    * W, ?' {  f* j7 l; R) A" v& X
83.     //USARTx->DR = (1<<8) | Addr;
    
84.     Addr |= (uint16_t)0x0100;
    0 e, z* b' ?" U+ u* ~
85.     USARTx->DR = (Addr & (uint16_t)0x010F);
    
86. }
    
87. 
    
88. #if EN_USART1_RX
    
89. void USART1_IRQHandler(void)                                //串口1中断服务程序
    
90. {
    * R0 k8 V* e% d$ ~2 e1 \
91.     u8 Res;
    
92.     if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)      //接收中断(接收到的数据必须是0x0d 0x0a结尾)
    
93.     {
    ; X6 u  D& C' K& s6 h
94.         Res =USART_ReceiveData(USART1);//(USART1->DR);        //读取接收到的数据
    
95.         
    
96.         if((USART_RX_STA&0x8000)==0)                        //接收未完成
    
97.         {
    7 C. Z2 |8 L' T
98.             if(USART_RX_STA&0x4000)                            //接收到了0x0d
    
99.             {
    
100.                 if(Res!=0x0a)
     
101.                     USART_RX_STA=0;                            //接收错误,重新开始
     
102.                 else
     3 a$ x# S0 \: ~$ y+ N! ?6 W* s0 z! H5 [
103.                     USART_RX_STA|=0x8000;                    //接收完成了
     
104.             }
     
105.             else                                             //还没收到0X0D
     / P( ~$ |; G% u# U: E
106.             {   
     
107.                 if(Res==0x0d)
     ' ^, q+ L+ Q! @1 w3 F: j+ V, ?7 s
108.                     USART_RX_STA|=0x4000;
     2 a  R3 i" m. n9 A) o5 p5 Q
109.                 else
     0 _4 @+ `" H! A* D3 `" N
110.                 {
     . ]: R# h6 h, ?: ~
111.                     USART_RX_BUF[USART_RX_STA&0X3FFF]=Res;
     
112.                     USART_RX_STA++;
     ) C' P9 ~6 ?# ~* s4 ]- _# o( ]# ~" W
113.                     if(USART_RX_STA>(USART_REC_LEN-1))
     
114.                         USART_RX_STA=0;                        //接收数据错误,重新开始接收      
     " ^* X2 c+ w$ G. e/ u8 X8 S5 B
115.                 }         
     $ I; S% \; h9 f8 e  V
116.             }
     
117.         }            
     $ g' w3 Q1 K, h  o/ e0 I# ~
118.      }
     " {6 P' S/ p- k9 I+ G9 |5 T
119. }
     0 l. q) @- y4 I2 [: N: S* Y
120. #endif

复制代码

在主机端，可以写个键盘控制发送地址，类似：

switch(KeyValue)
        {
$ h8 x# F: B1 g4 z& e9 b1 w            case 1: USART_SendAddr(USART1, 0x01); break;　　//从机1
8 R/ g5 G4 j# d, ?            case 2: USART_SendAddr(USART1, 0x02); break;　　//从机2

.............

然后即可自己设定通信协议分别处理从机发过来的数据了。

& S! Z4 A- T3 [- K0 i1 H# D9 U9 {

在从机端，由于要设为静默模式：

USART_SetAddress(USART1, 0x01); 　　 //设置USART1节点地址 如从机1设为0x01

USART_WakeUpConfig(USART1, USART_WakeUp_AddressMark);　　//地址标记唤醒

USART_ReceiverWakeUpCmd(USART1,ENABLE);　　//使处于静默模式

这几句在串口初始化时要开启。

" {3 I3 a& q# J( c5 o

当主机发出正确地址给从机时，下面if 语句便成立可执行。

//从机被唤醒, 接收中断恢复正常   

if((USART1->CR1 &((uint16_t)0x0002)) == 0)
{........}

从而可在其中添加从机要给主机发送数据的程序。