一、定时器功能
+ a4 \5 Z0 p1 R% C2 c         1.1 定时器分类
        STM32 的定时器分为高级定时器、 通用定时器 、基本定时器三种。
( _$ _& Q# r3 g9 P
7 v* t/ ]. X2 N* v" G( H: N. d        这三个定时器成上下级的关系，即基本定时器有的功能通用定时器都有，而且还增加了向下、向上/向下计数器、PWM生成、输出比较、输入捕获等功能；而高级定时器又包含了通用定时器的所有功能，另外还增加了死区互补输出、刹车信号。

        例如本文采用的STM32L496VGT6芯片中，高级定时器（TIM1、TIM8）、 通用定时器（TIM2、TIM3、TIM4、TIM5、TIM15，另外TIM5、TIM15亦有些许差异） 、基本定时器（TIM6、TIM7、TIM16、TIM17），高级定时器、 通用定时器 、基本定时器在STM32CubeMX配置界面中是不一样的：
! q/ ?  p) e& s0 c( l- O
$ [6 H- C( l' l+ \        高级定时器（TIM1）：


8 X- K' V! m# l3 @, ^
        通用定时器（TIM2）：
& X% h2 S, q! t/ P9 |/ ?8 \

; _  U+ J7 y. f- S5 t6 }
" Y. Z( H6 g  m, Z' Z        或通用定时器（TIM5）：



+ j- L7 p+ c1 }3 @) H         基本定时器（TIM6）：
+ z7 X6 X- ?" p
' `# X; ~# C8 a3 d- [' t6 e# F$ E- j" h

         在通用定时器，每个定时器都有一个16位的自动加载递增/递减计数器，一个16位的预分频器和4个独立通道，每个通道可用于输入捕获、输出比较、PWM和单脉冲模式输出。而TIM1、TIM8高级定时，其通道更是支持到6个通道，在一些高级芯片中支持到的通道会更多。

9 }& i* p* y) X% N  V" n  D( G  e        每个定时器都支持外部中断机制，还可以结合计数功能或时钟功能，实现轮询策略；每个定时器也支持独立的DMA请求机制。

* n% M2 ~2 J+ p# {; i% T) Z/ H$ v' q        通用定时器可以利用GPIO引脚进行脉冲输出，在配置为比较输出、PWM输出功能时，捕获/比较寄存器TIMx_CCR被用作比较功能。
6 r9 ^5 F# @7 {

        1.2 定时时间计算
, m+ V( I: [$ Y* K* z! W. y        定时器输出时间间隔(us)=(分频系数+1)*(计数周期+1)÷输入定时器时钟频率(MHz,APB*)，如下图所示。

2 M% n. P9 h" U7 V1 e. o
. u% b8 H5 E! q5 Z3 S

$ G" ]. ^4 J/ a# `" o         1.3 中断功能
  X! E) ?- ?6 a  g        通常STM32芯片支持所有GPIO设置为外部中断输入，外部IO可以由电平上升、电平下降、高低电平三种方式的中断触发或事件触发。定时器作为外设之一，同样支持到外部中断或事件触发。

+ w7 e3 x: i7 n% i/ |
2 R  U$ k: t) U5 y

二、工程创建及配置
' e* t1 y/ F9 j2 a1 }0 B        2.1 cubeMX图形配置
7 m" `: p7 k- E; T1 Y. P6 {/ _        本文基于STM32L496VGT6芯片创建工程，创建时钟、开启lpuart1串口，以及三个LED灯和按键KEY，配置如下：
# k$ F' o' }# Q# J4 |
        【1】系统配置
6 U" `0 l& F: L. g2 x9 h

; |: k, W1 @6 U6 u- X
         【2】RCC功能开启外部高速时钟（默认参数配置）及时钟树设置



/ m/ y6 @: Z! `( \# R. s         时钟树设置，STM32L496VGT6支持最大输出频率80MHz，本文直接拉满
" i" E: L5 q: l1 X& R$ g4 e

+ B5 H& |0 Z3 S7 b* ~9 u
         【3】lpuart1串口开启

% j3 u* J; Z4 r
! ?3 F8 P: s- U4 x. A
( i" {3 W/ t% W$ Z% {1 }8 _. U         开启lpuart1中断功能及按开发板引脚说明调整引脚：
+ v: o8 G1 ^! ~& Y/ M7 G
. I0 p4 a3 }; \

         【4】配置三个按键及LED
$ I; P6 n# P0 X8 M; m! c4 L! V
' r9 d( Y8 X/ K0 g( u  P
6 G3 O4 c0 r# Y
1 R. h+ f1 i: J( f         完成基本配置后，生成输出代码（每个外设独立的.h/.c文件）

2 t: C) g3 `& \: a; z        2.2 代码设计
* d$ C( ]4 Q* M        【1】禁用syscalls.c源文件


7 ^3 q, z4 p6 g8 ?, L( A
6 K5 }7 e4 m1 C* B& s2 b5 u# M4 {5 w         【2】在工程目录下，创建源文件夹ICore文件目录，



         【2】并在ICore目录下创建led、key、print、usart目录。
4 G% Z; g* e$ @/ R: `+ V
  X8 d. {: N; Y8 O' ~+ A

         【3】在print目录创建print.h和print.c源文件，将用来实现将printf标准函数输出映射到lpuart1串口的驱动程序。
- e/ ]' k6 T/ N4 ~
        print.h
, E3 Y/ `* S" s* r  g& ~

1. #ifndef INC_RETARGET_H_
   ) O& X6 X: t: Y" B' n* U
2. #define INC_RETARGET_H_
   # V( R' a) j% ]5 H0 {$ K
3. 
   . c# U% w) s! a% I  L
4. #include "stm32l4xx_hal.h"
   
5. #include "stdio.h"//用于printf函数串口重映射
   2 }* w" g. ]! j! C" C
6. #include <sys/stat.h>
   4 H$ l! V& }3 j
7. 
   , W8 ~" @( c$ T- k9 Z0 z
8. void ResetPrintInit(UART_HandleTypeDef  *huart);
   ; J3 W) a% O& f7 ~0 z
9. 
   
10. int _isatty(int fd);
    " O* k2 ]% U" g" y
11. int _write(int fd, char* ptr, int len);
    + S# g) K/ V. ~0 k+ U* T
12. int _close(int fd);
    $ @+ F' O" w- U& i- K
13. int _lseek(int fd, int ptr, int dir);
    
14. int _read(int fd, char* ptr, int len);
    ; u, Y& P' a; k
15. int _fstat(int fd, struct stat* st);
    
16. 
    0 U; ]! L. o3 z
17. #endif /* INC_RETARGET_H_ */

复制代码

. U; T7 Q, E/ e5 A         print.c
8 w. w% \  C" U0 U

1. #include <_ansi.h>
   
2. #include <_syslist.h>
   ( x/ E# U8 [; b/ w
3. #include <errno.h>
   
4. #include <sys/time.h>
   
5. #include <sys/times.h>
   1 c# b' B5 g/ z! ]* z$ [' ]
6. #include <limits.h>
   
7. #include <signal.h>
   * ?* y4 d; V# m0 f- u
8. #include <stdint.h>
   
9. #include <stdio.h>
   
10. 
    
11. #include "print.h"
    % G0 l+ |" X: t9 T" ]0 t( |8 |
12. 
    
13. #if !defined(OS_USE_SEMIHOSTING)
    1 ?: z% W1 [% y7 T% b
14. #define STDIN_FILENO  0
    
15. #define STDOUT_FILENO 1
    # m) h, A% E1 h! M
16. #define STDERR_FILENO 2
    
17. 
    
18. UART_HandleTypeDef *gHuart;
    # L% t  q: A* h. |4 G2 c
19. 
    
20. void ResetPrintInit(UART_HandleTypeDef *huart)  {
    1 M/ I; r1 C7 J  Q. D
21.   gHuart = huart;
    
22.   /* Disable I/O buffering for STDOUT  stream, so that
    % |9 u  [  J4 F+ T4 ]1 n$ H
23.    * chars are sent out as soon as they are  printed. */
    
24.   setvbuf(stdout, NULL, _IONBF, 0);
    / ?7 _) U, b: p$ D
25. }
    
26. int _isatty(int fd) {
    $ V; s/ o, A- U
27.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    
28.     return 1;
    " I$ L5 c6 P8 E; S# g: r; [
29.   errno = EBADF;
    
30.   return 0;
    
31. }
    
32. int _write(int fd, char* ptr, int len) {
    
33.   HAL_StatusTypeDef hstatus;
    . a3 u; K" ]7 w; ^9 E7 X
34.   if (fd == STDOUT_FILENO || fd ==  STDERR_FILENO) {
    7 m. Z, `7 r9 w8 g9 o* d# b! K
35.     hstatus = HAL_UART_Transmit(gHuart,  (uint8_t *) ptr, len, HAL_MAX_DELAY);
    8 g' e% Q7 h5 H
36.     if (hstatus == HAL_OK)
    
37.       return len;
    
38.     else
    " U& O& U6 R5 W! O( ?1 M! \2 `
39.       return EIO;
    1 J. j) M7 E! g, v; i2 Y
40.   }
    ) H* [, p7 d* l3 y' r* K
41.   errno = EBADF;
    0 Z% `! `3 s8 I# v# t( v
42.   return -1;
    , h5 N8 I+ Z- s$ o! `; d
43. }
    6 K: M1 P3 E) T1 k' [
44. int _close(int fd) {
    ( b7 X8 J( }0 F3 m, D
45.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    
46.     return 0;
      B8 Y- S. H) f4 U
47.   errno = EBADF;
    0 {" ]! _5 @) c4 z) e
48.   return -1;
    6 r6 }' ]0 I, _: R' F
49. }
    3 M: X( y! W# T& x, h5 w& }
50. int _lseek(int fd, int ptr, int dir) {
    + X) B' h' w8 t
51.   (void) fd;
    
52.   (void) ptr;
      _6 i# U( p: [: q8 f3 U
53.   (void) dir;
    
54.   errno = EBADF;
    
55.   return -1;
    
56. }
    
57. int _read(int fd, char* ptr, int len) {
    - b* ?$ {: `$ V$ r4 R2 L3 T
58.   HAL_StatusTypeDef hstatus;
    
59.   if (fd == STDIN_FILENO) {
    ' G4 A8 W  d, r) a/ I" Z7 E) f2 y
60.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
    4 G5 m" T4 Q5 o3 f9 Z1 I" p) r
61.     if (hstatus == HAL_OK)
    
62.       return 1;
    1 T6 y1 T) H* f* o
63.     else
    
64.       return EIO;
    
65.   }
    0 i( [2 l1 n4 B& i+ B2 C4 [' k; n
66.   errno = EBADF;
    4 M& ]0 _" D6 F1 Z. v/ m2 P4 E% T' O3 ~
67.   return -1;
    6 v/ k0 J0 I% w0 k0 c
68. }
    
69. int _fstat(int fd, struct stat* st) {
    
70.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO) {
    4 s# I5 X  s  d1 O, S9 ?0 b
71.     st->st_mode = S_IFCHR;
    
72.     return 0;
    + l$ O9 n; P- }
73.   }
    
74.   errno = EBADF;
    
75.   return 0;
    1 G2 o7 ~" \# v- t1 d
76. }
    
77. 
    
78. #endif //#if !defined(OS_USE_SEMIHOSTING)

复制代码

        【3】在led目录创建led.h和led.c源文件，将用来实现LED等状态控制的驱动程序。
5 R; q' H- b" E9 c4 [5 J' ~- ^        led.h
5 }; c- N9 R/ T% L  o- z% }

1. #ifndef LED_H_
   
2. #define LED_H_
   % z( C7 [/ y2 h4 ~
3. #include "main.h"
   : E$ q9 _$ H. F( b; k& Y2 J4 C
4. #include "gpio.h"
   * \0 V! D9 A: X* f4 V
5. 
   
6. void Toggle_led0();
   
7. void Toggle_led1();
   # x( [; z+ K% q& k1 \
8. void Toggle_led2();
   . [4 f. h7 ]: k/ c" o7 _' L, F
9. 
   
10. void set_led0_val(GPIO_PinState PinState);
    : ]* S! o: \* ~: t! @1 Q5 c; G5 b
11. void set_led1_val(GPIO_PinState PinState);
    
12. void set_led2_val(GPIO_PinState PinState);
    
13. 
    1 v3 @$ G& T' n( [5 h
14. #endif /* LED_H_ */

复制代码

) D9 j! h4 H6 c+ q        led.c

1. #include "led.h"
   . f5 ^8 [5 L6 ]  [+ g
2. 
   & }/ T( c+ Y2 n) m$ ?
3. void Toggle_led0()
   
4. {
   ( ]" `- N& s- W2 u2 N* h
5.         HAL_GPIO_TogglePin(LED0_GPIO_Port,LED0_Pin);
   7 Q  g  z3 w& [8 f) B
6. }
   
7. 
   
8. void Toggle_led1()
   3 e7 [" h! b2 `: }; B
9. {
   ' }5 q/ w) _. u3 H- t: ]/ U+ _( ^
10.         HAL_GPIO_TogglePin(LED1_GPIO_Port,LED1_Pin);
    3 U* }) I) t5 ]0 ], D9 w8 o
11. }
    ' L0 c0 `: k) B2 d' C7 r
12. 
    
13. void Toggle_led2()
    
14. {
    
15.         HAL_GPIO_TogglePin(LED2_GPIO_Port,LED2_Pin);
    
16. }
    
17. 
    8 i4 N$ `$ J: |  ]2 J
18. void set_led0_val(GPIO_PinState PinState)
    . v9 {8 R8 _. u% O! F
19. {
    
20.         HAL_GPIO_WritePin(LED0_GPIO_Port,LED0_Pin,PinState);
    + F4 F8 B4 W" o% H( r' |, E
21. };
    
22. 
    
23. void set_led1_val(GPIO_PinState PinState)
    & @0 L0 T  g7 Z0 ?& z0 U& b  a
24. {
    ' R4 u1 i- I! ?# Q& T4 j% L
25.         HAL_GPIO_WritePin(LED1_GPIO_Port,LED1_Pin,PinState);
    
26. };
    
27. 
    
28. void set_led2_val(GPIO_PinState PinState)
    
29. {
    
30.         HAL_GPIO_WritePin(LED2_GPIO_Port,LED2_Pin,PinState);
    0 i0 P, H/ e; x& t8 t
31. };

复制代码

        【4】在key目录创建key.h和key.c源文件，将用来实现KEY控制的驱动程序。

! Y% E, A6 T" f        key.h
+ d! q/ \( T* A9 C% }0 N/ z* ^

1. #ifndef KEY_H_
   
2. #define KEY_H_
   2 O  M: k( h9 {& u8 Y0 _
3. 
   , L6 `. U. t  n! A2 ^# b% k; B) d
4. #include "main.h"
   0 y( M% F$ e. `/ R' h8 b! i
5. #include "gpio.h"
   
6. 
   
7. GPIO_PinState get_key0_val();
   & ~+ G0 b" C$ I1 Z3 J: q8 }! {4 l
8. GPIO_PinState get_key1_val();
   2 l& u2 J: j" S$ Y: z2 v
9. GPIO_PinState get_key2_val();
   
10. 
    . C6 _4 N7 Z4 ]
11. uint8_t KEY_0(void);
    
12. uint8_t KEY_1(void);
    
13. uint8_t KEY_2(void);
    
14. 
    8 l- M- [3 a- o' O- g- d$ @
15. #endif /* KEY_H_ */

复制代码

        key.c

1. #include "key.h"
   " x( r/ s+ X9 G. y
2. 
   . g6 b! x6 P& w2 C
3. GPIO_PinState get_key0_val()
   
4. {
   ; z2 t  z/ ?0 V0 L6 F' p& U8 z1 h
5.         return HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin);
   
6. };
     t( m7 ?4 ?) Q/ v' k! N2 t% C
7. 
   
8. GPIO_PinState get_key1_val()
   ! W: n4 v' ]! q5 n$ ~0 p" y2 Q0 t$ A
9. {
   1 Q5 [% A/ W: _8 |& i! s
10.         return HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin);
    . @' g, g5 F3 {
11. };
    ) m  L6 R. ^! C) P, N
12. 
    
13. GPIO_PinState get_key2_val()
    - E/ x& ~+ m% O+ L1 r/ w0 P* y' f' ]
14. {
    
15.         return HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin);
    + U& N! d5 f' Y  ]3 h4 Z/ l7 c, B
16. };
    ( Y* J9 x3 `; v6 V7 h8 I
17. 
    
18. uint8_t KEY_0(void)
    
19. {
    
20.         uint8_t a;
    8 ], d/ w& _3 D
21.         a=0;//如果未进入按键处理，则返回0
    ' ]% r: P. p; d! I3 e1 Z; Z
22.         if(HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    
23.                 HAL_Delay(20);//延时去抖动
    
24.                 if(HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    1 G4 ^( c* U  Y% a' S2 l6 V4 i
25.                         a=1;//进入按键处理，返回1
    
26.                 }
    
27.         }
    # U* O* E6 V% f# a- `1 e1 l: G
28.         while(HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin)==GPIO_PIN_RESET); //等待按键松开
    
29.         return a;
    7 l: |9 e& g5 a- s/ R
30. }
    
31. 
    ) Q9 t- d- A3 q
32. uint8_t KEY_1(void)
    
33. {
    
34.         uint8_t a;
    
35.         a=0;//如果未进入按键处理，则返回0
    
36.         if(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    % J- D# }( s( t9 n# Q
37.                 HAL_Delay(20);//延时去抖动
    * t! e+ O  `) X: `4 N  Y1 R
38.                 if(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    
39.                         a=1;//进入按键处理，返回1
    " E) J9 ]& x& E8 ~5 l
40.                 }
    
41.         }
    
42.         while(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开
    
43.         return a;
    
44. }
    
45. 
    1 B0 ~  Q, r7 A' c* S
46. uint8_t KEY_2(void)
    
47. {
    
48.         uint8_t a;
    9 j9 g, n  I1 D" ^# x0 \3 B
49.         a=0;//如果未进入按键处理，则返回0
    
50.         if(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    ( n8 X* S, S: h  `4 q7 X
51.                 HAL_Delay(20);//延时去抖动
    ) K! L. N- T$ _" u* b8 N3 L
52.                 if(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    
53.                         a=1;//进入按键处理，返回1
    ' {2 {) ~% I  D8 f8 |0 E: \
54.                 }
    % e" e' c1 W. U: ^( W0 {
55.         }
    
56.         while(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开
    
57.         return a;
    " v9 {, U! t; }7 b" h/ Y0 S
58. }

复制代码

        【4】在usart目录创建usart.h和usart.c源文件，将用来实现lpuart1驱动程序。
        usart.h

1. #ifndef INC_USART_H_
   8 p8 \* T- Q, H9 f9 A, R: C8 {% n
2. #define INC_USART_H_
   : [& W! h% R- o/ P' p- X3 q
3. 
   
4. #include "stm32l4xx_hal.h" //HAL库文件声明
   2 X  H5 C, [! R, G8 C
5. #include <string.h>//用于字符串处理的库
   
6. #include "../print/print.h"//用于printf函数串口重映射
   % `; ~' ^3 J) ^1 x4 [6 J
7. 
   
8. extern UART_HandleTypeDef hlpuart1;//声明LPUSART的HAL库结构体
   
9. 
   
10. #define HLPUSART_REC_LEN  256//定义LPUSART最大接收字节数
    % G+ x0 L3 V. Z
11. 
    
12. extern uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
    
13. extern uint16_t HLPUSART_RX_STA;//接收状态标记
    
14. extern uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    
15. 
    . W( C1 S/ _6 ?8 N( o8 E6 f
16. 
    ; @; g. e( @5 l( I: C4 K; ]
17. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    
18. 
    
19. #endif /* INC_USART_H_ */

复制代码

        usart.c

1. #include "usart.h"
   
2. 
   + h* k3 h* T) m7 P
3. uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
   + _4 _: N2 |# ?0 H8 Z! Q! d
4. /*
   0 ]0 \/ o. B- x2 A5 o9 }1 Q
5. * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
   
6. * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
   
7. * bit13:预留
   
8. * bit12:预留
   + r8 M$ q2 B* g1 _
9. * bit11~0：接收到的有效字节数目(0~4095)
   
10. */
    0 }. j% G6 l. ]$ i, A: T- }
11. uint16_t HLPUSART_RX_STA=0;接收状态标记//bit15：接收完成标志，bit14：接收到回车(0x0d)，bit13~0：接收到的有效字节数目
    
12. uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    8 x7 p6 g8 |8 s# r6 d4 |- E
13. 
    & d% \( j( V1 u& `( S+ w9 L' b7 g
14. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    * W. d) u6 J9 U; n' y
15. {
    3 H. d- I; Q$ h7 \8 |- Z
16.         if(huart ==&hlpuart1)//判断中断来源（串口1：USB转串口）
    ( \2 w6 d. i6 L. v: R2 g" Y
17.     {
    
18.                 if(HLPUSART_NewData==0x0d){//回车标记
    ' ?3 P: C( i7 G: I! m* J7 a
19.                HLPUSART_RX_STA|=0x8000;//标记接到回车
    . K5 K/ Z5 G  J3 E- ?! B
20.                 }else{
    
21.                         if((HLPUSART_RX_STA&0X0FFF)<HLPUSART_REC_LEN){
    * L4 O( o3 @) m& L
22.                                 HLPUSART_RX_BUF[HLPUSART_RX_STA&0X0FFF]=HLPUSART_NewData; //将收到的数据放入数组
    * X! o( F" H+ ?& g
23.                                 HLPUSART_RX_STA++;  //数据长度计数加1
    
24.                         }else{
    8 \1 l$ g* f2 R. s8 [4 A- S
25.                                 HLPUSART_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    0 s$ O; `! F2 `; q
26.                         }
    " A& ?9 p7 \: o" u" Q
27.         }
    
28.        HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData,1); //再开启接收中断
    
29.     }
    
30. }

复制代码

        【5】在main.c文件中加入各驱动文件的头文件
6 W. p' P5 w8 i5 Z* A

1. /* USER CODE BEGIN Includes */
   
2. #include "../../ICore/key/key.h"
   
3. #include "../../ICore/led/led.h"
   , A- w/ V4 b8 H. g: w0 d. u
4. #include "../../ICore/print/print.h"
   
5. #include "../../ICore/usart/usart.h"
   
6. /* USER CODE END Includes */

复制代码

# ^" k2 ?0 N( t0 a+ F  l* f( m7 O        在主函数中，初始化lpuart1

1.   /* USER CODE BEGIN 2 */
   
2.   ResetPrintInit(&hlpuart1);
   % R; Y  p- H* F. F2 t* F! i! }
3.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
   
4.   HLPUSART_RX_STA = 0;
   
5.   /* USER CODE END 2 */

复制代码

        在主函数循环体中，实现lpuart1输入返回测试及按键时LED灯状态反转。

1. /* USER CODE BEGIN WHILE */
   
2.   while (1)
   
3.   {
   
4.           if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
   * A3 v5 y+ C: n9 k
5.                     printf("receive:%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
   * _8 M+ X+ `; p0 n8 j+ d
6.                     HLPUSART_RX_STA=0;//接收错误,重新开始
   , q6 d" @/ U, g
7.                     HAL_Delay(100);//等待
   + X- h. f& q: t0 Q; C" s
8.             }
   - V8 `! o  m, ^1 B3 @9 D1 i
9.       if(KEY_0())
   
10.           {
    
11.         Toggle_led0();//LED0等状态反转一次
    
12.           }
      _8 W. r% x/ F% ?4 O
13.             if(KEY_1())
    
14.           {
    ' }( M3 h; G6 ~8 I
15.         Toggle_led1();//LED1等状态反转一次
    
16.           }
    
17.             if(KEY_2())
    
18.           {
    
19.                     Toggle_led2();//LED2等状态反转一次
    : }- P7 B: F  u/ n
20.           }
    / R: R$ h. y2 v% i# w% K5 }
21.     /* USER CODE END WHILE */

复制代码

6 {( l! [) M/ R" v& }8 s5 C' Y        【6】配置输出文件格式支持，然后编译代码


- z; E) d& F/ y4 Q6 Z' Z$ J2 _
" |. e: E1 m5 Z5 x        【7】配置调试及下载支持
" ?: w' z6 g: Y1 J8 f

5 |6 }/ R5 G. x" F5 B0 @9 w
% ]% n+ G( \3 B' R! \; l         运行下载烧写程序到开发板，完成基本功能开发。


, D" Y1 j1 d: z" p6 v三、添加定时器及中断功能
* N& N- J9 k: e        3.1 GPIO外设中断
+ k; {8 a4 f; U0 v* S        打开.ioc进入cubeMX配置界面，将KEY0按钮调整为GPIO_EXTI类型

. t# L& C; @, x* w
) ?) d9 {% f6 ?$ w* [5 p
        并开启KEY0（PE11）的中断支持
/ `$ _$ c' [. {6 h' q

/ G/ ^7 k7 F& s. s* ~" U8 w9 T. _
         3.2 TIM2通用定时器，轮询
; ^9 b+ ~/ K, y& b        添加TIM2通用定时器功能实现定时轮询功能
5 A& b" w: B- C6 X
/ G7 L) v6 L% W0 z) z7 G
+ I5 F5 k' }6 o0 p" w
         并开启 TIM2的中断功能
2 A7 z7 _7 k3 G4 R) g
, c# ?) M- R5 R

6 L1 c; e* \2 o5 a& b9 Z         3.3 TIM3通用定时器，辅助lpuart1通信
        添加TIM3通用定时器功能实现间隔计时，辅助lpuart1串口在没有结束标记情况下实现超时（100ms）通知
. Q+ `0 b% _4 M9 k5 L

1 f/ {8 j  V6 L0 J
6 I8 o! C1 R, I0 k4 \         并开启TIM3的中断功能支持

1 I4 U: M+ d; ]  q) k  q
8 Z: X( h( K7 @
, P3 k3 [( |/ @: l
" ^+ a0 y- z" l5 {/ @) v         3.4  TIM4通用定时器，PWM输出
1 i. o2 G9 `) Z4 `& @5 Q8 e        添加TIM4通用定时器功能，开启其通道4对PWM输出功能支持，将KEY2（PD15）调整为TIM_CH4类型。PWM是定时器扩展出来的一个功能(本质上是使用一个比较计数器的功能)，配置过程一般为选定定时器、复用GPIO口、选择通道(传入比较值)、使能相应系统时钟、设定相应的预分频、计数周期、PWM模式(有两种)、电平极性等。
0 a/ b" n. @6 z- ]* ^6 x9 i
- j- i9 {5 {/ I# e9 c
9 I. l# _2 A5 J2 T$ v
        并开启TIM4的中断功能支持


; Y* y: i3 R2 L  R0 H5 u. j' B
/ r9 @8 v* \) a6 X; e* \         配置KEY2（PD15）GPIO引脚为交替推免GPIO模式，如下图。


* Y4 H+ I' b) d2 W- O* \2 E
         上述配置完成后输出生成代码。
+ A3 H) f& t5 g, ^; \) j4 p2 z

四、定时器及中断功能代码设计
        4.1 GPIO中断功能
        已经配置了KEY0（PE11）为GPIO_EXTI模式，并开启其中断支持，现需要重新实现stm32l4xx_hal_gpio.c文件中的HAL_GPIO_EXTI_Callback函数来实现GPIO外部中断回调功能。



         在main.c文件中，重新实现HAL_GPIO_EXTI_Callback函数，覆盖stm32l4xx_hal_gpio.c文件中HAL_GPIO_EXTI_Callback弱函数。
' l2 x+ i' |- h5 O& P

1. /* USER CODE BEGIN 0 */
   
2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   # g4 D; p6 I& I2 H5 M9 C" v& c; J# t
3. {
   4 g* ?1 t& f0 q% l$ Y2 B; J) U
4.         if(GPIO_Pin==KEY0_Pin)
   & ]5 @, Q) U' O0 R* |: B1 m2 i+ B
5.         {
   ! n+ A" I; M6 G5 E9 B3 V
6.                 static uint32_t key0_count = 0;
   
7.                 printf("this is %lu count for HAL_GPIO_EXTI_Callback!\r\n",key0_count++);
   + O0 s* V4 B' W6 S$ X
8.                 Toggle_led0();//LED0等状态反转一次
   
9.         }
   # l/ o) T( x3 X+ g4 U
10. }
    5 ^% Y8 y$ s5 i# |
11. /* USER CODE END 0 */

复制代码

         4.2 TIM2的定时轮询功能
9 i9 `* X3 ^( Y3 n' Y          已经配置了TIM2，并开启其中断支持，现需要重新实现stm32l4xx_hal_tim.c文件中的当计数溢出时调用的回调函数HAL_TIM_PeriodElapsedCallback。

( @: l7 b, J3 F1 J: R2 P' ~1 V0 A

5 z: k, U( T# |+ p         在mian.c文件中，重新实现HAL_TIM_PeriodElapsedCallback函数，覆盖stm32l4xx_hal_tim.c文件中的同名弱函数。
% V% r3 K1 P6 M, Q7 H1 v

1. /* USER CODE BEGIN 0 */
   
2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   ! f2 [* V( L9 Q- \2 V) h% x8 S
3. {
   
4.         if(GPIO_Pin==KEY0_Pin)
   # P$ c! `/ Y2 ?; {$ h
5.         {
   1 e3 l# q( J& {( P: |, }) r; u( O* [
6.                 static uint32_t key0_count = 0;
   ; T. x7 x1 X5 [' y
7.                 printf("this is %lu count for HAL_GPIO_EXTI_Callback!\r\n",key0_count++);
   
8.                 Toggle_led0();//LED0等状态反转一次
   
9.         }
   5 w7 ~  g% O: L) y% V: `( a
10. }
    , O* e( X, c3 _8 o) }
11. 
    
12. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
13. {
    
14.         if(htim==&htim2)
    + m* p1 f/ x0 {/ l' ~1 u
15.         {
    
16.                 static uint32_t key1_count = 0;
    
17.                 printf("this is %lu count for HAL_TIM_PeriodElapsedCallback!\r\n",key1_count++);
    3 K* i, ^2 z2 V2 Q  r2 ~
18.                 Toggle_led1();//LED1等状态反转一次
    
19.         }
    6 l' o% Y$ h) q: d: F4 h1 H
20. }
    
21. /* USER CODE END 0 */

复制代码

        4.3 TIM4的计数功能
! v, u, E; i* A8 L4 I% C       同样已经配置了TIM4，并开启其中断支持，现需要重新实现stm32l4xx_hal_tim.c文件中的当计数溢出时调用的回调函数HAL_TIM_PeriodElapsedCallback，在计数结束时，改写lpuart1的接收标记。

( }8 B, t$ v5 N5 |. w2 s7 @) q$ x. |$ x, J

1. /* USER CODE BEGIN 0 */
   
2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   - S4 ?) K6 I& ^/ ^- k9 w
3. {
   9 }7 a+ a5 Z! T, D: j% _
4.         if(GPIO_Pin==KEY0_Pin)
   ( L& _  z$ l5 C0 A8 R! s
5.         {
   9 B$ [' q# b; V/ L$ L6 ]
6.                 static uint32_t key0_count = 0;
   ' _1 M& r+ t0 x. Y! x: ]
7.                 printf("this is %lu count for HAL_GPIO_EXTI_Callback!\r\n",key0_count++);
   
8.                 Toggle_led0();//LED0等状态反转一次
   
9.         }
   3 Y: t3 s+ w3 }. n- I
10. }
    
11. 
    
12. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
13. {
    
14.         if(htim==&htim2)
    9 u: s) j* d! \& L! F5 B# j
15.         {
    1 P0 |  g3 t; E% Y
16.                 static uint32_t key1_count = 0;
    
17.                 printf("this is %lu count for HAL_TIM_PeriodElapsedCallback!\r\n",key1_count++);
    5 E" ~  s% E9 K
18.                 Toggle_led1();//LED1等状态反转一次
    
19.         }
    5 w8 e! C2 Y* D! m
20.         if(htim ==&htim3)//判断是否是定时器3中断（定时器到时表示一组字符串接收结束）
    
21.     {
    $ q' I8 @3 _5 y! j9 a! k
22.                 HLPUSART_RX_BUF[HLPUSART_RX_STA&0X0FFF]=0;//添加结束符
    9 J" Y5 x2 b, a. q& o0 R
23.                 HLPUSART_RX_STA|=0x8000;//接收标志位最高位置1表示接收完成
    
24.                 __HAL_TIM_CLEAR_FLAG(&htim3,TIM_EVENTSOURCE_UPDATE );//清除TIM3更新中断标志
    + b5 Q! t" p- o+ j1 M5 G
25.                 __HAL_TIM_DISABLE(&htim3);//关闭定时器3
    ! L2 {+ N9 _0 F+ z4 t
26.     }
    . T* u" m. X! e" G
27. }
    8 y# M$ V5 P* Q% P/ v
28. /* USER CODE END 0 */

复制代码

$ I; l7 [( A0 O9 n& u9 r         同时在usart.h增加对TIM3的引入
3 d2 ]: [) a6 `0 J3 j

1. #ifndef INC_USART_H_
     H1 I1 p  n  M1 e) i5 B$ k: I
2. #define INC_USART_H_
   
3. 
   8 }  r. C: [: T" L( t3 Y; ~
4. #include "stm32l4xx_hal.h" //HAL库文件声明
   
5. #include <string.h>//用于字符串处理的库
   , h7 }1 m5 k" F# V# t
6. #include "../print/print.h"//用于printf函数串口重映射
   ! o6 `; B- ?8 o6 C- V5 r
7. 
   
8. extern TIM_HandleTypeDef htim3;        //定时器3辅助串口接收数据
   , z7 J2 C$ {1 U! ]& z0 C
9. 
   
10. extern UART_HandleTypeDef hlpuart1;//声明LPUSART的HAL库结构体
    
11. 
    
12. #define HLPUSART_REC_LEN  256//定义LPUSART最大接收字节数
    ; q9 [% ?) N$ f" O/ e3 K, l
13. 
    
14. extern uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
    - [, b9 E  ^2 L4 J0 w) V& @
15. extern uint16_t HLPUSART_RX_STA;//接收状态标记
    0 N; M& u  c4 V' z. W! s
16. extern uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    " \  w8 d1 I( ?
17. 
    6 j3 r( Y' n% B' S' ~9 B3 \
18. 
    ( P5 C8 B8 C4 N* W/ R
19. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    
20. 
    5 g* J/ U* I# _& t- D0 h9 {& D
21. #endif /* INC_USART_H_ */

复制代码

        在usart.c中串口回调函数的lpuart1接收实现方式，通过htim3(TIM3)计数周期通知来告知lpuart1结束数据接收。

1. #include "usart.h"
   
2. 
   
3. uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
   4 Z) D) h# }  V( S% q0 e3 o
4. /*
   8 ]! @% K/ S. R6 l! g
5. * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
   
6. * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
   4 I: T5 q. F% H; z9 ]0 c. s
7. * bit13:预留
   7 T& A9 J$ ?8 S/ H
8. * bit12:预留
   7 s! p" o% D7 E
9. * bit11~0：接收到的有效字节数目(0~4095)
   2 h5 F5 e$ Z: k% i
10. */
    , v) k- D( L- W6 H
11. uint16_t HLPUSART_RX_STA=0;接收状态标记//bit15：接收完成标志，bit14：接收到回车(0x0d)，bit13~0：接收到的有效字节数目
    
12. uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    
13. 
    
14. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    / R0 j4 k9 t# H
15. {
    5 X6 ]2 p; n( G
16. //        if(huart ==&hlpuart1)//判断中断来源（串口1：USB转串口）
    
17. //    {
    # u( F6 R6 N! S+ \' }
18. //                if(HLPUSART_NewData==0x0d){//回车标记
    
19. //               HLPUSART_RX_STA|=0x8000;//标记接到回车
    ! l% y- V' q1 w5 n. k' U/ u
20. //                }else{
    
21. //                        if((HLPUSART_RX_STA&0X0FFF)<HLPUSART_REC_LEN){
    " |& ?: j' k# W7 l$ L! V
22. //                                HLPUSART_RX_BUF[HLPUSART_RX_STA&0X0FFF]=HLPUSART_NewData; //将收到的数据放入数组
    ( B+ k! t0 L6 F* n) p
23. //                                HLPUSART_RX_STA++;  //数据长度计数加1
    - [1 ?3 P/ D: t# d9 D9 }+ e" P5 G
24. //                        }else{
    
25. //                                HLPUSART_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    
26. //                        }
    ) q/ r" |! d8 r$ U! R& @& r
27. //        }
    * q* G' d3 L$ h, W
28. //       HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData,1); //再开启接收中断
    ' N4 g, j! U/ i( @$ u/ A7 i9 n
29. //    }
    + |% e. n# ]6 |/ d/ s
30.     //调整,通过htim3计数来通知接收数据结束
    
31.         if(huart ==&hlpuart1)//判断中断来源（串口lpuart1）//接收完的一批数据,还没有被处理,则不再接收其他数据
    5 h9 i% A' {& q4 [% Z7 w, }: i
32.         {
    
33.                 if(HLPUSART_RX_STA<HLPUSART_REC_LEN)//还可以接收数据
    
34.                 {
    , L) p2 {  @1 T$ |, Q0 N
35.                         __HAL_TIM_SET_COUNTER(&htim3,0); //计数器清空
    9 G) Y1 R! b- Q& Y5 l" F
36.                         if(HLPUSART_RX_STA==0) //使能定时器2的中断
    
37.                         {
    
38.                                 __HAL_TIM_ENABLE(&htim3); //使能定时器3
    
39.                         }
    
40.                         HLPUSART_RX_BUF[HLPUSART_RX_STA++] = HLPUSART_NewData;//最新接收数据放入数组
    / \1 ^6 G) H7 Z2 n* y& M
41.                 }else
    , U, j; ?4 a% s( p$ L5 V' x
42.                 {
    
43.                         HLPUSART_RX_STA|=0x8000;//强制标记接收完成
    & E. _+ i% q. L$ y/ j
44.                 }
    3 W, l0 b3 T( K/ g: y/ r- `
45. 
    
46.                 HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData,1); //再开启串口1接收中断
    9 ]0 b4 Q& L8 a! p" e2 H8 s" r3 }
47.         }
    / T, a# ~% m# U0 R0 Z
48. }

复制代码

- w/ E& Z- D' d! j9 C! z' J        4.4 TIM4定时器支持PWM输出功能实现
! n* n" U$ @/ M; w" K        TIM4定时器已经开启了通道4，向LED2（PD15）交替输出递减电压实现LED灯状态由亮变暗直至熄灭的循环，首选需要通过HAL_TIM_PWM_Start开启PWM功能，然后通过__HAL_TIM_SetCompare来设置占空比来实现输出信号调节。

        PWM输出工作过程：若配置脉冲计数器TIMx_CNT为向上计数，而重载寄存器TIMx_ARR被配置为N，即TIMx_CNT的当前计数值数值X在TIMxCLK时钟源的驱动下不断累加，当TIMx_CNT的数值X（对应下面代码的a）大于N（对应cubeMX配置的ARR值，即99）时，会重置TIMx_CNT数值为0重新计数 。

1. HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_4);
   3 I. q+ A4 t% s. J8 Y4 I; S! |- M
2. uint8_t a = ;
   
3. while(1){
   
4.     __HAL_TIM_SetCompare(&htim4,TIM_CHANNEL_4,a);
   
5.           a++;//占空比值加1
   
6.           if(a>=99)a=0;
   + _. p1 G- W( p( z  h# @
7.     HAL_Delay(10);
   , u" X, f# q+ w9 A( p- g; S
8. }

复制代码

& ^5 R4 \3 p! I; D" P% Z* H          4.5 功能调用及实现
5 N/ s! I$ T& y" v) x) R        在main.c函数中，初始化及启动TIM定时器
7 o, ?7 h. z) }, K  p" J+ Z6 A

1.   /* USER CODE BEGIN 2 */
   ) e1 h( \1 O: [& m. L/ ^
2.   ResetPrintInit(&hlpuart1);
   7 `5 l* {3 Q( l! o' M
3.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
   
4.   HLPUSART_RX_STA = 0;
   
5.   HAL_TIM_Base_Start_IT(&htim2);//开启定时器2中断（必须开启才能进入中断处理回调函数）
   
6.   HAL_TIM_Base_Start_IT(&htim3);//开启定时器3中断（必须开启才能进入中断处理回调函数）,辅助lpuart1接收数据
   
7.   HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_4);
   
8.   uint8_t memu = 0;    //用来标记按键KEY2按下,来开启或关闭TIM4的PWM功能
   7 G" r, m7 \' i  c1 {6 h: |
9.   uint16_t a = 0;      //占空比值
   
10.   /* USER CODE END 2 */

复制代码

4 K0 q5 l( Z0 ^        在main函数循环中，实现如下：

1. /* USER CODE BEGIN WHILE */
   
2.   while (1)
   - v& `. q5 l) s
3.   {
   . Y% @6 T4 n1 r% N4 [* i
4.           if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
   
5.                     printf("receive:%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
   
6.                     HLPUSART_RX_STA=0;//接收错误,重新开始
   - i: b9 u+ X# L$ ~* v
7.                     HAL_Delay(100);//等待
   
8.             }
   
9.             if(KEY_1())
   
10.           {
    ! T3 z  [, }3 E
11.           }
    
12.             if(KEY_2())
    5 U8 a9 e$ }  @8 Q: b$ Z
13.           {
    
14.                     memu=!memu;
    / S+ a( j) o3 J; v" r
15.                     printf("TIM4_PWM is runing!\r\n");
    
16.           }
    
17.             if(memu)
    ' K, }2 f5 S+ y* _
18.             {
    
19.                     __HAL_TIM_SetCompare(&htim4,TIM_CHANNEL_4,a);
    ' B, j( k4 S% `* c0 k5 y) t
20.                     a++;//占空比值加1
    " z1 t0 _1 w# @5 F9 W- B, |
21.                     if(a>=99)
    2 d5 s. v) i% [5 X8 O' A  P
22.                     {
    / [# S; I$ ~+ G- y4 i3 y5 H% e+ U/ u
23.                             printf("TIM4_PWM finish cycle!\r\n");
    
24.                             a=0;
    
25.                     }
    5 G7 q% `0 L: J$ a& ?+ i* y
26.                     HAL_Delay(10);//等待
    . w6 l* U1 ^( B' l% ^  _0 p
27.             }
    
28.     /* USER CODE END WHILE */

复制代码

; E: c! @. T/ k9 N! Y( q( C* }五、编译及测试
- ^7 n' z# N9 r5 h9 {3 G2 P        5.1 编译程序及下载
/ P' Y6 B) j! R) c: C( c( T3 V
4 z) g3 i9 H- R' X% E2 B
* Q. c  k% b# Z9 ?: C, h; D# ]8 S' w

         5.2 测试
1 j; Y+ t# t3 {( B0 k        【1】测试log输出
' X1 k) x* N/ j% q& [* m


% _: P! H* w4 V4 l         【2】注释掉相关打印输出，测试lpuart1输入数据无回车时（lpuart1的HAL_UART_Receive_IT调用后，TIM3每100毫秒通知其结束接收），能成功收到返回数据，如下图。


! x8 c3 s2 Z- S) i

' t2 ~& t/ p4 `4 v5 d         【3】LED等状态情况
/ ~% \: M7 K2 E        按键KEY0顺利切换LED0的状态，LED1灯周期切换状态（TIM2），按键KEY2开启TIM4的PWM输出功能，LED2灯周期由亮到灭切换状态（TIM4）。
————————————————
& m7 E: t# [2 H! J版权声明：py_free-物联智能
$ Z7 X- y5 O3 @5 b; C* h如有侵权请联系删除
5 ^1 F0 ?0 W! B: G* g' m$ K: |, R

6 s* l- N5 m- o& O, V* T