前言：
- }: Y1 ?8 U: E' T% P6 j% z. D
前一段时间需要编写一个使用双路串口的程序采集传感器数据，由于自身能力有限所以遇到了很多坑，后来经过多方学习和调试基本完成了所需功能，现将自己的一些经（踩）验（过）方（的）法（坑），与大家分享。由于本人水平有限文章中有不足之处也欢迎大家指出改正！
, o) b# B$ M" b2 d
8 v, S- x8 L* \' |$ F5 o* `, v1、串口配置
6 @4 c; p4 u# |4 J
本人采用的是stm32F407的串口1和串口3（串口2因为硬件问题让我给烧坏了…尴尬， 在此也提醒大家一定要确保硬件连接无误），配置串口的过程不再赘述，直接上代码

1. //初始化IO 串口1
   8 c. f! v; e3 j5 d+ A/ A8 q7 s
2. //bound:波特率
   % k! {% ?9 j; ]( x
3. void uart_init(u32 bound){
   $ S9 m7 t. H' h. }9 N$ u5 m
4.     //GPIO端口设置
   
5.     GPIO_InitTypeDef GPIO_InitStructure;
   
6.     USART_InitTypeDef USART_InitStructure;
   / ~: Q# F+ ^/ Q) b" G
7.     NVIC_InitTypeDef NVIC_InitStructure;
   6 f. }5 y6 G1 W5 q1 v
8. 
   ! V8 g3 f4 N3 |2 ~# J& a0 o
9.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE); //使能GPIOA时钟
   9 j) A7 l! F7 Z* Y- ?8 T
10.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//使能USART1时钟
    6 t/ p" T0 V: L& f
11. 
    
12.     //串口1对应引脚复用映射
    $ u) F( g- }. F3 V, O6 W
13.     GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_USART1); //GPIOA9复用为USART1
    5 ~: |9 L6 w0 K7 e. b
14.     GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_USART1); //GPIOA10复用为USART1
    
15. 
    6 z( f# P  @- Z. |$ a0 F
16.     //USART1端口配置
    # }5 c; U+ h( Q0 ?1 x# [' n/ S
17.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10; //GPIOA9与GPIOA10
    / j/ B6 N; `$ E5 v) K" a) H3 o( s
18.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    
19.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //速度50MHz
    1 f/ }% t5 ]! b" ^4 V* t* n9 w
20.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
    ) i; f# ~" p1 a* j; \" f. F
21.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
    ( z. s' Z7 z4 L# u9 h, b& J
22.     GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA9，PA10
    
23. 
    
24.    //USART1 初始化设置
    
25.     USART_InitStructure.USART_BaudRate = bound;//波特率设置
    
26.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    
27.     USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    
28.     USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    / F5 K0 n' I1 t7 ?" L  e
29.     USART_InitStructure.USART_HardwareFlowControl    USART_HardwareFlowControl_None;//无硬件数据流控制
    + }$ U+ p2 w/ N! W! a
30.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
    1 b6 N3 q) @4 ~
31.     USART_Init(USART1, &USART_InitStructure); //初始化串口1
    
32. 
    
33.     USART_Cmd(USART1, ENABLE);  //使能串口1
    
34. 
    
35.     //USART_ClearFlag(USART1, USART_FLAG_TC);
    
36. 
    
37. 
    
38.     USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启相关中断
    7 I# y4 S2 C6 m; @5 Q+ [" ], v  z
39.    //   USART_ITConfig(USART1, USART_IT_TC, ENABLE);
    * q2 f) k. v  }! x5 d& @8 s9 m/ L; D
40. 
    
41.     //Usart1 NVIC 配置
      a9 z4 I$ G8 v$ P& _" f
42.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;//串口1中断通道
    ' S+ R5 D( W  [
43.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//抢占优先级3
    
44.     NVIC_InitStructure.NVIC_IRQChannelSubPriority =3;       //子优先级3
    - w: w$ @% V& P' i! G! W6 }
45.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;         //IRQ通道使能
    , ~/ m3 D% }. V2 A/ K* p
46.     NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器、
    6 _0 U& |: U, _- z2 ~% q
47. 
    & B4 ]' e, H+ {7 w5 ]  o
48. 
    ( R: Z: u) v, h( s' s$ J7 T- {
49. }
    
50. 
    
51. void uart3_init(u32 bound)
    $ E* V# _2 h& f
52. {
    
53.     //GPIO端口设置
    ! G  k) Y) O* M% n& A9 O4 F3 f
54.     GPIO_InitTypeDef GPIO_InitStructure;
    
55.     USART_InitTypeDef USART_InitStructure;
    . m( a7 [& a3 g/ ^: s. c3 p0 P
56.     NVIC_InitTypeDef NVIC_InitStructure;
    5 f8 v6 i4 G( Y3 y. r0 E. P
57. 
    
58.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB,ENABLE); //使能GPIOA时钟
    
59.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);//使能USART1时钟
    & P7 J& F% b% j, n5 Y
60. 
    4 ?$ m; M  `8 P' G) I* Z, q
61.     //串口3对应引脚复用映射
    
62.     GPIO_PinAFConfig(GPIOB,GPIO_PinSource10,GPIO_AF_USART3); //GPIOA9复用为USART1
    
63.     GPIO_PinAFConfig(GPIOB,GPIO_PinSource11,GPIO_AF_USART3); //GPIOA10复用为USART1
    
64. 
      d  z. A' X: j: S6 c
65.     //USART3端口配置
    ' ~9 A* ^7 D1 b. N, v2 O2 F$ O
66.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11; //GPIOB10与GPIOB11
    5 w: S/ L1 ?- {3 V
67.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    
68.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //速度50MHz
    3 e/ E3 C  x/ c6 \. X+ }$ p
69.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
      ?. U; {4 o1 T% v1 ^
70.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
    
71.     GPIO_Init(GPIOB,&GPIO_InitStructure); //初始化PA9，PA10
    * G* E. V1 y9 ]! j! u
72. 
    & |% ]2 k: t5 c& z
73.    //USART3 初始化设置
    1 ~/ ^! k  }% T- ^8 S) G% h
74.     USART_InitStructure.USART_BaudRate = bound;//波特率设置
    7 s, a  C0 m9 [& J
75.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    1 U' R9 |- w. b" W$ j
76.     USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    
77.     USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    % r4 o. c9 [1 R, }% Y* j; t) H
78.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    
79.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
    3 S- V% D; [/ u9 |7 H4 F
80. 
    
81.     USART_Init(USART3, &USART_InitStructure); //初始化串口3
    3 t; B) f  _  B3 G+ }1 j9 y
82.     USART_Cmd(USART3, ENABLE);  //使能串口3
    $ c5 ~+ ~6 [5 L+ k
83. 
    
84.     USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);  //开启接收中断   
    , J% b8 K& ^3 X9 G/ y
85.     USART_ITConfig(USART3, USART_IT_IDLE, ENABLE);  //开启空闲中断
    & J9 |. M7 u) o
86. 
    
87.     //Usart3 NVIC 配置
    $ q3 O* S; r" X  x9 T( m( x1 s
88.     NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;//串口1中断通道
    
89.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//抢占优先级3
    
90.     NVIC_InitStructure.NVIC_IRQChannelSubPriority =3;       //子优先级3
    6 [  m. g8 A( F; w2 R3 K
91.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;         //IRQ通道使能
    
92.     NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器、
    
93. 
    8 j" E; R5 W8 Z7 S, z3 i
94. 
    
95. }

复制代码

这里需要说明的强调的是，在配置串口3的时候开启了空闲中断，这里是为了实现接收不定长数据，会在下文详细说明。
& q" M5 N' f+ |: K
2、接收不定长数据的实现
+ E" n1 W1 D; _- g2 ~8 @
& S/ k* `# W5 F+ n# O" }0 [8 p首先说明一下个人的思路，如下图。
- X7 w  y4 t: L: Y
1 Q: k$ \. }) h: U' @

! ?1 c) ]2 R2 k4 X首先是由上位机通过串口1向stm32发送一条相关指令，stm32再将指令转发给传感器端，传感器接收到相关指令后通过串口3发送相关数据给stm32，最后再由stm32将数据进行相应解析后通过串口1回传给上位机。

但是无论是上位机指令还是传感器回传的数据，其数据长度都不是固定的，以下给出两种方法分别实现对串口1和串口3的数据接收。
8 F) Y/ q! P* s  U: C+ n
2.1、使用循环队列的方法接收串口1的数据
4 L3 D, b3 j' X
; z7 R0 W& \. K8 k! b1 F$ W& K2 o# e

如上图所示，RevBuff1为串口1的接收缓存区；usart1_in为队头，每次接收到一个字节的数据后usart1_in++，用来记录当前入队的位置；usart1_out为队尾，每次出队后队尾记录上次入队的位置。串口1中断函数如下：
8 J7 @: w- {( ^+ [

1. uint32_t usart1_in  = 0;
   
2. uint32_t usart1_out = 0;
   
3. u8 RevBuff1[BUFFSIZE] = {0};
   ! b% p' G( y& b: X
4. u8 flag = 0;
   
5. 
   
6. void USART1_IRQHandler(void)                    //串口1中断服务程序
   " W4 P8 v, d8 {
7. {
   
8.     u8 res1 = 0;
   
9. 
     D; l1 E3 @" T
10.     if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)//接收到数据
    
11.     {
    
12. 
    
13.         res1 = USART_ReceiveData(USART1);
    % m0 V) r4 }* V
14.         USART_ClearITPendingBit(USART1, USART_IT_RXNE);
      |' V" r' a% U/ {. d/ Q* K
15.         RevBuff1[usart1_in++] = res1;
    * C) j9 G1 R8 c' O: V
16. 
    
17.         if (usart1_in >= BUFFSIZE) {
    ; S* q$ U3 B9 \' O' v! \
18.             usart1_in = 0;
    
19.         }
    ) d6 |9 t+ l# x* a
20. 
      |; {3 |/ R4 D: D, w
21.         flag = 1;
    9 x) |1 m9 z8 N/ R! ^
22.     }
    
23. }

复制代码

按照这个思路，要想将串口1的接收到的数据发送给串口3时，只需要判断队头和队尾的位置，然后发送队尾至队头之间的数据就可以实现不定长数据的发送了，具体代码实现如下：
  b0 B: L0 R  a( e

1. //把串口1接收到的数据透传发送给串口3
   ( z$ @  m) b4 B: |4 Z1 g  C
2. if (flag == 1) {   
   . m& z$ u+ h/ x; l, x4 `' h
3.    if (usart1_out != usart1_in) {       //在队头队尾不相等的情况下，即有数据存入RecBuff1
   
4.        if (usart1_out < usart1_in) {    //若队尾小于队头，直接发送队尾至队头之间的数据
   8 {9 }2 D5 C$ D  c
5.             for (t = usart1_out; t < usart1_in; t++) {
   ' }0 @8 X5 l4 R9 ?' B# I; }) q# e
6.                 while(USART_GetFlagStatus(USART3,USART_FLAG_TXE)!=SET);
   # b% p! M) x+ ]/ T
7.                 USART_SendData(USART3, RevBuff1[t]);        
   1 |2 D7 j  V# G
8.             }  
   
9.             usart1_out = usart1_in;     //发送完成后队尾移至当前队头的位置
   
10.             flag = 0;
    ' ~6 Q) ~/ A/ n3 Y7 {5 U1 l/ `
11.        }
    
12.        else {
    ; ?. N2 c4 Y6 H! l/ @# P: k( e# {7 `
13.            //若队尾大于队头，先发送队尾至RecBuff1[BUFFSIZE]之间的数据
    $ T: r) {5 ~  i# y1 D6 D
14.            //然后发送RecBuff1[0]至队头之间的元素
    8 `% ]+ [) f- s, X
15.            for (t = usart1_out; t < BUFFSIZE; t++) {
    
16.                 while(USART_GetFlagStatus(USART3,USART_FLAG_TXE)!=SET);
    3 t; L  B: m6 s' D& I- V
17.                 USART_SendData(USART3, RevBuff1[t]);        
    
18.             }  
    * k: N5 I. s7 C) h  m9 o
19.             for (t = 0; t < usart1_in; t++) {
    
20.                while(USART_GetFlagStatus(USART3,USART_FLAG_TXE)!=SET);
    
21.                USART_SendData(USART3, RevBuff1[t]);  
    - X1 x+ E3 h" `2 A& u; v
22.             }
    
23.             usart1_out = 0;           //发送完成后队尾移至RecBuff1[0]的位置
    
24.             flag = 0;
    
25.        }
    
26.     }   
    
27. }

复制代码

+ E; k/ g$ Y5 d- X7 y: p2.2、利用串口的RXNE和IDLE中断接收串口3的数据

首先说明，IDLE中断就是串口收到一帧数据后，发生的中断；所谓一帧数据是指给单片机一次发来1个字节，或者一次发来若干个字节，这些一次发来的数据，就称为一帧数据。 而当接收到1个字节，就会产生RXNE中断。

# v  g/ j& e4 C2 |2 `( @' @  Z! l上图为状态寄存器描述图，当串口接收到数据时，bit5就会自动变成1，当接收完一帧数据后，bit4就会变成1。

需要注意的是，在中断函数里面，需要把对应的位清0，否则会影响下一次数据的接收。比如RXNE接收数据中断，只要把接收到的一个字节读出来，会清除这个中断。IDLE中断，如果是F0系列的单片机，需要用ICR寄存器来清除，如果是F1系列的单片机，清除方法是“先读SR寄存器，再读DR寄存器”，经测试，F4系列与F1系列的方法相同。在使用IDLE中断之前先要在串口3配置时开启相应中断（上文已经提到过），如下图：

接着来看串口3的中断程序：

1. void USART3_IRQHandler(void)     //串口3中断服务程序
   
2. {
   
3.     u8 res3  = 0;
   
4.     u8 Clear = 0;
   6 S' f9 g! d' Y  X; P
5. 
   
6.     //如果接收到一个字节
   
7.     if (USART_GetITStatus(USART3, USART_IT_RXNE) != RESET) {
   
8.         res3 = USART_ReceiveData(USART3);
   
9.         RevBuff3[usart3_in++] = res3;
   
10. 
    
11.         if (usart3_in >= BUFFSIZE) {
    
12.             usart3_in = 0;
    * N+ @- r% g6 `: P" I% N
13.         }
    
14. 
    4 m4 i- Y* I& |# C4 R' ~
15.         flag3 = 1;
    
16.     }
    # `6 W" e  Z+ O$ m
17.     //如果接收到一帧数据
    
18.     else if (USART_GetITStatus(USART3, USART_IT_IDLE) != RESET) {
    , I# r1 Z8 V4 x3 I1 j
19.         Clear = USART3->SR;     //读SR寄存器
    9 J2 l9 ?# L2 M' @4 N
20.         Clear = USART3->DR;     //读DR寄存器（先读SR再度DR，可以清除IDLE中断）
    
21.         ReceiveStave = 1;       //标记接收到1帧的数据
    
22.     }
    3 g' r& V' o0 N
23. 
    
24. }

复制代码

串口3中断函数中，分别来判断是否接收到1个字节，以及判断是否接收到1帧数据，这样不仅能接收不定长数据，同时usart3_in中也记录了RevBuff3的大小。此时再进行其他的控制就容易多了，以下是我自己控制部分的代码：

1. //当串口3接收到一个完整数据帧，处理数据帧，将处理好结果发回串口1
   7 J$ I1 I( p0 i1 j) P1 s4 b
2.          if (ReceiveStave == 1) {  
   - Q1 w, j( }: y. R( o7 [- _+ P+ S) I
3.             ReceiveStave = 0;
   
4.             t = 0;
   
5. 
   3 T' ?. H% Q+ k% n8 X0 n
6.             //复制RevBuff3到tmp
   
7.             for (t = 0, tmpLen = 0; t < usart3_in; t++,tmpLen++) {
   , C; K4 ?, @9 T
8.                 tmp[tmpLen] = RevBuff3[t];
   % `. t3 l$ @5 b/ B2 P/ G! Y+ `2 ~
9.             }
   
10. 
    / e( p% f: H& A
11.             //得到处理后的数据
    3 @) R) n( \( z& ]$ N* w1 @
12.             p = ReadRealTimeData(tmp, tmpLen);
    : G, c( a& B6 Z3 W. k
13. 
    
14. 
    
15.             //发送处理后的数据
    
16.             for (i = 0; i < strlen( p ); i++) {
    1 b1 x! d3 S' a7 T3 ?( K
17.                 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)!=SET);               
    
18.                 USART_SendData(USART1, p[i]);
    
19.                // while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
    
20.             }
    
21. 
    
22.              usart3_in = 0;
    
23.          }

复制代码

3、串口发送数据的TC/TXE行为
6 x7 J! \1 s* F6 X: ^6 \. A+ v
先来看看串口数据发送的过程是什么样的：
; @' S* h0 E1 P+ T  z
先写数据到DR寄存器->移位寄存器->TX管脚。当数据从DR寄存器移出到移位寄存器(即DR寄存器空）时TXE就置位，优点是能保持发送数据的连续性；而当一帧数据全部发送完成（”\0”结束符）则触发TC中断，优点是可确定发送完成的时间多用于数据的流控。

, Y- \+ u5 V- S- Z2 P: R( y- x也就是说，TXE=1代表发送数据寄存器空，可以往里存放数据 ；TC=1代表该寄存器中的数据已全部发送完成。借用openedv论坛中一句形象的描述就是：

7 T2 j+ \( t& m你写数据到串口时，是装入弹仓，硬件会将数据移到枪膛，这时，TXE为1，TC为0，STM32硬件的TX脚正在发送数据，但你还可以装入数据到弹仓，装入后，TXE为0，TC为0.

, r4 {' a! S2 g: Y6 QTX发送完一个数据后，立即将数据从弹仓移入枪膛，这时，TXE为1，TC为0.
( A$ ~% J; p' }+ v2 U
: d  H/ v& m# M( g- Z/ n最后TX发送完数据，你又没有装入新数据，这时。TXE为1，TC为1.
3 u0 U% Q' w1 q$ a: X) Y2 v
那么了解这两个有什么具体的用处呢？
常见的使用方式有以下两种，在向串口写数据时需要知道上一次数据是否发送完成，既然TXE=1代表发送数据寄存器空，可以往里存放数据，那么我们在写数据之前可以先进行TXE中断判断，代码如下：
9 f8 U( w0 o5 J

1. //发送处理后的数据
   ( a) ~: Q2 _+ u
2.   for (i = 0; i < strlen( p ); i++) {
   
3.       while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)!=SET);               
   7 D% F& z5 s. I; ]0 {' p
4.       USART_SendData(USART1, p[i]);  
   
5.   }

复制代码

而TC=1代表该寄存器中的数据已全部发送完成，可以理解为每发送一次数据后，判断此次发送是否完成，代码如下：
/ ~0 L* V2 u6 S& V

1. for(t=0;t<len;t++) {
   ' d' e/ {; L) J" `6 G
2.     USART_SendData(USART1, USART_RX_BUF[t]);      
   6 Q# l9 h# n5 K6 j
3.     while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);
   
4. }

复制代码

4、注意硬件接线及标号是否正确！！！

注意硬件接线及标号是否正确！！！
. e$ c. Q- j$ X8 t0 c6 s* M6 f4 m/ k) Z注意硬件接线及标号是否正确！！！
+ y0 g- k* @" p注意硬件接线及标号是否正确！！！
& W4 k# P( S/ j3 [
' i+ ]% M8 G4 S& P解决了数据发送和接收的大问题，程序基本就应该可以完成了吧，想想还有点小激动呢！连接线路，RX接TX，TX接RX，一切看起来十分完美，然而出现了尴尬的情况，程序怎么也读不到数据……刚开始我觉得一定是程序写的有问题，找了好久后无果，请大神来看看，大神看完程序也说没问题，思考片刻后交换了一下接线，然后就好了！！！好了！！！最后发现是传感器上的标号标错了（RX，TX标反了！！！）。这大概是这个项目中最大的一个坑吧。所以再次提醒大家一定要注意硬件接线及标号是否正确！！！

3 x/ y: W+ g* M总结

跌跌撞撞地总算是实现了基本的功能，由于自己也是第一次入手串口相关项目，所以遇到了许多大大小小的问题，项目至今也还有一些BUG，比如说，采集数据时还会出现丢包现象，用两种不同方式实现接收不定长数据是因为只用第一种就会出现数据丢失… 但是也算有所收获吧，写下来和大家分享交流。

7 ^% i( Y% r( L+ Y$ Q7 D# i

) ]3 G8 v$ [  {3 I5 r' Q! k6 W转载自it-is-time-to
. i4 [0 W; g3 z