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

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

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

1. // .h
   1 m9 {" \0 G* O
2. #ifndef _MULTIUSART_H
   : u# Z4 m! t+ O, t! ]
3. #define _MULTIUSART_H
   
4. #include "sys.h"
   : |$ u& K8 V+ y: u- }9 J5 Z9 i
5. #include "stm32f10x_usart.h"
   
6. 
   + X: U+ }; k0 p
7. /*
   
8.     USART_SR状态寄存器
   # i5 l4 e/ I" ~  Y  v+ [2 D& j
9.     USART_DR数据寄存器
   ) n2 J: s1 |& g; Q# B& R
10.     USART_BRR波特率寄存器
    
11.    
    4 z7 N0 o1 h, a+ ~
12.     TXD-PA9
    
13.     RXD-PA10
    6 |( q1 O) y: O3 S2 Y# `" a
14. */
    
15. 
    
16. #define USART_REC_LEN              60      
    
17. #define EN_USART1_RX             1        //使能（1）/禁止（0）串口1接收
    8 P: P7 I% f  a8 C
18.          
    
19. extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
    ! u6 |1 p/ y# H" M8 ]4 H# R
20. extern u16 USART_RX_STA;                 //接收状态标记   
    
21. 
    2 r" b9 D3 l7 b4 W/ D
22. extern void USART_InitEx(u32 bound);
    ) u! v6 A% U& m' u, B
23. extern void USART_SendDataEx(USART_TypeDef* USARTx, uint16_t Data);
    , G4 [# S$ G" x; D
24. extern void USART_SendAddr(USART_TypeDef* USARTx, uint16_t Addr);
    
25. 
    / R& i6 t, f2 o! ~: _
26. 
    
27. #endif

复制代码

1. // .c
   
2. #include "MultiUSART.h"
   
3. 
   . \9 N( j, i: {8 ]: `
4. 
   
5. 
   - {6 {# V0 l1 U7 C
6. //串口1中断服务程序
   ; w% R/ X1 g! D  `
7. //注意,读取USARTx->SR能避免莫名其妙的错误      
     z1 L& e2 F" f9 k, s9 f
8. u8 USART_RX_BUF[USART_REC_LEN] = "";     //接收缓冲,最大USART_REC_LEN个字节.
   
9. //接收状态
     L- m6 I- ~. i4 Q  q
10. //bit15，    接收完成标志
    
11. //bit14，    接收到0x0d
    
12. //bit13~0，    接收到的有效字节数目
    
13. u16 USART_RX_STA=0;       //接收状态标记      
    , F& V+ v: \) r& U8 K4 e1 `
14. 
    " N4 c* s! j# @8 A7 W
15. 
    
16. 
    4 N- a  x7 D$ {8 n
17. void USART_InitEx(u32 bound)
    
18. {
    
19.     GPIO_InitTypeDef GPIO_InitStructure;
    
20.     USART_InitTypeDef USART_InitStructure;
    
21.     NVIC_InitTypeDef NVIC_InitStructure;
    8 h+ |7 v9 t- x" l* n6 {% ~
22.      
    1 V0 E7 {8 M0 x; _
23.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);    //使能USART1，GPIOA时钟
    
24.      USART_DeInit(USART1);                                      //复位串口1
    & O4 r/ ^& k. Q8 N" k4 m: a7 W% N; |
25.    
    0 H5 N7 d! f. O+ Z/ _# V% E
26.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;         
    2 i6 O  E$ H- M! v# ]
27.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    7 b) i: N2 B" H
28.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;            //复用推挽输出
    
29.     GPIO_Init(GPIOA, &GPIO_InitStructure);            
    
30.    
    ; }% E" [, X" F. [0 B1 u
31.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    
32.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;    //浮空输入
    8 x. {' y4 }" c
33.     GPIO_Init(GPIOA, &GPIO_InitStructure);         
    
34. 
    % H8 w+ M9 Q1 U9 x$ ^) Y7 }
35.    //Usart1 NVIC 配置
    
36.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
37.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
    
38.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;        //子优先级3
    $ i# S4 G; O. M
39.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;            //IRQ通道使能
    
40.     NVIC_Init(&NVIC_InitStructure);   
    
41.   
    ! M, K# A5 p- }; Z' q) m( g
42.    //USART 初始化设置
    
43.     USART_InitStructure.USART_BaudRate = bound;
    
44.     USART_InitStructure.USART_WordLength = USART_WordLength_9b;
    
45.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
    * J( L7 h) d" F1 @
46.     USART_InitStructure.USART_Parity = USART_Parity_No;        
    
47.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
48.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;   
    
49. 
    6 A* h2 t' g6 M3 }
50.     USART_Init(USART1, &USART_InitStructure);         //初始化串口
    
51.     USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);    //开启中断   接收中断
    
52.     USART_Cmd(USART1, ENABLE);                        //使能串口
    
53.    
    
54.    
    , s: _$ S3 w- P6 C2 l
55.     USART_SetAddress(USART1, 0x01);                    //设置USART1节点地址
    
56.     //USART_WakeUpConfig(USART1, USART_WakeUp_AddressMark);//地址标记唤醒
    " o* I4 A* ~! u+ I, i3 B' y
57.    
    4 Y5 f/ `# Y, }# |( F" _$ G- d
58.     //USART_ReceiverWakeUpCmd(USART1,ENABLE);
    7 S8 D* k6 E$ p! R: l% [$ a/ P' \) \1 R
59. }
    
60. 
    
61. 
    7 Z/ w  U: l9 A- K1 l  F0 p
62. void USART_SendDataEx(USART_TypeDef* USARTx, uint16_t Data)
    
63. {
    . D& B* n$ c; h3 C# ?
64.     /* Check the parameters */
    
65.     assert_param(IS_USART_ALL_PERIPH(USARTx));
    7 I6 t9 V6 {- M) C( V* y
66.     assert_param(IS_USART_DATA(Data));
    : x) w' f, @" d, T; E+ F
67.    
    
68.     /* Transmit Data */
    
69.     USARTx->DR = (Data & (uint16_t)0x01FF);
    6 t8 @. R* o& P$ T
70.    
    
71.     //等待发送缓冲区空
    & h# ~9 }6 n- F/ v/ u
72.     //或   等待发送结束
    ! b; V# i  w6 ~1 ~! L  a8 U
73.     //while((USART1->SR&0X40)==0);
    
74.     while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET){};
    ( t4 N: w1 g4 A; h) l: `
75. }
    & D* z3 E% t/ M& _" [1 \
76. 
    
77. void USART_SendAddr(USART_TypeDef* USARTx, uint16_t Addr)
    1 ?) n' Z6 k0 w
78. {
    
79.     /* Check the parameters */
    6 Y0 Z: G0 C+ N1 q
80.     assert_param(IS_USART_ALL_PERIPH(USARTx));
    6 k3 b; j, c0 F( _: @+ G
81.    
      _" q$ A' O0 @, S- ~4 A1 u  ]( t
82.     // 9位字长， 最高位为1，低四位为地址
      y3 P* G! n1 V3 O! p3 [
83.     //USARTx->DR = (1<<8) | Addr;
    
84.     Addr |= (uint16_t)0x0100;
    + w8 f7 u% S2 h# l
85.     USARTx->DR = (Addr & (uint16_t)0x010F);
    
86. }
    
87. 
    
88. #if EN_USART1_RX
    
89. void USART1_IRQHandler(void)                                //串口1中断服务程序
    " T! x! l8 G, A  \3 Q
90. {
    . e) |( d- ?- G3 @1 C6 C
91.     u8 Res;
    - [  i2 l8 j) I0 Y) @
92.     if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)      //接收中断(接收到的数据必须是0x0d 0x0a结尾)
    
93.     {
    3 ]- Q3 _. I" u, e* m% K6 P0 T) J  G
94.         Res =USART_ReceiveData(USART1);//(USART1->DR);        //读取接收到的数据
      q8 z; ~4 @$ |. Q( r4 z
95.         
    
96.         if((USART_RX_STA&0x8000)==0)                        //接收未完成
    
97.         {
    
98.             if(USART_RX_STA&0x4000)                            //接收到了0x0d
    
99.             {
    $ E& `9 [7 f5 \2 J
100.                 if(Res!=0x0a)
     # N* K; F, r+ V$ Q
101.                     USART_RX_STA=0;                            //接收错误,重新开始
     
102.                 else
     0 y% U1 R: I: k, {' N5 E
103.                     USART_RX_STA|=0x8000;                    //接收完成了
     6 _2 G! P8 \; L9 U
104.             }
     
105.             else                                             //还没收到0X0D
     
106.             {   
     - R2 F) M! P9 t, S
107.                 if(Res==0x0d)
     # o, n3 y" a. T4 @
108.                     USART_RX_STA|=0x4000;
     $ u, m6 j( E; Y1 c/ O
109.                 else
     " e( `% I0 W8 Z7 o  f# }; w
110.                 {
     
111.                     USART_RX_BUF[USART_RX_STA&0X3FFF]=Res;
     
112.                     USART_RX_STA++;
     & Y9 |" O6 B/ G" F( M0 @( {# S
113.                     if(USART_RX_STA>(USART_REC_LEN-1))
     
114.                         USART_RX_STA=0;                        //接收数据错误,重新开始接收      
     2 @+ C0 U7 G0 h3 t; }& ]* \6 m
115.                 }         
     - c6 e6 z4 B' _7 K* J" ]+ N
116.             }
     
117.         }            
     
118.      }
     
119. }
     
120. #endif

复制代码

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

switch(KeyValue)
        {
            case 1: USART_SendAddr(USART1, 0x01); break;　　//从机1
            case 2: USART_SendAddr(USART1, 0x02); break;　　//从机2

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

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

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

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

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

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

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

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

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

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

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