# k4 ?2 |. Q# h7 v  S. l【MCU实战经验】+基于STM32和PID算法的小车车速控制
5 @4 D0 X9 N6 g6 G
$ K) @% [, V4 \4 K0 M2 H/ g【MCU实战经验】+ STM32F103RBT6三个USART发送与接收设置
& r3 O/ A% d1 u% F
( E) x# O* z: [" m  u【MCU实战经验】+用stm32单片机做J-Link和ST-Link（PCB工程+固件库+资料工具）

! c4 s' Y3 n  w9 o
之前的一个项目按键比较多，面板上面有按键，遥控器，处理的稍微复杂一点，MCU使用的是STM8S005K6.
关于按键部分的处理，现在拿处理来和大家分享一下，说的不对的地方还请各位大侠请教，大家共同进步。
: ^( O: p* j4 ]
按键通常分有IO口按键（BUTTON),AD按键（通过AD采样电压），IR（遥控器）
4 Y$ k* J' @- A9 v; q7 X6 B5 |按按键功能分：有短按键，长按键，连续按键。打个比方，遥控电视机，按一下音量键，音量增加1，这个就是短按键。
按住音量键不放，音量连续加，这个就是连续按键。按住一个按键5s,系统会复位，这个是长按键。
- \, l$ ^! d! x& {6 D7 e" J* m
2 r% W* l2 H3 w2 b怎么去处理这些不同的按键了，下面我们就细细来说

+ Q5 f0 D$ `* ?1,IO口按键，就是我们比较常见的一个IO接一个按键，或者是一个矩阵键盘。很多新人的处理方法可能是采样延时的方法，当年我也是这样的，如下
4 B+ a$ S- G% H# Q7 ]: _9 E

1.     if(GETIO==low)
   ; M) a$ W9 ^% L
2.     {
   2 a, Y+ j" n! c( M% d. q1 c  \
3.       delay_10ms()
   
4.       if(GETIO==low)
   
5.       {
   7 o1 I# X) _1 A) w
6.         //得到按键值
   9 w4 Q! P( O. i
7.       }
   * G- t; E% ?% `( T
8.     }

复制代码

   
, Z: o) _0 t7 n- k   这种方法虽然简单，但是有很大弊端。
   首先 Delay 浪费很多时间，影响系统。
" s1 i9 ], Q8 z6 s7 Z3 J   第二，无法判断长短按键，连续按键。
   第三，如果这个按键是开关机按键系统在低功耗状态下，需要中断唤醒，这种方法比较容易出问题，如STM8S系列的 halt 模式。
" h0 c( J9 X" r4 U   
' B3 x, G1 ?9 o% l   所以我们一般在产品开发的过程中，采用扫描的方法，就是每隔10ms 去检测IO的状态，看是否有按键，然后去抖动，判断按键功能。
- z+ a$ G! f& i' g3 e   
   参考代码如下，这段代码是之前在一个论坛看到的比我自己写的更加优秀，所以拿出来和大家分享一下，也顺便感谢一下作者。
; k" T6 a' o3 W. e! `% C  ?   这段代码，容易修改，可以根据自己的时间需要，进行长短按键，连续按键,还有组合按键的判断。
$ F3 I4 D5 [1 x& x+ o   
   
# a5 p& h7 ?4 w; L$ {* [6 W" t/ I) }/ {

1. /* 按键滤波时间50ms, 单位10ms
   1 s( v/ H9 M6 P- G! B+ t% O
2. 只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   
3. */
   # a& U# e3 @+ H. |7 M# T
4. #define BUTTON_FILTER_TIME         5
   * [8 D+ W; m* A# ?3 N& [- ?
5. #define BUTTON_LONG_TIME         300                /* 持续1秒，认为长按事件 */
   5 t  ]9 L( f3 Z: j- ~5 t
6. 
   
7. /*
   % u5 ^: M' n& n6 O6 Z
8.         每个按键对应1个全局的结构体变量。
   
9.         其成员变量是实现滤波和多种按键状态所必须的
   
10. */
    
11. typedef struct
    1 R3 o9 S+ s9 J1 x; H8 c. K
12. {
    
13.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
    ; d" y/ |7 Y: y/ E$ u
14.         unsigned char  (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
    $ X* M9 p! @+ F: M
15. 
    
16.         unsigned char  Count;                        /* 滤波器计数器 */
    / S9 u3 O& Z8 X& r
17.         unsigned char  FilterTime;                /* 滤波时间(最大255,表示2550ms) */
    
18.         unsigned short LongCount;                /* 长按计数器 */
    
19.         unsigned short LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    
20.         unsigned char   State;                        /* 按键当前状态（按下还是弹起） */
    
21.         unsigned char  KeyCodeUp;                /* 按键弹起的键值代码, 0表示不检测按键弹起 */
    
22.         unsigned char  KeyCodeDown;        /* 按键按下的键值代码, 0表示不检测按键按下 */
    1 N0 n9 g" Q7 O' c% T% T
23.         unsigned char  KeyCodeLong;        /* 按键长按的键值代码, 0表示不检测长按 */
    7 g6 y5 {, Z9 h( F) x- }5 Q8 R
24.         unsigned char  RepeatSpeed;        /* 连续按键周期 */
    
25.         unsigned char  RepeatCount;        /* 连续按键计数器 */
    % @* s7 J/ Y+ i6 T& C
26. }BUTTON_T;
    % c" ^; c0 V' V' C! U- o% s1 I
27. 
    $ Z) V2 U. Y1 |* K3 H2 J
28. typedef enum
    + W8 l3 e! N/ z7 {+ z! Q! @0 @. J: D) j
29. {
    , X& ~: U6 m5 ?" r, L
30.         KEY_NONE = 0,                        /* 0 表示按键事件 */
    7 v3 p+ {3 }1 y( _; y! f  r" d3 d9 F0 h
31. 
    . n4 U% c7 q5 M+ u$ M1 u" T
32.         KEY_DOWN_Power,                        /* 按键键按下 */
    
33.         KEY_UP_Power,                        /* 按键键弹起 */
    % g4 t3 n- ?0 U2 V8 y9 |7 I$ X4 E9 q
34.         KEY_LONG_Power,                        /* 按键键长按 */
    
35.         
    
36.         KEY_DOWN_Power_TAMPER        /* 组合键，Power键和WAKEUP键同时按下 */
    
37. }KEY_ENUM;
    
38. 
    
39. BUTTON_T s_Powerkey;               
    
40. //是否有按键按下接口函数
      }6 C7 L0 A$ b6 X( O
41. unsigned char  IsKeyDownUser(void)                 
    . Q5 O! L6 y  n/ [# ~/ D
42. {if (0==GPIO_ReadInputPin(POWER_KEY_PORT, POWER_KEY_PIN) ) return 1;return 0;}
    3 P- W( o' u9 d3 J$ W# ]1 Z) W
43. 
    
44. 
    
45. void  PanakeyHard_Init(void)
    
46. {
    
47.    GPIO_Init (POWER_KEY_PORT, POWER_KEY_PIN, GPIO_MODE_IN_FL_NO_IT);//power key
    
48. }
    
49. void  PanakeyVar_Init(void)
    
50. {
    
51.         /* 初始化USER按键变量，支持按下、弹起、长按 */
    
52.         s_Powerkey.IsKeyDownFunc = IsKeyDownUser;                /* 判断按键按下的函数 */
    , v; J) {5 Y' l, T
53.         s_Powerkey.FilterTime = BUTTON_FILTER_TIME;                /* 按键滤波时间 */
      o$ j7 y2 o8 h. }% O
54.         s_Powerkey.LongTime = BUTTON_LONG_TIME;                        /* 长按时间 */
    
55.         s_Powerkey.Count = s_Powerkey.FilterTime / 2;                /* 计数器设置为滤波时间的一半 */
    6 X) q1 N$ v- H1 G
56.         s_Powerkey.State = 0;                                                        /* 按键缺省状态，0为未按下 */
    
57.         s_Powerkey.KeyCodeDown = KEY_DOWN_Power;                        /* 按键按下的键值代码 */
    0 V: g; M6 G! f, `: a
58.         s_Powerkey.KeyCodeUp =KEY_UP_Power;                                /* 按键弹起的键值代码 */
    & A7 p% \- L4 S1 E' p
59.         s_Powerkey.KeyCodeLong = KEY_LONG_Power;                        /* 按键被持续按下的键值代码 */
    
60.         s_Powerkey.RepeatSpeed = 0;                                                /* 按键连发的速度，0表示不支持连发 */
    
61.         s_Powerkey.RepeatCount = 0;                                                /* 连发计数器 */               
    
62. }
    
63. void Panakey_Init(void)
    4 C6 ^: F9 v1 F, \; G% X5 C4 }
64. {
    # [6 ?+ N  X, U9 }- e# A# C
65.         PanakeyHard_Init();                /* 初始化按键变量 */
    6 d  G% ?; Z6 W
66.         PanakeyVar_Init();                /* 初始化按键硬件 */
    ( _+ j, ~; i! l) n9 r/ ~
67. }

复制代码

*********************************************************************************************************
*        函 数 名: bsp_DetectButton
5 j- [! S' i. Z  V  s: A+ p2 \*        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
*        形    参：按键结构变量指针
*        返 回 值: 无
*********************************************************************************************************
- U7 ^3 s/ e1 u' D9 i

1. */
   
2. void Button_Detect(BUTTON_T *_pBtn)
   
3. {
   
4.         if (_pBtn->IsKeyDownFunc())
   % y- T9 p3 W: ^+ h
5.         {
   ! S- R! X9 s4 I. x
6.                 if (_pBtn->Count < _pBtn->FilterTime)
   
7.                 {
   , r3 x  P9 H7 n) a  a1 Z5 l2 ~
8.                         _pBtn->Count = _pBtn->FilterTime;
   
9.                 }
   $ V) o6 Y# v" P4 L  B
10.                 else if(_pBtn->Count < 2 * _pBtn->FilterTime)
    - z  z$ k; u$ D7 y
11.                 {
    7 U: J+ \" o) q! ~( h
12.                         _pBtn->Count++;
    ' n0 {7 G9 ^# A5 s2 T
13.                 }
    2 R8 X- s  _# v
14.                 else
    
15.                 {
    
16.                         if (_pBtn->State == 0)
    6 N0 @' D! X  h( y& `8 N
17.                         {
    7 z$ Q  f2 |0 D) c- X9 B
18.                                 _pBtn->State = 1;
    : d3 ^( n0 F6 W  Y, p7 v* p
19. 
    
20.                                 /* 发送按钮按下的消息 */
    - q! U' R5 G8 k3 z6 H6 Y
21.                                 if (_pBtn->KeyCodeDown > 0)
    
22.                                 {
    
23.                                         /* 键值放入按键FIFO */
    
24.                                         Pannelkey_Put(_pBtn->KeyCodeDown);// 记录按键按下标志，等待释放
    7 c$ w2 P8 M. d% \) C) J7 o
25. 
    1 X* X8 ^9 o& B: j: g7 @
26.                                 }
    
27.                         }
    " [% r. b# r+ N& |* K# v
28. 
    
29.                         if (_pBtn->LongTime > 0)
    
30.                         {
    ( U, x4 ^5 R* |  V0 S, G
31.                                 if (_pBtn->LongCount < _pBtn->LongTime)
    
32.                                 {
    
33.                                         /* 发送按钮持续按下的消息 */
    
34.                                         if (++_pBtn->LongCount == _pBtn->LongTime)
    9 o5 Z  S9 ~: h2 n4 i( k, t
35.                                         {
    ! S5 k& q9 W) c4 R, d* N( s% m
36.                                                 /* 键值放入按键FIFO */
    1 X' R/ b) {( q
37.                                                 Pannelkey_Put(_pBtn->KeyCodeLong);        
    
38.                                 
    % E1 y* e$ T) q' ~. O& {, n
39.                                         }
    4 K6 G' K, D! U4 r* G; l' E
40.                                 }
    8 U. K6 g+ e  Z% y. H. g# a
41.                                 else
    # V' k$ ~4 K: z3 n% ?' Q! u
42.                                 {
    # d- I4 a2 @- w
43.                                         if (_pBtn->RepeatSpeed > 0)
    
44.                                         {
    8 B( t6 E  k1 \7 q
45.                                                 if (++_pBtn->RepeatCount >= _pBtn->RepeatSpeed)
    2 t& {  `. S3 j  n5 p0 U
46.                                                 {
    
47.                                                         _pBtn->RepeatCount = 0;
    6 H9 Y6 r  A/ P' E$ ]
48.                                                         /* 常按键后，每隔10ms发送1个按键 */
    ; A( g* q4 ~& V& y
49.                                                         Pannelkey_Put(_pBtn->KeyCodeDown);        
    
50.                                 
    ' V5 I- M4 K3 f) ^$ g4 O
51.                                                 }
    
52.                                         }
    
53.                                 }
    ( o8 p; V* M3 F  b- ~( o
54.                         }
    ; ~5 O: w- L3 J; m& L8 _9 X
55.                 }
    
56.         }
    
57.         else
    
58.         {
    3 m; w8 t4 J& M- c& m' {
59.                 if(_pBtn->Count > _pBtn->FilterTime)
    
60.                 {
    
61.                         _pBtn->Count = _pBtn->FilterTime;
    : P# v2 Y" l9 V
62.                 }
    3 v" v3 p$ {- S" ?
63.                 else if(_pBtn->Count != 0)
    9 p( x* Y2 I% z2 q' @: s
64.                 {
    ; B% j, @$ w! _4 u  \! q
65.                         _pBtn->Count--;
    
66.                 }
    & b  P! Y' I, g/ Q' F' L  Z, l6 n
67.                 else
    " A+ T( U, s  X* f4 N7 J
68.                 {
    # y. J; t, G; ]! X9 k: A" A# V
69.                         if (_pBtn->State == 1)
    - }/ {- I6 v1 {9 w3 Z. L2 N
70.                         {
    1 ^% u% U# _+ U6 B
71.                                 _pBtn->State = 0;
    
72. 
    . C$ k* V% B$ b$ i7 i: g5 ^
73.                                 /* 发送按钮弹起的消息 */
    4 I! o8 ]4 v$ h
74.                                 if (_pBtn->KeyCodeUp > 0) /*按键释放*/
    
75.                                 {
    
76.                                         /* 键值放入按键FIFO */
    
77.                                 Pannelkey_Put(_pBtn->KeyCodeUp);        
    
78.                         
    ( L7 C- G+ ^  j6 @
79.                                 }
    9 A0 A% {# @/ s
80.                         }
    $ n& X& B. m  n0 z/ d0 N
81.                 }
    
82. 
    
83.                 _pBtn->LongCount = 0;
    : I  G3 Y1 W$ }# E0 F( @  Z. B
84.                 _pBtn->RepeatCount = 0;
    
85.         }
    
86. }
    8 f/ X  H2 ^) _( }& J0 R( ?5 ]
87. //功能说明: 检测所有按键。10MS 调用一次
    8 _  O% V4 L$ s
88. void Pannelkey_Polling(void)
    
89. {
    ) O! z; l; o0 {+ s) _0 j. m: M
90.         Button_Detect(&s_Powerkey);                /* USER 键 */
    . ^% m" L0 p4 |8 b! }
91. }
    
92. void Pannelkey_Put（void)
    
93. {
    ) E1 g5 a' _% c7 F" A/ Q
94.         
    
95.   // 定义一个队列 放入按键值        
    
96. }

复制代码

1 X/ I4 _2 D* ~& c5 ?9 M
0 d2 h. j1 G; L4 h4 L   
2,遥控器按键，遥控器解码的一般就有两种 脉宽调制和脉冲调制，这里就不细讲解码的过程了。这里详细解码之后，如何处理遥控器按键
   实现遥控器按键的长短按功能和连续按键功能。
   代码裁剪过，大家根据实际需要改动
  其实AD按键，通过AD采样获得按键值之后，可以采取如下面的一样方法处理，提一个函数接口即可

1.    typedef struct
   
2. {
   
3.   unsigned char count;//
   * |# i* v. w+ F
4.   unsigned char LongkeyFlag;/*是否长按键，1代表是*/
   3 H3 l) [' b( h/ w* B
5.   unsigned char  PreKeyValue;/*按键值的一个备份，用于释放按键值*/
   
6.   
   $ |1 Q. v8 B. h1 u: R# `
7. }ScanKeyDef;
   ' Z4 ]9 ^0 `( o; i( F
8. 
   ; r3 v; {/ N- K  T' P, v
9. #define SHORT_PRESS_TIME_IR                16 // 10ms
   / M3 K/ U. X3 v4 L4 S) [
10. #define SERIES_PRESS_TIME_IR            10  
    . h" C. s: N- b0 ~
11. #define LONG_PRESS_TIME_IR                    22
    3 m1 q1 B' g9 S3 L0 A! z
12. #define KEY_RELEASE_TIME_OUT_IR     12  // 10ms
    0 _7 V  }6 |  ~+ t  \% g' s9 W
13. //提供5个接口函数，如下。
    
14. unsigned char get_irkey(void);
    ) o& \" ^& t8 P+ O# N2 W1 x: b
15. unsigned char ISSeriesKey(unsigned char temp);//按键是否需要做连续按键
    
16. unsigned char changeSeriesKey(unsigned char temp);//转换连续按键值
    # q6 y: u: y, N, A3 ?6 u+ S. V
17. unsigned char ISLongKey(unsigned char temp);//按键是否需要做连续按键
    ( K( U/ X' h1 H1 L  E; X* m4 f- t7 w/ P
18. unsigned char changeToLongKey(unsigned char temp);//转换连续按键值
    : L  ^9 _/ K# B) k% r# R- V
19. 
    1 |$ [6 r) Z7 I% p1 |
20. 
    
21. unsigned char KeyScan(void)
    
22. {
    
23.     unsigned char  KeyValue = KEY_NONE,
    
24.                                 KeyValueTemp = KEY_NONE;
    . }: q' E+ e- c2 \" N3 G( |
25.     static   unsigned char KeyReleaseTimeCount =0;
    5 F! p' K6 A  ?; b0 ]8 F" `* }
26. 
    3 Q' }+ y+ F# X5 g& O' k
27.     KeyValueTemp = get_irkey();
    # a0 T; T/ x5 t8 e" `
28. 
    1 c$ R! j' H2 |1 `: n
29.     if(KeyValueTemp != KEY_NONE)
    & l: R. g! x! `' _
30.     {
    
31.         ScanKeyDef.count++;
    
32.         KeyReleaseTimeCount =0;
    5 P5 ?; S+ N' K1 C& T# ^
33. 
    ) M# l. x) v8 T9 I& R, F* w0 G
34.         if(ScanKeyDef.count < LONG_PRESS_TIME_IR )
    
35.         {
    
36.             ScanKeyDef.LongkeyFlag = 0;
    
37.             if((ScanKeyDef.count == SERIES_PRESS_TIME_IR) && ISSeriesKey(KeyValueTemp)) //处理连续按键
    
38.                 {
    2 U4 M8 K9 w5 e: l1 F) e0 s& P
39.                     KeyValue = changeSeriesKey ( KeyValueTemp );
    - |/ ?# w/ D* L& v, Q6 ~% y5 B  o
40.                     ScanKeyDef.PreKeyValue = KEY_NONE;
    
41.                 }
    ! X/ p8 L: N, J1 m( p7 `
42.             else if ( ScanKeyDef.count  < SHORT_PRESS_TIME_IR )
    
43.             {
    / g; B' z& y3 d# }4 [
44.                 ScanKeyDef.PreKeyValue = KeyValueTemp;
    
45.             }
    , u3 y3 N" {! f
46.             else
    
47.             {
    1 ^$ e2 g, n( E( f- h8 G
48.             
    
49.                 ScanKeyDef.PreKeyValue  = KEY_NONE; // 无效按键
    , r; @5 ?6 F9 j3 V) e1 c
50.             }
    * P& ~, r/ h8 T7 l% E3 d$ [. Y( N
51.         }
    
52.         else if ( ScanKeyDef.count  == LONG_PRESS_TIME_IR )
    
53.         {
    
54.       
    & `& `. w- r' F9 i# V( I8 n  Y0 Y, Z
55.            if (ISLongKey(KeyValueTemp))
    
56.             {
    0 T5 ?0 ^  H# @1 a* l
57.                 {
    
58.                    ScanKeyDef.LongkeyFlag = 1;
    - H2 D# k( A+ O% `5 J6 H4 K
59.                    KeyValue = changeToLongKey ( KeyValueTemp );
    9 y* G% @: }0 L3 ?% p
60.                }
    ) P" h. s- G! l, \
61.           }
    
62.             ScanKeyDef.PreKeyValue = KEY_NONE;
      e' P0 v5 n$ h2 J: A8 B* I; V: @
63.          
    
64.         }
    - R) w4 Q' s& N" z% r; G8 t
65.         else if (ScanKeyDef.count > LONG_PRESS_TIME_IR )
    
66.         {
    6 [" r  Q" F+ d2 J
67.       
    / R( i8 k  j) Q4 t4 y
68.             ScanKeyDef.PreKeyValue  = KEY_NONE; //无效按键
    
69.         }
    ) |2 P0 S" ]& L+ }8 I( t
70.     }
    " Z8 E4 s& P( Q6 q7 T. e  ?
71.     else//release & no press
    
72.     {
    ; W, |8 T# e& w) x2 N: S
73.         KeyReleaseTimeCount ++;
    ( d- G0 P, _! h+ s' _: \% ~
74.         if(KeyReleaseTimeCount >= KEY_RELEASE_TIME_OUT_IR)
    8 Y+ _8 t7 S, |' B
75.         {
      ?& Z5 _; T9 i" T3 ]9 S" T
76.   
    
77.             if ( ScanKeyDef.PreKeyValue != KEY_NONE ) //释放按键值
    ) e# Y0 n3 J, @1 [0 ?
78.             {
    
79.                 if ( ScanKeyDef.LongkeyFlag == 0 )
    6 c# n# t7 B, A) k4 }6 E! q
80.                 {
    
81.            
    6 R3 n  R* a$ L/ d
82.                     KeyValue =ScanKeyDef.PreKeyValue ;
    
83.                 }
    
84.             }         
    ; |% \5 H" {4 N3 z+ o. s
85.             ScanKeyDef.count  = 0;
    0 o3 ?3 _( ^7 p2 v0 P/ Y
86.             ScanKeyDef.LongkeyFlag = 0;
    : h0 C. p6 E9 x1 H. P' g9 O. e
87.            ScanKeyDef.PreKeyValue = KEY_NONE;
    
88.    
    7 _- v/ g4 K/ v5 j% Y3 T
89.         }
    
90.     }
    " x# l% m7 x6 a$ t7 t0 S
91.     return(KeyValue);
    
92. }     

复制代码

* [, n7 v$ k, j8 D

6 e# [3 K& x8 C2 c+ ^$ _& H

wakup引脚做普通按键两种用途应该都能吧，不过wakup之后需要重新配置各种功能，不知道有没有好的方法。
0 E2 g3 w$ H; c: p9 C! {2 X& K4 H

不错                 

确实不错        

很好的按键解决方法，学习了

很好的按键检测方法，学习了

不错，学习了！

不错，学习了！

学习了

学习，感谢楼主分享

可以的，学习一下

很好的学习资料，感谢楼主的好资料

学习中，谢谢分享。

不错，学习了

学习了