14.1 USART定义

: P4 I* p% {2 e; g1 Z$ x0 j& LUSART（Universal Synchronous/Asynchronous Receiver/Transmitter，即通用同步/异步收发器）串行通信是单片机最常用的一种通信技术，通常用于单片机和电脑之间以及单片机和单片机之间的通信。


14.2 USART串行通信协议
! X: x1 s5 w' m/ Y8 p
14.2.1 波特率和数据格式

USART通信中的同步通信功能很少用到，大多情况下只采用异步通信，只能实现异步通信功能的接口就称之为 UART。UART 通信通常以字节为单位组成数据帧，由通信收发双方根据预先约定的波特率（传输速率）进行通信。
3 {" y5 [5 X- P( y9 h, @
波特率表示每秒发送二进制数据位的速率，单位是 bps，即 位/秒，波特率越高，传输速度越快，常用的 UART 通信波特率有2400，4800，9600，115200 等等。在进行串行通信之前，通信双方需要设置波特率保持一致，否则不能正常通信。
/ }% b, h) Q1 [# ^3 ~
2 F4 e# I" W( F" o( |单片机标准串口进行通信时，没有数据传输时通信线路保持高电平状态。当要发送数据时，先发送一位0，用以表示开始发送，叫做起始位。然后再按照低位在前，高位在后的顺序发送8位数据。当8位数据发送完毕时，再发送一位1表示停止位。

( K+ d' U/ ?, W% u# p对于接收端而言，开始时传输线路一直保持高电平，一旦检测到低电平，便准备开始接收数据。当接收完8位数据时，便检测停止位，检测完毕后，表示一帧数据发送完毕，开始准备接受下一帧数据。为了确保数据准确性，通常会在数据位之后设置校验位。
, W! g1 U& j3 w
串行通信的数据帧的格式由起始位、数据位、奇偶校验位（可选）和停止位等部分组成，如图：
# q" S8 k- b' \1 \



8 c" v, C% H5 D( L& S14.2.2 TTL通信接口和RS232通信接口
! x. {6 V6 g( q+ T' n! t/ n
电脑和单片机之间进行串口通信，通常使用USB转UART芯片，将USB通信协议转成UART协议和单片机通信。
/ ^7 r+ [+ `  [/ k4 u" p


14.3 USART配置步骤
; ~# O" l: J; n! ]
/ ~1 X% ~/ t& v4 ^; [1.时钟使能
2.设置中断分组
3.串口复位
7 v3 a# ^$ W0 z% V6 u) u. V$ v4.GPIO初始化（TX，RX引脚）
& u& {+ w- {" ^' a9 Y5.设置中断分组
6.串口初始化
7.开启中断
8.使能串口
% V* E( w  h) i$ O
, h1 C* g  }8 n* e
) H1 o( ~. O  m6 [# W5 A+ C2 y' \  w1. 新建两个文件，usart.c 和 usart.h

3 Z6 n' R9 |/ s


* \" V7 @. f9 {. _) E* Q  m2. 在头文件 usart.h 添加下面代码：

1. #ifndef _USART_H
   1 a4 [- x) v1 ~
2. #define _USART_H
   
3. #include "stdio.h"
   
4. #include "stm32f10x.h"
   
5. 
   
6. #define USART_REC_LEN        200      //定义最大接收字节数 200
   
7. #define EN_USART1_RX         1        //使能（1）/禁止（0）串口1接收
   
8. 
   
9. extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
   
10. extern u16 USART_RX_STA;                //接收状态标记
    
11. 
    
12. void usart_init(u32 bound);
    
13. 
    7 Q% T/ ^$ c; _. ^
14. #endif

复制代码

; N; f, b$ t5 I; o% V( o& _3 X3 n& k
& t3 w* N7 E( t) X7 L
  d$ s; C8 B5 G- {- v( Q; g
8 w9 a$ o- [' W3. 把 usart.c 添加到工程中

. w1 ^- `4 l, c) r# x6 M& U% z$ C

4. 在 usart.c 中添加以下代码：
, {& W* a2 `  K. K! W. x* H

1. #include "usart.h"
   $ T, t& z  G: e
2. 
   
3. #pragma import(__use_no_semihosting)
   & G4 |, Q6 t, B, ^
4. //标准库需要的支持函数
   
5. struct __FILE
   
6. {
   
7.     int handle;
   
8. };
   
9. 
   , O7 P( z' O4 I' H
10. FILE __stdout;
    
11. 
    6 [/ M& z- n6 M) w
12. //定义_sys_exit()以避免使用半主机模式
    . [. n9 p) |! D' s7 k4 i& _
13. void _sys_exit(int x)
    ; b7 V1 L& w' q
14. {
    $ H8 ?2 b! H. @; v9 q0 b  D6 n4 T" `
15.     x = x;
    $ s1 `. D8 U. s2 u, A
16. }
    0 Z9 V% U2 u0 D# r
17. 
    
18. //重定义fputc函数
    
19. int fputc(int ch, FILE *f)
    / E( F. y5 k' v5 s5 M
20. {
    
21.     while((USART1->SR & 0X40) == 0); //循环发送,直到发送完毕
    ) C+ p9 m$ }! E
22.     USART1->DR = (u8)ch;
    
23.     return ch;
    
24. }
    * }: R$ j5 @$ @; p
25. 
    
26. #if EN_USART1_RX                    //如果使能了接收
    
27. //串口1中断服务程序
    9 ~1 h$ z9 d6 L. _6 d
28. //注意,读取USARTx->SR能避免莫名其妙的错误
    2 X5 L' U& L% \* y4 }2 r
29. u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
    / j( E+ i. x! [
30. //接收状态
    
31. //bit15，    接收完成标志
    
32. //bit14，    接收到0x0d
    / k# ?5 \7 K1 x2 r# M& D
33. //bit13~0，    接收到的有效字节数目
    2 w+ ^( D- k* A) J0 e
34. u16 USART_RX_STA = 0;                //接收状态标记
    6 l9 h: t( N- K
35. 
    - @* }4 v7 N% W. Z# k1 L
36. void usart_init(u32 bound){
    
37. 
      I/ d. |/ `( R6 {# g4 \( c
38.     //GPIO端口设置
    
39.     GPIO_InitTypeDef GPIO_InitStructure;
    - Z' x3 E: A* f2 \& ?
40.     USART_InitTypeDef USART_InitStructure;
    
41.     NVIC_InitTypeDef NVIC_InitStructure;
    
42. 
    + a  l! j* |" W. e8 C. _: d
43.     //使能USART1，GPIOA时钟
      I( n, F4 i8 P6 {* h
44.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA,ENABLE);
    
45.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);   //配置中断优先级分组
    
46. 
    2 y& I8 I: I8 P0 D0 h
47.     //USART1_TX   GPIOA.9
    
48.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;         //PA.9
    * `. O; D" y& E) q% v# X# i
49.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    + A* m9 E. L) o. u6 r
50.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;   //复用推挽输出
    
51.     GPIO_Init(GPIOA,&GPIO_InitStructure);             //初始化GPIOA.9
    
52. 
    
53.     //USART1_RX      GPIOA.10初始化
    ' W  J- h6 Q$ a
54.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;               //PA.10
    
55.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;    //浮空输入
    + I0 C: R2 O' v; Z! w( V
56.     GPIO_Init(GPIOA,&GPIO_InitStructure);                    //初始化GPIOA.10
    
57. 
    7 h6 `/ Z  I) L, y* \
58.     //Usart1 NVIC 配置
    8 m8 h% q3 }0 q
59.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    - [2 a: u( p; e* y) o* v9 ^! K* v% C
60.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3 ;  //抢占优先级3
    . Q7 k2 i- y1 M8 [, f
61.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;          //子优先级3
    % ]- p- s- y* q6 e1 @+ k2 r  C, u
62.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;             //IRQ通道使能
    * ?4 l( I( I2 }6 D* c6 K7 |  p
63.     NVIC_Init(&NVIC_InitStructure);            //根据指定的参数初始化NVIC寄存器
    
64. 
    
65.     //USART 初始化设置
    
66.     USART_InitStructure.USART_BaudRate = bound;                    //串口波特率
    
67.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;    //字长为8位数据格式
    ' `& D. J& p+ t$ j' B% z
68.     USART_InitStructure.USART_StopBits = USART_StopBits_1;         //一个停止位
    
69.     USART_InitStructure.USART_Parity = USART_Parity_No;            //无奇偶校验位
      |7 |+ C- j% W8 ^" c3 u! m
70.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    2 {1 M% i8 V. o
71.     USART_InitStructure.USART_Mode = USART_Mode_Rx|USART_Mode_Tx;  //收发模式
    8 ?1 g! W1 F6 s
72.     USART_Init(USART1,&USART_InitStructure);        //初始化串口1
    6 K8 e& p" ^8 R+ q* b
73. 
    & e" P0 \+ `. ^7 p6 {+ y
74.     USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);    //开启串口接受中断
    
75.     USART_Cmd(USART1,ENABLE);                       //使能串口1
    
76. }
    / \  h% F5 z9 `% s" n. G) M% M
77. 
    
78. void USART1_IRQHandler(void)         //串口1中断服务程序
    
79. {
    
80.     u8 Res;
    
81. 
    & [7 z" M& _5 M  t/ l0 P3 |
82.     //接收中断(接收到的数据必须是0x0d 0x0a结尾)
    
83.     if(USART_GetITStatus(USART1,USART_IT_RXNE) != RESET)
    
84.     {
    
85.         Res = USART_ReceiveData(USART1);            //读取接收到的数据
    $ ~8 C; F: A4 r0 H6 _/ B# N
86. 
    
87.         if((USART_RX_STA & 0x8000) == 0)            //接收未完成
    & k; N/ ^. }7 N3 k7 H0 K
88.         {
    
89.             if(USART_RX_STA & 0x4000)               //接收到了0x0d
    
90.             {
    + M. C7 ^8 Y, O1 F0 m6 t
91.                 if(Res != 0x0a) USART_RX_STA = 0;   //接收错误,重新开始
    ( y+ q9 j; O2 v: W4 Y; o5 l
92.                 else USART_RX_STA |= 0x8000;        //接收完成了
    ' B8 ?. H, n: f9 D- i6 G$ U
93.             }
    
94.             else //还没收到0X0D
    
95.             {
    
96.                 if(Res == 0x0d) USART_RX_STA |= 0x4000;
    
97.                 else
    
98.                 {
    : n, z& v! h- ]# q8 c$ S- F
99.                     USART_RX_BUF[USART_RX_STA & 0X3FFF] = Res;
    0 H, H' Z* R* b& \. \) T
100.                     USART_RX_STA++;
     
101.                     if(USART_RX_STA > (USART_REC_LEN - 1))USART_RX_STA = 0; //接收数据错误,重新开始接收
     " ]! v5 Y  |; H
102.                 }
     , i: }, F5 v- H  P
103.             }
     
104.         }
     
105.         /*---- User Code Begin ----*/
     0 z2 g8 E% d* ?9 P" `& C( ^. g3 }
106. 
     
107.         /*---- User Code End ----*/
     
108.     }
     
109. }
     6 k4 |! r1 t, Y3 _5 L
110. #endif

复制代码

  I( i4 U  t1 z. C+ Y5 T5 l/ O





5 M0 g/ B7 [  ]3 A* a, z2 |& W
7 r5 C$ g# @! ?5. 实现USART串口通信（以printf函数为例）
4 J. B4 q9 B( n1 J, i6 I' B+ h) K, f

1. #include "stm32f10x.h"
   ) f/ a  @: z" U2 |
2. #include "delay.h"
   
3. #include "led.h"
   
4. #include "tim.h"
   
5. #include "key.h"
   
6. #include "pwm.h"
   
7. #include "usart.h"
   
8. 
   
9. int main(void)
   
10. {
    
11.     delay_init();
    ) T2 m, Y, t8 A( G2 _! o0 F7 O0 O
12.     usart_init(115200);
      w* U/ \# E% I2 H1 F1 ^4 N
13. 
    ' f. a2 m- `1 m
14.     printf("USART Init Complete.\r\n");
    
15.     while(1)
    
16.     {
    9 }" n  R8 W# }2 Y+ Q
17.         printf("Hello World !\r\n");
    % C$ Y4 z( e) K% a  j% T; w5 @0 [, M/ [
18.         delay_ms(500);
    
19.     }
    
20. }

复制代码

2 }( K2 l8 \3 f) y) e
9 N( U  t( H( k! F' |- ~& B+ O& ?
测试结果：
; v7 m+ d7 J) [- h

) \- w& l0 q  u7 C: C

  J- t: |1 `) d, k+ i* W