我们板子第一次上电的时候看到的就是LED的闪烁实验，而且还可以通过按键来调整闪烁的频率，这个板载demo的效果，两个LED交替闪烁，一般板载的demo都是通过延时的方式实现的。这次我们将通过定时的方式实现两个LED的同频闪烁，通过外部中断的方式采集按键，调整同频闪烁的频率。
       我们先看一下需要使用的硬件资源：
       LED：
2 D8 Y5 B. |) |/ E" A& {* r

0 R9 K9 C! j" a6 c

       按键：
% c+ c9 m8 j7 T: `4 A

5 ~5 p0 J  F) T/ P8 g

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

) [/ o& M6 `9 y9 u- q3 R

       我们先看一下基于STM32Cube的模块配置，由于引脚的多样性，我们可以在引脚上直接操作：

       接下来配置三个引脚，一个按键，两个LED：
- o1 T; Z$ |1 C: X$ f+ V

# i4 r: l7 R7 w5 i

       配置定时器模块前先看一下时钟配置，并修改为24M，最大支持48M：
: o) B& o9 D1 S% _% m5 [7 O

4 {6 h9 f5 C! z+ f; m( |1 M; l# a

       接下来配置定时器，我们选用的是定时器14，是一个普通定时器，配置的参数也比较少，定时1ms：
8 u- r9 I1 e, j# \0 R! D( i6 o5 w5 Q

) c. `- l+ I) r* L# {# @  z0 G       接下来是中断配置，实际上我们在上面的具体模块配置的时候就可以进行中断配置，也可以统一开启：
) c& C- a3 o) h

       到这里硬件方面的配置已经基本完成，我们开始软件方面的操作，实际上我们实现的功能也是非常基础了，初始化和定时处理部分都已经添加了：
+ X: d, E$ P  s! v: i! T

       我们创建两个变量：
& o% H( x5 z% `/ Q0 r0 U
2 n8 F. |( r* `& k

1. uint16_t LED_TimeCnt_limit = 0;
   % f, u/ t9 M/ [) G
2. uint16_t TimeCnt = 0;

复制代码

      LED的闪烁就是通过判断TimeCnt是否等于或者大于LED_TimeCnt_limit进行LED的状态翻转。
7 z8 D! i9 A% i) J- l$ g7 {9 Q# R       我们需要做的就是编写对应的回调函数：
8 T$ e( y+ s9 B$ w5 \+ P" _& N5 J

1. void HAL_GPIO_EXTI_Falling_Callback(uint16_t GPIO_Pin)
   6 w4 N1 i' Q% g4 X) n+ ^: |7 J
2. {
   ( l' @4 _9 g0 B2 d! \( D
3.      if(GPIO_Pin == GPIO_PIN_13)
   
4.      {
   
5.                 LED_TimeCnt_limit += 500;
   
6.                 TimeCnt = 0;
   
7.                 if(LED_TimeCnt_limit > 1500 )
   ( M' i8 d5 g* V: W0 s
8.                     LED_TimeCnt_limit = 500;
   / @1 C! V# k- t9 J. x2 `( X
9.      }
   " N! R" T& J8 _: |
10. }
    7 g  Q, C2 [! {. S( f; r( Z% a; H3 J
11. 
    ; ]8 K: o9 J# w( `
12. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
13. {
    ' D7 v' V& S; n* j2 P
14.   if (htim->Instance == TIM14) {
    ; v6 l4 {3 [1 p: I
15.     HAL_IncTick();
    1 |( \- j+ |3 J4 k3 c+ J, i% W6 o
16.         TimeCnt++;
      H; I) R. X  [# T8 B( k9 U
17.         if(TimeCnt > LED_TimeCnt_limit)
    + ~8 r7 Q$ h& E6 D- O3 |1 r
18.         {
    
19.             HAL_GPIO_TogglePin(LD1_GPIO_Port, LD1_Pin);
    ) s& ~, t$ B  a/ u
20.             HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
    2 C6 S1 B2 Q4 Z
21.             TimeCnt = 0;
    
22.         }
    6 A* `3 K, l' a
23.   }
    
24. }

复制代码

      这样我们就通过定时器实现的了LED的翻转控制，这个时候我们加入串口的控制，实在是串口和这种多模式的控制太搭了，我们可以通过串口实现同样的翻转控制命令，同时也可以通过串口打印当前状态，我们试一下加入模式变量，因为要实现同步控制，必须按键和串口命令控制的对象是同一个。
       配置串口2模块：
5 W" H/ e1 v' W0 R/ B( ^

. {0 K' s2 `# n! }% i7 H+ w

       实际上在生成工程的的时候这个模块就配置了，估计当成必备选项了，行为这个串口连接的STlink：
9 G3 @2 W# Q4 B6 w; ?- j) a: S4 t2 Y

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

1. #if defined(__ICCARM__)
   
2. __ATTRIBUTES size_t __write(int, const unsigned char *, size_t);
   
3. #endif /* __ICCARM__ */
   / {2 y6 c+ W: {0 F; a$ N
4. 
   
5. #if defined(__ICCARM__)
   5 ?7 @7 ?- }3 k+ N4 K" z0 `
6. /* New definition from EWARM V9, compatible with EWARM8 */
   . K/ D& l3 ~$ S( |) V
7. int iar_fputc(int ch);
   
8. #define PUTCHAR_PROTOTYPE int iar_fputc(int ch)
   $ b3 D( Q  h6 V$ k
9. #elif defined ( __CC_ARM ) || defined(__ARMCC_VERSION)
   
10. /* ARM Compiler 5/6*/
    / M+ @3 \/ m# |; h
11. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    
12. #elif defined(__GNUC__)
    
13. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
    
14. #endif /* __ICCARM__ */

复制代码

      然后将printf与串口2关联：

1. PUTCHAR_PROTOTYPE
     r1 E! X+ j7 K3 v& v$ L
2. {
   
3.   /* Place your implementation of fputc here */
   
4.   /* e.g. write a character to the USART3 and Loop until the end of transmission */
   
5.   HAL_UART_Transmit(&huart2, (uint8_t *)&ch, 1, 0xFFFF);
   : c7 s6 L% P5 i9 _* K/ F+ d
6. 
   
7.   return ch;
   5 Z( F2 J; h- `, B7 ]- x5 G0 Z
8. }

复制代码

      这个时候我们就可以用使用printf打印功能了。
       串口的接收依然使用的是回调函数的方式，同时修改按键控制内容：
5 o& b: w; n. P" F

1. void HAL_GPIO_EXTI_Falling_Callback(uint16_t GPIO_Pin)
   , G$ g; C+ K: ]4 e
2. {
   9 @% a1 H, U7 a, L  [, L- g
3.      if(GPIO_Pin == GPIO_PIN_13)
   0 ^  H3 A7 c8 ?% b& E2 ^4 P9 A
4.      {
   
5.                 LED_Mode++;
   
6. 
   " y" W. x) {; v
7.                 LED_TimeCnt_limit = 500+500*LED_Mode;
   ! |, F9 G0 [: L4 N0 D1 \5 n; t2 p. n' \$ H
8.                 TimeCnt = 0;
   
9.                 if(LED_TimeCnt_limit > 1500 )
   
10.                 {
    
11.                     LED_Mode = 0;
    
12.                     LED_TimeCnt_limit = 500;
    
13.                 }
    ) ^( P* \0 G0 ~0 y9 W: A; x
14.                 printf("New Mode:    %d\n\r",LED_Mode);
    
15.      }
    
16. }
    % T( @( o2 w7 _8 [
17. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    
18. {
    
19.     if(huart->Instance==USART2)
    1 A( C( S5 t9 I
20.   {
    
21.             if(UART2_RXData == 0x00||UART2_RXData == 0x01 || UART2_RXData == 0x02)
    1 `/ m/ V# F( Y. h! J
22.             {
    ! \. e, F5 ]8 `5 \
23.                 LED_Mode = UART2_RXData;
    # k! E& _, B+ |* O% Q  G
24.                 printf("New Mode:    %d\n\r",LED_Mode);
    
25.                 LED_TimeCnt_limit = 500+500*LED_Mode;
    
26.                 TimeCnt = 0;
    
27.             }
    : Z2 ~: `- A  r2 m+ T1 `% |+ t+ X
28.             HAL_UART_Receive_IT(&huart2, &UART2_RXData, 1);
    ( B/ @( w  ]5 ?" m' m' v8 ?1 i
29.   }
    
30. }

复制代码

      整体的效果如下，我们将操作过程和串口控制过程通过动图的方式进行展示：
1 [9 |" _( p& t( F

       整个对应的串口反应：

8 r! F2 ]1 r6 k6 O$ a

$ S1 c2 w9 H: Z* B2 m2 K


$ K) f2 o# L8 c( X/ K

8 K0 Q$ X( \. o6 D! J0 z. A
" G/ V( D+ P  o* L4 W# a

% D$ P( o* @( x' }, I

% n7 G2 Q/ e% d3 q- d" ~

' g/ b) s, d: w5 M1 [3 b$ d
) ~- f" G! w% Y8 U  G$ E- ?) K& h+ c