概述
' T# y6 w; b0 E9 x0 n0 g本文利用中断实现串口不定长接收（非DMA），使用HAL库，将接收的数据打印出去。
4 y( T+ J, r3 f2 K( q
硬件准备
6 v, ^5 U  o4 N' J首先需要准备一个开发板，这里我准备的是NUCLEO-F030R8的开发板：

$ U! W% s" c& c, G4 z
" M" {, ]- ?4 k1 p) Z$ y% M  x选择芯片型号
* v' e9 v7 N  x9 Q* y2 I- p使用STM32CUBEMX选择芯片stm32f030r8，如下所示：

; j6 ^4 P5 ~) q' w
1 r8 a7 `& i' L0 ^
6 |  m$ X4 W5 R! f2 J配置时钟源
' |! e# m0 j+ a) D* @% yHSE与LSE分别为外部高速时钟和低速时钟，在本文中使用内置的时钟源，故都选择Disable选项，如下所示：
" E# P5 l3 w9 t0 r; |
+ A1 J3 z7 \) l
: p& W! Z5 s0 I) Q
配置时钟树
$ f$ _9 t" v0 h1 Z- D$ {STM32F0的最高主频到48M，所以配置48即可：

% E0 C  f$ f4 Z
, h+ T% t0 ~0 a/ A3 j  m% J0 ~( G
* J& T' h$ t5 [, N串口配置
本次实验使用的串口1进行串口通信，波特率配置为115200。
+ G2 ~1 N! I0 Z. V2 ~9 y" L

  F7 u' C& s4 u) F  E: N/ A
中断
$ I7 B. N* Q! j# \+ ^


GPIO配置
7 o' ?5 O' {6 U' t: f板子上led为PA5端口，故设置PA5闪烁来验证是否正确。
' B' n: ~1 E$ r2 p7 N2 j/ P5 T, y

' \1 d8 d* w: B! F" u* V. t
定时器配置
$ g0 g7 K% R3 [, ?6 X0 l, S0 A本次实验使用的是TIM3来进行计数。
' b) i# t4 O% v( V/ w) }. N. }


# B$ @& i# h8 F$ ^4 c2 N# cPWM频率计算如下所示
, U  t1 x0 D: w: K" R


在上面配置TIM3参数，预分频系数设置为480-1, 自动重载值设置为10000-1，那么PWM频率为48,000,000/((480-1+1)*(10000-1+1))=10Hz，即 100ms一个周期。
; D* q' v4 [' A- K0 [$ T
7 M* ~0 h; e8 J- L! ^生成工程设置
注意在生成工程设置中不能出现中文，不然会报错。
, ?" k9 X' Z8 c/ W; H  ^
* a1 R1 N6 D" }! B2 d0 v

) y" F" [! n$ W8 }* x代码生成设置
% B: \* ^6 B6 W, v最后设置生成独立的初始化文件：
3 G8 L! e( P! l+ \, F7 n: x: @

' \" X0 G  ]# c4 y
生成代码

: l' ~; G" x, A9 M; z

4 X# C, I, ?( L3 D* d) p" k配置keil
. X4 w, W, W* n  h


代码
' T; k( \+ \0 X# `! c在main.c中，先加入头文件。

1. /* USER CODE BEGIN Includes */
   3 I. p9 H3 c" q, [+ V- c& U& O
2. #include "stdio.h"//printf头文件
   
3. #include "string.h"//memset头文件
   9 P. T+ g7 M0 j, n0 K' E4 k
4. /* USER CODE END Includes */

复制代码

( \; \0 `+ u* o# C" d1 Z/ s定义变量存储。

1. /* USER CODE BEGIN PV */
   - X4 r# n1 R0 e# a2 @: @
2. uint8_t RxBuff[1];      //进入中断接收数据的数组
   
3. uint8_t DataBuff[5000]; //保存接收到的数据的数组
   
4. int RxLine=0;           //接收到的数据长度
   6 j+ R1 E3 P0 W0 v7 v$ d
5. int Rx_flag=0;                                        //接受到数据标志
   - V6 [  n/ P4 t8 m: [* E
6. /* USER CODE END PV */

复制代码

定义printf的重定向函数fputc。
+ M$ |# F: b" D- G: ]
# @- n6 C8 T& a# M; w  v

1. /* USER CODE BEGIN 0 */
   . Z  [$ i/ R' q+ I. N
2. void printf_usart(void);//输出内容
   
3. int fputc(int ch, FILE* file)//定义printf的重定向函数fputc，满足串口调试打印
   
4. {
   7 I% E- p9 m* F
5.     return HAL_UART_Transmit(&huart1, (uint8_t*)&ch, 1, 100);
   ; J6 r& r6 X; h: N1 k$ Y
6. }
   / w; J) P9 y+ s2 _# H. g8 c$ C
7. /* USER CODE END 0 */

复制代码

$ S( _1 E  G- l. Z打开串口和定时器。
! D3 o; ?, p8 V4 X' g
1 U+ u3 x5 D  B" n. P5 T' b9 y

1.   /* USER CODE BEGIN 2 */
   
2.         HAL_UART_Receive_IT(&huart1, (uint8_t *)RxBuff, 1); //打开串口中断接收
   * u! T- S+ i$ @4 \! v, `
3.         HAL_TIM_Base_Start_IT(&htim3);//开启定时器
   5 r% [" G1 G+ d7 D1 M) ~( H2 z
4.   /* USER CODE END 2 */

复制代码

串口接受代码，当接受到最后数据为FF时候，直接打印，否则等待100ms打印。
4 d, B: b" O- u9 Z$ K* k
1 l2 u& ^# s1 Y" k- r# L

1. /* USER CODE BEGIN 4 */
   + j9 ?) K* P( R, |: e, w0 l0 I
2. void printf_usart(void)
   
3. {
   6 l& u7 ?9 K3 b: {* U
4.         printf("数据长度=%d\r\n",RxLine);
   
5.         for(int i=0;i<RxLine;i++)
   6 a. C) h  U- }2 W8 y! H( k! J
6.                 printf("数据：[%d] = 0x%x\r\n",i,DataBuff<i>);                           
   " ~7 J: {9 X/ H8 R
7.         memset(DataBuff,0,sizeof(DataBuff));  //清空缓存数组
   $ w: H( L% U& Z$ R
8.         //memset()作用：可以方便的清空一个结构类型的变量或数组。
   ; L2 v) F4 }( o8 O
9.         //例句：memset(aTxbuffer,0,sizeof(aTxbuffer))  用memset清空aTxbuffer。
   8 Z( P6 }* A2 |
10.         RxLine=0;  //清空接收长度
    
11. }
    
12. 
    
13. 
    3 U7 D$ K1 U' e7 p4 K# T9 m
14. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    ) t3 g+ e" C: d' G( Y
15. {
    
16.     if (htim->Instance == htim3.Instance)
    
17.     {
    
18.                         HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_5);
    5 d% j6 Z! q8 o* y6 m0 U5 x
19.         /* Toggle LED */
    ! Y; P: y7 k8 t& f- ~% q) |
20.                         if(Rx_flag==1)
    * q& g3 N# N8 N; }: K
21.                         {
    
22.                                 printf_usart();
    
23.                                 Rx_flag=0;
    
24.                         }
    # ?. `! w( I" n( s
25.                 }        
    ( t/ U/ F  H9 Q4 v% r
26. }
    6 v. T5 D4 _* K1 U" f
27. 
    
28. 
    
29. 
    / W' G2 i  X- n; C, y9 ?
30. // 捕获中断回调函数，每次捕获到信号就会进入这个回调函数
    ' R8 {3 R, {  T: Q  {
31. void HAL_UART_RxCpltCallback(UART_HandleTypeDef*UartHandle)
    
32. {
    
33.     RxLine++;                      //每接收到一个数据，进入回调数据长度加1
    
34.     DataBuff[RxLine-1]=RxBuff[0];  //把每次接收到的数据保存到缓存数组
    
35.                 Rx_flag=1;
    $ u7 b$ K' Y5 T' Z/ W; c# o
36.     if(RxBuff[0]==0xff)            //接收结束标志位，这个数据可以自定义，根据实际需求，这里只做示例使用，不一定是0xff
    % |" V+ g* f/ h
37.     {
    5 A) O; M2 A/ N2 \4 C; n
38.                         printf_usart();
    
39.     }   
    
40.     RxBuff[0]=0;
    0 n" q; e5 s6 r0 {* I
41.     HAL_UART_Receive_IT(&huart1, (uint8_t *)RxBuff, 1); //每接收一个数据，就打开一次串口中断接收，否则只会接收一个数据就停止接收
    & B5 M" Y6 a- d4 q
42.                 __HAL_TIM_SET_COUNTER(&htim3, 1); // 计数清零，从头开始计
    9 @  x, B/ X" w* [. `" Y
43. }
    1 Q; \! |9 y: D( r" W1 z& ~: o# |
44. /* USER CODE END 4 */</i>

复制代码

演示效果
可以看到 发送11 12 13需要等待100ms左右才能发送，如果最后加上ff直接发送。

* y! I. Q. A9 ]( ~; O$ y


3 k+ u: i. p  w6 f) d( z