生成例程
9 g. ?6 g$ ^4 g. v$ s使用STM32CUBEMX生成例程，这里使用NUCLEO-F103RB开发板


查看原理图，PA2和PA3设置为开发板的串口。
) a# `, ?, ~" p& c


5 o* u1 }- t5 |  A: k% D" f6 V; g配置串口。

/ M* x* x+ P* T, |7 s. a
- B. V. F/ y! ~7 C4 B" O5 t! d
开启中断。
; e6 _7 D1 [2 S' D" Y* M2 I  ~


' r2 J4 ^6 Y/ C, a5 e: K! ySTM32CUBEIDE配置
  ?0 U" f& T  R: f, G/ \, M* q( q) V
% \! O' P* m! ~; x1 \
5 S' O% l* C  p0 o
; z( y8 v- ^. J  x0 f5 c$ L若需要打印浮点型，需要勾选下面的选项。
- ~5 j3 F$ L1 P" c0 S" A6 ~" v% ~- s
$ {8 k3 v/ a, t! |% Z3 Q

串口重定向
9 F: s: r! r- `在main.c中，添加头文件，若不添加会出现 identifier “FILE” is undefined报错。

' q" d; k: N. B$ F4 x  p- h

1. /* USER CODE BEGIN Includes */
   
2. #include "stdio.h"
   % T. `- d. Q/ i) u3 q6 O
3. /* USER CODE END Includes */

复制代码

函数声明和串口重定向：
& |9 \$ K% Q# {! r
. T, ~. V7 d3 c' e0 d& F

1. /* USER CODE BEGIN PFP */
   
2. #ifdef __GNUC__                                                                        //串口重定向
   , f) c; D! F* {: Z- g& p3 @4 w' j
3. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
   8 ]4 ~; p% e' t) I9 O
4. #else
   ' u. [: I) S4 _2 [6 q8 W! `1 ^% X
5. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
   : L! r; F( i+ T; V
6. #endif
   
7. PUTCHAR_PROTOTYPE
   7 P+ H  H; _( `( M
8. {
   # o8 {/ `" i6 t9 l
9.     HAL_UART_Transmit(&huart2 , (uint8_t *)&ch, 1, 0xFFFF);
   , o6 Y6 }  C  F. v6 [1 f
10.     return ch;
    ' Z! W% _* I3 F: L
11. }
    
12. /* USER CODE END PFP */

复制代码

串口发送接收函数
一般情况下，串口发送接收函数有如下所示。
● HAL_UART_Transmit();串口轮询模式发送,使用超时管理机制。
● HAL_UART_Receive();串口轮询模式接收,使用超时管理机制。
● HAL_UART_Transmit_IT();串口中断模式发送
● HAL_UART_Receive_IT();串口中断模式接收
# {) T: m$ s  i● HAL_UART_Transmit_DMA();串口DMA模式发送
: I5 j, v" C. U● HAL_UART_Receive_DMA();串口DMA模式接收

HAL_UART_Transmit()发送
通过轮询，将数据发送出去。
2 v6 d# a. S5 a( t

1. 
   
2.           uint8_t buffer1[10]="0123456789";
   ! H4 x# E) c+ d% ]
3.           HAL_UART_Transmit(&huart2, buffer1, 10,0xFFFF);//把buffer1的内容通过uart2发送出去，长度为10，timeout的时间是0xffff

复制代码

7 z% w' H% N' y' O  W: f演示结果如下所示。

/ o1 A; E& c) m' d* P

HAL_UART_Transmit_IT()发送
通过中断模式发送，这个模式下需要开启串口中断，否则无法发出数据。
6 a' R3 Q8 O. J; j

1.           /***********方法1********************/
   / K( Z, t9 j$ P+ D- O4 X) |
2.           uint8_t buffer2[10]="9876543210";
   % r4 V/ P/ Z" o2 b
3.           HAL_UART_Transmit_IT(&huart2, buffer2, 10);//把buffer1的内容通过uart2发送出去，长度为10，
   - C9 G+ @3 y! G+ l) X5 {2 u5 \
4.           while(huart2.gState != HAL_UART_STATE_READY);
   % ]0 ~# O0 J6 I' `
5. 
     ?7 I3 h, T% G6 Y& \" q0 u
6. 
   : p* p8 i2 S9 e4 F# x6 A
7.           /***********方法2********************/
   
8. //          uint8_t buffer2[10]="9876543210";
   
9. //          HAL_UART_Transmit_IT(&huart2, buffer1, 10);//把buffer1的内容通过uart2发送出去，长度为10，
   2 W, ?: W: U! ~+ W0 M, H
10. //          while(HAL_UART_Transmit_IT(&huart2, buffer2, 10) != HAL_OK);

复制代码

4 @% B1 k2 K  o# W上述代码中，可以不使用while进行等待也可以发送，但是需要注意不能未发送完毕又重新发送。
演示结果如下所示。
' ^2 D+ i5 Y4 w. h  a% b; c
, s& }7 c) @5 N1 `$ `. A9 aHAL_UART_Transmit()和HAL_UART_Transmit_IT()对比
若HAL_UART_Transmit_IT()不使用while进行等待，他的波形图如下所示。
: `1 U# ?$ L3 R, W# z$ T黄色线为波形，红色线为发送后的电平翻转。


$ x. {+ C, u# x" ]5 y, K+ n
HAL_UART_Transmit()发送如下所示。

3 z' h; O, M5 ]3 [$ A

5 ~! m% m! l; p. K2 Q, X* S" f* F9 Z可以看到，HAL_UART_Transmit()发送必须要等待发送完毕才可以接着往下执行。
. c2 }6 e: Q7 W9 V2 D6 kHAL_UART_Transmit_IT()为中断发送，可以在发送数据时候执行其他指令。

$ M' ?; f: J0 k- BHAL_UART_Receive()接收
4 _' i  F/ `$ f- f串口轮询模式接收,使用超时管理机制。
例如接收一个10个数据。
! P3 y; ]! [5 H. C
( |- _) B% B4 b0 {7 z

1.           uint8_t rxdata1[10]={0,0,0,0,0,0,0,0,0,0};
   
2.       /* 判断是否接收成功 */
   8 ^9 F$ t6 F# E/ ~, `# I
3.       if(HAL_UART_Receive(&huart2, rxdata1, 10, 10000) == HAL_OK)
   4 z1 B. c9 Y+ P7 J
4.       {
   
5.           /* 将接收成功的数据通过串口发出来 */
   ; [6 w2 i% m! |  X
6.           HAL_UART_Transmit(&huart2,rxdata1, 10, 0xffff);
   
7.       }

复制代码

3 f# x5 [7 c6 z; Y. z测试结果如下所示。



HAL_UART_Receive_IT()接收
) ~' d0 L+ K% |6 D5 ?7 O1 c2 B串口中断模式接收，这样就可以不需要等待，单片机在没有数据接收时候可以进行其他工作。
; }* u$ X3 ]4 a7 M1 Y8 N例如接收一个10个数据。
定义接收数组。
7 X3 G4 {2 O9 a/ }/ P0 V- Y0 n
  p6 S1 k! L2 q4 C6 i2 ^

1. /* USER CODE BEGIN PV */
   # Q& D$ b* O5 f$ A
2.   uint8_t Rx_Data[10]={0,0,0,0,0,0,0,0,0,0};
   
3. /* USER CODE END PV */

复制代码

! [6 I& w; i8 S' Y" T2 [7 z开启接收中断。

1.   /* USER CODE BEGIN 2 */
   ! O- {& k% A' c3 j5 d
2.   HAL_UART_Receive_IT(&huart2, (uint8_t *)Rx_Data, 10); //开启接收中断，接收10个数据到Rx_Data
   5 f" \1 i- ~' o
3.   /* USER CODE END 2 */

复制代码

! H' E5 Q! F' u" T# ^/ n读取回调函数。

1. /* USER CODE BEGIN 4 */
   
2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   
3. {
   
4.         /* 将接收成功的数据通过串口发出*/
   - T  O6 q7 g& H6 C9 q0 b' C' I! O3 f
5.         HAL_UART_Transmit(&huart2,Rx_Data, 10, 0xffff);
   - h' ]6 l. ~+ F& M) e
6.         HAL_UART_Receive_IT(&huart2, (uint8_t *)Rx_Data, 10); //重新开启，接收10个数据到Rx_Data
   6 s) G$ W- [! H2 p& N1 m) Y' K
7. 
   $ _7 ?$ s8 o9 K! f/ }2 w$ [2 O
8. }
   8 k+ _  _. ~& @
9. /* USER CODE END 4 */

复制代码

: l! c9 {3 k6 k  A测试结果如下。
) K6 Y. i/ |# }
. m+ g4 I0 z% C  C# e* u% ~

3 R# o) ]8 [% ^, b; p2 VHAL_UART_Receive_IT和HAL_UART_Receive的区别就是：中断接收是有数据到了才去读；直接接收是直接读取，如果超时就返回。
! I3 E* q- e7 d& ]" J. u5 v/ ]
- h8 \5 Q. S. Q. u- H
/ y5 o+ Q; M3 R
0 g* ?2 e4 k  |; j" o# Z% s1 g2 V