1、 串口的基本概念

       在STM32的参考手册中，串口被描述成通用同步异步收发器(USART)，它提供了一种灵活的方法与使用工业标准NRZ异步串行数据格式的外部设备之间进行全双工数据交换。USART利用分数波特率发生器提供宽范围的波特率选择。它支持同步单向通信和半双工单线通信，也支持LIN（局部互联网），智能卡协议和IrDA（红外数据组织）SIR ENDEC规范，以及调制解调器(CTS/RTS)操作。它还允许多处理器通信。还可以使用DMA方式，实现高速数据通信。

      USART通过3个引脚与其他设备连接在一起，任何USART双向通信至少需要2个引脚：接受数据输入(RX)和发送数据输出(TX)。

• RX: 接受数据串行输入。通过过采样技术来区别数据和噪音，从而恢复数据。
• TX: 发送数据输出。当发送器被禁止时，输出引脚恢复到它的I/O端口配置。当发送器被激活，并且不发送数据时，TX引脚处处于高电平。在单线和智能卡模式里，此I/O口被同时用于数据的发送和接收。
  
  

2、串口的如何工作的

      一般有两种方式：查询和中断。

• 查询：串口程序不断地循环查询，看看当前有没有数据要它传送。如果有，就帮助传送（可以从PC到STM32板子，也可以从STM32板子到PC）。
• 中断：平时串口只要打开中断即可。如果发现有一个中断来，则意味着要它帮助传输数据——它就马上进行数据的传送。同样，可以从 PC到STM3板子，也可以从STM32板子到PC。
  5 q6 n0 x4 t" S
  . |+ w# I5 P: t9 w3 t% _! X( R

3、串口的硬件连接

       我用的奋斗STM32 开发板拥有多路RS-232 接口，CPU 的PA9-US1-TX（P68）、PA10-US1-RX（P69）、PA9-US2-TX（P25）、PA10-US2-RX（P26）通过MAX3232 实现两路RS-232 接口，分别连接在XS5 和XS17 接口上。  USART1 在系统存储区启动模式下，将通过该口通过PC对板上的CPU进行ISP，该口也可作为普通串口功能使用，JP3，JP4 的短路冒拔去，将断开第二路的RS232通信，仅作为TTL 通信通道。

4、编程实例

       我们要对串口进行操作，首先要将STM32的串口和CPU进行连接。在Windows操作系统中，有一个自带的系统软件叫“超级终端”。VISTA以上的操作系统去掉了这个软件，不过可以从XP的系统中，复制“hypertrm.dll”和“hypertrm.exe”到“windows/system32”文件夹下，然后双击运行hypertrm.exe，就可以看见超级终端的运行界面了。

       运行超级终端以后，会弹出“连接描述”，输入名称和选择图标，这个地方随便写个什么名称都可以。然后弹出“连接到”设置，在“连接时使用”选择你自己PC和STM32连接的COMx，如果不知道是哪个COM口的话，可以在PC的设备管理器中找到。在选择好COM口之后，会弹出一个“属性”对话框，在“位/秒”选择和你STM32中设置的波特率一致就好，数据位也是按照STM32的设置来选择，奇偶校验选择无，停止位选择1，数据流控制选择无。注意，以上的选项都必须和STM32中的串口设置相匹配，要不然可能会出现一些未知错误。

配置好超级终端之后，我们便可以开始对STM32进行编程了。编程一般按照如下步骤进行：

（1）       RCC配置；

（2）       GPIO配置；

（3）       USART配置；

（4）       NVIC配置；

（5）       发送/接收数据。

在RCC配置中，我们除了常规的时钟设置以外，要记得打开USART相对应的IO口时钟，USART时钟，还有管脚功能复用时钟。

在GPIO配置中，将发送端的管脚配置为复用推挽输出，将接收端的管脚配置为浮空输入。

        在USART的配置中，通过USART_InitTypeDef结构体对USART进行初始化操作，按照自己所需的功能配置好就可以了。注意，在超级终端的设置中，需要和这个里面的配置相对应。由于我是采用中断接收数据的方式，所以记得在USART的配置中药打开串口的中断，同时最后还要打开串口。

在NVIC的配置中，主要是USART1_IRQChannel的配置，和以前的笔记中讲述的中断配置类似，不会配置的可以参考以前的笔记。

全部配置好之后就可以开始发送/接收数据了。发送数据用USART_SendData()函数，接收数据用USART_ReceiveData()函数。具体的函数功能可以参考固件库的参考文件。根据USART的配置，在发送和接收时，都是采用的8bits一帧来进行的，因此，在发送的时候，先开辟一个缓存区，将需要发送的数据送入缓存区，然后再将缓存区中的数据发送出去，在接收的时候，同样也是先接收到缓存区中，然后再进行相应的操作。

      注意在对数据进行发送和接收的时候，要检查USART的状态，只有等到数据发送或接收完毕之后才能进行下一帧数据的发送或接收。采用USART_GetFlagStatus()函数。

       同时还要注意的是，在发送数据的最开始，需要清除一下USART的标志位，否则，第1位数据会丢失。因为在硬件复位之后，USART的状态位TC是置位的。当包含有数据的一帧发送完成之后，由硬件将该位置位。只要当USART的状态位TC是置位的时候，就可以进行数据的发送。然后TC位的置零则是通过软件序列来清除的，具体的步骤是“先读USART_SR，然后写入USART_DR”，只有这样才能够清除标志位TC，但是在发送第一帧数据的时候，并没有进行读USART_SR的操作，而是直接进行写操作，因此TC标志位并没有清空，那么，当发送第一帧数据，然后用USART_GetFlagStatus()检测状态时返回的是已经发送完毕（因为TC位是置1的），所以程序会马上发送下一帧数据，那么这样，第一帧数据就被第二帧数据给覆盖了，所以看不到第一帧数据的发送。

     按照上面的方法编程后，我们便可以在超级终端上查看串口通信的具体状态了。我的这个例程，在硬件复位以后，可以马上在超级终端上看见“Welcome to my STM32! Please press any key!”字样，然后如果在超级终端中通过PC机键盘按下相应的键，则这个键会发送到STM32中，并且马上返回到PC机的超级终端上，因此可以马上从超级终端的页面中看到按下的相应的键。

5、程序源代码

1. #include "stm32f10x_lib.h"
   ! w. g/ {8 l) B$ i, X$ r
2. 
   
3. FlagStatus RX_status;
   8 K* U4 X, U: W+ u3 ?( N
4. 
   
5. void RCC_cfg();
   
6. 
   , Q3 ]2 o0 D) \. C5 B3 q
7. void GPIO_cfg();
   
8. 
   
9. void USART_cfg();
   
10. 
    
11. void NVIC_cfg();
    7 P% F: S. X7 K- l
12. 
    # W( f4 F. s, E8 _3 Z
13. int main()
    : P3 W& \7 R, W% D$ J) ~* v
14. 
    
15. {
    
16. 
    
17.        int i;
    : F, M* p( ^) Z: J* i+ r' b
18. 
    
19.        unsigned char TxBuf1[] = "Welcome to my STM32! Please press any key!";
    
20. 
    
21.        RCC_cfg();
    $ V2 R% w$ y# F
22. 
    
23.        GPIO_cfg();
    3 u3 v/ W) L" ?: A+ ?- b3 o" j0 |
24. 
    $ t9 G+ F* {* o2 e$ K
25.        NVIC_cfg();
    3 ]8 H" ^  o  |
26. 
    
27.        USART_cfg();
    + N9 Q2 _, L5 }: r( m( p& ?6 |3 }
28. 
    
29.        //清除标志位，否则第1位数据会丢失
    , }: u0 ]% n/ f6 j% x1 ]
30. 
    
31.        USART_ClearFlag(USART1,USART_FLAG_TC);
    " Q3 t' {- y# L3 K
32. 
    
33.        //发送数据
    % ~# o" `, d3 V" {
34. 
    
35.        //PB5的作用是显示正在发送数据
    : M! x6 T0 s8 [* i
36. 
    
37.        //当有数据在发送的时候，PB5会亮
    
38. 
    
39.        for( i=0;TxBuf1!='\0';i++)
    
40. 
    
41.        {
    2 V3 V+ y& U8 [' ~+ H0 O6 o
42. 
    
43.               USART_SendData(USART1,TxBuf1);
    
44. 
    2 p' ~  G  k( ]3 e; G/ m4 o
45.               GPIO_SetBits(GPIOB,GPIO_Pin_5);
    $ r# ~! G& l( K9 k# E. m2 x; N8 W
46. 
      _6 q; A: N7 X2 r+ g& R
47.               //等待数据发送完毕
    
48. 
    
49.               while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET);
    7 C. _* q0 R0 [6 ?) o1 L7 ?+ e" D
50. 
    
51.               GPIO_ResetBits(GPIOB,GPIO_Pin_5);
    2 ~& V- O. ]+ z; ]2 u" s+ v* U
52. 
    % `% \1 j- h/ T% |- f
53.        }
    
54. 
    - C# x. d0 N9 r) h, D( L
55.        while(1);
    , D0 o) M! T7 l% U/ y# G- r( N
56. 
    
57. }
    * w$ z/ o8 |1 O- Y
58. 
    
59.    
    ' r2 V* ]" i- c* a
60. 
    $ z& [" P) `" I% H2 y0 M
61. //RCC时钟配置
    
62. 
    
63. void RCC_cfg()
    0 z  C# R. C  v4 V- w5 }
64. 
    
65. {
    4 M% \/ P  S7 l; k  U9 R( g* ?
66. 
    9 G9 x4 e  {, v4 L" Q4 G3 g+ y
67.        //定义错误状态变量
    
68. 
    
69.        ErrorStatus HSEStartUpStatus;   
    
70. 
    
71.        //将RCC寄存器重新设置为默认值
    3 N5 d) |! q% Y' @
72. 
    
73.        RCC_DeInit();
    : f9 z2 I' d( m  Q; P+ O
74. 
    . l) g' l! l- E, q+ N
75.        //打开外部高速时钟晶振
    $ O# ]& p3 D& K) v" p  @$ u5 _
76. 
    
77.        RCC_HSEConfig(RCC_HSE_ON);
    " ~' N, l" A8 c; O+ H
78. 
    
79.        //等待外部高速时钟晶振工作
    
80. 
    - R" p8 d+ ]- V- F
81.        HSEStartUpStatus = RCC_WaitForHSEStartUp();
    $ B4 M. {+ w' V2 e$ n( o! c
82. 
    
83.        if(HSEStartUpStatus == SUCCESS)
    - v5 X5 I/ X$ g8 K0 A+ g# l0 V3 _
84. 
    
85.        {
    ( z5 d: t& I7 M0 E
86. 
    
87.               //设置AHB时钟(HCLK)为系统时钟
    2 I/ N  Q( q3 x0 w$ ?0 {
88. 
    
89.               RCC_HCLKConfig(RCC_SYSCLK_Div1);
    5 \+ }/ M# i/ q8 ^8 T" O; k( ~
90. 
    ; H: D6 G3 f3 t
91.               //设置高速AHB时钟(APB2)为HCLK时钟
    # Q6 E6 b0 o: d! A- p% D% K! R$ i- c
92. 
    ; I3 F2 g( u  |
93.               RCC_PCLK2Config(RCC_HCLK_Div1);
    , f# {* B  S: H! L1 q! \+ E) j
94. 
    
95.               //设置低速AHB时钟(APB1)为HCLK的2分频
    
96. 
    6 H0 Z! T0 \6 F2 P* |  C
97.               RCC_PCLK1Config(RCC_HCLK_Div2);         
    ) G) n8 `: E- T
98. 
    
99.               //设置FLASH代码延时
      D: _4 U. G: e% q. N
100. 
     
101.               FLASH_SetLatency(FLASH_Latency_2);
     / J* R% d0 s( P# l& `2 h) q8 f& J
102. 
     
103.               //使能预取指缓存
     
104. 
     & P; ?0 l0 R% t! n
105.               FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
     
106. 
     & Z4 i4 ~2 \7 l2 |) H
107.               //设置PLL时钟，为HSE的9倍频 8MHz * 9 = 72MHz
     ) ?* u; t9 O' \. p8 x
108. 
     ! _2 f, \( `" }
109.               RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
     
110. 
     
111.               //使能PLL
     
112. 
     
113.               RCC_PLLCmd(ENABLE);
     / \' g+ _- \8 C$ B
114. 
     ! v4 Q3 q/ M9 R
115.               //等待PLL准备就绪
     
116. 
     
117.               while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
     8 c$ ^2 t" I) n4 v) N
118. 
     
119.               //设置PLL为系统时钟源
     & B$ E' K3 Z8 f; d) r  r, M% P0 j
120. 
     
121.               RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
     + l; U& U$ ?9 g' r0 C4 W0 [
122. 
     " R" z& ~0 O. a, [6 j
123.               //判断PLL是否是系统时钟
     & F2 B4 G# o6 x/ N7 e  U) }
124. 
     7 A5 S; v- |! C
125.               while(RCC_GetSYSCLKSource() != 0x08);
     ; I  J5 A$ E" W! s$ j' u
126. 
     
127.        }
     
128. 
     8 w: ^2 ^, m4 Q6 }# C+ d
129.          //打开GPIO时钟，复用功能，串口1的时钟
     * m8 r% h! x! ~  {! R+ D
130. 
     
131.          RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO | RCC_APB2Periph_USART1, ENABLE);
     
132. 
     * k  I6 ~3 j6 k+ ]$ V
133. }
     
134. 
     - o! i% a- c) H2 d3 L2 ^! Y' M2 z2 [. ?
135. //IO口配置
     
136. 
     5 A9 Y2 d6 z: W" v) o, O  w. Q6 }& v
137. void GPIO_cfg()
     / e0 |& }) ~4 |3 D) c' k" |
138. 
     
139. {
     
140. 
     3 F' c& |/ I7 J  J
141.        GPIO_InitTypeDef GPIO_InitStructure;
     9 X: ~, V' ]; Q- V+ g. V% I
142. 
     8 x& K& Q" `3 u( [
143.        //PA9作为US1的TX端，打开复用，负责发送数据
     % ^+ E1 J9 V/ E1 Q
144. 
     
145.        GPIO_StructInit(&GPIO_InitStructure);
     
146. 
     7 s! O4 C7 X% \- M! q: A
147.        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
     8 ?2 {. a/ l; y
148. 
     
149.        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
     
150. 
     
151.        GPIO_Init(GPIOA , &GPIO_InitStructure);
     
152. 
     : l9 Y: t9 l4 M. Q9 J! i  {
153.        //PA10作为US1的RX端，负责接收数据
     2 X" f. k+ S* \( W
154. 
     
155.        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
     
156. 
     & |+ ^% ^7 L1 H
157.        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
     2 e0 M- z7 H" B/ T
158. 
     # u5 G8 I$ i# O+ U1 }# p
159.        GPIO_Init(GPIOA, &GPIO_InitStructure);
     
160. 
     
161.        //LED显示串口正在发送/接收数据
     
162. 
     
163.        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
     * U: d) }$ X0 D0 a1 R
164. 
     * |0 h1 V! y" b! a
165.        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
166. 
     * L4 S  I$ k6 L& |  O5 I4 T
167.        GPIO_Init(GPIOB, &GPIO_InitStructure);
     " `7 A& w. @6 i6 a( W# x4 D& U
168. 
     % S: S8 K" q1 }# @! \
169. }
     
170. 
     - s1 k$ u! w1 w! G
171. //串口初始化
     , `* r3 Q& V9 p8 N# O  Z2 L7 N) r
172. 
     
173. void USART_cfg()
     
174. 
     
175. {
     % E6 Z. Q1 i$ a: H
176. 
     $ L) a3 z5 E5 I3 W; `
177.        USART_InitTypeDef USART_InitStructure;
     , [' l3 T0 U5 ~, O$ j
178. 
     . N% g/ S- i3 F4 L9 Z
179.        //将结构体设置为缺省状态
     * t1 u0 |& O$ {5 R, a# A' x( L* ]
180. 
     : m* X/ P/ h1 i
181.        USART_StructInit(&USART_InitStructure);
     6 X( v4 e7 H5 d0 d( m3 c
182. 
     
183.     //波特率设置为115200
     
184. 
     3 {. _& E6 a. F; d9 [- c' m: z% N
185.        USART_InitStructure.USART_BaudRate = 115200;
     9 a! [, T$ B( \1 ]; |& {( V
186. 
     + h& x3 c! O3 F1 @
187.        //一帧数据的宽度设置为8bits
     ) M2 c/ b9 m5 n+ \  v
188. 
     
189.        USART_InitStructure.USART_WordLength = USART_WordLength_8b;
     
190. 
     
191.        //在帧结尾传输1个停止位
     
192. 
     3 m/ z/ B/ ~! d1 `0 r
193.        USART_InitStructure.USART_StopBits = USART_StopBits_1;
     4 Q- z6 G1 x3 \# H7 m; p
194. 
     
195.        //奇偶失能模式，无奇偶校验
     1 I( \% W* @$ K# J
196. 
     ; h4 X  \  V2 s2 S
197.        USART_InitStructure.USART_Parity = USART_Parity_No;
     
198. 
     
199.        //发送/接收使能
     
200. 
     3 N( f4 `: j" \  e4 l# ~- H
201.        USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
     , y7 W. A) a; F  T) a' ^
202. 
     ! X) W* L/ _  a$ r, J. {4 s
203.        //硬件流控制失能
     8 T3 N: c8 D9 \8 o; X/ Z
204. 
     . W8 @" Y+ ]* v* f: a: U  t7 q: ?
205.        USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
     5 S. F  @1 C, t9 r2 s- ~
206. 
     % y- N& U; l# \  @; u& ~
207.        //设置串口1
     
208. 
     : J' e8 z% V) D" [* Z
209.        USART_Init(USART1, &USART_InitStructure);
     4 C4 ]: c% }# d' E6 u6 g
210. 
     + ]0 o1 \4 {2 u* ^6 \6 r
211.        //打开串口1的中断响应函数
     
212. 
     ' R0 x3 g$ y$ V6 b* j4 m  a. D( C7 P
213.        USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
     8 Q7 |. D4 D1 O
214. 
     " t% j1 P# \3 g+ H; y; y7 Y
215.        //打开串口1
     
216. 
     
217.        USART_Cmd(USART1, ENABLE);
     # T& D' {; _9 T; E
218. 
     
219. }
     
220. 
     7 z1 C( `6 `  C, G, j" t: `
221.   
     - L$ L( n; @* A: n- C
222. 
     
223. //配置中断
     5 B3 [  i# j/ F  T" d
224. 
     3 A8 l, ^; Z" b- {3 C  k
225. void NVIC_cfg()
     
226. 
     
227. {
     % q2 q" O( r. W# S! D* `
228. 
     
229.         NVIC_InitTypeDef NVIC_InitStructure;
     0 ?5 G" l9 j& J: L! q4 a* u
230. 
     # c) {" L0 d/ L" Z) k$ l
231.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                                               //选择中断分组2      
     
232. 
     / q) I, u& B; y( h& Z
233.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQChannel;                              //选择串口1中断
     & r. [3 Y2 k6 D# r  n5 g
234. 
     
235.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;                                 //抢占式中断优先级设置为0
     
236. 
     + r$ ?- O7 G; j/ j
237.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                                            //响应式中断优先级设置为0
     " d- w  b, n! a& `8 |' i/ @2 r9 h$ i
238. 
     9 y. R9 B/ V- u/ J1 h
239.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                                                 //使能中断
     
240. 
     
241.         NVIC_Init(&NVIC_InitStructure);
     , f" j1 n* u8 Q: `  q. n
242. 
     
243. }　
     

复制代码

- D8 D1 _' z2 A% W

然后在stm32f10x_it.c文件中找到相应的中断处理函数，并填入一下内容。注意在stm32f10x_it.c中，要声明一下外部变量RX_status

: ~0 y- y# y) c  Z. l+ n

1. extern FlagStatus RX_status;
     \, U2 s/ w6 g, E5 U
2. 
   & |+ F  o# s2 ]
3. void USART1_IRQHandler(void)
   
4. 
   " `1 G5 ]7 `3 m! u, V" o) ^  k  H9 A: W
5. {
   ( w) a$ K, l% ?: F
6. 
   
7.        GPIO_SetBits(GPIOB, GPIO_Pin_5);
   ' A7 D; g. f# F
8. 
   4 h9 P! t6 g$ u( f
9. 
   3 {% W6 C' A' _* U- n6 Z! S6 x4 j
10.        //确认是否接收到数据
    
11. 
    8 B0 y' h8 w" ~/ V1 V
12.        RX_status = USART_GetFlagStatus(USART1, USART_FLAG_RXNE);
    / [% W: |/ V: ~) P0 r( F: I* N
13. 
    3 b5 C  d) c! n; @/ E8 a0 E
14.        //接收到数据
    
15. 
    
16.        if(RX_status == SET)
    9 g) i- Z, k( I( s) J3 B- V
17. 
    
18.        {
    - F! S. q+ N' {! u0 S2 V3 @+ g+ m
19. 
    
20.               //将数据回送至超级终端
    $ \( D. T: r6 z& h: ?! {+ N. G6 i
21. 
    6 R2 ?" f7 M6 q/ S# H9 N& w
22.               USART_SendData(USART1, USART_ReceiveData(USART1));
    ! b$ v+ o  `( ~: ]" W
23. 
    
24.               //等待数据发送完毕
    
25. 
    
26.               while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
    
27. 
    8 Y" u+ |7 Q4 M% A/ y  i- u% y& Y
28.               GPIO_ResetBits(GPIOB, GPIO_Pin_5);
    ( h- W) r# X- m) D' @+ K
29. 
    
30.        }
    . L  N3 k. L/ \1 w# u* ?+ |! U2 t5 p
31. 
    5 x/ k- ]9 V1 a* e
32. }
    

复制代码