14.1 USART定义

8 @( p* e" O$ Q8 \" ]3 s! D( VUSART（Universal Synchronous/Asynchronous Receiver/Transmitter，即通用同步/异步收发器）串行通信是单片机最常用的一种通信技术，通常用于单片机和电脑之间以及单片机和单片机之间的通信。


8 N8 x' m$ K$ x2 c14.2 USART串行通信协议
2 h: Y  K6 x* ]3 N
# f" H+ C) X4 C. `( Z$ Q2 G$ A, g14.2.1 波特率和数据格式
6 U+ Z2 @, _- {- Z5 A
USART通信中的同步通信功能很少用到，大多情况下只采用异步通信，只能实现异步通信功能的接口就称之为 UART。UART 通信通常以字节为单位组成数据帧，由通信收发双方根据预先约定的波特率（传输速率）进行通信。
; k5 q% S2 ?0 g" V, A
+ {& |6 _, R% Q4 M波特率表示每秒发送二进制数据位的速率，单位是 bps，即 位/秒，波特率越高，传输速度越快，常用的 UART 通信波特率有2400，4800，9600，115200 等等。在进行串行通信之前，通信双方需要设置波特率保持一致，否则不能正常通信。
( R1 A  P% r' g9 b& U
1 }6 n" x8 J6 b. t1 [单片机标准串口进行通信时，没有数据传输时通信线路保持高电平状态。当要发送数据时，先发送一位0，用以表示开始发送，叫做起始位。然后再按照低位在前，高位在后的顺序发送8位数据。当8位数据发送完毕时，再发送一位1表示停止位。

6 J& r4 I2 K; _, U- g5 W' ]4 x6 X, j: X对于接收端而言，开始时传输线路一直保持高电平，一旦检测到低电平，便准备开始接收数据。当接收完8位数据时，便检测停止位，检测完毕后，表示一帧数据发送完毕，开始准备接受下一帧数据。为了确保数据准确性，通常会在数据位之后设置校验位。
4 k/ A* S5 t2 s
: N( @% ?5 \* T$ a% c, m( m串行通信的数据帧的格式由起始位、数据位、奇偶校验位（可选）和停止位等部分组成，如图：


8 {& Y; k) [  d3 B' A: q
' `( \* j+ h, n9 _3 e+ O
) s; W, Q$ y. n14.2.2 TTL通信接口和RS232通信接口
; ]/ f" }0 K$ B8 a% D
3 z. f6 _' T- p电脑和单片机之间进行串口通信，通常使用USB转UART芯片，将USB通信协议转成UART协议和单片机通信。
# }4 q9 H; m" [$ F* d+ h3 ?1 P
' ~0 V- D2 ^4 O$ C$ [0 n1 Q, K$ [
3 c6 m7 P0 q' B6 p- w; J
# `/ x+ N/ [0 `1 M14.3 USART配置步骤

1.时钟使能
" h$ m) W8 G: N3 Z! p2.设置中断分组
; l, V0 F7 r) n2 V. O3.串口复位
4.GPIO初始化（TX，RX引脚）
! m( v. n' _  F) `" t5.设置中断分组
6.串口初始化
7.开启中断
; g8 ~$ W9 M: A' }8.使能串口

2 C8 {# S! w, [7 L' m
6 O. M8 m0 `6 h1 T1. 新建两个文件，usart.c 和 usart.h
2 V0 z' ?' d/ u" e3 W1 R' q0 G- d$ G
4 r' L3 \* l! J, L7 A

  s1 a3 U4 Z  X- ?5 A& V: o$ z) M
3 m0 O$ m) F! R0 L2. 在头文件 usart.h 添加下面代码：

1. #ifndef _USART_H
   
2. #define _USART_H
   : a+ u9 Y4 O$ @+ l! b
3. #include "stdio.h"
   
4. #include "stm32f10x.h"
   / ?/ z( s& i; @( }+ Y7 ]5 W
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个字节.末字节为换行符
   2 a$ t) W  i6 A( r6 O& Q* z# n
10. extern u16 USART_RX_STA;                //接收状态标记
    1 a" M2 `% ?! [: J, ^* V
11. 
    / ?' e8 @! [9 r1 G# i" \
12. void usart_init(u32 bound);
    
13. 
    % {8 Q- ~8 Z* W) D- @5 s
14. #endif

复制代码

3 U) I. e8 w, Z% x3 j. ~8 M
9 k1 w/ ~. U! O
3. 把 usart.c 添加到工程中



4. 在 usart.c 中添加以下代码：
+ h# f, ^' N2 K* m/ V7 V

1. #include "usart.h"
   
2. 
   
3. #pragma import(__use_no_semihosting)
   0 L) ~2 U: J/ g& L) d8 l
4. //标准库需要的支持函数
   
5. struct __FILE
   : ?" N! l- \" \7 d/ t
6. {
   
7.     int handle;
   
8. };
     B3 a, i+ L2 [6 f/ c) s
9. 
   
10. FILE __stdout;
    ! e9 B9 L' A; g" n7 V
11. 
    1 d. x' A. Y" p9 u5 T$ T/ V" u3 u% l
12. //定义_sys_exit()以避免使用半主机模式
    
13. void _sys_exit(int x)
    ' m! e) l- h) J" x1 i
14. {
    
15.     x = x;
    
16. }
    
17. 
    ' h2 B. k; g2 U. C
18. //重定义fputc函数
      c1 Y$ z8 Q- j& O
19. int fputc(int ch, FILE *f)
    
20. {
    + i( ~- r" [" r7 t6 A
21.     while((USART1->SR & 0X40) == 0); //循环发送,直到发送完毕
      g! h% k. ]2 f. @
22.     USART1->DR = (u8)ch;
    2 [3 {4 ?/ q2 B' k/ `
23.     return ch;
    * G( h- e- i* K& l( r) h* e6 }
24. }
    " Y/ ?: R4 u! u5 V; ~
25. 
    
26. #if EN_USART1_RX                    //如果使能了接收
    / P; _, j) q( G; ^7 o
27. //串口1中断服务程序
    
28. //注意,读取USARTx->SR能避免莫名其妙的错误
    
29. u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
    
30. //接收状态
    
31. //bit15，    接收完成标志
    
32. //bit14，    接收到0x0d
    
33. //bit13~0，    接收到的有效字节数目
    
34. u16 USART_RX_STA = 0;                //接收状态标记
    1 G: [- `# I  }$ I8 t
35. 
    % H! P7 z" d6 z: j1 `
36. void usart_init(u32 bound){
    ! }4 ~1 x1 a' F7 {5 q
37. 
    7 _, ?: l  R0 Q
38.     //GPIO端口设置
    
39.     GPIO_InitTypeDef GPIO_InitStructure;
    6 d9 F9 K0 z( K
40.     USART_InitTypeDef USART_InitStructure;
    $ H1 j% O* w9 m: ~6 |
41.     NVIC_InitTypeDef NVIC_InitStructure;
    
42. 
    
43.     //使能USART1，GPIOA时钟
    0 D) ~1 p& `( n& j) K$ Y9 n8 \
44.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA,ENABLE);
    
45.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);   //配置中断优先级分组
    
46. 
    ( n9 h* M: `8 v
47.     //USART1_TX   GPIOA.9
    / B9 q2 ^( T& N' _: t6 U% |
48.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;         //PA.9
    2 Z* P" f  X3 C9 z) a: O. ]6 c+ B5 S0 ~
49.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
50.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;   //复用推挽输出
    
51.     GPIO_Init(GPIOA,&GPIO_InitStructure);             //初始化GPIOA.9
    , L- B: |( A7 v8 Y+ b$ l
52. 
    
53.     //USART1_RX      GPIOA.10初始化
    
54.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;               //PA.10
    
55.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;    //浮空输入
    
56.     GPIO_Init(GPIOA,&GPIO_InitStructure);                    //初始化GPIOA.10
    7 S/ Y. Q5 y( }9 B0 l: X
57. 
    
58.     //Usart1 NVIC 配置
    
59.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    " _$ c0 l* a1 O$ `
60.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3 ;  //抢占优先级3
    & f# @$ X; L  L
61.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;          //子优先级3
    
62.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;             //IRQ通道使能
    . n+ c% Z$ C/ Y2 W1 ~% j7 W; w
63.     NVIC_Init(&NVIC_InitStructure);            //根据指定的参数初始化NVIC寄存器
    
64. 
    
65.     //USART 初始化设置
    0 R- B- n4 ?+ w8 x& u0 j$ v
66.     USART_InitStructure.USART_BaudRate = bound;                    //串口波特率
    
67.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;    //字长为8位数据格式
    / U! f- N, d' F& N
68.     USART_InitStructure.USART_StopBits = USART_StopBits_1;         //一个停止位
    4 K- X4 C# N( e, |7 u7 O
69.     USART_InitStructure.USART_Parity = USART_Parity_No;            //无奇偶校验位
    
70.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    * T, P! E, B. i. x9 N5 S& s
71.     USART_InitStructure.USART_Mode = USART_Mode_Rx|USART_Mode_Tx;  //收发模式
    
72.     USART_Init(USART1,&USART_InitStructure);        //初始化串口1
    % i3 P* P0 u5 I( _* \6 B# y
73. 
    
74.     USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);    //开启串口接受中断
    
75.     USART_Cmd(USART1,ENABLE);                       //使能串口1
    ' d- @' a8 c8 Z0 |2 g  J
76. }
    # J  {3 N4 k7 o) X8 O
77. 
    " t) }" A) R5 O: s  G$ h8 u% z
78. void USART1_IRQHandler(void)         //串口1中断服务程序
    ) U# Y' h: F0 \
79. {
    5 o# V2 P" C3 {8 Y# V
80.     u8 Res;
    
81. 
    ) b. i! ]% Y4 w& e" [; {
82.     //接收中断(接收到的数据必须是0x0d 0x0a结尾)
    
83.     if(USART_GetITStatus(USART1,USART_IT_RXNE) != RESET)
    6 \- r0 w) t% n+ g/ d
84.     {
    - P, ]8 x8 a/ k4 B1 i0 p
85.         Res = USART_ReceiveData(USART1);            //读取接收到的数据
    6 C* f% k; A6 o8 d8 @
86. 
    
87.         if((USART_RX_STA & 0x8000) == 0)            //接收未完成
    
88.         {
    
89.             if(USART_RX_STA & 0x4000)               //接收到了0x0d
    
90.             {
    
91.                 if(Res != 0x0a) USART_RX_STA = 0;   //接收错误,重新开始
    
92.                 else USART_RX_STA |= 0x8000;        //接收完成了
    8 v+ W0 r/ W+ B& p0 m3 S
93.             }
      g2 r5 n! j# `; \# q& ~
94.             else //还没收到0X0D
    
95.             {
    
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.                 }
     : T7 S, h" l4 ]0 V1 ?9 n
103.             }
     7 |' q, v4 {- F6 E
104.         }
     , U  I- x' b0 ]$ x; a* a' B
105.         /*---- User Code Begin ----*/
     
106. 
     & N- |0 F9 u! ^8 {. a3 x: d; @+ j
107.         /*---- User Code End ----*/
     9 \: D3 m$ A4 c0 ?
108.     }
     
109. }
     
110. #endif

复制代码

9 ]% s! l" d) a  {0 F. B1 r
1 l% z, c+ F9 m1 j; Q


& u5 u0 E! J& r
4 C. C! J; O+ J) ~+ T

6 J& X* W4 L- E: I
/ x$ b9 }: t( ]3 v- x6 C
! C5 N! i9 f9 W0 Z
6 K4 [4 D0 i2 j' o1 F- W5. 实现USART串口通信（以printf函数为例）
2 n) \+ w8 |/ n0 {- r5 A9 V
* B/ n. W1 q5 K1 d

1. #include "stm32f10x.h"
   # U1 _4 I9 ]6 p8 h1 X
2. #include "delay.h"
   
3. #include "led.h"
   
4. #include "tim.h"
   0 v) Q1 Q+ o( W8 |! O
5. #include "key.h"
   & I1 b. y8 l& p
6. #include "pwm.h"
   
7. #include "usart.h"
   
8. 
   
9. int main(void)
   
10. {
    " V9 T4 g$ R( r: U& x
11.     delay_init();
    4 }7 z  L) z) s" V* A/ x
12.     usart_init(115200);
    5 H& G& _  G3 h  u) B, b
13. 
    " L- a$ v% }" r6 M) `- m
14.     printf("USART Init Complete.\r\n");
    
15.     while(1)
    * c' C+ g# B* p8 ~0 C; J
16.     {
    2 J2 r4 N( F9 D9 d, a# x
17.         printf("Hello World !\r\n");
    5 m$ y/ T6 `4 k8 O
18.         delay_ms(500);
    
19.     }
    
20. }

复制代码

9 `4 h5 X; d8 Y- O- O" b

4 K) V# Y0 {; m: g/ O/ _5 l7 e测试结果：
8 J0 Q. L! x( {3 p7 P- L
/ r8 p) Y! i7 Q
. B2 L! \7 N. U$ |