之前我们用外部中断测量了PWM的频率，而外部触发是设置2个定时器，利用按键触发，一个定时器2用来接受外部触发信号并计数，另一个定时器6实时检测按键。
按照这样的思路，我们的按键读取用状态机思想去读取，使定时器6产生10ms的定时中断来实时检测按键并利用状态机设计思想处理按键信号，将PA1设置成输出引脚，设置定时器2的PA0引脚来接收信号，通过按键触发改变标志位来发送电平信号，再定义全局数存放PA0接收脉冲信号次数，最后串口配置。

: C5 I  _9 q5 g说实话，状态机思想可以清晰把你的代码逻辑弄清楚，这个是我自己写按键时画的草图：

% H: R+ I, P* j0 J% q
0 d5 P- H' z, B- S( E
1 g6 i9 U3 u6 g$ p% t* I2 @3 q( f

' l( Z. p! q& Y7 l& X; ^画的只要你自己可以看懂就行
8 I4 O( k0 _! @6 W1 M

代码讲解
# R3 ~9 w  R; i& r0 ~首先我们需要按键的状态，它的状态分为检测，按下，释放，所以定义枚举类型的结构体
  @* Z0 U1 t# B

1. /* USER CODE BEGIN PTD */
   
2. typedef enum
   
3. {
   . A5 D+ k: u1 S( F2 P$ Q4 H
4.         KEY_CHECK=0,
   
5.         KEY_CONFRIM,
   ! V( l: {1 r4 j7 l: `
6.         KEY_RELAESE
   
7. }KEY_STATE;
   4 p' X/ V; e: x6 f, x0 |% r3 C
8. /* USER CODE END PTD */
   ' G9 Z- H: Y: y; |) k' y5 m  W& X5 A5 q

复制代码

! q9 M& B! }  h* R6 ]  V8 ?. E状态变量的定义以及标志位，计数值
7 k7 u  s8 W( U! ^# g

1. /* USER CODE BEGIN PV */
   
2. KEY_STATE  keyState=KEY_CHECK;
   1 e- h2 U; {: ?6 M" J
3. int Result=0;
   0 ]- x$ v# j9 t: @2 t
4. uint8_t keyvalue=0;
   - m5 D6 I9 k7 v
5. 
   ! V+ \3 j: S, Y+ m% P1 W1 ~
6. /* USER CODE END PV */
   7 r/ e% M& N# o1 J0 m! c

复制代码

) B9 N% d" r# B# j7 n* B5 P对于按键检测，是在TIM6里处理的，选用KEY1即PE3
* s+ J+ W) l& w
3 r, n8 z/ H3 m' \5 m
& }' i3 R; ~" k8 h

$ x+ z1 ?+ i4 n, U; a. y/ u( w

! `' }" m/ T, i( [8 g+ T

+ Z* }, D- S8 v4 O, V& f7 V而之间的状态转移是通过判断电平实现的，按下时为低电平，未按下为高电平，根据我们按下的一个完整过程，我们可以通过switch语句实现我们的整个过程


' c( G6 n- J4 B" i9 k- B" Y

1. /* USER CODE BEGIN 4 */
   
2. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   
3. {
   9 r$ `2 M7 Q7 u
4.         if(htim->Instance==TIM6)//判断是否为TIM6中断
   
5.         {
   
6.                 switch(keyState)
   
7.                 {
   " V. G/ F2 @9 V/ Y$ [3 u
8.                         case KEY_CHECK://检测状态下
   1 k9 k8 F; }# v9 \. V6 ^
9.                         {
   3 I' s6 W) }: m5 Z+ B- a
10.                                 if(HAL_GPIO_ReadPin(GPIOE,GPIO_PIN_3)==GPIO_PIN_RESET)//检测按键为低电平
    
11.                                 {
    * v8 S3 ?7 b) ]& k: `; v
12.                                         keyState=KEY_CONFRIM;//确认按下状态
    
13.                                 }
    & X% l; x2 [$ G0 K& m% s! P
14.                                 break;
    
15.                         }
    
16.                         case KEY_CONFRIM://确认按下状态下
    
17.                         {
    6 L' i6 `0 J7 X
18.         if(HAL_GPIO_ReadPin(GPIOE,GPIO_PIN_3)==GPIO_PIN_RESET)//再次判断       
    ' v+ F2 ^: ^" \9 i. S
19.                                 {
    6 k5 s- n  J! z+ ^+ P4 c
20.               keyvalue=1;//改变标志位用于触发脉冲信号
    $ a" e, ?" j8 B* L4 n$ W
21.               keyState=KEY_RELAESE;//按下后释放
    
22.                                 }
    
23.          else               
    
24.                                  {
      ^( }& l* X4 j2 E5 y, d# c( o0 c
25.                                             keyState=KEY_CHECK;//排除抖动干扰或者误判，回到检测
    
26.                                  }
    . ]2 c1 T( m1 Q
27.                                  break;
    
28.                          }
    
29.                         case KEY_RELAESE://释放状态下
    
30.                         {
    
31.                                 if(HAL_GPIO_ReadPin(GPIOE,GPIO_PIN_3)==GPIO_PIN_SET)        //判断按键未按下
    
32.                                 {
    
33.                                         keyState=KEY_CHECK;//回到检测状态
    , v3 |( e5 @& }5 n
34.                                 //        keyvalue=1;
    
35.                                 }
    
36.                                 break;
    
37.                         }
    
38.                         default: break;
    
39. }
    # x7 L. Z1 b1 j2 x/ c
40.                 }
    + Q8 o0 \1 I8 g+ G' E: f- o
41.         }
    / H0 T0 P( N# `# ~& L- F+ Q
42. /* USER CODE END 4 */
    

复制代码

主函数内
# L% j4 P0 x% S) Q* L! t: P

1.   /* USER CODE BEGIN 2 */
   
2.         HAL_TIM_Base_Start(&htim2);//开启TIM2用于计数
   
3.         HAL_TIM_Base_Start_IT(&htim6);//开启TIM6用于按键检测
   
4.         printf("Timer counter founction test: \n");//串口起始提示
   $ T- P5 R1 p6 R# L
5.   /* USER CODE END 2 */
   
6. 
   
7.   /* Infinite loop */
   
8.   /* USER CODE BEGIN WHILE */
   
9.   while (1)
   
10.   {
    & s1 T7 B5 t$ ]
11.     /* USER CODE END WHILE */
    
12. 
    
13.     /* USER CODE BEGIN 3 */
    * c: f% K! n( }9 T7 o7 m/ ^: f
14.                 if(keyvalue==1)//如果为按下状态
    
15.                 {
    
16.                         keyvalue=0;
    
17.                         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_1,GPIO_PIN_SET);
    
18.                         HAL_Delay(1);
    * c6 j3 N8 O$ U4 k4 `# s7 U2 l
19.                         HAL_GPIO_WritePin(GPIOA,GPIO_PIN_1,GPIO_PIN_RESET);
    
20.                         HAL_Delay(1);//发出周期为2ms的脉冲
    
21.                         Result=__HAL_TIM_GET_COUNTER(&htim2);//读取计数值
    
22.                         printf("Counter:%d.\n",Result);
    
23.                 }
    . Q4 h0 _1 C! o, E' P* y
24.   }
    
25.   /* USER CODE END 3 */
    ( _$ n6 P3 c6 n

复制代码

CUBEMX配置
' o  S7 R7 b# O4 o8 l1.时钟配置外部晶振，主时钟为72MHz

& t1 a: p8 A! J
! n" _0 b) I9 O2 m


! X+ C3 e3 x$ ^7 d
# G) u1 M) s; s, u
0 A, Y5 [+ A  m' S# A2.GPIO：选择PA1输出，PE3输入



0 ^* u% K, f& T7 c" Y

# Y0 T. r/ S1 E. R( S# Z3 e3.TIM：
& j9 X! Q/ x9 Z" b& iTIM2：Clock Source：外部触发
2 S* e  h; H4 S$ }4 e

; T2 e* ?' @8 _) s3 ^* H
6 z: f+ _. {# x8 A
" r3 n+ Z( f$ M- y, b, ?
/ E, h) q( `5 }! q8 H9 r/ Y这时PA0为你的触发引脚
& y7 S1 e. z9 H. y
6 r% B* F- d2 {/ T/ S7 t* {" w



3 n% v2 }5 E- `- ?2 v5 yTIM6：激活并生成10ms中断



* m( V5 B  m; W4 i

4.usart设置



4 J8 a  b- I6 f! o, C

& Y  J) e: t( a6 N1 ^6 a& i; I' d3 O- Z5.Project的设置，
& j, A: I% J) t1 @4 n$ ?+ v

+ G" x4 s6 y  F6 w5 k0 P7 i8 b
' K9 u& G( Q& e) d+ F# g

) Y  l* z* J3 E# K& K还有一个之前没注意，就是在Code Generator一栏中第一个方框里选择第二个：Copy only the necessary library files，要不一个工程就是百八十MB，占内存。


- H* {- b  `8 j, p


% y, z5 }* j* X/ |& f8 P最后生成代码
————————————————
# s4 {( q: P1 j4 l; A& u7 P版权声明：南山笑

1 L, z! C+ `5 R. u+ {1 P# T" q如有侵权请联系删除


- Q2 O5 e' V" G& `- M- o# D) U