我们板子第一次上电的时候看到的就是LED的闪烁实验，而且还可以通过按键来调整闪烁的频率，这个板载demo的效果，两个LED交替闪烁，一般板载的demo都是通过延时的方式实现的。这次我们将通过定时的方式实现两个LED的同频闪烁，通过外部中断的方式采集按键，调整同频闪烁的频率。
       我们先看一下需要使用的硬件资源：
# L& W& J2 _8 K5 f       LED：

  P' H2 G# D5 \) H" I& {: O

* L+ F1 J- R: O" i       按键：
; Q: `3 \" B4 x2 I2 z4 z0 o8 e

4 G8 v- B+ w0 ]( {8 k. d, L

       GPIO的功能专注于具体引脚的实现，涵盖输入与输出两大核心方面。输入功能主要用于采集外部器件的状态信息（例如按键状态），而输出功能则实现对外部器件的有效控制（LED的控制）。本开发板装备了两个LED灯作为可操控的外部器件实例，同时配备一个用户按键，用于输入信号的检测。简单分析一下原理图，LD1事业绿灯，想要点亮需要PA5输出高电平，LD2为蓝灯，要点亮需要PC9输出低电平。按键按下的时候另一端是地，也就是低电平，所以对应PC13引脚的初始状态要为高电平，不过硬件中R34并没有连接，我们需要通过引脚配置内部上拉。
       定时器是MCU的内部模块，通过精准计数进行计时，这就涉及到时钟的配置来计算定时器参数。
       接下来我们基于板卡创建工程：

# R1 B' N2 q2 R( i: w. d* R& Q

       我们先看一下基于STM32Cube的模块配置，由于引脚的多样性，我们可以在引脚上直接操作：
& J6 i% ?# }: u4 @

) V. i2 g) l7 Q

       接下来配置三个引脚，一个按键，两个LED：
" |* L; Q3 v8 o! t4 @: ~

/ {8 I+ h5 x9 F; A5 U

       配置定时器模块前先看一下时钟配置，并修改为24M，最大支持48M：
3 J6 h8 ~/ F8 V2 D: v2 l

9 W" M! R" ?9 y

       接下来配置定时器，我们选用的是定时器14，是一个普通定时器，配置的参数也比较少，定时1ms：

; X* ]' E7 o) s( a       接下来是中断配置，实际上我们在上面的具体模块配置的时候就可以进行中断配置，也可以统一开启：
* o9 U. v' ^: b8 r7 B

# P2 w  K9 _3 g( K+ w

4 p4 f5 F( E! p0 S1 R       到这里硬件方面的配置已经基本完成，我们开始软件方面的操作，实际上我们实现的功能也是非常基础了，初始化和定时处理部分都已经添加了：

       我们创建两个变量：

0 _7 ~7 P3 n  K- \: u

1. uint16_t LED_TimeCnt_limit = 0;
   
2. uint16_t TimeCnt = 0;

复制代码

      LED的闪烁就是通过判断TimeCnt是否等于或者大于LED_TimeCnt_limit进行LED的状态翻转。
: g9 o  S. y. {! g) K       我们需要做的就是编写对应的回调函数：

1. void HAL_GPIO_EXTI_Falling_Callback(uint16_t GPIO_Pin)
   
2. {
   6 H. z9 x2 J5 }2 f6 U" K
3.      if(GPIO_Pin == GPIO_PIN_13)
   1 ^6 {' [1 E0 a# u
4.      {
   7 u" g" ~6 s" ?" c& ]0 T; `, F
5.                 LED_TimeCnt_limit += 500;
   . r3 Y& e! a8 J1 \2 `3 ?
6.                 TimeCnt = 0;
   
7.                 if(LED_TimeCnt_limit > 1500 )
   7 O% E1 H, l& F$ F# ?
8.                     LED_TimeCnt_limit = 500;
   : W% R5 N( r4 x
9.      }
   + m2 T# R6 k) l8 N) e5 z
10. }
    
11. 
    
12. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
13. {
    " W* e/ P  ?9 x
14.   if (htim->Instance == TIM14) {
    
15.     HAL_IncTick();
    3 X+ r* `4 k: g5 d
16.         TimeCnt++;
    
17.         if(TimeCnt > LED_TimeCnt_limit)
    ' S, p* ^+ r# h
18.         {
    
19.             HAL_GPIO_TogglePin(LD1_GPIO_Port, LD1_Pin);
    8 h! Q/ v; Z" O8 n9 b5 ]
20.             HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
    ) o! \/ o6 d% A% ^8 \, o. A
21.             TimeCnt = 0;
    
22.         }
    ' S! y$ s- V6 q& p
23.   }
    
24. }

复制代码

      这样我们就通过定时器实现的了LED的翻转控制，这个时候我们加入串口的控制，实在是串口和这种多模式的控制太搭了，我们可以通过串口实现同样的翻转控制命令，同时也可以通过串口打印当前状态，我们试一下加入模式变量，因为要实现同步控制，必须按键和串口命令控制的对象是同一个。
; W5 b5 H# v7 C* p2 C       配置串口2模块：
: i7 h  V+ N7 P$ f* ?

+ [0 h+ G; O2 `+ }' w/ H  j2 v- M

. h' T; A/ M) h       实际上在生成工程的的时候这个模块就配置了，估计当成必备选项了，行为这个串口连接的STlink：
( Y, b" A7 E# U4 R( z) P

% ]* h( r: P  @: M

       我们先实现一下printf打印功能，加入一下代码即可：

1. #if defined(__ICCARM__)
   
2. __ATTRIBUTES size_t __write(int, const unsigned char *, size_t);
   " k' ~# m+ z2 b3 N% b
3. #endif /* __ICCARM__ */
   + C. h6 \0 F+ ]
4. 
   ' u: B* s& S6 y! z' z7 T1 g; ?1 Z
5. #if defined(__ICCARM__)
   
6. /* New definition from EWARM V9, compatible with EWARM8 */
   
7. int iar_fputc(int ch);
   ( Z5 ]/ R9 m) y5 [' ~; K
8. #define PUTCHAR_PROTOTYPE int iar_fputc(int ch)
   
9. #elif defined ( __CC_ARM ) || defined(__ARMCC_VERSION)
   
10. /* ARM Compiler 5/6*/
    % w' n8 Z2 }+ S
11. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    * T) d3 A7 j9 u( Z
12. #elif defined(__GNUC__)
    
13. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
    
14. #endif /* __ICCARM__ */

复制代码

      然后将printf与串口2关联：

1. PUTCHAR_PROTOTYPE
   0 K# T. |6 q/ ]0 N' ]- P: x# N
2. {
   2 k' x4 g; a, a" s
3.   /* Place your implementation of fputc here */
   % H% `0 h8 h' E. p2 e  Q
4.   /* e.g. write a character to the USART3 and Loop until the end of transmission */
   % D# }4 F! Y4 h& G" {- p3 ~
5.   HAL_UART_Transmit(&huart2, (uint8_t *)&ch, 1, 0xFFFF);
   
6. 
   
7.   return ch;
   0 a$ q5 v; ?7 g
8. }

复制代码

      这个时候我们就可以用使用printf打印功能了。
8 M* S' k4 t2 J$ i: z       串口的接收依然使用的是回调函数的方式，同时修改按键控制内容：
2 q1 [+ U# {5 _% {8 Q6 D

1. void HAL_GPIO_EXTI_Falling_Callback(uint16_t GPIO_Pin)
   
2. {
   * H  A. x/ j6 W. Z! m& i0 G% i
3.      if(GPIO_Pin == GPIO_PIN_13)
   
4.      {
   
5.                 LED_Mode++;
   
6. 
   
7.                 LED_TimeCnt_limit = 500+500*LED_Mode;
   ( J- |" E9 ]6 ]! A, k! {" v4 u
8.                 TimeCnt = 0;
   
9.                 if(LED_TimeCnt_limit > 1500 )
   
10.                 {
    
11.                     LED_Mode = 0;
    
12.                     LED_TimeCnt_limit = 500;
    
13.                 }
    
14.                 printf("New Mode:    %d\n\r",LED_Mode);
    8 a. ^" F+ e9 M$ K/ M
15.      }
    $ n, d+ W) _5 @5 I% ?/ A: F
16. }
    7 o$ [# s; {& ]$ z
17. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    1 v) S5 Y6 b3 U- ~2 a  x9 C
18. {
    
19.     if(huart->Instance==USART2)
    
20.   {
    3 n0 p1 p! I$ d: t& s
21.             if(UART2_RXData == 0x00||UART2_RXData == 0x01 || UART2_RXData == 0x02)
    " v5 ?4 F" z; [  v
22.             {
    ) F5 _0 t: J" F; K( C# h& |0 F
23.                 LED_Mode = UART2_RXData;
    
24.                 printf("New Mode:    %d\n\r",LED_Mode);
    8 N( l3 ]3 |3 E& i# [
25.                 LED_TimeCnt_limit = 500+500*LED_Mode;
    
26.                 TimeCnt = 0;
    , P* {9 |' w# w2 Q
27.             }
    
28.             HAL_UART_Receive_IT(&huart2, &UART2_RXData, 1);
    $ I, u- O% A7 }1 O
29.   }
      T: x0 h7 {- T  Q
30. }

复制代码

      整体的效果如下，我们将操作过程和串口控制过程通过动图的方式进行展示：

       整个对应的串口反应：

4 M+ P5 s4 l+ @4 V8 ~6 Y

7 ~& t0 O8 K* D' l0 z- z" d
$ v, v$ X+ B0 [- Z: [1 p' J


) @% ~3 z& E' h: x


* J) s0 S. {1 A  B6 F* L7 N
4 {; W9 C4 c% L/ P( ^


& ?5 J6 ^4 t: ~3 {3 B
* |( }: E8 v5 A4 l& R