【MCU实战经验】+基于STM32和PID算法的小车车速控制
, Z. Y1 F+ W; d& o" H, E% m
( b  i+ h! S  ~. q5 L/ l【MCU实战经验】+ STM32F103RBT6三个USART发送与接收设置
6 o& x5 {; y2 [  H, _, }
) T; L8 T) y1 l2 Y4 ?. ^; G6 ^* f【MCU实战经验】+用stm32单片机做J-Link和ST-Link（PCB工程+固件库+资料工具）
, k$ R  ~5 S# B: I

; T" L) I, G3 d1 |: X3 O$ X之前的一个项目按键比较多，面板上面有按键，遥控器，处理的稍微复杂一点，MCU使用的是STM8S005K6.
关于按键部分的处理，现在拿处理来和大家分享一下，说的不对的地方还请各位大侠请教，大家共同进步。

按键通常分有IO口按键（BUTTON),AD按键（通过AD采样电压），IR（遥控器）
按按键功能分：有短按键，长按键，连续按键。打个比方，遥控电视机，按一下音量键，音量增加1，这个就是短按键。
按住音量键不放，音量连续加，这个就是连续按键。按住一个按键5s,系统会复位，这个是长按键。

怎么去处理这些不同的按键了，下面我们就细细来说
; `* B* @0 z% K2 z) K1 v  L' Q
8 y# f4 C: l% e# z) O1,IO口按键，就是我们比较常见的一个IO接一个按键，或者是一个矩阵键盘。很多新人的处理方法可能是采样延时的方法，当年我也是这样的，如下
9 N) p5 u; W" Z

1.     if(GETIO==low)
   " a" `# r4 Y* i( d4 r9 q! v; \
2.     {
   : O6 i0 r6 A  j0 q% x
3.       delay_10ms()
   / l% W5 k7 D* S  U7 X
4.       if(GETIO==low)
   / z$ i: g! ~8 b- r
5.       {
   , t' v( {5 }; u9 d- q. P1 S6 Y  U
6.         //得到按键值
   5 B& S5 _1 v" _' Y+ X
7.       }
   * n8 X/ k8 e- K
8.     }

复制代码

   
' R+ f8 ]* ~$ ]3 t% D- l2 `   这种方法虽然简单，但是有很大弊端。
4 ^3 r5 G* U8 y" s( u   首先 Delay 浪费很多时间，影响系统。
+ |. G( |- u3 l  f$ I   第二，无法判断长短按键，连续按键。
0 D( r' {6 Y; ~! t( E   第三，如果这个按键是开关机按键系统在低功耗状态下，需要中断唤醒，这种方法比较容易出问题，如STM8S系列的 halt 模式。
  E4 K- f3 J2 y, n   
- P; R0 Z( V# c+ k   所以我们一般在产品开发的过程中，采用扫描的方法，就是每隔10ms 去检测IO的状态，看是否有按键，然后去抖动，判断按键功能。
   
' W5 ]9 N* o7 O! S, q   参考代码如下，这段代码是之前在一个论坛看到的比我自己写的更加优秀，所以拿出来和大家分享一下，也顺便感谢一下作者。
   这段代码，容易修改，可以根据自己的时间需要，进行长短按键，连续按键,还有组合按键的判断。
   
$ W" X  [" z$ j   
0 S7 G9 i# v5 w8 A+ J, z8 h( n

1. /* 按键滤波时间50ms, 单位10ms
   + j4 g; B, x& u& H* g0 ?# L1 |
2. 只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   4 ]6 X% F: z) u2 L6 L  f
3. */
   
4. #define BUTTON_FILTER_TIME         5
   
5. #define BUTTON_LONG_TIME         300                /* 持续1秒，认为长按事件 */
   # P- j5 w' a# k; D6 V
6. 
   - E1 u3 ~( o* `% Y# }# T+ `/ K' U0 k
7. /*
   ; t' m6 W- F+ L7 \
8.         每个按键对应1个全局的结构体变量。
   
9.         其成员变量是实现滤波和多种按键状态所必须的
   $ @( ^* t+ f% F# O& T
10. */
    
11. typedef struct
    ' Y& Q9 \! g& c# J! d* i
12. {
    " V% C9 I' m& E
13.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
    
14.         unsigned char  (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
    # C7 E3 i0 A5 Y; r0 [1 j
15. 
    6 o5 E$ b" x; I6 `
16.         unsigned char  Count;                        /* 滤波器计数器 */
    $ k% F$ P2 m1 F( `
17.         unsigned char  FilterTime;                /* 滤波时间(最大255,表示2550ms) */
    
18.         unsigned short LongCount;                /* 长按计数器 */
    
19.         unsigned short LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    ) H& j% n  ~' Q
20.         unsigned char   State;                        /* 按键当前状态（按下还是弹起） */
    
21.         unsigned char  KeyCodeUp;                /* 按键弹起的键值代码, 0表示不检测按键弹起 */
    . t7 B( G( |- Z9 t4 O( v
22.         unsigned char  KeyCodeDown;        /* 按键按下的键值代码, 0表示不检测按键按下 */
    ( j' j6 S) L1 {$ B. \
23.         unsigned char  KeyCodeLong;        /* 按键长按的键值代码, 0表示不检测长按 */
    
24.         unsigned char  RepeatSpeed;        /* 连续按键周期 */
    
25.         unsigned char  RepeatCount;        /* 连续按键计数器 */
    
26. }BUTTON_T;
    - [6 c3 u: P" Q' x* d7 V' J- ~
27. 
    
28. typedef enum
    # l  f9 m2 G) v
29. {
    
30.         KEY_NONE = 0,                        /* 0 表示按键事件 */
    
31. 
    
32.         KEY_DOWN_Power,                        /* 按键键按下 */
    
33.         KEY_UP_Power,                        /* 按键键弹起 */
    
34.         KEY_LONG_Power,                        /* 按键键长按 */
    # x. x% N" X1 X' O( @
35.         
    : D7 D2 q$ G! o$ P  n
36.         KEY_DOWN_Power_TAMPER        /* 组合键，Power键和WAKEUP键同时按下 */
    
37. }KEY_ENUM;
    
38. 
    + m& d8 |( x8 B- D" K* s
39. BUTTON_T s_Powerkey;               
      x& A  a& |2 f& _) A
40. //是否有按键按下接口函数
    
41. unsigned char  IsKeyDownUser(void)                 
    * k# A3 h& h# g' ^' r
42. {if (0==GPIO_ReadInputPin(POWER_KEY_PORT, POWER_KEY_PIN) ) return 1;return 0;}
    
43. 
    
44. 
    & f8 A0 w& P6 P( X0 ]0 C
45. void  PanakeyHard_Init(void)
    
46. {
    
47.    GPIO_Init (POWER_KEY_PORT, POWER_KEY_PIN, GPIO_MODE_IN_FL_NO_IT);//power key
    ) F* s6 k$ ~& h
48. }
    
49. void  PanakeyVar_Init(void)
    , f5 Q# o' g. W
50. {
    
51.         /* 初始化USER按键变量，支持按下、弹起、长按 */
    ( N* f# e1 e9 k. v7 |
52.         s_Powerkey.IsKeyDownFunc = IsKeyDownUser;                /* 判断按键按下的函数 */
    
53.         s_Powerkey.FilterTime = BUTTON_FILTER_TIME;                /* 按键滤波时间 */
    4 ?8 e! x9 A/ R
54.         s_Powerkey.LongTime = BUTTON_LONG_TIME;                        /* 长按时间 */
    3 H) B! O0 m( u$ R) W+ K" V5 _
55.         s_Powerkey.Count = s_Powerkey.FilterTime / 2;                /* 计数器设置为滤波时间的一半 */
    
56.         s_Powerkey.State = 0;                                                        /* 按键缺省状态，0为未按下 */
    
57.         s_Powerkey.KeyCodeDown = KEY_DOWN_Power;                        /* 按键按下的键值代码 */
    ; W$ j3 d( Z% U7 O2 W4 ^
58.         s_Powerkey.KeyCodeUp =KEY_UP_Power;                                /* 按键弹起的键值代码 */
    
59.         s_Powerkey.KeyCodeLong = KEY_LONG_Power;                        /* 按键被持续按下的键值代码 */
    
60.         s_Powerkey.RepeatSpeed = 0;                                                /* 按键连发的速度，0表示不支持连发 */
    $ L9 z% c; n( \7 |0 J' I, f: T
61.         s_Powerkey.RepeatCount = 0;                                                /* 连发计数器 */               
    * I' |) x2 D: @$ q) k: i6 y) o" P
62. }
    8 F# A* k) }/ j+ o/ w( f
63. void Panakey_Init(void)
    & ^5 d  m! y. y2 e5 k1 b/ a9 P! n
64. {
    
65.         PanakeyHard_Init();                /* 初始化按键变量 */
    0 Z/ z& T( P2 b6 i# _* W$ a
66.         PanakeyVar_Init();                /* 初始化按键硬件 */
    
67. }

复制代码

*********************************************************************************************************
' t8 T6 l6 |- I- p*        函 数 名: bsp_DetectButton
; y; [, M8 D! V*        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
*        形    参：按键结构变量指针
0 w2 e& A# u( r& X  i9 a' N: u! _*        返 回 值: 无
5 K! `7 t: Z4 v$ R0 J$ I4 _8 P: Q*********************************************************************************************************

1. */
   : C9 H2 U% y5 Q) a0 Z
2. void Button_Detect(BUTTON_T *_pBtn)
   % C2 T" }) j+ F- P2 V
3. {
   " H: t0 O) ~6 i* u! _0 K
4.         if (_pBtn->IsKeyDownFunc())
   6 x9 k8 G1 O9 Y: S
5.         {
   2 Y' E& h5 {: R8 a$ }8 {8 P
6.                 if (_pBtn->Count < _pBtn->FilterTime)
   " u+ A- M! \+ ]( M
7.                 {
   . [5 b, p2 ^1 @% j6 N) }) I5 A
8.                         _pBtn->Count = _pBtn->FilterTime;
   ' u* ?( n" k# P, }7 s
9.                 }
   
10.                 else if(_pBtn->Count < 2 * _pBtn->FilterTime)
    
11.                 {
    
12.                         _pBtn->Count++;
    
13.                 }
    , T, O( J7 u+ ^" o3 e7 `- z* ]
14.                 else
    & W2 V; [( ?# z2 [1 r1 X! F
15.                 {
    ! P2 ^$ {9 A# T0 }- {5 Q5 t4 [& W( z
16.                         if (_pBtn->State == 0)
    
17.                         {
    ' r( u7 X% W. H3 r4 z' D
18.                                 _pBtn->State = 1;
    
19. 
    ! h9 p8 d* j6 `7 [) t+ V
20.                                 /* 发送按钮按下的消息 */
    
21.                                 if (_pBtn->KeyCodeDown > 0)
    
22.                                 {
    ! J- O6 @1 W/ V' _3 i
23.                                         /* 键值放入按键FIFO */
    
24.                                         Pannelkey_Put(_pBtn->KeyCodeDown);// 记录按键按下标志，等待释放
    9 f$ N! T8 g% a$ F: N/ n: G
25. 
    
26.                                 }
    
27.                         }
    
28. 
    8 l# K3 w, a/ A4 ^
29.                         if (_pBtn->LongTime > 0)
    9 }( X% D& N) O  }" q- M
30.                         {
    & V3 O, D9 {/ d2 ~4 A
31.                                 if (_pBtn->LongCount < _pBtn->LongTime)
    7 x7 b8 ?: N9 R7 T4 L, Y' |* j; H/ D
32.                                 {
    + N1 {! m5 U6 b) O, b
33.                                         /* 发送按钮持续按下的消息 */
    % p+ [# K7 O4 L+ v% ~
34.                                         if (++_pBtn->LongCount == _pBtn->LongTime)
    4 L5 m7 o" V1 X/ Z$ f
35.                                         {
    
36.                                                 /* 键值放入按键FIFO */
    
37.                                                 Pannelkey_Put(_pBtn->KeyCodeLong);        
    
38.                                 
    
39.                                         }
    
40.                                 }
    
41.                                 else
    
42.                                 {
    
43.                                         if (_pBtn->RepeatSpeed > 0)
    & e+ N' R# G& q
44.                                         {
    
45.                                                 if (++_pBtn->RepeatCount >= _pBtn->RepeatSpeed)
    - w! _  u" x( U9 F# c0 p
46.                                                 {
    ; `& [3 ]6 O- k: I+ m" t
47.                                                         _pBtn->RepeatCount = 0;
    
48.                                                         /* 常按键后，每隔10ms发送1个按键 */
    1 p9 }' L+ O6 D. J  ]5 }. R
49.                                                         Pannelkey_Put(_pBtn->KeyCodeDown);        
    + v( w' @) o) q3 \1 @: t
50.                                 
    
51.                                                 }
    
52.                                         }
    % m- O9 h8 J# S/ {$ q. B6 d' X
53.                                 }
    
54.                         }
    # F1 n9 j- _- Y; u6 }
55.                 }
    
56.         }
    2 X3 }4 r# ~% I1 D
57.         else
    5 V- `. z. Y# d1 ^& |* m
58.         {
    $ U; w' Q( _1 e) m- E, e
59.                 if(_pBtn->Count > _pBtn->FilterTime)
    
60.                 {
    5 t; }9 u6 }, @! X; s+ Y9 n( }( q
61.                         _pBtn->Count = _pBtn->FilterTime;
    
62.                 }
    $ ^4 ^# v$ n& O  u
63.                 else if(_pBtn->Count != 0)
    $ G0 m. k: }& m2 j
64.                 {
    
65.                         _pBtn->Count--;
    
66.                 }
    
67.                 else
    ; e, p. P- J# T/ e7 k
68.                 {
    
69.                         if (_pBtn->State == 1)
    ( s$ d( [6 R0 }/ Z$ P
70.                         {
    
71.                                 _pBtn->State = 0;
    
72. 
    6 [8 |0 [6 N. V7 e$ {5 W
73.                                 /* 发送按钮弹起的消息 */
    
74.                                 if (_pBtn->KeyCodeUp > 0) /*按键释放*/
    
75.                                 {
    
76.                                         /* 键值放入按键FIFO */
    3 t( _4 a0 M; A8 M8 d" T* A1 _
77.                                 Pannelkey_Put(_pBtn->KeyCodeUp);        
    
78.                         
    9 d; q7 L) V1 r+ y/ Z+ |5 X( I
79.                                 }
    1 `- d# ~7 `1 n4 W
80.                         }
    6 k; \! T0 E2 u  M( n* T$ H
81.                 }
    6 b* W* S' d( @4 G+ \& r/ w& ^% V; ^( i
82. 
    ' V. L  v; W. r
83.                 _pBtn->LongCount = 0;
      P0 s7 T& ^* I
84.                 _pBtn->RepeatCount = 0;
    2 i1 Y; e4 o5 n1 \- ~6 b
85.         }
    
86. }
    
87. //功能说明: 检测所有按键。10MS 调用一次
    
88. void Pannelkey_Polling(void)
    
89. {
    
90.         Button_Detect(&s_Powerkey);                /* USER 键 */
    ) ?8 _# q$ |( l( e4 i7 {
91. }
    
92. void Pannelkey_Put（void)
    
93. {
    
94.         
    
95.   // 定义一个队列 放入按键值        
    2 K9 Q0 p+ k3 `
96. }

复制代码

   
2,遥控器按键，遥控器解码的一般就有两种 脉宽调制和脉冲调制，这里就不细讲解码的过程了。这里详细解码之后，如何处理遥控器按键
4 x1 W' w2 A3 ]) t  a1 R   实现遥控器按键的长短按功能和连续按键功能。
   代码裁剪过，大家根据实际需要改动
& k- ?2 d, S: e+ D) S  其实AD按键，通过AD采样获得按键值之后，可以采取如下面的一样方法处理，提一个函数接口即可

1.    typedef struct
   5 s0 r! M2 t2 y
2. {
   % s  z" Q8 i( H# O
3.   unsigned char count;//
     K# w. R( X9 V
4.   unsigned char LongkeyFlag;/*是否长按键，1代表是*/
   
5.   unsigned char  PreKeyValue;/*按键值的一个备份，用于释放按键值*/
   ) w# s2 U1 @3 w# z2 G6 I
6.   
   
7. }ScanKeyDef;
   + q7 G( H# k7 W, V5 e6 ], L* b4 V8 U
8. 
   
9. #define SHORT_PRESS_TIME_IR                16 // 10ms
   
10. #define SERIES_PRESS_TIME_IR            10  
    ( o% H5 ^4 C) s
11. #define LONG_PRESS_TIME_IR                    22
    
12. #define KEY_RELEASE_TIME_OUT_IR     12  // 10ms
    5 j* a+ i' N2 S) |
13. //提供5个接口函数，如下。
    9 h* @( p4 b& H$ M& k* |$ \. u
14. unsigned char get_irkey(void);
    0 ], I5 b7 H3 U) J- h& U; G
15. unsigned char ISSeriesKey(unsigned char temp);//按键是否需要做连续按键
    
16. unsigned char changeSeriesKey(unsigned char temp);//转换连续按键值
    6 E1 U8 E6 a/ P4 r' \$ M! g
17. unsigned char ISLongKey(unsigned char temp);//按键是否需要做连续按键
    5 P7 s! u/ x" o9 k5 h3 W( O- j
18. unsigned char changeToLongKey(unsigned char temp);//转换连续按键值
      j$ L1 z8 S/ v, ]( O$ B
19. 
    
20. 
    + u+ I: u/ _' S: n$ _, I" B' P) T
21. unsigned char KeyScan(void)
    ! p% `4 u$ G) N+ U! ^! N, L
22. {
    
23.     unsigned char  KeyValue = KEY_NONE,
    : a) x) Q3 j$ P9 i6 X+ v) J" q
24.                                 KeyValueTemp = KEY_NONE;
    $ `% {3 O/ k# l* ]  E" \6 ]/ m: ~
25.     static   unsigned char KeyReleaseTimeCount =0;
    
26. 
    
27.     KeyValueTemp = get_irkey();
    
28. 
    , ?, m( N7 G. U; z! e5 @* i
29.     if(KeyValueTemp != KEY_NONE)
    $ W/ V3 {5 [4 k+ l' y3 A$ {
30.     {
    ; L% v: @& U7 M
31.         ScanKeyDef.count++;
      e+ ]6 E5 ?; }9 g! J! T% }
32.         KeyReleaseTimeCount =0;
    8 f- C0 ~( a% y% Y$ e! n% z
33. 
    , r# \/ t0 X" b8 ~6 T4 @( B$ ?
34.         if(ScanKeyDef.count < LONG_PRESS_TIME_IR )
    0 c- W6 A: l' {% u1 }, |
35.         {
    
36.             ScanKeyDef.LongkeyFlag = 0;
    
37.             if((ScanKeyDef.count == SERIES_PRESS_TIME_IR) && ISSeriesKey(KeyValueTemp)) //处理连续按键
    1 {' L, C- }6 e" z; Q" w
38.                 {
    
39.                     KeyValue = changeSeriesKey ( KeyValueTemp );
    
40.                     ScanKeyDef.PreKeyValue = KEY_NONE;
    5 Y) n; L* b$ Z8 M6 e; X
41.                 }
    
42.             else if ( ScanKeyDef.count  < SHORT_PRESS_TIME_IR )
    
43.             {
    
44.                 ScanKeyDef.PreKeyValue = KeyValueTemp;
    + I+ y0 \% n2 h* U
45.             }
    : I" p4 x0 m" K1 W, E
46.             else
    
47.             {
    
48.             
    ! [: M! F) e$ L2 V' ]
49.                 ScanKeyDef.PreKeyValue  = KEY_NONE; // 无效按键
    * [5 O6 {5 L$ e) E) A2 K0 }( h
50.             }
    ! s* ^0 P, y% x# `8 [6 n4 [- M
51.         }
    % c" a0 U: j% |# N$ v% n# O
52.         else if ( ScanKeyDef.count  == LONG_PRESS_TIME_IR )
    
53.         {
    . |) q  @& y, g/ j# s3 _
54.       
    1 N- K0 s2 |; U5 P8 r
55.            if (ISLongKey(KeyValueTemp))
    
56.             {
    
57.                 {
    
58.                    ScanKeyDef.LongkeyFlag = 1;
    
59.                    KeyValue = changeToLongKey ( KeyValueTemp );
    
60.                }
    
61.           }
    & Y3 {2 ?- _+ j/ I& `# @1 }
62.             ScanKeyDef.PreKeyValue = KEY_NONE;
    
63.          
    
64.         }
    8 V5 f7 {) X6 ?  d& Z9 ?
65.         else if (ScanKeyDef.count > LONG_PRESS_TIME_IR )
    6 o; h9 Y; R% I6 a; [
66.         {
    0 u+ w& I. j+ |/ P" E
67.       
    & K3 \4 n5 H9 F# f
68.             ScanKeyDef.PreKeyValue  = KEY_NONE; //无效按键
    
69.         }
    
70.     }
    - S3 O! ]! c4 w/ z
71.     else//release & no press
    0 X1 U3 q8 H% q6 r+ X  X) J
72.     {
    
73.         KeyReleaseTimeCount ++;
    
74.         if(KeyReleaseTimeCount >= KEY_RELEASE_TIME_OUT_IR)
    
75.         {
    8 R1 z0 N# Z: @
76.   
    
77.             if ( ScanKeyDef.PreKeyValue != KEY_NONE ) //释放按键值
    ! P# N- ?& P' Z% W% p- x
78.             {
    / s( d! _, O% e2 A
79.                 if ( ScanKeyDef.LongkeyFlag == 0 )
    
80.                 {
    6 r; K8 C! a  a- t
81.            
    $ _! E) b- D7 A; i3 N) v
82.                     KeyValue =ScanKeyDef.PreKeyValue ;
    
83.                 }
    
84.             }         
    ) A# [( O) \0 h, ~$ L" q7 J( d
85.             ScanKeyDef.count  = 0;
    ' |2 e( c5 s' o# m$ M' {
86.             ScanKeyDef.LongkeyFlag = 0;
    
87.            ScanKeyDef.PreKeyValue = KEY_NONE;
    & Z5 G4 _. T8 ], |& V$ g) d; M
88.    
    3 ~1 a0 v  M" q6 p7 d' J) M
89.         }
    + E4 V) G9 Z# ^  _' s
90.     }
    & w: m/ v, R; f- x  |
91.     return(KeyValue);
    
92. }     

复制代码

' f9 q2 V3 u# s+ {/ Q

wakup引脚做普通按键两种用途应该都能吧，不过wakup之后需要重新配置各种功能，不知道有没有好的方法。
0 T  k9 P) B+ I0 d' w

不错                 

确实不错        

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

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

不错，学习了！

不错，学习了！

学习了

学习，感谢楼主分享

可以的，学习一下

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

学习中，谢谢分享。
8 z1 d; V% ^! W( @  S. \

不错，学习了

学习了