3 z6 B2 h& u7 w8 o6 e  o【MCU实战经验】+基于STM32和PID算法的小车车速控制
8 N5 }/ x/ u; n  X: m* [/ b1 s
【MCU实战经验】+ STM32F103RBT6三个USART发送与接收设置
( V3 u) m$ e* q% A( `% }
  I; V; a( F8 d1 ^- ?【MCU实战经验】+用stm32单片机做J-Link和ST-Link（PCB工程+固件库+资料工具）
' F! V/ d  a6 n" V4 I6 `
, s  k  z) R; \& o+ r3 `. D( O
+ t  K, x$ x! _* e* Q5 y( i" y3 }之前的一个项目按键比较多，面板上面有按键，遥控器，处理的稍微复杂一点，MCU使用的是STM8S005K6.
' A3 ~# S/ }& `6 N0 ~, i关于按键部分的处理，现在拿处理来和大家分享一下，说的不对的地方还请各位大侠请教，大家共同进步。
& G' f' p3 G/ S9 u  v! W7 Y) h; u6 e
; c) Q  c' u9 a# |9 V按键通常分有IO口按键（BUTTON),AD按键（通过AD采样电压），IR（遥控器）
按按键功能分：有短按键，长按键，连续按键。打个比方，遥控电视机，按一下音量键，音量增加1，这个就是短按键。
按住音量键不放，音量连续加，这个就是连续按键。按住一个按键5s,系统会复位，这个是长按键。

2 p% E0 j% }, N0 q怎么去处理这些不同的按键了，下面我们就细细来说
8 |3 ]# c) T( j: N
. L" T9 c. I/ [* S- u2 N1,IO口按键，就是我们比较常见的一个IO接一个按键，或者是一个矩阵键盘。很多新人的处理方法可能是采样延时的方法，当年我也是这样的，如下

1.     if(GETIO==low)
   
2.     {
   
3.       delay_10ms()
   % o' U$ ^: A3 k0 ~: z+ Z
4.       if(GETIO==low)
   ( q4 v: I. B1 a2 t+ J
5.       {
   
6.         //得到按键值
   
7.       }
   . l2 f* {1 B# U1 L/ [
8.     }

复制代码

   
4 L+ H) d2 N; c9 ^* |   这种方法虽然简单，但是有很大弊端。
   首先 Delay 浪费很多时间，影响系统。
   第二，无法判断长短按键，连续按键。
# q: d4 _. e, |6 n7 N1 T   第三，如果这个按键是开关机按键系统在低功耗状态下，需要中断唤醒，这种方法比较容易出问题，如STM8S系列的 halt 模式。
   
   所以我们一般在产品开发的过程中，采用扫描的方法，就是每隔10ms 去检测IO的状态，看是否有按键，然后去抖动，判断按键功能。
   
6 {( \: e- j( w: ]" K   参考代码如下，这段代码是之前在一个论坛看到的比我自己写的更加优秀，所以拿出来和大家分享一下，也顺便感谢一下作者。
2 I. T3 w# z8 w, O   这段代码，容易修改，可以根据自己的时间需要，进行长短按键，连续按键,还有组合按键的判断。
   
/ H' a- e  s5 v( m0 F   
; n" u) U0 M( L  }

1. /* 按键滤波时间50ms, 单位10ms
   
2. 只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   1 W+ ~  r# Y/ A& y3 |" P  ?& x
3. */
   ) ^0 ]6 u! \8 K
4. #define BUTTON_FILTER_TIME         5
   2 I6 A- e  g7 @  f. ]
5. #define BUTTON_LONG_TIME         300                /* 持续1秒，认为长按事件 */
   
6. 
   
7. /*
   
8.         每个按键对应1个全局的结构体变量。
   
9.         其成员变量是实现滤波和多种按键状态所必须的
   
10. */
    * I  }# X* p7 J
11. typedef struct
    
12. {
    
13.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
    ( G7 W  ~+ e; W$ w% ~0 Q, o
14.         unsigned char  (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
    
15. 
    2 c) x3 F4 [$ @& h2 P/ v
16.         unsigned char  Count;                        /* 滤波器计数器 */
    ' V$ o9 x) G7 }
17.         unsigned char  FilterTime;                /* 滤波时间(最大255,表示2550ms) */
    $ ]- l- q, \5 }, W
18.         unsigned short LongCount;                /* 长按计数器 */
    
19.         unsigned short LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    ' u' H  k; q1 a* H" c; S( Y0 I
20.         unsigned char   State;                        /* 按键当前状态（按下还是弹起） */
    
21.         unsigned char  KeyCodeUp;                /* 按键弹起的键值代码, 0表示不检测按键弹起 */
    ( K6 b5 u, Y8 `
22.         unsigned char  KeyCodeDown;        /* 按键按下的键值代码, 0表示不检测按键按下 */
    
23.         unsigned char  KeyCodeLong;        /* 按键长按的键值代码, 0表示不检测长按 */
    
24.         unsigned char  RepeatSpeed;        /* 连续按键周期 */
    3 m5 \) B3 a( l: k% M0 I
25.         unsigned char  RepeatCount;        /* 连续按键计数器 */
    
26. }BUTTON_T;
    " @3 M( m7 S( r) T- _# ?+ m1 X* _
27. 
    
28. typedef enum
    
29. {
    % O* H- h# i& j# {3 D0 c
30.         KEY_NONE = 0,                        /* 0 表示按键事件 */
    % I+ J  y, Z4 B* e  K) M! b
31. 
    5 p9 ]: O% N, `# ]; h- g8 O
32.         KEY_DOWN_Power,                        /* 按键键按下 */
    
33.         KEY_UP_Power,                        /* 按键键弹起 */
    
34.         KEY_LONG_Power,                        /* 按键键长按 */
    $ l: Z2 F7 t7 z2 \
35.         
    - u2 r$ w/ v  u1 U. f
36.         KEY_DOWN_Power_TAMPER        /* 组合键，Power键和WAKEUP键同时按下 */
    ) J3 f1 m: d- {, N
37. }KEY_ENUM;
    
38. 
    3 l7 m, F6 ]5 c8 f# w
39. BUTTON_T s_Powerkey;               
    
40. //是否有按键按下接口函数
    
41. unsigned char  IsKeyDownUser(void)                 
    . `) i. w; {2 n, i
42. {if (0==GPIO_ReadInputPin(POWER_KEY_PORT, POWER_KEY_PIN) ) return 1;return 0;}
    
43. 
    
44. 
    
45. void  PanakeyHard_Init(void)
    
46. {
    ! S7 H1 d+ w" F0 s) r9 r5 N% u% e6 I' Y! N
47.    GPIO_Init (POWER_KEY_PORT, POWER_KEY_PIN, GPIO_MODE_IN_FL_NO_IT);//power key
    ) `# z- b8 o: Y
48. }
    + }; ]7 G& {, @3 q/ t7 |
49. void  PanakeyVar_Init(void)
    6 m; C) e/ j9 z# ~+ A3 s4 c0 A1 z# o
50. {
    : d# f, X! K9 c: @. O* H& e
51.         /* 初始化USER按键变量，支持按下、弹起、长按 */
    . A  C. a, S; U( f( x- `# x
52.         s_Powerkey.IsKeyDownFunc = IsKeyDownUser;                /* 判断按键按下的函数 */
    3 o1 j5 M/ K$ f
53.         s_Powerkey.FilterTime = BUTTON_FILTER_TIME;                /* 按键滤波时间 */
    , \7 s. ^& K7 y0 ]
54.         s_Powerkey.LongTime = BUTTON_LONG_TIME;                        /* 长按时间 */
    # y2 B( A/ p' G7 V2 F. e3 a+ V" }# C
55.         s_Powerkey.Count = s_Powerkey.FilterTime / 2;                /* 计数器设置为滤波时间的一半 */
    
56.         s_Powerkey.State = 0;                                                        /* 按键缺省状态，0为未按下 */
    
57.         s_Powerkey.KeyCodeDown = KEY_DOWN_Power;                        /* 按键按下的键值代码 */
    # E/ K; d. _1 g- ?% `
58.         s_Powerkey.KeyCodeUp =KEY_UP_Power;                                /* 按键弹起的键值代码 */
    + Q$ e6 s" R6 q; x9 O. S
59.         s_Powerkey.KeyCodeLong = KEY_LONG_Power;                        /* 按键被持续按下的键值代码 */
    + U( }  E( {& \2 u% ?) T* \3 Z/ w
60.         s_Powerkey.RepeatSpeed = 0;                                                /* 按键连发的速度，0表示不支持连发 */
    . @7 r/ Z3 t6 L5 H3 U% @, z3 C
61.         s_Powerkey.RepeatCount = 0;                                                /* 连发计数器 */               
    
62. }
    
63. void Panakey_Init(void)
    . a. C( k( b; V8 V$ V
64. {
    
65.         PanakeyHard_Init();                /* 初始化按键变量 */
    + K0 f4 K8 }8 G) K" T6 ^
66.         PanakeyVar_Init();                /* 初始化按键硬件 */
    * n2 ^2 I; T0 c' A% \1 T
67. }

复制代码

*********************************************************************************************************
*        函 数 名: bsp_DetectButton
*        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
*        形    参：按键结构变量指针
*        返 回 值: 无
*********************************************************************************************************

1. */
   # d+ @) j: f( @9 z6 G* I
2. void Button_Detect(BUTTON_T *_pBtn)
   8 e, X) U" {1 G, d# ^6 N' M
3. {
   ' p* h! `. B" `2 k" [, [4 H
4.         if (_pBtn->IsKeyDownFunc())
   0 w# H& j" D. \" p/ ^
5.         {
   3 w( V; x  L+ T/ S1 j& b+ A
6.                 if (_pBtn->Count < _pBtn->FilterTime)
   6 k. s1 ~0 K( w( W" _9 Z6 @, O
7.                 {
   * e9 @7 \- G8 {  M
8.                         _pBtn->Count = _pBtn->FilterTime;
   6 L5 a$ h$ Y. I
9.                 }
   : D3 C5 Z  w5 c/ o. P3 `
10.                 else if(_pBtn->Count < 2 * _pBtn->FilterTime)
    2 L6 {% q( T# O7 r/ ]5 u) ~# |
11.                 {
    " k$ H  F; e- z% l0 `1 O
12.                         _pBtn->Count++;
    
13.                 }
    
14.                 else
    
15.                 {
    4 Z9 m- T1 ?: D% ?( }. ^
16.                         if (_pBtn->State == 0)
    , l) A0 s! y/ m
17.                         {
    
18.                                 _pBtn->State = 1;
    3 Q9 b9 V: a8 @8 A2 w* D
19. 
    
20.                                 /* 发送按钮按下的消息 */
    9 X* i/ y( b& ?# x- q9 C
21.                                 if (_pBtn->KeyCodeDown > 0)
    
22.                                 {
    
23.                                         /* 键值放入按键FIFO */
    1 n: ]# d% o7 g8 w, w3 z7 i/ q3 O5 a. i
24.                                         Pannelkey_Put(_pBtn->KeyCodeDown);// 记录按键按下标志，等待释放
    5 J. O1 R5 e5 Q/ w0 `  x1 M
25. 
    
26.                                 }
    
27.                         }
    
28. 
    
29.                         if (_pBtn->LongTime > 0)
    0 }. h  @' ~! s' O4 ?
30.                         {
    
31.                                 if (_pBtn->LongCount < _pBtn->LongTime)
    2 q& v9 N; m$ Y' F4 I. }, Q/ [
32.                                 {
    * `+ u+ S+ H: z1 c7 ^8 F
33.                                         /* 发送按钮持续按下的消息 */
    4 @2 l( d8 E0 Q
34.                                         if (++_pBtn->LongCount == _pBtn->LongTime)
    
35.                                         {
    2 r- B8 c1 T) x: x& x7 O5 S4 E! y
36.                                                 /* 键值放入按键FIFO */
    . @& [* E/ G0 ~8 |! e
37.                                                 Pannelkey_Put(_pBtn->KeyCodeLong);        
    ( p# k% t; H6 E) I
38.                                 
    5 H: m# Z/ J4 Y
39.                                         }
    # h1 X6 S! v# M. g  w1 X9 Z
40.                                 }
    
41.                                 else
    2 U* m0 Z  i; v# n
42.                                 {
    
43.                                         if (_pBtn->RepeatSpeed > 0)
    
44.                                         {
    5 n; R: B$ |+ g" v* d; G4 U
45.                                                 if (++_pBtn->RepeatCount >= _pBtn->RepeatSpeed)
    + x) a1 [* d$ u: x: C0 E
46.                                                 {
    
47.                                                         _pBtn->RepeatCount = 0;
    
48.                                                         /* 常按键后，每隔10ms发送1个按键 */
    
49.                                                         Pannelkey_Put(_pBtn->KeyCodeDown);        
    
50.                                 
    
51.                                                 }
    
52.                                         }
    $ Y$ ?5 P( h( q4 v. y- }' o
53.                                 }
    
54.                         }
    
55.                 }
    
56.         }
    
57.         else
    
58.         {
    0 C+ S' ~( x& s0 a  ?
59.                 if(_pBtn->Count > _pBtn->FilterTime)
    8 |# q8 i8 ]  V. ?1 v
60.                 {
    : z6 s# U6 F* R; a+ ?1 N
61.                         _pBtn->Count = _pBtn->FilterTime;
    
62.                 }
    ; H& @+ V5 N" r$ P
63.                 else if(_pBtn->Count != 0)
    
64.                 {
    
65.                         _pBtn->Count--;
    
66.                 }
    : k$ E" \0 i& ?* {
67.                 else
    ; u# [! f' J$ E4 v5 f5 z
68.                 {
    
69.                         if (_pBtn->State == 1)
    
70.                         {
    9 }0 e* J8 o! i: `; s. y
71.                                 _pBtn->State = 0;
    
72. 
    
73.                                 /* 发送按钮弹起的消息 */
    
74.                                 if (_pBtn->KeyCodeUp > 0) /*按键释放*/
    
75.                                 {
    
76.                                         /* 键值放入按键FIFO */
    
77.                                 Pannelkey_Put(_pBtn->KeyCodeUp);        
    4 r3 _! I7 e$ ]; _
78.                         
    
79.                                 }
    
80.                         }
    - z. n. t& o% x* O' ^! K6 @
81.                 }
    ( [1 j) |0 _$ v2 J# J+ E; P7 i& Y
82. 
    % U1 {+ H1 r& t" o" d1 N& t
83.                 _pBtn->LongCount = 0;
    
84.                 _pBtn->RepeatCount = 0;
    " @* b0 h5 e7 D9 \$ ~/ J
85.         }
    9 D- _: m5 R) k, U1 g3 X
86. }
    / A# k+ s  J9 N6 {
87. //功能说明: 检测所有按键。10MS 调用一次
    
88. void Pannelkey_Polling(void)
    
89. {
    8 ?8 L8 N' M4 o9 f
90.         Button_Detect(&s_Powerkey);                /* USER 键 */
    
91. }
    
92. void Pannelkey_Put（void)
    
93. {
    ' E7 K/ h9 d! T& V6 `
94.         
      s4 W, G$ z& k' G# V/ k( Q
95.   // 定义一个队列 放入按键值        
    ' B+ U* A0 F; `( p
96. }

复制代码

   
" u4 {$ C8 A7 I, a2,遥控器按键，遥控器解码的一般就有两种 脉宽调制和脉冲调制，这里就不细讲解码的过程了。这里详细解码之后，如何处理遥控器按键
   实现遥控器按键的长短按功能和连续按键功能。
1 j- m2 x1 F2 r8 d$ t" E   代码裁剪过，大家根据实际需要改动
  其实AD按键，通过AD采样获得按键值之后，可以采取如下面的一样方法处理，提一个函数接口即可

1.    typedef struct
   . F8 E# o& R3 z' ~6 @( `8 [0 A
2. {
   
3.   unsigned char count;//
   
4.   unsigned char LongkeyFlag;/*是否长按键，1代表是*/
   $ f4 V4 N6 b9 x  b; t
5.   unsigned char  PreKeyValue;/*按键值的一个备份，用于释放按键值*/
   
6.   
   
7. }ScanKeyDef;
   ) \) a9 q" L" T( a6 \/ P& B0 P; i
8. 
   
9. #define SHORT_PRESS_TIME_IR                16 // 10ms
   
10. #define SERIES_PRESS_TIME_IR            10  
    
11. #define LONG_PRESS_TIME_IR                    22
    
12. #define KEY_RELEASE_TIME_OUT_IR     12  // 10ms
    
13. //提供5个接口函数，如下。
    ' L1 `% _, O- D5 z! g2 K
14. unsigned char get_irkey(void);
    
15. unsigned char ISSeriesKey(unsigned char temp);//按键是否需要做连续按键
    0 R9 v7 ?7 R7 ^" G
16. unsigned char changeSeriesKey(unsigned char temp);//转换连续按键值
    1 e& u% e/ q4 I5 |/ f
17. unsigned char ISLongKey(unsigned char temp);//按键是否需要做连续按键
    $ U- Y* ]7 U6 w/ Y/ T8 [
18. unsigned char changeToLongKey(unsigned char temp);//转换连续按键值
    ( j% S. S3 G' D) \+ U( M" ?# M" s
19. 
    
20. 
    
21. unsigned char KeyScan(void)
    
22. {
    
23.     unsigned char  KeyValue = KEY_NONE,
    
24.                                 KeyValueTemp = KEY_NONE;
    
25.     static   unsigned char KeyReleaseTimeCount =0;
    
26. 
    % Q, i& y! H$ K' O; f% p' b
27.     KeyValueTemp = get_irkey();
    
28. 
    
29.     if(KeyValueTemp != KEY_NONE)
    
30.     {
    
31.         ScanKeyDef.count++;
    
32.         KeyReleaseTimeCount =0;
    
33. 
    . l# ~( L4 L% s: X  Y
34.         if(ScanKeyDef.count < LONG_PRESS_TIME_IR )
    
35.         {
    
36.             ScanKeyDef.LongkeyFlag = 0;
    
37.             if((ScanKeyDef.count == SERIES_PRESS_TIME_IR) && ISSeriesKey(KeyValueTemp)) //处理连续按键
    5 W8 Z! Z/ q" i, |" w
38.                 {
    
39.                     KeyValue = changeSeriesKey ( KeyValueTemp );
    : D. f: o2 a& ]+ l0 \# i& E
40.                     ScanKeyDef.PreKeyValue = KEY_NONE;
    / ]5 o/ b+ U$ e. I
41.                 }
    + ?  C( w/ v, x7 m( J  W
42.             else if ( ScanKeyDef.count  < SHORT_PRESS_TIME_IR )
    
43.             {
    
44.                 ScanKeyDef.PreKeyValue = KeyValueTemp;
    : F! v# S9 U! i  {9 V& f: f
45.             }
    
46.             else
    0 q/ d3 A7 D: _  I
47.             {
      F1 Y" f) V% g' n' G, L' |
48.             
    7 s# E- b  e1 y5 f
49.                 ScanKeyDef.PreKeyValue  = KEY_NONE; // 无效按键
    
50.             }
    
51.         }
    # {* j8 }: y" Y" ?3 P3 U/ R# R
52.         else if ( ScanKeyDef.count  == LONG_PRESS_TIME_IR )
    
53.         {
    
54.       
    
55.            if (ISLongKey(KeyValueTemp))
    ' s& n4 B! S& I' C5 D* e
56.             {
    5 p) _, d8 J2 h8 e: W+ X, [4 E
57.                 {
    
58.                    ScanKeyDef.LongkeyFlag = 1;
    
59.                    KeyValue = changeToLongKey ( KeyValueTemp );
    4 ?8 n" n. L( I& [' D
60.                }
    4 y+ E3 ^# d* [3 ?* {; T6 s
61.           }
    
62.             ScanKeyDef.PreKeyValue = KEY_NONE;
    
63.          
    & Z# n- h, Z5 r: o$ o
64.         }
    
65.         else if (ScanKeyDef.count > LONG_PRESS_TIME_IR )
    * m/ m( Z" F0 h) C8 @
66.         {
    
67.       
    
68.             ScanKeyDef.PreKeyValue  = KEY_NONE; //无效按键
    8 h: a. M  _4 Z: S+ M
69.         }
    ; n/ P- h$ L2 k& q0 u
70.     }
    ( {+ W' j. |: w7 U$ P9 I# L4 ]
71.     else//release & no press
    
72.     {
    * i3 p$ ]. D7 I5 W! u1 U+ i  k8 H
73.         KeyReleaseTimeCount ++;
    
74.         if(KeyReleaseTimeCount >= KEY_RELEASE_TIME_OUT_IR)
    ; W& w1 F) Z. W3 v; G+ ^
75.         {
    
76.   
      R% ~2 p7 v6 c( X% ?
77.             if ( ScanKeyDef.PreKeyValue != KEY_NONE ) //释放按键值
    : G. J- g7 M  y$ I; t' P
78.             {
    
79.                 if ( ScanKeyDef.LongkeyFlag == 0 )
    % {( E  O+ |6 i
80.                 {
    
81.            
    
82.                     KeyValue =ScanKeyDef.PreKeyValue ;
    : g+ Z8 K9 m6 y; E6 i
83.                 }
    
84.             }         
    
85.             ScanKeyDef.count  = 0;
    ! _2 N* a8 M3 _" g. X+ N& r$ A% Z/ P) g
86.             ScanKeyDef.LongkeyFlag = 0;
    
87.            ScanKeyDef.PreKeyValue = KEY_NONE;
    - r: N5 e- a  {; g& t$ \/ d
88.    
    
89.         }
    
90.     }
    
91.     return(KeyValue);
    $ n5 g* q" x4 K0 {
92. }     

复制代码

% ~# v4 F/ G2 M

wakup引脚做普通按键两种用途应该都能吧，不过wakup之后需要重新配置各种功能，不知道有没有好的方法。

不错                 

确实不错        

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

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

不错，学习了！

不错，学习了！

学习了

学习，感谢楼主分享

可以的，学习一下

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

学习中，谢谢分享。
8 `2 B$ r5 n* f# F

不错，学习了

学习了