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

4 s: Y$ X0 ^9 [% r5 f6 J+ }

& Q" ]. X! j8 X4 ]0 O       按键：

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

$ O9 q' h6 X4 U6 J       我们先看一下基于STM32Cube的模块配置，由于引脚的多样性，我们可以在引脚上直接操作：

       接下来配置三个引脚，一个按键，两个LED：
+ ^3 _* V. T( N

- i, S( j7 \1 b3 z       配置定时器模块前先看一下时钟配置，并修改为24M，最大支持48M：
  u  c4 y1 Z- g, {) E" L/ V

) u; U* z) |% w- L; i  @

* u. S# c# z6 N7 \& b5 d* D$ Q; R       接下来配置定时器，我们选用的是定时器14，是一个普通定时器，配置的参数也比较少，定时1ms：

" m8 g6 N1 r! H: O0 |7 D

6 J( W+ R. m+ }* W, \       接下来是中断配置，实际上我们在上面的具体模块配置的时候就可以进行中断配置，也可以统一开启：

" \; v3 d* E8 }, z) ?$ t0 d7 P5 q/ n

) O, G1 W1 @, Q- ~& W* y       到这里硬件方面的配置已经基本完成，我们开始软件方面的操作，实际上我们实现的功能也是非常基础了，初始化和定时处理部分都已经添加了：

# S$ X8 l: y+ T0 k, G# v9 N2 E2 r! n       我们创建两个变量：
3 [9 [7 N2 h; x4 h: v$ `; F% C, J
' F* I& l% s5 P3 _

1. uint16_t LED_TimeCnt_limit = 0;
   ) d( d) j; G0 R) }. }# ^# {0 H4 y
2. uint16_t TimeCnt = 0;

复制代码

      LED的闪烁就是通过判断TimeCnt是否等于或者大于LED_TimeCnt_limit进行LED的状态翻转。
& @5 r5 s" u0 ]% A       我们需要做的就是编写对应的回调函数：
. L7 c4 O* Z& {  k0 `0 |

1. void HAL_GPIO_EXTI_Falling_Callback(uint16_t GPIO_Pin)
   2 B% A( K/ S7 M: U3 m7 z# ^* ?
2. {
   5 W, ^) f/ }. f7 I5 Q
3.      if(GPIO_Pin == GPIO_PIN_13)
   
4.      {
   & J' J2 ]& k# m* V  p) C7 U. P
5.                 LED_TimeCnt_limit += 500;
   
6.                 TimeCnt = 0;
   
7.                 if(LED_TimeCnt_limit > 1500 )
   
8.                     LED_TimeCnt_limit = 500;
   
9.      }
   
10. }
    
11. 
    
12. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
13. {
    . h$ y: \9 h9 y+ X) q: q
14.   if (htim->Instance == TIM14) {
    
15.     HAL_IncTick();
    ; N. r, s9 `; b4 |" u
16.         TimeCnt++;
    $ ]8 q; {) G$ z" s; M
17.         if(TimeCnt > LED_TimeCnt_limit)
    
18.         {
    + _4 J( V! L5 _+ b4 _2 y& B
19.             HAL_GPIO_TogglePin(LD1_GPIO_Port, LD1_Pin);
    , W+ L5 i3 S( U, ?9 n" R, B
20.             HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
    " l. o+ a: ~( f
21.             TimeCnt = 0;
    5 n+ ~* j& _" I# ^
22.         }
    $ n* n3 s& ]4 v& N% O8 Z8 @9 c
23.   }
    2 |' W) W% n2 }# t
24. }

复制代码

      这样我们就通过定时器实现的了LED的翻转控制，这个时候我们加入串口的控制，实在是串口和这种多模式的控制太搭了，我们可以通过串口实现同样的翻转控制命令，同时也可以通过串口打印当前状态，我们试一下加入模式变量，因为要实现同步控制，必须按键和串口命令控制的对象是同一个。
       配置串口2模块：
. t6 B3 z. I2 K8 E0 O9 Y; H7 R

+ \+ P: t: P) [- e% F* Q5 r

; ^$ c% r9 ?! L8 j; a       实际上在生成工程的的时候这个模块就配置了，估计当成必备选项了，行为这个串口连接的STlink：
5 G7 s1 X4 Z6 y

1 \7 Z8 n' d) k; x

       我们先实现一下printf打印功能，加入一下代码即可：
2 {* N+ O+ [/ \" I4 E5 v

1. #if defined(__ICCARM__)
   
2. __ATTRIBUTES size_t __write(int, const unsigned char *, size_t);
   
3. #endif /* __ICCARM__ */
   - ^- n: j( E0 y1 |9 w% V$ y
4. 
   
5. #if defined(__ICCARM__)
   : o" s1 T1 X4 p2 q! a
6. /* New definition from EWARM V9, compatible with EWARM8 */
   " {, D9 j: M: o1 X2 u5 ]
7. int iar_fputc(int ch);
   
8. #define PUTCHAR_PROTOTYPE int iar_fputc(int ch)
   
9. #elif defined ( __CC_ARM ) || defined(__ARMCC_VERSION)
   
10. /* ARM Compiler 5/6*/
    
11. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    8 {. F/ G( G: F
12. #elif defined(__GNUC__)
    . P$ x/ X, c& A; N) \
13. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
    
14. #endif /* __ICCARM__ */

复制代码

      然后将printf与串口2关联：
/ R; N& s6 c4 b2 K

1. PUTCHAR_PROTOTYPE
   
2. {
   
3.   /* Place your implementation of fputc here */
   ; ~* C$ G* k4 r, V( m1 d% w
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);
   8 [5 F3 T. P; A, {& s! F
6. 
   
7.   return ch;
   : S& x6 L: R. y" A# {" g
8. }

复制代码

      这个时候我们就可以用使用printf打印功能了。
       串口的接收依然使用的是回调函数的方式，同时修改按键控制内容：

1. void HAL_GPIO_EXTI_Falling_Callback(uint16_t GPIO_Pin)
   
2. {
   + B4 Q' V' i2 R* k# \3 d/ i$ I4 `+ I
3.      if(GPIO_Pin == GPIO_PIN_13)
   
4.      {
   - L) |0 B/ g  l' v& P+ ~
5.                 LED_Mode++;
   ' v0 R) M$ O4 C% i; A/ c
6. 
   % {, Z* N+ Y2 d- _( ?/ a
7.                 LED_TimeCnt_limit = 500+500*LED_Mode;
   
8.                 TimeCnt = 0;
   ( U% m5 V; s1 R# Z* g* [# V/ c
9.                 if(LED_TimeCnt_limit > 1500 )
   / _5 C9 a) U- b/ V8 q7 `% E
10.                 {
    
11.                     LED_Mode = 0;
    
12.                     LED_TimeCnt_limit = 500;
    " t. y3 \, N& T% p9 @. U
13.                 }
    4 v% @$ \7 L- w. R( z" q8 f
14.                 printf("New Mode:    %d\n\r",LED_Mode);
    ) C. G: D" K" Q7 l. ~
15.      }
    
16. }
    
17. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
    & ]% C% w. S- O
18. {
    
19.     if(huart->Instance==USART2)
    
20.   {
    ; E# x0 O) t  P3 C& ?0 p
21.             if(UART2_RXData == 0x00||UART2_RXData == 0x01 || UART2_RXData == 0x02)
    & ^' Y  g' t) N% B. O
22.             {
    2 M* z9 A! H$ c7 Q7 r$ U% v
23.                 LED_Mode = UART2_RXData;
    
24.                 printf("New Mode:    %d\n\r",LED_Mode);
    
25.                 LED_TimeCnt_limit = 500+500*LED_Mode;
    
26.                 TimeCnt = 0;
    
27.             }
    
28.             HAL_UART_Receive_IT(&huart2, &UART2_RXData, 1);
    
29.   }
    
30. }

复制代码

      整体的效果如下，我们将操作过程和串口控制过程通过动图的方式进行展示：
7 O& N* @- v1 Y, `

  i8 g) B/ s, u; s3 U2 }2 J5 X) W       整个对应的串口反应：
3 X5 x4 n! W( g# M7 i

( C) v* D, ~! |; ]; u0 F
$ V+ T0 h1 g- u/ r; R7 I9 \3 ?
$ j! g: `# r! C' j

! K3 v5 j# b9 B! W! j4 w



* b( ^$ x% A% ~; |& P
( I8 C* w" [- f' d! x

/ l4 |6 G/ I: }) M; r( D' ~* S

# Z8 O" h- T1 }4 H. L