一、定时器功能
         1.1 定时器分类
- V3 Q; K! K/ v) K4 c5 H. t        STM32 的定时器分为高级定时器、 通用定时器 、基本定时器三种。

: K7 j  R  J5 g; ?. t: M6 V" l        这三个定时器成上下级的关系，即基本定时器有的功能通用定时器都有，而且还增加了向下、向上/向下计数器、PWM生成、输出比较、输入捕获等功能；而高级定时器又包含了通用定时器的所有功能，另外还增加了死区互补输出、刹车信号。

( M; Z) y( |$ B( n        例如本文采用的STM32L496VGT6芯片中，高级定时器（TIM1、TIM8）、 通用定时器（TIM2、TIM3、TIM4、TIM5、TIM15，另外TIM5、TIM15亦有些许差异） 、基本定时器（TIM6、TIM7、TIM16、TIM17），高级定时器、 通用定时器 、基本定时器在STM32CubeMX配置界面中是不一样的：
$ `& G4 ~) H( {
* C& A% Q& ~/ t  }1 ^. j9 ~        高级定时器（TIM1）：

$ a4 o1 o( O# ~3 F2 d
2 I# ?, ~! @: C# e- t$ r
. u* f. n1 h4 Z& U/ n, `+ M" ^( t        通用定时器（TIM2）：

" a! J! B' j2 U7 P) q* Q0 r

        或通用定时器（TIM5）：

9 [' W- F1 Y* Y% D! h& [

         基本定时器（TIM6）：
1 n* f0 l+ Q7 ~( Z& M6 x
  p' v% d; c' Q
  x4 u% r8 {5 N: ]
         在通用定时器，每个定时器都有一个16位的自动加载递增/递减计数器，一个16位的预分频器和4个独立通道，每个通道可用于输入捕获、输出比较、PWM和单脉冲模式输出。而TIM1、TIM8高级定时，其通道更是支持到6个通道，在一些高级芯片中支持到的通道会更多。

5 |4 G& k: B( F7 _8 M        每个定时器都支持外部中断机制，还可以结合计数功能或时钟功能，实现轮询策略；每个定时器也支持独立的DMA请求机制。

$ ^0 G4 r+ m. I' X        通用定时器可以利用GPIO引脚进行脉冲输出，在配置为比较输出、PWM输出功能时，捕获/比较寄存器TIMx_CCR被用作比较功能。

: H( u4 Q$ D' B& s/ D
        1.2 定时时间计算
        定时器输出时间间隔(us)=(分频系数+1)*(计数周期+1)÷输入定时器时钟频率(MHz,APB*)，如下图所示。
0 V) V6 V  d% l* q
& m  ?6 Y. g# E( w- _, V$ i% R
' w$ d2 M# C1 L' @" }; G
/ P& d8 f& w4 `- D; J3 C3 X5 S- G/ y
( B, e2 W" M4 _% H9 A         1.3 中断功能
4 r5 H4 B) V0 W8 \, M) D        通常STM32芯片支持所有GPIO设置为外部中断输入，外部IO可以由电平上升、电平下降、高低电平三种方式的中断触发或事件触发。定时器作为外设之一，同样支持到外部中断或事件触发。

8 B& \4 G9 A7 I! F* M7 n2 Q/ H

: N7 i7 W$ X3 m8 a. q# I6 c( c
" S9 G- Z# [% a9 R2 t- {* {% ]二、工程创建及配置
        2.1 cubeMX图形配置
        本文基于STM32L496VGT6芯片创建工程，创建时钟、开启lpuart1串口，以及三个LED灯和按键KEY，配置如下：
( N. Y+ l( X9 y
        【1】系统配置
5 z4 \2 Z0 h$ I


         【2】RCC功能开启外部高速时钟（默认参数配置）及时钟树设置


7 g. k4 t1 t0 y- X
         时钟树设置，STM32L496VGT6支持最大输出频率80MHz，本文直接拉满



         【3】lpuart1串口开启
' `2 ~# M- j9 i; r: q4 [0 I5 G6 z
8 H. K: R5 ]2 w- J; \

* x( c6 l6 R& X9 l0 `: N         开启lpuart1中断功能及按开发板引脚说明调整引脚：

. m5 Z' @; w0 ]

         【4】配置三个按键及LED


" u  v* ]' ~- c1 O; u
! C& P7 f* {$ T9 E. r6 ~; E$ @         完成基本配置后，生成输出代码（每个外设独立的.h/.c文件）

        2.2 代码设计
        【1】禁用syscalls.c源文件
" t1 S8 Z9 N# s1 a& Q

7 o" A/ c+ Y% Z+ @4 x
! b& {4 k$ R1 |         【2】在工程目录下，创建源文件夹ICore文件目录，



         【2】并在ICore目录下创建led、key、print、usart目录。
% Y; u. l4 g' ]+ K


         【3】在print目录创建print.h和print.c源文件，将用来实现将printf标准函数输出映射到lpuart1串口的驱动程序。
# Q$ F) m5 h5 Z5 V9 R" }" q
        print.h

1. #ifndef INC_RETARGET_H_
   1 K# A  q  a- g) h
2. #define INC_RETARGET_H_
   
3. 
   * ?+ Y3 P; C) p4 u1 I4 p
4. #include "stm32l4xx_hal.h"
   
5. #include "stdio.h"//用于printf函数串口重映射
   7 z3 e* F- V7 D& z* E' c* Y
6. #include <sys/stat.h>
   8 `7 I3 ]4 K' q- ^2 r/ n
7. 
   + T8 [6 H# I, `, I1 Y
8. void ResetPrintInit(UART_HandleTypeDef  *huart);
   + ?, U% c- B+ L
9. 
   
10. int _isatty(int fd);
    5 V+ A5 ]- a" P; p) G" Q  U' t
11. int _write(int fd, char* ptr, int len);
    , F9 P8 }" k0 E6 P; d
12. int _close(int fd);
    ' `7 m7 v6 l6 W* ~
13. int _lseek(int fd, int ptr, int dir);
    
14. int _read(int fd, char* ptr, int len);
    ; C4 ^5 a5 T3 k, D" \2 _
15. int _fstat(int fd, struct stat* st);
    3 S- C- r% b  N
16. 
    
17. #endif /* INC_RETARGET_H_ */

复制代码

         print.c

1. #include <_ansi.h>
   * S$ u" d" T7 y- W
2. #include <_syslist.h>
   
3. #include <errno.h>
   ) y* {2 G( E$ K( x
4. #include <sys/time.h>
   
5. #include <sys/times.h>
   : T9 G4 _0 l+ g& {4 a
6. #include <limits.h>
   
7. #include <signal.h>
   3 ~3 _2 o6 z* l1 c1 P# [
8. #include <stdint.h>
   
9. #include <stdio.h>
   2 Q  E: E8 \: N# J0 Z
10. 
    
11. #include "print.h"
    ; m( o+ e" X6 S9 ?: L
12. 
    
13. #if !defined(OS_USE_SEMIHOSTING)
    ! i) E9 R  n3 f
14. #define STDIN_FILENO  0
    
15. #define STDOUT_FILENO 1
    ( Z  ]: w# ^( w& s( w6 |' ]3 k
16. #define STDERR_FILENO 2
    6 I0 Q) v4 C% ?& W' F
17. 
    6 r! f, f6 h/ ?9 N4 d& `; X& D
18. UART_HandleTypeDef *gHuart;
    
19. 
    4 c1 T3 q6 ^- m3 Q: A6 P  {% b1 J
20. void ResetPrintInit(UART_HandleTypeDef *huart)  {
    
21.   gHuart = huart;
    
22.   /* Disable I/O buffering for STDOUT  stream, so that
    
23.    * chars are sent out as soon as they are  printed. */
    
24.   setvbuf(stdout, NULL, _IONBF, 0);
    7 Y+ P7 n% B' D
25. }
    
26. int _isatty(int fd) {
    3 s+ y# g5 p' a# X- m
27.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    
28.     return 1;
    
29.   errno = EBADF;
    
30.   return 0;
    4 n7 R, S7 e1 }( v1 D
31. }
      m  A8 k- b7 S+ z( C- r; M1 \0 c
32. int _write(int fd, char* ptr, int len) {
    6 z' U2 Q8 y  l$ c7 w5 ?7 E; W8 t  O
33.   HAL_StatusTypeDef hstatus;
    
34.   if (fd == STDOUT_FILENO || fd ==  STDERR_FILENO) {
    
35.     hstatus = HAL_UART_Transmit(gHuart,  (uint8_t *) ptr, len, HAL_MAX_DELAY);
    7 x) A, a1 C3 C! G+ u; M* E' f
36.     if (hstatus == HAL_OK)
    
37.       return len;
    * m6 B( M( i& @- r& d- I
38.     else
    4 P8 n3 S$ S% n) a
39.       return EIO;
    8 q6 f9 R) |: q! [
40.   }
    
41.   errno = EBADF;
    
42.   return -1;
    4 V; [5 J. P# l% P+ l; t( R
43. }
    . S' S, g' v; B$ g. ]- b& V
44. int _close(int fd) {
      g$ B! i" t. m- }6 ^# w
45.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO)
    % U- s3 t6 t% N! J! J  g
46.     return 0;
    
47.   errno = EBADF;
    
48.   return -1;
    
49. }
    
50. int _lseek(int fd, int ptr, int dir) {
    
51.   (void) fd;
    2 x0 H. K, _6 O3 N' r5 C
52.   (void) ptr;
    + k9 i2 y: }* U( v' I- ]3 }' j
53.   (void) dir;
    
54.   errno = EBADF;
    / U6 B7 [& j6 `
55.   return -1;
    
56. }
    ' F5 l' c$ P5 o0 L6 @8 g! V
57. int _read(int fd, char* ptr, int len) {
    4 S2 q# ?; H/ Q. Q
58.   HAL_StatusTypeDef hstatus;
    7 y! I8 F  ?+ t& D
59.   if (fd == STDIN_FILENO) {
      q! b, V" E0 u" L
60.     hstatus = HAL_UART_Receive(gHuart,  (uint8_t *) ptr, 1, HAL_MAX_DELAY);
    
61.     if (hstatus == HAL_OK)
    4 k6 b9 X3 l  S& q
62.       return 1;
    
63.     else
    
64.       return EIO;
    
65.   }
    
66.   errno = EBADF;
      |+ \4 Y. U1 J( E; d6 I$ a! S
67.   return -1;
    
68. }
    * x. f9 p. ?2 l- I4 e0 `
69. int _fstat(int fd, struct stat* st) {
    ' u8 v1 D( @0 e9 X
70.   if (fd >= STDIN_FILENO && fd <=  STDERR_FILENO) {
      V, m; X( T# z1 i1 S" G7 J) H
71.     st->st_mode = S_IFCHR;
    $ `- `( e7 e: W: m
72.     return 0;
    % {0 E( _4 |! A& L6 K
73.   }
    
74.   errno = EBADF;
    , H( I% Q5 H' @1 g4 w
75.   return 0;
    * M+ W) E4 Y! {' ?/ h- m
76. }
    
77. 
    * T5 C% q% }( w0 y, W
78. #endif //#if !defined(OS_USE_SEMIHOSTING)

复制代码

/ C. u- N1 G! v        【3】在led目录创建led.h和led.c源文件，将用来实现LED等状态控制的驱动程序。
        led.h
! J2 i! @  i# }+ z0 E! @, A

1. #ifndef LED_H_
   
2. #define LED_H_
   
3. #include "main.h"
   9 F: U: h2 d  V4 Y! B1 t9 [
4. #include "gpio.h"
   
5. 
   & S7 D. I% Y) |( ^6 M4 p7 L% }+ P
6. void Toggle_led0();
   4 x. T3 A5 I) y" ~) ?* {% B, u
7. void Toggle_led1();
   
8. void Toggle_led2();
   2 J4 Y6 |% `7 |4 f2 B& O) A
9. 
   
10. void set_led0_val(GPIO_PinState PinState);
    
11. void set_led1_val(GPIO_PinState PinState);
    
12. void set_led2_val(GPIO_PinState PinState);
      \" y& M$ F4 }/ o) X9 Q
13. 
    
14. #endif /* LED_H_ */

复制代码

        led.c

1. #include "led.h"
   , A9 }- Q% ]2 X" v( h( s) t! m
2. 
   ! J/ W0 L6 [# D/ m# }
3. void Toggle_led0()
   
4. {
   9 h; Z' Z! N: p
5.         HAL_GPIO_TogglePin(LED0_GPIO_Port,LED0_Pin);
   2 z. P! U# o: }& ]& ?( h, N; _. C
6. }
   9 _9 K7 s! p, c; y0 ^, P! s
7. 
   / q% y5 s2 ]) }8 R3 L
8. void Toggle_led1()
   
9. {
   , v$ y! s; u$ Z: r! R: W  E* v0 S
10.         HAL_GPIO_TogglePin(LED1_GPIO_Port,LED1_Pin);
    
11. }
    / ^3 D+ Z! R; k0 C
12. 
    
13. void Toggle_led2()
    " L+ q% P% p! F! o, p
14. {
    
15.         HAL_GPIO_TogglePin(LED2_GPIO_Port,LED2_Pin);
    + S4 _% m& z6 l4 g" E7 E) u. U/ E6 j
16. }
    4 c: l% {' R% x: d4 o
17. 
    $ ]" D" B4 |' y$ K2 R) h& q; S! i
18. void set_led0_val(GPIO_PinState PinState)
    
19. {
    * q* q5 |2 R9 o/ J0 {( j
20.         HAL_GPIO_WritePin(LED0_GPIO_Port,LED0_Pin,PinState);
    % p1 X" h% R' z6 J; F
21. };
    9 D( ~# X2 I: {
22. 
    2 M( ^6 ]  d4 }1 O+ [! z
23. void set_led1_val(GPIO_PinState PinState)
    : d6 Y! b7 ]! y; W' R* `
24. {
    0 q2 V- T. a' ]/ Y
25.         HAL_GPIO_WritePin(LED1_GPIO_Port,LED1_Pin,PinState);
    ; x# F. t5 [6 r( B& L  ~1 F
26. };
    & @3 o6 v0 r3 J
27. 
    % W( E5 _2 y# J/ F
28. void set_led2_val(GPIO_PinState PinState)
    * f1 T3 F) C' z) t
29. {
    
30.         HAL_GPIO_WritePin(LED2_GPIO_Port,LED2_Pin,PinState);
    
31. };

复制代码

: ]$ ~( @! r! L* q6 m4 z1 _. ~        【4】在key目录创建key.h和key.c源文件，将用来实现KEY控制的驱动程序。

        key.h

1. #ifndef KEY_H_
   
2. #define KEY_H_
   4 c( _, c9 G& f: l( H4 e
3. 
   ) A* m! d) I) [* O* m8 w
4. #include "main.h"
   
5. #include "gpio.h"
   4 h) j1 }4 M- S9 \
6. 
   
7. GPIO_PinState get_key0_val();
   ; {: X- X6 j! u( d
8. GPIO_PinState get_key1_val();
   
9. GPIO_PinState get_key2_val();
   9 N, t/ S& k: I: g2 P) E
10. 
    - l( k* ?2 `1 @6 o
11. uint8_t KEY_0(void);
    % l% m& `, q6 r8 `/ B) l( H
12. uint8_t KEY_1(void);
    : @: J/ |! {3 g: l& C
13. uint8_t KEY_2(void);
    
14. 
    
15. #endif /* KEY_H_ */

复制代码

        key.c

1. #include "key.h"
   $ |& H0 N6 E- i" E, S
2. 
   
3. GPIO_PinState get_key0_val()
   " _; P* C4 j; U8 l& `6 }# [6 m5 k4 O
4. {
   
5.         return HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin);
   , W; {" x1 h2 }
6. };
   
7. 
   
8. GPIO_PinState get_key1_val()
   . z" t5 n8 V) v1 y
9. {
   " K) d3 T, r& X6 p( B
10.         return HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin);
    0 Z( H: n5 P6 y* R1 Z. a
11. };
    
12. 
    6 b% t& T5 {: i; B% R  O
13. GPIO_PinState get_key2_val()
    
14. {
    : e1 c% W& Q' [; L' V6 ]
15.         return HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin);
    , C2 t: E* @5 w# P( d) |  G: {
16. };
    % U2 ?1 U) z' Y2 |, s) q
17. 
    8 d( Q5 Z9 \8 N
18. uint8_t KEY_0(void)
    
19. {
    
20.         uint8_t a;
    % G; L/ ?% _1 l
21.         a=0;//如果未进入按键处理，则返回0
    
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){ //读按键接口的电平
    8 N; Y( ^% X4 f3 [
25.                         a=1;//进入按键处理，返回1
    % l# k" A  C, e  p3 O
26.                 }
    
27.         }
    ) X. Y% |0 J. Y' n
28.         while(HAL_GPIO_ReadPin(KEY0_GPIO_Port,KEY0_Pin)==GPIO_PIN_RESET); //等待按键松开
    
29.         return a;
    
30. }
      y. x- U% A; A. Y0 {- ~
31. 
    
32. uint8_t KEY_1(void)
    
33. {
    - d% D; X* _5 ]6 ?0 {; U8 {3 e
34.         uint8_t a;
    
35.         a=0;//如果未进入按键处理，则返回0
    
36.         if(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    
37.                 HAL_Delay(20);//延时去抖动
    6 O/ x4 [+ G) ?  _3 D
38.                 if(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    " N) K8 n" ^% w/ {
39.                         a=1;//进入按键处理，返回1
    * a0 U! ?: d' E, w" S" H
40.                 }
    
41.         }
    / U& X, P) E$ V  _3 J/ S
42.         while(HAL_GPIO_ReadPin(KEY1_GPIO_Port,KEY1_Pin)==GPIO_PIN_RESET); //等待按键松开
    
43.         return a;
    - H7 k; D, Y: i$ D; T7 n
44. }
    ( I# C6 A4 f8 j7 i+ x
45. 
    
46. uint8_t KEY_2(void)
    ! |5 w* g) n4 V' u- q' Y" s
47. {
    # h( ~" P7 a: g
48.         uint8_t a;
    ; x1 u5 H* L' G
49.         a=0;//如果未进入按键处理，则返回0
    " q* c. S% D& x# l" q( }( w2 W
50.         if(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET){//读按键接口的电平
    . i" V3 N$ O. x) V( B
51.                 HAL_Delay(20);//延时去抖动
    
52.                 if(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET){ //读按键接口的电平
    
53.                         a=1;//进入按键处理，返回1
    
54.                 }
    % ~# w8 V9 U# f6 e( p% [5 s" r
55.         }
    ! k4 l( a% U$ W9 W( b( z5 g
56.         while(HAL_GPIO_ReadPin(KEY2_GPIO_Port,KEY2_Pin)==GPIO_PIN_RESET); //等待按键松开
    ; f/ U" W# n6 O' l$ C
57.         return a;
    
58. }

复制代码

        【4】在usart目录创建usart.h和usart.c源文件，将用来实现lpuart1驱动程序。
% K5 W3 R/ ]$ f0 O- M7 X2 I1 M        usart.h
$ R- b3 G. z+ G% f% T' \

1. #ifndef INC_USART_H_
   + O% H) _; {* U' Z% {6 \  b
2. #define INC_USART_H_
   : q7 [$ d3 Y4 ]' c/ r9 t  }7 c: P0 W& }7 z
3. 
   
4. #include "stm32l4xx_hal.h" //HAL库文件声明
   . b$ ^1 [! D$ v4 s$ n7 v
5. #include <string.h>//用于字符串处理的库
   7 A7 n6 w. n5 {1 D4 [
6. #include "../print/print.h"//用于printf函数串口重映射
   
7. 
   
8. extern UART_HandleTypeDef hlpuart1;//声明LPUSART的HAL库结构体
   
9. 
   
10. #define HLPUSART_REC_LEN  256//定义LPUSART最大接收字节数
    " m( U/ g/ {- l! T
11. 
    . r4 F1 N' g# H7 J
12. extern uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
    5 c- H% j8 i1 r% u
13. extern uint16_t HLPUSART_RX_STA;//接收状态标记
    1 ^/ j* Y% L0 O( d2 O: H* s
14. extern uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    
15. 
    + W) X2 X. w0 i* ~# Y2 V3 D9 a7 R
16. 
    
17. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    ' g0 v1 \5 e# }8 y( P
18. 
    ; f  t+ {+ v  k- |( z5 m1 ~. b4 b
19. #endif /* INC_USART_H_ */

复制代码

        usart.c
- {- q/ [& \8 {3 a4 X) }( G" N

1. #include "usart.h"
   , K" R+ e) @& Z# m
2. 
   
3. uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
   
4. /*
   5 p& z. k! a5 ~" E4 G7 }
5. * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
   
6. * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
   
7. * bit13:预留
   
8. * bit12:预留
   
9. * bit11~0：接收到的有效字节数目(0~4095)
   ) i3 |! a/ D8 v9 B  ?
10. */
    
11. uint16_t HLPUSART_RX_STA=0;接收状态标记//bit15：接收完成标志，bit14：接收到回车(0x0d)，bit13~0：接收到的有效字节数目
    9 J  v2 l1 Y: g7 j3 B% R3 x
12. uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    
13. 
    & K4 x) Q4 K9 b/ k2 D( p# `
14. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    + [& W: g0 p' b* ~/ E
15. {
    
16.         if(huart ==&hlpuart1)//判断中断来源（串口1：USB转串口）
    
17.     {
    
18.                 if(HLPUSART_NewData==0x0d){//回车标记
    
19.                HLPUSART_RX_STA|=0x8000;//标记接到回车
    ( p( {2 F+ j+ `' B& Z
20.                 }else{
    # l/ {7 A) m) o9 z
21.                         if((HLPUSART_RX_STA&0X0FFF)<HLPUSART_REC_LEN){
    
22.                                 HLPUSART_RX_BUF[HLPUSART_RX_STA&0X0FFF]=HLPUSART_NewData; //将收到的数据放入数组
    
23.                                 HLPUSART_RX_STA++;  //数据长度计数加1
    - P' e8 [! B1 n" z! i5 k( u
24.                         }else{
    ( d- P, N* K' O7 K7 f  l
25.                                 HLPUSART_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    
26.                         }
    % R% n, f, A+ H& O- {
27.         }
    
28.        HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData,1); //再开启接收中断
    ( J2 |+ E" z+ G/ L, {9 U
29.     }
    ) _+ p( M; ~  p0 z: }
30. }

复制代码

        【5】在main.c文件中加入各驱动文件的头文件

1. /* USER CODE BEGIN Includes */
   
2. #include "../../ICore/key/key.h"
   ! t. x. D2 [: I+ u6 i/ j
3. #include "../../ICore/led/led.h"
   ; e0 H( o9 }( M' P& q
4. #include "../../ICore/print/print.h"
   
5. #include "../../ICore/usart/usart.h"
   
6. /* USER CODE END Includes */

复制代码

        在主函数中，初始化lpuart1
* ~9 F1 H1 p3 H9 S

1.   /* USER CODE BEGIN 2 */
   
2.   ResetPrintInit(&hlpuart1);
   
3.   HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData, 1); //再开启接收中断
   * i1 w' o0 Z, d& u5 D6 G
4.   HLPUSART_RX_STA = 0;
   
5.   /* USER CODE END 2 */

复制代码

' P' j4 s3 p! }; {        在主函数循环体中，实现lpuart1输入返回测试及按键时LED灯状态反转。

1. /* USER CODE BEGIN WHILE */
   
2.   while (1)
   
3.   {
   3 J* ]1 v; L! r# Q' a! L$ }
4.           if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
   
5.                     printf("receive:%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
   
6.                     HLPUSART_RX_STA=0;//接收错误,重新开始
   ; l- [" e& b* U. K' l- s) i: s
7.                     HAL_Delay(100);//等待
   
8.             }
   
9.       if(KEY_0())
   
10.           {
    
11.         Toggle_led0();//LED0等状态反转一次
      U; u9 ?/ u) K! d) t
12.           }
    9 q/ ]! E2 C4 q2 P7 G% ]# ~; v6 {
13.             if(KEY_1())
    
14.           {
    
15.         Toggle_led1();//LED1等状态反转一次
    
16.           }
    1 M2 s8 w3 S3 x  \" E
17.             if(KEY_2())
    , q; x5 `1 [" G+ `3 i) x
18.           {
    , S" w, l2 O! }4 \
19.                     Toggle_led2();//LED2等状态反转一次
    
20.           }
    
21.     /* USER CODE END WHILE */

复制代码

5 i5 ?$ b- v! {- {4 `, W3 i        【6】配置输出文件格式支持，然后编译代码


) p" B: h- k# y3 T8 E
        【7】配置调试及下载支持
& U% I2 z9 U# p
3 a( ]( h. U- b" j! R; _

         运行下载烧写程序到开发板，完成基本功能开发。


0 G9 V, ^0 G' `三、添加定时器及中断功能
+ s- D  L! z- {$ V$ T4 C# D) f        3.1 GPIO外设中断
1 o& Q( Q. ], K7 N6 W6 O        打开.ioc进入cubeMX配置界面，将KEY0按钮调整为GPIO_EXTI类型
9 n/ B0 {' C$ Z, g
. E3 M) l6 v, G8 ~# Q6 g6 _5 A
% r) v. U0 c/ F/ a$ i$ P
        并开启KEY0（PE11）的中断支持

6 ?( \$ W' X# c# Q- M+ P

         3.2 TIM2通用定时器，轮询
        添加TIM2通用定时器功能实现定时轮询功能
/ \6 E8 C! t; n; v8 U, x' s

' {( B  p* j- W
7 L5 T( \' V0 o+ A         并开启 TIM2的中断功能

  y1 d5 f' _8 Q9 u- j
1 {2 g1 r4 g2 ~* t( n$ T
         3.3 TIM3通用定时器，辅助lpuart1通信
5 o; B1 t, T3 l5 U' F) D9 p        添加TIM3通用定时器功能实现间隔计时，辅助lpuart1串口在没有结束标记情况下实现超时（100ms）通知

( y8 @! t- I  j# Y9 {1 v
: W( ?0 G- R% Z! i
         并开启TIM3的中断功能支持
1 Z5 c, O% ~1 W) }' x
' G6 P' I5 i) p3 b% X( L$ [$ p

- P' V, K, C& P  L6 j- L+ A5 B
         3.4  TIM4通用定时器，PWM输出
        添加TIM4通用定时器功能，开启其通道4对PWM输出功能支持，将KEY2（PD15）调整为TIM_CH4类型。PWM是定时器扩展出来的一个功能(本质上是使用一个比较计数器的功能)，配置过程一般为选定定时器、复用GPIO口、选择通道(传入比较值)、使能相应系统时钟、设定相应的预分频、计数周期、PWM模式(有两种)、电平极性等。


; ^% H/ e4 Q, W
7 \( |; x" y. f5 E        并开启TIM4的中断功能支持
3 p& K; J1 i6 R+ D3 w: q* A1 B/ w


         配置KEY2（PD15）GPIO引脚为交替推免GPIO模式，如下图。
6 `# g2 `, S. h; T0 s. f7 ?; P5 n
! [+ s( V, @7 K# C7 c5 T
- _) L- A/ t8 a0 ?1 z& n
$ O2 n# D  a' U3 o         上述配置完成后输出生成代码。
1 a; N/ u; D" `4 B4 N/ ?+ f: `! M
" K# D& G0 ]5 n! x
  R  w( S/ {- }* I6 Y) R! p四、定时器及中断功能代码设计
; [. P2 B: D/ U7 F        4.1 GPIO中断功能
        已经配置了KEY0（PE11）为GPIO_EXTI模式，并开启其中断支持，现需要重新实现stm32l4xx_hal_gpio.c文件中的HAL_GPIO_EXTI_Callback函数来实现GPIO外部中断回调功能。


* ^8 e) W3 S0 W
1 c1 d  @7 K* l+ }; p4 ]" ^         在main.c文件中，重新实现HAL_GPIO_EXTI_Callback函数，覆盖stm32l4xx_hal_gpio.c文件中HAL_GPIO_EXTI_Callback弱函数。

, g* k' N7 ]8 p

1. /* USER CODE BEGIN 0 */
   9 F( E- ^) ?* J. T  o: ^
2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   
3. {
   4 v" i0 U6 Y3 [/ ~* H. [0 i5 ^
4.         if(GPIO_Pin==KEY0_Pin)
   ! @5 s5 Y3 C2 v* Q% ~7 S5 V
5.         {
   4 _6 S( }% S3 [6 O. \+ X% s
6.                 static uint32_t key0_count = 0;
   
7.                 printf("this is %lu count for HAL_GPIO_EXTI_Callback!\r\n",key0_count++);
   
8.                 Toggle_led0();//LED0等状态反转一次
   
9.         }
   
10. }
    
11. /* USER CODE END 0 */

复制代码

% h) Y2 t, f; O0 v* z7 V         4.2 TIM2的定时轮询功能
1 R. p+ }7 O/ z, ~- k/ j0 R          已经配置了TIM2，并开启其中断支持，现需要重新实现stm32l4xx_hal_tim.c文件中的当计数溢出时调用的回调函数HAL_TIM_PeriodElapsedCallback。



         在mian.c文件中，重新实现HAL_TIM_PeriodElapsedCallback函数，覆盖stm32l4xx_hal_tim.c文件中的同名弱函数。
8 T* c1 }1 {/ v5 J6 s7 E" I$ t

1. /* USER CODE BEGIN 0 */
   9 J8 B6 R5 F' p' \( O% R# D$ B
2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   
3. {
   
4.         if(GPIO_Pin==KEY0_Pin)
   
5.         {
   . Y) p- ]" W( V9 ]
6.                 static uint32_t key0_count = 0;
   4 ?% n* s+ q" _+ E) o
7.                 printf("this is %lu count for HAL_GPIO_EXTI_Callback!\r\n",key0_count++);
   
8.                 Toggle_led0();//LED0等状态反转一次
   
9.         }
   
10. }
    % c1 C. C/ \4 X/ W
11. 
    . Y1 |6 g% u* Z, j$ r; m
12. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    % h* P9 N1 M9 X4 |+ b
13. {
    
14.         if(htim==&htim2)
    
15.         {
    
16.                 static uint32_t key1_count = 0;
    
17.                 printf("this is %lu count for HAL_TIM_PeriodElapsedCallback!\r\n",key1_count++);
    0 Q  V* H) ~5 [* v: N2 J; a; B
18.                 Toggle_led1();//LED1等状态反转一次
    ' O; O* }  a8 h# K
19.         }
    " \) K8 h% g  j$ a- b7 M4 L
20. }
    
21. /* USER CODE END 0 */

复制代码

. Y) E# E) U; C2 t# q4 e$ H4 x8 i        4.3 TIM4的计数功能
% q9 i% u& E1 \1 Y! y$ g7 @       同样已经配置了TIM4，并开启其中断支持，现需要重新实现stm32l4xx_hal_tim.c文件中的当计数溢出时调用的回调函数HAL_TIM_PeriodElapsedCallback，在计数结束时，改写lpuart1的接收标记。

" O: U3 O, Q" [0 D2 X

1. /* USER CODE BEGIN 0 */
   
2. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
   : ?. f9 Y- u- G1 E5 W( t- y& p
3. {
   
4.         if(GPIO_Pin==KEY0_Pin)
   1 M! A6 m- M3 c
5.         {
   1 L. K2 x" h' o
6.                 static uint32_t key0_count = 0;
   7 W! \- R* D$ A1 q
7.                 printf("this is %lu count for HAL_GPIO_EXTI_Callback!\r\n",key0_count++);
   
8.                 Toggle_led0();//LED0等状态反转一次
   
9.         }
   
10. }
    + w' h! U8 |' M+ Z" l: E, H
11. 
    
12. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    5 p( V1 [" r/ e. E% U
13. {
    
14.         if(htim==&htim2)
    % j- B" v! }* t* ]9 I
15.         {
    ' u# N3 @+ N4 l* g% O( A* O. A4 l
16.                 static uint32_t key1_count = 0;
    
17.                 printf("this is %lu count for HAL_TIM_PeriodElapsedCallback!\r\n",key1_count++);
    ) }  H; r* L4 u# @) t; Z
18.                 Toggle_led1();//LED1等状态反转一次
    2 P; J7 Z0 f9 ^# a
19.         }
    . S( a/ W6 P7 n* R' ]
20.         if(htim ==&htim3)//判断是否是定时器3中断（定时器到时表示一组字符串接收结束）
    
21.     {
    . D  \2 E" s8 \# T# d& `
22.                 HLPUSART_RX_BUF[HLPUSART_RX_STA&0X0FFF]=0;//添加结束符
    
23.                 HLPUSART_RX_STA|=0x8000;//接收标志位最高位置1表示接收完成
    2 r9 q$ |, m4 {7 Y5 ^4 A5 L
24.                 __HAL_TIM_CLEAR_FLAG(&htim3,TIM_EVENTSOURCE_UPDATE );//清除TIM3更新中断标志
    
25.                 __HAL_TIM_DISABLE(&htim3);//关闭定时器3
    
26.     }
    
27. }
    
28. /* USER CODE END 0 */

复制代码

         同时在usart.h增加对TIM3的引入

1. #ifndef INC_USART_H_
   
2. #define INC_USART_H_
   
3. 
   5 i* `' Q, P6 j" j  V3 b
4. #include "stm32l4xx_hal.h" //HAL库文件声明
   ' q3 {% X  y: d$ f, L4 m
5. #include <string.h>//用于字符串处理的库
   
6. #include "../print/print.h"//用于printf函数串口重映射
   6 U8 N+ K+ H* Q1 I0 b
7. 
   
8. extern TIM_HandleTypeDef htim3;        //定时器3辅助串口接收数据
   6 }$ j& g( c( R# q9 X1 t
9. 
   
10. extern UART_HandleTypeDef hlpuart1;//声明LPUSART的HAL库结构体
    " C. G. z8 D& \+ ~. ~
11. 
    
12. #define HLPUSART_REC_LEN  256//定义LPUSART最大接收字节数
    
13. 
    
14. extern uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
    % m! I  W0 O" x
15. extern uint16_t HLPUSART_RX_STA;//接收状态标记
    ! {( L( P$ L2 M9 R# C1 E, ~
16. extern uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    ! ~" w. V) O) }! ^
17. 
    
18. 
    ; ?1 Q. a1 o& e
19. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart);//串口中断回调函数声明
    
20. 
    & r; W, S+ u- Z* b+ m. j5 [" F2 k
21. #endif /* INC_USART_H_ */

复制代码

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

1. #include "usart.h"
   & a& `3 B: ~/ |1 X0 B9 ?
2. 
   
3. uint8_t  HLPUSART_RX_BUF[HLPUSART_REC_LEN];//接收缓冲,最大HLPUSART_REC_LEN个字节.末字节为换行符
   
4. /*
   
5. * bit15:接收到回车(0x0d)时设置HLPUSART_RX_STA|=0x8000;
   
6. * bit14:接收溢出标志，数据超出缓存长度时，设置HLPUSART_RX_STA|=0x4000;
   
7. * bit13:预留
   
8. * bit12:预留
   
9. * bit11~0：接收到的有效字节数目(0~4095)
   
10. */
    ; ?9 R: J! U8 D$ b' }
11. uint16_t HLPUSART_RX_STA=0;接收状态标记//bit15：接收完成标志，bit14：接收到回车(0x0d)，bit13~0：接收到的有效字节数目
    5 s' t2 R( ?' h5 D" P! e& i0 \1 W
12. uint8_t HLPUSART_NewData;//当前串口中断接收的1个字节数据的缓存
    
13. 
    ) C5 F8 n" x; W( p4 n
14. void  HAL_UART_RxCpltCallback(UART_HandleTypeDef  *huart)//串口中断回调函数
    
15. {
    
16. //        if(huart ==&hlpuart1)//判断中断来源（串口1：USB转串口）
    
17. //    {
    3 @. k; J3 ?% `9 N* U
18. //                if(HLPUSART_NewData==0x0d){//回车标记
    
19. //               HLPUSART_RX_STA|=0x8000;//标记接到回车
      L* _) u7 Z7 I. u, d
20. //                }else{
    
21. //                        if((HLPUSART_RX_STA&0X0FFF)<HLPUSART_REC_LEN){
    : L$ o8 p% i: N) m
22. //                                HLPUSART_RX_BUF[HLPUSART_RX_STA&0X0FFF]=HLPUSART_NewData; //将收到的数据放入数组
    ' {9 W2 ]$ \* W" C! O( I+ S
23. //                                HLPUSART_RX_STA++;  //数据长度计数加1
    
24. //                        }else{
    
25. //                                HLPUSART_RX_STA|=0x4000;//数据超出缓存长度,标记溢出
    
26. //                        }
    $ A# I2 O# _. z/ f( _. l" x
27. //        }
    1 N' M# t( l2 Y, @, o" S9 I
28. //       HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData,1); //再开启接收中断
    
29. //    }
    
30.     //调整,通过htim3计数来通知接收数据结束
    
31.         if(huart ==&hlpuart1)//判断中断来源（串口lpuart1）//接收完的一批数据,还没有被处理,则不再接收其他数据
    
32.         {
    
33.                 if(HLPUSART_RX_STA<HLPUSART_REC_LEN)//还可以接收数据
    . ?  S+ [/ Z# V! B0 G. T8 x* A4 f
34.                 {
    ' ~) D; C; V1 Q2 I, Q1 ^8 H
35.                         __HAL_TIM_SET_COUNTER(&htim3,0); //计数器清空
    $ b5 X* E" Q, g! r6 G+ s7 J4 _
36.                         if(HLPUSART_RX_STA==0) //使能定时器2的中断
    
37.                         {
    
38.                                 __HAL_TIM_ENABLE(&htim3); //使能定时器3
    . D3 E- t4 A2 o! |" L3 ~
39.                         }
    
40.                         HLPUSART_RX_BUF[HLPUSART_RX_STA++] = HLPUSART_NewData;//最新接收数据放入数组
    
41.                 }else
    
42.                 {
    & R& {4 U+ ], s0 s7 X" E
43.                         HLPUSART_RX_STA|=0x8000;//强制标记接收完成
    
44.                 }
    
45. 
    8 d0 U. }) Z4 @1 Q  L7 Y
46.                 HAL_UART_Receive_IT(&hlpuart1,(uint8_t *)&HLPUSART_NewData,1); //再开启串口1接收中断
    
47.         }
    
48. }

复制代码

9 G# ?8 R/ p% Q8 R        4.4 TIM4定时器支持PWM输出功能实现
        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重新计数 。
7 Y9 q$ s" z3 p( K7 M: b
. E$ |0 b  S! W# p- l/ J& |

1. HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_4);
   ) A  W: @7 `  |+ n5 I1 i
2. uint8_t a = ;
   
3. while(1){
   & j7 d% D) P$ v+ r3 U  B' r) E# [
4.     __HAL_TIM_SetCompare(&htim4,TIM_CHANNEL_4,a);
   
5.           a++;//占空比值加1
   ! o1 J+ a1 u. C0 v! H
6.           if(a>=99)a=0;
   
7.     HAL_Delay(10);
   
8. }

复制代码

* m% J' y9 w; ^* X          4.5 功能调用及实现
) U$ l; l  m. J: G        在main.c函数中，初始化及启动TIM定时器

1.   /* USER CODE BEGIN 2 */
   
2.   ResetPrintInit(&hlpuart1);
   , b; M1 d6 x" I" N2 _! Y5 \6 Y) t: 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接收数据
   ( f! O8 n* H9 C/ B
7.   HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_4);
   1 H, W; x; S, ?5 C7 s
8.   uint8_t memu = 0;    //用来标记按键KEY2按下,来开启或关闭TIM4的PWM功能
   / x5 u/ C6 P2 }% \' z& K: S% |% s: ~
9.   uint16_t a = 0;      //占空比值
   
10.   /* USER CODE END 2 */

复制代码

        在main函数循环中，实现如下：
; e! O) f2 U1 Q2 L6 \3 c; V" O- i; Q

1. /* USER CODE BEGIN WHILE */
   , H( \1 o9 w9 f- P
2.   while (1)
   4 @% [: e3 Y+ Q& m
3.   {
   " ]$ r/ N  s' v
4.           if(HLPUSART_RX_STA&0xC000){//溢出或换行，重新开始
   % r2 S2 l( Y+ Q0 n. U, C% ?
5.                     printf("receive:%.*s\r\n",HLPUSART_RX_STA&0X0FFF, HLPUSART_RX_BUF);
   
6.                     HLPUSART_RX_STA=0;//接收错误,重新开始
   
7.                     HAL_Delay(100);//等待
   7 a2 {% b- H! U3 s, |6 @
8.             }
   - l$ m# `- |; Y5 v
9.             if(KEY_1())
   ) h2 s* g. E! a3 B; V5 Y) {2 l. ]
10.           {
    
11.           }
    5 U9 N4 v# c. t+ B/ s5 j6 c" @
12.             if(KEY_2())
    + C1 l; K  a: U4 D6 j
13.           {
    
14.                     memu=!memu;
    * x7 D! [2 W0 j1 ?8 `
15.                     printf("TIM4_PWM is runing!\r\n");
    + n: R- e7 V  Z0 [0 q
16.           }
    
17.             if(memu)
    2 ^$ }% G( Z2 W9 F+ c: u
18.             {
    
19.                     __HAL_TIM_SetCompare(&htim4,TIM_CHANNEL_4,a);
    
20.                     a++;//占空比值加1
    
21.                     if(a>=99)
    
22.                     {
    % n  i, t6 N* |* v  n
23.                             printf("TIM4_PWM finish cycle!\r\n");
    * }* Z9 C6 M8 W
24.                             a=0;
    5 Q2 b. c# M3 |$ x# K, Q9 ^$ H
25.                     }
    ' Z0 i  M+ m" C( L9 ?; q4 C
26.                     HAL_Delay(10);//等待
    
27.             }
    $ }$ M" X: x" l' |2 a1 Q, U
28.     /* USER CODE END WHILE */

复制代码

' |2 u2 f2 D8 X' P: u8 {  |8 t9 `五、编译及测试
        5.1 编译程序及下载
6 S" X7 `( g1 w6 Z9 o' t
- G% ~% c) ]6 `/ o. Z( J* M
( Y& R. j9 A$ {# m8 g* q
# S6 m% j, K) V9 N6 D% W. A  U! \
         5.2 测试
, A/ U' P6 q: |& g0 y        【1】测试log输出
2 M! C) S& N& w


         【2】注释掉相关打印输出，测试lpuart1输入数据无回车时（lpuart1的HAL_UART_Receive_IT调用后，TIM3每100毫秒通知其结束接收），能成功收到返回数据，如下图。
0 `4 O7 O, M. W2 ~& g) n



         【3】LED等状态情况
  G/ Z5 M; B( ?+ y. H" U        按键KEY0顺利切换LED0的状态，LED1灯周期切换状态（TIM2），按键KEY2开启TIM4的PWM输出功能，LED2灯周期由亮到灭切换状态（TIM4）。
8 I6 R" V5 c8 n; X: {————————————————
版权声明：py_free-物联智能
* |2 ^- i8 ]9 S* e+ a如有侵权请联系删除
  @: j; S" M! p
2 y; A* `, I+ L) I
/ b. [: U7 X+ ^. ]. ^" ]* \
, |" L4 W2 t, J5 Z) @% z4 `. W