首先总结全文，通过查询方式运用USART1口收发数据的主要步骤如下：
' j" C8 D* \( c4 S1.初始化GPIO口
/ k% @$ P4 y+ r. k( y) w: b5 r9 S2.初始化串口
. ?5 e/ ^! i9 X5 D' d* P# h# S$ e3.编写发送数据函数
4.编写主函数
5 B* c: ?2 A* f下面介绍详细步骤：

1.初始化GPIO口
通过查阅STM32数据手册可知，stm32f103c8 ，USART1的输入、输出引脚，分别为GPIOA端口的 Pin_10，Pin_9引脚，所以先定义GPIO结构体并赋值：

1. void IO_Init()
   9 M, M. {0 ?0 R1 |7 B$ r0 V
2. {
   
3.         GPIO_InitTypeDef Uart_A;
   ! W6 q. ^$ S0 m' I
4.        
   
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
   
6.         Uart_A.GPIO_Pin = GPIO_Pin_9;
   ' q+ R. E6 j9 K6 s
7.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
   ; J! k1 \. y$ |! P
8.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
   6 S3 _( V5 l) u. x! P) @0 x
9.         GPIO_Init(GPIOA,&Uart_A);
   
10.        
    
11.         Uart_A.GPIO_Pin = GPIO_Pin_10;
    4 x: e1 S5 M9 z$ Y4 ?1 S& `
12.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    2 }: X% U) P% y/ R
13.         Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING; //stm32 data sheet page 110
    
14.         GPIO_Init(GPIOA,&Uart_A);
    # d3 u! I# e  \: g6 @  j  z+ R
15. 
    + y/ B. s/ K8 ?
16. }

复制代码

还和以前一样，先定义GPIO结构体变量，在使能GPIO外设时钟，紧接着分别对各个引脚的寄存器赋值并初始化。

这里需要注意引脚模式的选择：根据STM32参考手册，在全双工模式下，输出口的引脚（Pin_9）要配置为推挽复用输出，接收口的引脚（Pin_10）要配置为浮空输入或带上拉输入，刚开始学STM32不需要过深了解，只需要知道引脚要配置为相应模式即可。如想深究请查看STM32参考手册110页。

" p. j1 Z3 p4 ^  `2，初始化串口
  X1 p( V, N3 A& m8 M要初始化串口可以利用库函数中的串口结构体 USART_InitTypeDef，这样对于初学者来说方便易懂。

7 H1 m( {6 s( T  ~) [8 j( L. [+ H0 v: O库函数中的结构体 USART_InitTypeDef为：
7 C7 ~2 w2 n9 f1 c- g6 Q

1. typedef struct
   4 F% ^! x# ^7 {9 M- f8 Z2 N
2. {//波特率
   
3.   uint32_t USART_BaudRate;            /*!< This member configures the USART communication baud rate.
   
4.                                            The baud rate is computed using the following formula:
   ( W( F! v& ~, ?6 b2 x
5.                                             - IntegerDivider = ((PCLKx) / (16 * (USART_InitStruct->USART_BaudRate)))
   6 \; @# ]8 H+ f, t$ a  A0 F. G
6.                                             - FractionalDivider = ((IntegerDivider - ((u32) IntegerDivider)) * 16) + 0.5 */
   , {1 A1 |  D9 |9 e
7. //字长
   
8.   uint16_t USART_WordLength;          /*!< Specifies the number of data bits transmitted or received in a frame.
   
9.                                            This parameter can be a value of @ref USART_Word_Length */
   - M$ I' l4 l) F* A0 ?
10. //停止位
    
11.   uint16_t USART_StopBits;            /*!< Specifies the number of stop bits transmitted.
    
12.                                            This parameter can be a value of @ref USART_Stop_Bits */
    
13. //是否奇偶校验
    , O' V- |) n& L9 {9 M$ B" K9 e! x" ]( \
14.   uint16_t USART_Parity;              /*!< Specifies the parity mode.
    
15.                                            This parameter can be a value of @ref USART_Parity
    % K! b) ~, w+ F. F: S
16.                                            @note When parity is enabled, the computed parity is inserted
    
17.                                                  at the MSB position of the transmitted data (9th bit when
    
18.                                                  the word length is set to 9 data bits; 8th bit when the
    : o$ T2 k0 \) m% m7 A
19.                                                  word length is set to 8 data bits). */
    
20. //串口模式，收or发？
    
21.   uint16_t USART_Mode;                /*!< Specifies wether the Receive or Transmit mode is enabled or disabled.
    9 ~; V- P* y$ }/ C6 O8 u8 C! o& i
22.                                            This parameter can be a value of @ref USART_Mode */
    
23. //是否使能硬件流，这个初学者暂时先放放，还用不到（博主现在是初学者）
    
24.   uint16_t USART_HardwareFlowControl; /*!< Specifies wether the hardware flow control mode is enabled
    1 |  f. {7 }  F) P; r5 x5 ], y4 X5 |
25.                                            or disabled.
    
26.                                            This parameter can be a value of @ref USART_Hardware_Flow_Control */
    
27. } USART_InitTypeDef;

复制代码

知道了结构体，便可轻松理解下面的定义了。

1. USART_InitTypeDef Uart;

复制代码

使能串口时钟后，依次对结构体中的变量赋值（注：STM32的每个外设都有其单独的时钟，只有使能了其时钟，外设才能开始工作）详细代码如下：

1. RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
   
2. Uart.USART_BaudRate = 115200;//波特率115200
   + ?1 q0 [3 W( _
3. Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//硬件流失能
   $ b% d, }( o5 \; t" O
4. Uart.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//设置为 输出和输入模式
   & I3 J4 Z6 c: Y& k* q4 G# D
5. Uart.USART_Parity = USART_Parity_No;//不进行奇偶校验
   
6. Uart.USART_StopBits = USART_StopBits_1;//1个停止位
   8 u9 C0 ?2 a6 k$ i& }
7. Uart.USART_WordLength = USART_WordLength_8b;//单次数据长读为8
   
8. USART_Init(USART1,&Uart);//初始化串口

复制代码

在初始化串口后，按照STM32参考手册还需要对usart使能见下图：
- ?- B1 _) ^6 p. Y* y9 M8 W; g7 Z) z
9 P* O3 e$ t( r

（注：博主当时在这里想到一个问题：STM32有多个串口，但是只有这一个串口使能位，也就是这么多串口公用一个使能位，那么，当使用多个串口工作，如果临时需要关闭一个串口，怎么办？答案见文章最下部分，答案1。）

由上图可知，在初始化串口完毕后，还需要使能串口：

1. USART_Cmd(USART1,ENABLE);

复制代码

2 u9 P) a3 R! z6 m& d8 o

  {0 C% A5 k& a; J然后根据参考手册：

( I. q9 p  a0 ^/ W+ H4 {
8 }4 y+ q3 ^7 `
, P7 a5 ~1 K9 |+ ^/ X
$ p2 z% o# G8 U1 |5 b. P

此时还需要先清除状态寄存器USART_SR的发送完成（TC）位，要不然发送数据的第一个字节显示不出来。代码如下：

1. SART_ClearFlag(USART1,USART_FLAG_TC);

复制代码

( p6 {% e% O2 I6 e/ R; n% ~到此，串口的初始化也就完成了。
& m& I6 H: X% n( g% v+ M  d
) r  z* H+ |% d4 h9 @$ }' u3，编写发送函数
; k, h/ D$ P2 W. f此处比较简单，先说代码：
$ C3 p( l9 y, @. L

1. void sendByte(uchar character)
   
2. {
   
3.         USART1->DR = character;
   8 V# w' G8 T$ Y% a8 }2 h
4.         while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
   ) Y& _* Z6 J+ u9 N6 j1 x
5. }

复制代码

需要发送时，直接把数据赋值给USART1的数据寄存器（USART_DR）,即可通过串口发出，接下来需要等待数据发送完毕，当数据发送完毕后，USART的状态寄存器的发送寄存器空（TXE）位会置1，（RESET在库函数的宏定义为 0），即，若数据未发送完成，那么循环会一直空转，直到数据全部转到移位寄存器。

4.编写主函数
2 L' p# y, y4 r! ~本文是通过运用查询方法来实现串口的发送。通过串口向电脑发送一个字符，串口之后会自动向电脑发送已发送字符的后9个。

" h9 _% h' T" u7 g* J先粘贴代码在解释：

; W/ O( r; V  `: |$ m3 s0 \

1. int main()
   
2. {
   
3.         int count= -1;
   / p* O* w4 v% }, A/ A# q2 e
4.         char temp= '0';
   3 U- Z7 [2 P/ u" N/ ~5 o4 T4 \
5.         IO_Init();
   / p( ~: g! m; k+ p
6.         Usart1_Init();
   0 r: x7 j8 w0 K* [, ^2 s0 K
7.         while(1){
   
8.                 if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE))//判断是否接受到数据
   
9.                 {
   5 L' R. w+ X; B7 O1 r
10.                         temp = USART1->DR;//若接收到数据，则将数据从数据寄存器取出
    
11.                         count = 10;
    , o$ X; ]: q0 N" W7 ?
12.                 }       
    
13.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TC) && (count >=0))//判断能否发送数据
    
14.                 {
    
15.                         while(count >0){
    . l6 E* Z5 K& |- t7 _: p& @
16.                             sendByte(temp++);//若能发送数据，则向接收端发送数据
    ; T8 X0 X8 j' D: i) x
17.                             count--;//连着发送10个字符
    
18.                             delay(1000);延时一秒
    
19.                         }
    
20.                         if(count<0){
    * Z8 F9 [7 c" Z; }* V: N. g0 s' }3 Y0 f
21.                                 sendByte('\r');//博主本来想在电脑接收端输出回车换行，但是一直接收不了，还没弄明白。
    * J! z0 q7 h; i
22.                         }
    8 B# B2 @' W! w4 }  s, A/ e
23.                 }
    . j# K% ^6 Y  h
24.         }
      V8 u1 Q3 T9 v7 d# {  n
25. }

复制代码

解释见代码中的注释。

答案1：当不需要使用多个串口中的一个时，直接将对应串口外设的时钟失能就可以了。

9 F- t5 M1 V5 D: W# x通过查询方式实现串口收发数据完结。2018年3月20日

下一篇，通过中断来使用串口。
! e6 X4 `$ S- n2 |5 `! @2 W
见STM32基础设计（3）---中断串口通信
7 L# e8 m& e$ i
本文的完整代码如下：
. y% |8 i/ t% a) p. X; R" x

1. #include<stm32f10x.h>
   4 `$ m' D6 d3 S
2. #define uint unsigned int
   ! @% d! b# ^# Q( _7 M) ]
3. #define uchar unsigned char
   
4. void delay(uint n)
   
5. {
   
6.         int i,j;
   
7.         for(i=0;i<n;i++)
   . o1 B' f$ @0 p! Z- I
8.         for(j=0;j<8500;j++);
   $ t+ u5 f0 e; L# k
9. }
   2 `+ M+ A+ M! r9 m' T  {
10. 
    
11. void IO_Init()
    
12. {
    $ {/ _9 {: I6 q5 S6 H  N' H" d! t& a
13.         GPIO_InitTypeDef Uart_A;
    
14.        
    - K, H5 U% @5 D6 ?+ I$ ^4 w
15.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    
16.         Uart_A.GPIO_Pin = GPIO_Pin_9;
    1 N& X! R. V8 e4 X& K+ u
17.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    
18.         Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;
    
19.         GPIO_Init(GPIOA,&Uart_A);
    
20.        
    
21.         Uart_A.GPIO_Pin = GPIO_Pin_10;
    - i! S; d  E' S- D# H8 v# X
22.         Uart_A.GPIO_Speed = GPIO_Speed_50MHz;
    * O5 Y1 c  o4 K0 I
23.         Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING; //page 110
    7 x( z! {. f# e- w. F
24.         GPIO_Init(GPIOA,&Uart_A);
    
25. 
    * u) z- e5 n* ?+ e7 K9 F
26. }
    8 A) g, a2 z4 ^& _) a
27. void Usart1_Init()
    
28. {
    
29.         USART_InitTypeDef Uart;
    
30.        
    
31.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    
32.         Uart.USART_BaudRate = 115200;
    
33.         Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    : X2 D% J. q: }* o3 _
34.         Uart.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
35.         Uart.USART_Parity = USART_Parity_No;
    
36.         Uart.USART_StopBits = USART_StopBits_1;
    ( z8 V* d; H% U$ Z: R
37.         Uart.USART_WordLength = USART_WordLength_8b;
    
38.         USART_Init(USART1,&Uart);
    
39.        
    % L5 \8 b4 P9 z7 z/ n0 [
40.         USART_Cmd(USART1,ENABLE);
    % U+ p: x" V2 R; v) G$ Y
41.         USART_ClearFlag(USART1,USART_FLAG_TC); //page 540
    1 N! X4 y1 |- k' Q
42. }
    
43. 
    * Q& M+ _2 K) Z9 x6 Z# j
44. void sendByte(uchar character)
    2 r: `' K- s$ b8 }8 ]: o
45. {
    
46.         USART1->DR = character;
    
47.         while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
    
48. }
    
49. 
    
50. int main()
    
51. {
    
52.         int count= -1;
    
53.         char temp= '0';
    7 q# o4 k5 L3 F' F" Q% M* C
54.         IO_Init();
    & P% I, x9 J1 h  q" b
55.         Usart1_Init();
    ) ^0 K. M5 n% g, ~6 l4 o
56.         while(1){
    4 v' U: `: x0 }$ v0 [; u
57.                 if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE))
    
58.                 {
    
59.                         temp = USART1->DR;
    4 e5 m. L5 ?9 ?% i% |
60.                         count = 10;
    
61.                 }       
    & E6 J/ b7 ~1 t1 {
62.                 if(USART_GetFlagStatus(USART1,USART_FLAG_TC) && (count >=0))
    
63.                 {
    
64.                         while(count >0){
    - Z3 S, o7 i+ n6 m
65.                             sendByte(temp++);
    1 h  b" n0 Q# o" R' \! f
66.                             count--;
    ; `( X2 p3 F- i
67.                             delay(1000);
    & t6 _7 r) b% u& t7 t# }$ E! p
68.                         }
    
69.                         if(count<0){
    
70.                             sendByte('\r');                                          
    
71.                         }
    
72.                 }
    . S& Q% H$ [  e7 k1 p
73.         }
    6 y7 Y" B9 j' N: y
74. }

复制代码

————————————————
9 S1 X6 e9 n1 W9 i, @* @版权声明：家安
" ]/ c/ o9 C, F; R