14.1 USART定义

( n8 |. t8 k0 l" bUSART（Universal Synchronous/Asynchronous Receiver/Transmitter，即通用同步/异步收发器）串行通信是单片机最常用的一种通信技术，通常用于单片机和电脑之间以及单片机和单片机之间的通信。


14.2 USART串行通信协议

14.2.1 波特率和数据格式

USART通信中的同步通信功能很少用到，大多情况下只采用异步通信，只能实现异步通信功能的接口就称之为 UART。UART 通信通常以字节为单位组成数据帧，由通信收发双方根据预先约定的波特率（传输速率）进行通信。

波特率表示每秒发送二进制数据位的速率，单位是 bps，即 位/秒，波特率越高，传输速度越快，常用的 UART 通信波特率有2400，4800，9600，115200 等等。在进行串行通信之前，通信双方需要设置波特率保持一致，否则不能正常通信。
9 Z2 e3 u: g5 n& G( ]
; s. O' F' u7 R4 P! q* {' g7 R单片机标准串口进行通信时，没有数据传输时通信线路保持高电平状态。当要发送数据时，先发送一位0，用以表示开始发送，叫做起始位。然后再按照低位在前，高位在后的顺序发送8位数据。当8位数据发送完毕时，再发送一位1表示停止位。

对于接收端而言，开始时传输线路一直保持高电平，一旦检测到低电平，便准备开始接收数据。当接收完8位数据时，便检测停止位，检测完毕后，表示一帧数据发送完毕，开始准备接受下一帧数据。为了确保数据准确性，通常会在数据位之后设置校验位。
' f6 Y  |. c1 x' m( u' v* x7 U
& s' B; Y! \4 |* }* m; V" x串行通信的数据帧的格式由起始位、数据位、奇偶校验位（可选）和停止位等部分组成，如图：
. V. J$ G8 ^! n# `* `
! E  Z0 d) U, C1 T: I" n: s0 a
( m1 F. q& j9 v$ I! _+ _

% {: [3 g- J; F' R; v14.2.2 TTL通信接口和RS232通信接口

4 \- M  U# C& ]7 R! z; u电脑和单片机之间进行串口通信，通常使用USB转UART芯片，将USB通信协议转成UART协议和单片机通信。



. z1 `3 n* d* t3 x% y+ h: A6 u/ s& `14.3 USART配置步骤

$ K+ K4 v& [, Z8 M# g1.时钟使能
2.设置中断分组
3 [3 O9 l; S8 V9 j9 t9 g* x  N) R3.串口复位
4.GPIO初始化（TX，RX引脚）
5.设置中断分组
, N; |1 b6 P7 m& u0 n' ]8 p6 s6.串口初始化
7.开启中断
8.使能串口
( y8 h: f. e# d$ f

1. 新建两个文件，usart.c 和 usart.h
; x1 g8 J5 L+ C% b
+ _9 [0 [0 [4 s$ ~! {* \
& D9 G3 y# [5 s% X+ S* Q( h- o8 A
$ Y* a( i. {2 T& f  }
2. 在头文件 usart.h 添加下面代码：

1. #ifndef _USART_H
   2 O- i5 X3 Z" D1 [! V4 R( e/ E
2. #define _USART_H
   $ |- H* `' A- i; @; h
3. #include "stdio.h"
   
4. #include "stm32f10x.h"
   - b, W& Z# ^5 u0 I
5. 
   " _7 c' x1 Q" U) g( ~- G
6. #define USART_REC_LEN        200      //定义最大接收字节数 200
   * H  d3 g& K+ q4 @1 Q* ~
7. #define EN_USART1_RX         1        //使能（1）/禁止（0）串口1接收
   + n" b0 z8 p- ^5 B# E2 j( K9 h3 [: G/ N
8. 
   , @* H. {7 f1 ~8 P! p# q' U- b4 K
9. extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
   / R$ I  S6 ?2 B0 L
10. extern u16 USART_RX_STA;                //接收状态标记
    
11. 
    
12. void usart_init(u32 bound);
    
13. 
    ( v' [, I+ L+ L% v! Z
14. #endif

复制代码

7 X" O, |' y) K; u* w. \! W

+ L6 A+ Z9 Q$ A) @. M% r3. 把 usart.c 添加到工程中
1 D4 Q8 d! x4 s! Q. n: G


4. 在 usart.c 中添加以下代码：
" v+ m! V* S$ G# c) v. J5 g

1. #include "usart.h"
   
2. 
   
3. #pragma import(__use_no_semihosting)
   
4. //标准库需要的支持函数
   & C; [( X: z( j% |2 {+ F0 N
5. struct __FILE
   ! ?/ {. O5 S/ L
6. {
   / |; s, t( K$ C0 |0 D
7.     int handle;
   
8. };
   
9. 
   
10. FILE __stdout;
    # w/ ]/ R5 }; m
11. 
    
12. //定义_sys_exit()以避免使用半主机模式
    
13. void _sys_exit(int x)
    5 H( ~8 k" O/ ?+ g) Y% N
14. {
    
15.     x = x;
    " j- Y& n+ q9 N+ U6 i
16. }
    
17. 
    
18. //重定义fputc函数
    
19. int fputc(int ch, FILE *f)
    7 a# F- d8 g( R0 [& D, s2 W
20. {
    
21.     while((USART1->SR & 0X40) == 0); //循环发送,直到发送完毕
    
22.     USART1->DR = (u8)ch;
    $ B2 e! E+ s" Y: ^# A9 {
23.     return ch;
    7 b1 e! S; `- T  |/ i5 `2 c: U$ S' `
24. }
    1 s4 }7 v( x$ O3 [" j. S
25. 
    
26. #if EN_USART1_RX                    //如果使能了接收
    
27. //串口1中断服务程序
    
28. //注意,读取USARTx->SR能避免莫名其妙的错误
    + i5 N) ?7 I( ^: W1 l3 N% y
29. u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
    
30. //接收状态
    % |: H! H* @% C) b
31. //bit15，    接收完成标志
    * F! e* D9 J! j1 j5 R# [$ g
32. //bit14，    接收到0x0d
    # W; f# m5 i$ d* d$ j6 v1 R
33. //bit13~0，    接收到的有效字节数目
    
34. u16 USART_RX_STA = 0;                //接收状态标记
    
35. 
    
36. void usart_init(u32 bound){
    6 K0 u7 G: I) [8 `. R$ b
37. 
    1 x: v) w+ \& J2 M7 |
38.     //GPIO端口设置
    / v7 y- ?+ Z) l( _# Y
39.     GPIO_InitTypeDef GPIO_InitStructure;
    
40.     USART_InitTypeDef USART_InitStructure;
    
41.     NVIC_InitTypeDef NVIC_InitStructure;
    ) n/ F% w. a, a* ^# i% l
42. 
    
43.     //使能USART1，GPIOA时钟
    " e. a) d1 l! f* v% }
44.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA,ENABLE);
    
45.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);   //配置中断优先级分组
    * `3 w/ I8 d3 g( p8 U
46. 
    
47.     //USART1_TX   GPIOA.9
    
48.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;         //PA.9
    . V* O, @# l% D
49.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
50.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;   //复用推挽输出
      I! T6 x# S: W9 M) R: Z
51.     GPIO_Init(GPIOA,&GPIO_InitStructure);             //初始化GPIOA.9
    
52. 
      I; \2 E7 B$ U7 B1 U. ], c6 H5 _. K' x
53.     //USART1_RX      GPIOA.10初始化
      p7 Y8 T9 {* ~, L( P
54.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;               //PA.10
    9 Q; C% A- Z8 j& L9 ?9 D2 Y
55.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;    //浮空输入
    
56.     GPIO_Init(GPIOA,&GPIO_InitStructure);                    //初始化GPIOA.10
    4 B. Z/ r- n9 u, @
57. 
    7 z4 g5 J  s0 v  G( t
58.     //Usart1 NVIC 配置
    ! f6 h" L) p" \- Q8 I  W6 m. n
59.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    $ q% z+ k* b5 K1 }6 z4 M# r; Y4 _
60.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3 ;  //抢占优先级3
    " f  d- n- v1 H! ^# M  q
61.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;          //子优先级3
    ; M3 e8 x" z2 k" k) o# F
62.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;             //IRQ通道使能
    
63.     NVIC_Init(&NVIC_InitStructure);            //根据指定的参数初始化NVIC寄存器
    ; Y# k' A# n- B  v/ N  z
64. 
    , B1 R' e3 E1 s& o8 T# l/ b- J( I
65.     //USART 初始化设置
    
66.     USART_InitStructure.USART_BaudRate = bound;                    //串口波特率
      Z$ M) Z2 J. x) e, a* u3 M0 o6 ~
67.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;    //字长为8位数据格式
    + M* W3 E6 D: Q9 c$ y5 ?
68.     USART_InitStructure.USART_StopBits = USART_StopBits_1;         //一个停止位
    
69.     USART_InitStructure.USART_Parity = USART_Parity_No;            //无奇偶校验位
    
70.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    
71.     USART_InitStructure.USART_Mode = USART_Mode_Rx|USART_Mode_Tx;  //收发模式
    
72.     USART_Init(USART1,&USART_InitStructure);        //初始化串口1
    - W5 {% w$ f% j& X5 [$ b
73. 
    
74.     USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);    //开启串口接受中断
    
75.     USART_Cmd(USART1,ENABLE);                       //使能串口1
    ) m, C6 L, h" S" E1 a
76. }
    2 q7 Y! M1 a; V6 a
77. 
    & C& f$ I0 ^( D' B. f+ f( c5 r9 ]" K# z
78. void USART1_IRQHandler(void)         //串口1中断服务程序
    
79. {
    & R) |$ @2 o; |: ~: b1 I1 c" o
80.     u8 Res;
    8 {$ |! v, X+ |# \3 T
81. 
    - ~: ]+ g6 J+ V) e: R) J
82.     //接收中断(接收到的数据必须是0x0d 0x0a结尾)
    
83.     if(USART_GetITStatus(USART1,USART_IT_RXNE) != RESET)
    
84.     {
    
85.         Res = USART_ReceiveData(USART1);            //读取接收到的数据
    
86. 
    
87.         if((USART_RX_STA & 0x8000) == 0)            //接收未完成
    5 j2 J" H1 B0 U, c- [% }9 X" I1 g
88.         {
    
89.             if(USART_RX_STA & 0x4000)               //接收到了0x0d
    & s6 x$ Z4 R" ^' v; ]! A
90.             {
      ]9 d' {% J- Z1 |6 `
91.                 if(Res != 0x0a) USART_RX_STA = 0;   //接收错误,重新开始
    $ S/ j+ g; D. ~2 V. _
92.                 else USART_RX_STA |= 0x8000;        //接收完成了
    " B9 L, l$ E; ]7 C' g6 r' ~% P$ C
93.             }
    ' k1 G: G, s( C/ u5 B+ e
94.             else //还没收到0X0D
    
95.             {
    6 N- m8 z0 m/ S  f& S
96.                 if(Res == 0x0d) USART_RX_STA |= 0x4000;
    
97.                 else
    
98.                 {
    
99.                     USART_RX_BUF[USART_RX_STA & 0X3FFF] = Res;
    
100.                     USART_RX_STA++;
     
101.                     if(USART_RX_STA > (USART_REC_LEN - 1))USART_RX_STA = 0; //接收数据错误,重新开始接收
     
102.                 }
     
103.             }
     3 S& t0 p2 i' G! x9 R6 z: U
104.         }
     
105.         /*---- User Code Begin ----*/
     
106. 
       O; O' P9 r' J" Q. V
107.         /*---- User Code End ----*/
     
108.     }
     9 {/ s& i4 ]. |, {
109. }
     
110. #endif

复制代码

5 a& h, V2 b! G# w3 n0 Z0 D
! ]8 Z( ~1 w% Q# W

2 i9 E; V/ U* l; a' l




( O- K4 ?9 x: R2 x
/ f/ ~: d$ z% F
- Q/ L* C8 y1 f5. 实现USART串口通信（以printf函数为例）
) [9 p. l: Z* ]" x# p' x: L: ^# G
6 j1 ?2 j5 @9 o9 A

1. #include "stm32f10x.h"
   
2. #include "delay.h"
   / _' f; C" y& D) C8 \% `: Z
3. #include "led.h"
   
4. #include "tim.h"
   
5. #include "key.h"
   
6. #include "pwm.h"
   
7. #include "usart.h"
   2 @& q3 K8 r9 v' v/ q
8. 
   0 S: C, ^4 \( `$ U# n* j
9. int main(void)
   
10. {
    ' I5 e# ^# R+ o, H/ y4 A5 c5 [% ^
11.     delay_init();
    $ ]5 J# S5 ?2 K3 W; b3 ^1 a
12.     usart_init(115200);
    
13. 
    
14.     printf("USART Init Complete.\r\n");
    ) v* r# {* u! T
15.     while(1)
    
16.     {
    
17.         printf("Hello World !\r\n");
    , b/ p1 {. k' I& k
18.         delay_ms(500);
    
19.     }
    
20. }

复制代码

( n5 H2 b. p% |3 g: L1 w+ d
测试结果：
/ F/ P6 V( `$ v- R



0 q1 p2 R# {" ~! t% D/ C! c2 D