STM32的串口通信

本文在于记录自己的学习过程中遇到的问题和总结，各种情况下串口通信在STM32的实际使用方面占有很大的比重，本文主要对串口通信做一个简要的总结。

一、STM32里的串口通信

在STM32里，串口通信是USART,STM32可以通过串口和其他设备进行传输并行数据，是全双工，异步时钟控制，设备之间是点对点的传输。

, G! y' @, d  S8 Y  x' J

对应的STM32引脚分别是RX和TX端。STM32的串口资源有USART1、USART2、USART3.

串口的几个重要的参数:

; K$ y. y6 N2 n& x3 a% Q

• 波特率，串口通信的速率
  
  
• 空闲，一般为高电平
  
  
• 起始位，标志一个数据帧的开始，固定为低电平。当数据开始发送时，产生一个下降沿。(空闲–>起始位)
  
  ( H: ^. c# r1 _. J
• 数据位，发送数据帧，1为高电平，0为低电平。低位先行。
  
  7 P8 V) G( M+ t' L3 U" _
• 比如 发送数据帧0x0F 在数据帧里就是低位线性 即 1111 0000
  
  
• 校验位，用于数据验证，根据数据位的计算得来。有奇校验，偶校验和无校验。
  
  8 d3 T& c6 b) ~! @2 R, Y+ [
• 停止位，用于数据的间隔，固定为高电平。数据帧发送完成后，产生一个上升沿。(数据传输–>停止位)
  
  6 P5 d* l+ X' T% X4 e% s

/ A3 y1 r# g& B; ?2 O6 X  P

下方就是一个字节数据的传输过程，从图中可以看出，串口发送的数据一般都是以数据帧的形式进行传输，每个数据帧都由起始位，数据位，停止位组成， 且停止位可变。

2 ]/ N; I# U0 s& T0 H* H, d/ W

二、串口的发送和接收

USART是STM32内部集成的硬件外设，可以根据数据寄存器的一个字节数据自动生成数据帧时序，从TX引脚发送出去，也可以自动接收RX引脚的数据帧时序，拼接成一个字节数据，存放在数据寄存器里。

当配置好USART的电路之后，直接读取数据寄存器，就可以自动发送数据和接收数据了。在发送和接收的模块有4个重要的寄存器

5 G1 ]6 ]; f( J8 H- D

• 发送数据寄存器TDR
  
  
• 发送移位寄存器，把一个字节的数据一位一位的移出去
  
  
• 接收数据寄存器RDR
  
  - u4 m+ [' }% \% E
• 接收移位寄存器，把一个字节的数据
  
  % ]6 c. Z* q' R  h8 g; m( d

8 g" u6 N7 Z- \0 j) X5 \7 I' Y- n

下方为串口的发送和接收图解：

' g$ Y( y4 t: F) M) O! ]( `0 l

- {: D# J* j2 K9 ~8 V5 Z

串口发送

在配置串口的各个参数时，可以选择发送数据帧的数据位的大小，可选8位或9位。

- }- B$ v( l9 v3 T

串口发送数据实际上就是对发送数据寄存器TDR进行写操作。

$ q6 U4 d# j9 Q' D6 ~

1. 当串口发送数据时，会检测发送移位寄存器是不是有数据正在移位，如果没有移位，那么这个数据就会立刻转移到发送移位寄存器里。准备发送。

' s/ s: h  S/ J! d6 j  F" R

2. 当数据移动到移位寄存器时，会产生一个TXE发送寄存器空标志位，该位描述如下。当TXE被置1，那么就可以在TDR写入下一个数据了。即发送下一个数据。

  L2 P2 i1 r! Z0 @9 s. `

/ J% f8 ?7 f* w: [  M2 L

3. 发送移位寄存器在发送器控制的控制下，向右移位，一位一位的把数据传输到TX引脚。

; k6 x/ u# o# \) b

4. 数据移位完成后，新的数据就会再次从TDR转移到发送移位寄存器里来，依次重复1-3的过程。通过读取TXE标志位来判断是否发送下一个数据。

) g: ^* X8 x7 I1 E7 Y

串口接收

数据从RX引脚通向接收移位寄存器，在接收控制的控制下，一位一位的读取RX的电平，把第一位放在最高位，然后右移，移位八次之后就可以接收一个字节了。

, k) t% N/ b4 q; G4 L6 c

当一个字节数据移位完成之后，这一个字节的数据就会整体的移到接收数据寄存器RDR里来。

& ]$ @( I/ }5 p" j7 q' |

在转移时会置RXNE接收标志位，即RDR寄存器非空，下方为该位的描述。当被置1后，就说明数据可以被读出。

0 Q. S* F# X7 Z2 E, r

6 g8 r5 Y+ I- \6 z3 n5 z( d

下图即为串口接收的工作流程

三、串口在STM32中的配置

6 h% P6 ?/ U5 K: G7 ^* U

首先要明确几点：使用STM32串口外设中的哪一个？串口发送或者接收数据？串口相关的参数配置？发送或接收是否使用到中断？

3 `1 g5 x' m1 y( x* `% Y& Q. x$ c

下方为串口发送的配置。

" E+ `  b! l7 L8 f+ ?9 _( A

1. RCC开启USART、串口TX/RX所对应的GPIO口

6 }, F- t- d- R/ ~2 K

1. RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);  //开启USART2的时钟
   1 J: v( \$ ?% g) M0 K$ q/ a' \
2. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);   //开启GPIOA的时钟

复制代码

2 ]: M3 M% d, p' v3 C

2. 初始化GPIO口

6 V/ i, Q/ C* T% c9 U( Q5 Z' {

这里注意哈，根据自己的需求来配置GPIO口，发送和接收是都需要还是只需要其中一个。然后对应的根据引脚定义表来初始化对应的GPIO口。

USART2对应的引脚

4 q. q. b$ s" m8 ]- y8 t' q

5 T) S, `. v, B, O. a. K

USART1对应的引脚

! v# I! A% A; g1 E4 l% b

这里根据手册来看，RX引脚模式配置成浮空输入或者上拉输入。TX引脚模式配置成复用推挽输出。

' a2 T: m0 @0 u, v$ |% \! O( _! C

**比如我这里只初始化TX发送端**

1. //TX端
   
2.     GPIO_InitTypeDef GPIO_InitStructure;
   : H& Z8 G9 \! ~
3.     GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;  //复用推挽输出
   
4.     GPIO_InitStructure.GPIO_Pin=GPIO_Pin_2;   //USART2对应的TX端为GPIOA2
   4 r9 ?$ F8 U7 P! S/ x6 W
5.     GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;  //50MhZ
   2 x, d3 [0 A  N" I. U  U! h
6.     GPIO_Init(GPIOA,&GPIO_InitStructure);

复制代码

3. 串口初始化

4 `# e; g1 G& z# v  e

注意哈，USART_Init()这个函数，是用来配置串口的相关参数的。

1 x* C( |2 g0 a+ z  Q

• USART_BaudRate 串口通信使用的波特率 一般是9600或者是115200，这里我们给9600
  
  
• USART_HardwareFlowControl 是否选择硬件流触发，一般这个我们也不选，所以选择无硬件流触发。
  
  
• USART_Mode 这个参数要注意了哈，串口的模式，发送模式还是接收模式，还是两者都有
  
  . w6 t1 T  K+ Z3 Q7 ]) J; V. v
• USART_Parity 校验位，可以选择奇偶校验和不校验。没有需求就直接无校验
  
  
• USART_StopBits 停止位 有1、0.5、2位，我们这里选1位停止位
  
  
• USART_WordLength 数据位 有8位和9位可以选择
  
  - h. t/ h+ H1 X8 L( f+ H( ^

1. //串口初始化
   
2.   USART_InitTypeDef USART_InitStruct;
     Z5 j2 ?# z2 }  Z
3.   USART_StructInit(&USART_InitStruct);  //初始默认值
   
4.   USART_InitStruct.USART_BaudRate=9600;
   
5.   USART_InitStruct.USART_HardwareFlowControl=USART_HardwareFlowControl_None;   //不使用硬件流触发
   
6.   USART_InitStruct.USART_Mode=USART_Mode_Tx;         //TX 发送模式
   
7.   USART_InitStruct.USART_Parity=USART_Parity_No;       //不选择校验
   ; Z8 ~9 k( S- G% c/ C2 s' |
8.   USART_InitStruct.USART_StopBits=USART_StopBits_1;      //停止位1位
   
9.   USART_InitStruct.USART_WordLength=USART_WordLength_8b;  //数据位8位
   / e2 H+ Y8 b9 d
10.   USART_Init(USART2,&USART_InitStruct);

复制代码

4 o5 P$ U) c5 M5 l- i, v

4. 串口使能

1. //串口使能
   
2.    USART_Cmd(USART2,ENABLE);

复制代码

5. 串口发送数据

8 l1 Y4 ]" p6 l+ F3 k) C' }- S注意哈，我们要判断TXE标志位的状态。0，数据还没有被转移到移位寄存器；1,数据已经被转移到移位寄存器。

当TXE标志位为1时，就说明可以发送下一个数据了。详细过程可看上面串口发送的解释。

1. void Serial_SendByte(uint16_t Byte)
   
2. {
   ; q' T. k* V3 y9 @( N
3.   USART_SendData(USART2,Byte);
   
4.   //0 表示数据还未转移到移位寄存器 循环等待 1 数据已经被转移到了移位寄存器可以发送数据
     e2 S! u4 _3 G( D5 _9 I0 o2 m. Y
5.   while(USART_GetFlagStatus(USART2,USART_FLAG_TXE)==RESET);  //不需要手动清零 再次写入TDR时会自动清零  
   
6. }

复制代码

  U# a! P  ?2 ^3 @7 H# `

经过上述五步的配置，单片机就可以通过串口发送数据了。

下方为发送数据图例，STM32向串口发送0x16数据

+ l7 e- Q5 A5 e0 O# H! W; t/ r4 h

/ n7 w8 ]& Z/ m' X

四、串口接收的两种实现方式

上方是发送数据的例子，那么串口接收又该如何配置，又要在串口发送的例子上做哪些更改呢？

这里我们可以通过查询或者中断的方式来进行接收数据的两种方式。

; @/ E4 I% ?4 \1 e# a8 c

• 查询方式就是通过不断的查询RXNE标志位，通过判断RXNE位的状态来确定数据是否接收。
  
  
• 中断方式就是通过配置接收输出控制通道，配置NVIC，在中断服务子函数里进行数据的接收。
  
  + ~+ r6 d+ D$ F  T" U9 D) Y

1. 需要更改的地方
# B4 m, V& l9 U/ h7 a
; \3 r  ]7 g* [  q" Z5 E

既然我们要实现串口的接收，那么就要配置串口RX引脚，在串口模式中添加USART_Mode_RX模式。

" ~, r# R2 u4 T/ W

• 初始化RX引脚
  
  

1. //RX端
   
2.   GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;  //上拉输入
   
3.     GPIO_InitStructure.GPIO_Pin=GPIO_Pin_3;
   
4.     GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;  //50MhZ
   6 b0 q" `' O( _' ^% U
5.     GPIO_Init(GPIOA,&GPIO_InitStructure);

复制代码

9 c* b) x, S( \) p  m. `

, b# }5 |3 z. m  N

• 添加串口模式
  
  ! q% T3 L! ?, H5 o; s1 _7 n

1. USART_InitStruct.USART_Mode=USART_Mode_Tx|USART_Mode_Rx;         //TX 发送模式  RX 接收模式

复制代码

2. 查询RXNE标志位

这里我们还是来看一看RXNE标志位的描述

上图描述，为0时数据没有收到，为1时收到了数据，数据可以从RDR里读出

( g/ l; K  o0 s( b8 |, R

所以在主程序里不断读取RXNE标志位，如果为1，表示数据可以读出

1. uint8_t RX_Data;
   
2. int main()
     ?% N. F) _$ O7 V
3. {
   
4.     Serial_Init();
   : K, X' c" W+ u, Q. [
5.     Serial_SendByte(0x16);
   , x2 r- m4 o, F( v5 k/ n
6.     while(1)
   ) q$ x  o& O/ v" I/ O
7.     {
   - S% i6 B) a% V3 Z4 B
8.         if(USART_GetFlagStatus(USART2,USART_FLAG_RXNE)==SET)   //0 循环等待 1 可以接收数据
   ' n. @3 s* L, N3 x: @4 T# A
9.         {
   
10.             RX_Data=USART_ReceiveData(USART2);           
    
11.       Serial_SendByte(RX_Data);
    ! `' x3 |9 C* K
12.         }
    
13.     }
    
14. }

复制代码

下图为程序现象：pc向单片机发送数据0x15，单片机接收数据0x15，并且把接收到的数据作为数据发送到pc，在pc上显示0x15。

3. 使用中断

3 A# i0 P9 }# U; b% w" r1 Z

• 通过配置串口的接收作为中断源，开启中断输出控制，配置NVIC。开启中断通道。
  
  

1. //开启中断输出控制
   
2.   USART_ITConfig(USART2,USART_IT_RXNE,ENABLE);
   
3.   
   . e% ~) |) q' I; G
4.   //配置NVIC
   
5.   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
   
6.   NVIC_InitTypeDef NVIC_InitStruct;
   5 C. G: F/ K# J, D; ]( w
7.   NVIC_InitStruct.NVIC_IRQChannel=USART2_IRQn;   //选择USART2的中断通道
   ! U( O* o4 h( U% N( D
8.   NVIC_InitStruct.NVIC_IRQChannelCmd=ENABLE;    //中断使能
   
9.   NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority=1;
   6 k7 }. g, @2 m4 q9 R4 R0 q
10.   NVIC_InitStruct.NVIC_IRQChannelSubPriority=1;
    
11.   NVIC_Init(&NVIC_InitStruct);

复制代码

8 p/ z2 i" P0 ^  H

: B& n$ P$ i% R

• 中断服务子函数
  
  

中断服务子函数写好后，就可以在中断里读取接收到的数据了。

当接收到数据后，触发接收中断，主程序暂停执行。接收完数据后主程序回复执行。当接收到数据时，就触发中断。

1. void USART2_IRQHandler(void)
   
2. {
   # z! V! V7 C* a- C  N
3.   if(USART_GetITStatus(USART2,USART_IT_RXNE)==SET)   //RXNE 标志位为1 表示可以接收数据
   - n+ Q0 W8 y- j9 t% _" r/ E$ O
4.   {
     h) q" M2 z: U, {; i9 J1 z8 \
5.     RX_Data=USART_ReceiveData(USART2);
   , i+ ?7 T, B9 [7 j! P% d1 _/ N
6.     Flag=1;
   8 U7 L4 E6 [7 S! B3 D1 e
7.     USART_ClearITPendingBit(USART2,USART_IT_RXNE);  //清除RXNE标志位
   ( |# t! S' M/ ^
8.   }
   
9. }

复制代码

• 主程序测试
  
  

1. uint8_t RX_Data;
     P  g9 D: P3 V6 G1 `& W, E& v& C6 w2 A
2. uint8_t Flag;
   & A+ t) Q3 G: s+ L3 }
3. 
   ! s0 y; F+ K$ U4 E& p4 }* D
4. int main()
   7 C! Q6 {, u& L
5. {
   
6.     Serial_Init();
   
7.     Serial_SendByte(0x16);
   9 }1 U8 i3 H8 k5 L# e
8. 
   - N( _& [/ H8 R' \4 Z" y
9. 
   8 D$ K; N! f8 Y- Y0 \0 @: n
10.     while(1)
    8 d9 \' F* ?0 F
11.     {
    + c2 l& L' `! k1 a/ w0 j
12.         if(Flag==1)
    ) K' }( m( C/ c4 D9 V# C* {
13.         {
    
14.             Serial_SendByte(RX_Data);
    
15.         }
    2 w# u" T0 l" O
16.     }
    
17. }
    
18. 
    
19. void USART2_IRQHandler(void)
    ; @5 |: [% X. G/ T2 U! g! l' t
20. {
    
21.     if(USART_GetITStatus(USART2,USART_IT_RXNE)==SET)   //RXNE 标志位为1 表示可以接收数据
    8 }, W7 t7 C) D; k7 P# G* F
22.     {
    
23.         RX_Data=USART_ReceiveData(USART2);
    
24.         Flag=1;
    * a% E0 X# P3 G! m9 Q/ }5 U, m
25.         USART_ClearITPendingBit(USART2,USART_IT_RXNE);  //清除RXNE标志位
    8 O, W: [" G) ~7 ~
26.     }
    4 D$ v& }* X: f5 D/ c  @! |" f
27. }

复制代码

: a8 e9 P) H5 A1 f. y- m, g

* U, B8 ?( U1 m* s

下图为程序现象：可以看到，串口确实收到了数据，只是我把接收到的数据0xFE放在了while循环里，这说明数据接收是成功的，使用中断是可行的。

$ S$ A/ `. R( h5 N3 g& a

5 X  L  K9 a, ?% m

  c& C9 C% t6 b" l) n

' {& b3 Y7 B- V3 Z1 s. B

总结

到这里，就大致总结了串口的发送和接收。

串口的配置，使用查询或者中断来接收数据。

- A* z3 c" E' \8 |! T) A2 W

串口的使用会很常用到，所以在这里对串口做一个总结，也算是对之前知识的一个回顾和总结，加强印象。

/ n' H0 T: r0 ?) t) ^

如果有什么写的不对的地方，欢迎指正！

+ v% z9 D0 f! w$ z, h, C

转载自： 古月居

如有侵权请联系删除

6 k5 S2 T* Q2 I) E

. g- ]- r0 U7 _* H