【MCU实战经验】+基于STM32和PID算法的小车车速控制
7 ~: _: m0 B( j. L: K( c- F, m, v
【MCU实战经验】+ STM32F103RBT6三个USART发送与接收设置

8 B4 S7 x3 `3 y# U  T5 [. A* ?3 A% `# f9 E【MCU实战经验】+用stm32单片机做J-Link和ST-Link（PCB工程+固件库+资料工具）
' N8 y4 ]: ]. N9 z. A
$ j% f" ]) k2 K6 W: s. c, n1 \. ]* V! l
8 h" ?: N7 ~4 K8 I1 x5 _之前的一个项目按键比较多，面板上面有按键，遥控器，处理的稍微复杂一点，MCU使用的是STM8S005K6.
关于按键部分的处理，现在拿处理来和大家分享一下，说的不对的地方还请各位大侠请教，大家共同进步。

1 K' y8 i& ^( U* Q按键通常分有IO口按键（BUTTON),AD按键（通过AD采样电压），IR（遥控器）
2 ?' X. b% S: B& C- v按按键功能分：有短按键，长按键，连续按键。打个比方，遥控电视机，按一下音量键，音量增加1，这个就是短按键。
按住音量键不放，音量连续加，这个就是连续按键。按住一个按键5s,系统会复位，这个是长按键。

" a  e& b; S  L9 y& [怎么去处理这些不同的按键了，下面我们就细细来说
  M/ |" q, S# B& `0 G1 g
" q. ^5 F/ y' L/ c) Y" R9 l; m/ G8 ]1,IO口按键，就是我们比较常见的一个IO接一个按键，或者是一个矩阵键盘。很多新人的处理方法可能是采样延时的方法，当年我也是这样的，如下

1.     if(GETIO==low)
   
2.     {
   4 O4 \* u9 q% X' D
3.       delay_10ms()
   - r1 f; d9 j# s% c, B  B) s
4.       if(GETIO==low)
   / d! k" X! Z; B) v( i
5.       {
   7 W; Q  g3 [& |9 V
6.         //得到按键值
   8 F/ w8 g! n5 j1 c. T3 o
7.       }
   
8.     }

复制代码

   
9 I  a* ?! |& L; O1 f! E" b   这种方法虽然简单，但是有很大弊端。
- ^  h6 t$ q9 h& z7 E4 V   首先 Delay 浪费很多时间，影响系统。
4 U4 x+ h; X! J9 z9 V   第二，无法判断长短按键，连续按键。
   第三，如果这个按键是开关机按键系统在低功耗状态下，需要中断唤醒，这种方法比较容易出问题，如STM8S系列的 halt 模式。
% k: B! `4 l( D   
1 ~8 V/ g. s6 c/ I# }$ ]; _5 u   所以我们一般在产品开发的过程中，采用扫描的方法，就是每隔10ms 去检测IO的状态，看是否有按键，然后去抖动，判断按键功能。
  F+ X# t3 Y# u$ Z, @" T   
: B& _$ m$ X6 Q, H" I   参考代码如下，这段代码是之前在一个论坛看到的比我自己写的更加优秀，所以拿出来和大家分享一下，也顺便感谢一下作者。
+ H4 I2 m8 E1 I* c; y; g4 a) A   这段代码，容易修改，可以根据自己的时间需要，进行长短按键，连续按键,还有组合按键的判断。
/ e! f$ j/ J3 k8 M+ `! Q! f% u   
   

1. /* 按键滤波时间50ms, 单位10ms
   ( T. E! z1 O5 N4 O  j# T4 g
2. 只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   
3. */
   
4. #define BUTTON_FILTER_TIME         5
   
5. #define BUTTON_LONG_TIME         300                /* 持续1秒，认为长按事件 */
   
6. 
   
7. /*
   * K" M# d  U& A+ L# u0 D) D
8.         每个按键对应1个全局的结构体变量。
   ; G. i& k4 R% [  X% R+ Y, g: g
9.         其成员变量是实现滤波和多种按键状态所必须的
   
10. */
    
11. typedef struct
    & ]  ]" {$ [* x, i5 ~
12. {
    5 B# E) m3 m6 w, E  r
13.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
    + W( @# F- ?  L0 x5 k+ O4 N7 N4 \6 @
14.         unsigned char  (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
    
15. 
    
16.         unsigned char  Count;                        /* 滤波器计数器 */
    ! ]+ E& d$ b/ V/ y6 q; V
17.         unsigned char  FilterTime;                /* 滤波时间(最大255,表示2550ms) */
    ) ^4 q: H0 ]  h
18.         unsigned short LongCount;                /* 长按计数器 */
    
19.         unsigned short LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    $ A% f  t7 i3 y8 W- l& f
20.         unsigned char   State;                        /* 按键当前状态（按下还是弹起） */
    9 G+ n5 I' n+ Y, e& i
21.         unsigned char  KeyCodeUp;                /* 按键弹起的键值代码, 0表示不检测按键弹起 */
    
22.         unsigned char  KeyCodeDown;        /* 按键按下的键值代码, 0表示不检测按键按下 */
    
23.         unsigned char  KeyCodeLong;        /* 按键长按的键值代码, 0表示不检测长按 */
    
24.         unsigned char  RepeatSpeed;        /* 连续按键周期 */
    
25.         unsigned char  RepeatCount;        /* 连续按键计数器 */
    
26. }BUTTON_T;
    
27. 
    
28. typedef enum
    
29. {
    1 a' T( z* i: }
30.         KEY_NONE = 0,                        /* 0 表示按键事件 */
    ! d$ \- ?) w8 ^, A0 |
31. 
    9 M$ j$ G8 i3 y( U/ n& Y' ^
32.         KEY_DOWN_Power,                        /* 按键键按下 */
    * a/ O5 M$ J" k/ q4 K5 L& L5 ^- P
33.         KEY_UP_Power,                        /* 按键键弹起 */
    
34.         KEY_LONG_Power,                        /* 按键键长按 */
    
35.         
    ' |) E$ c+ N$ {  d
36.         KEY_DOWN_Power_TAMPER        /* 组合键，Power键和WAKEUP键同时按下 */
    
37. }KEY_ENUM;
    0 R4 e* R$ ^' A( Q# r
38. 
    
39. BUTTON_T s_Powerkey;               
    
40. //是否有按键按下接口函数
    * Q# O  E3 w& x0 @1 e
41. unsigned char  IsKeyDownUser(void)                 
    
42. {if (0==GPIO_ReadInputPin(POWER_KEY_PORT, POWER_KEY_PIN) ) return 1;return 0;}
    + }$ U! S2 S' |- ^7 s/ r
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
    " d5 y9 P2 ?1 p; D
48. }
    & G( v+ C+ }! ?  Y% Y$ W# _" z
49. void  PanakeyVar_Init(void)
    : m5 ^. U4 V, Q4 N% U/ w) _+ o. y
50. {
    ; F. p( c* |% W' {: v9 e7 c4 s
51.         /* 初始化USER按键变量，支持按下、弹起、长按 */
    , A0 [$ L1 i5 L$ K! y: i" G
52.         s_Powerkey.IsKeyDownFunc = IsKeyDownUser;                /* 判断按键按下的函数 */
    
53.         s_Powerkey.FilterTime = BUTTON_FILTER_TIME;                /* 按键滤波时间 */
    ! ^, o6 x2 x( ~7 Z
54.         s_Powerkey.LongTime = BUTTON_LONG_TIME;                        /* 长按时间 */
    
55.         s_Powerkey.Count = s_Powerkey.FilterTime / 2;                /* 计数器设置为滤波时间的一半 */
    
56.         s_Powerkey.State = 0;                                                        /* 按键缺省状态，0为未按下 */
    9 J7 ^9 P; A* ^7 J& B
57.         s_Powerkey.KeyCodeDown = KEY_DOWN_Power;                        /* 按键按下的键值代码 */
    
58.         s_Powerkey.KeyCodeUp =KEY_UP_Power;                                /* 按键弹起的键值代码 */
    # \- [* G1 V$ ~. l+ c) n9 R
59.         s_Powerkey.KeyCodeLong = KEY_LONG_Power;                        /* 按键被持续按下的键值代码 */
    $ r5 A+ Q* f/ B0 V
60.         s_Powerkey.RepeatSpeed = 0;                                                /* 按键连发的速度，0表示不支持连发 */
    
61.         s_Powerkey.RepeatCount = 0;                                                /* 连发计数器 */               
    
62. }
    
63. void Panakey_Init(void)
    8 H* Q6 T( E  G$ E# N
64. {
    
65.         PanakeyHard_Init();                /* 初始化按键变量 */
    
66.         PanakeyVar_Init();                /* 初始化按键硬件 */
    
67. }

复制代码

* Z6 Z# L, G- P8 E$ l+ J0 R) w& ?4 Q*********************************************************************************************************
8 v2 H- W" I1 l0 W2 s*        函 数 名: bsp_DetectButton
, B7 V' I& Q" C. |/ q$ d3 _, N( q*        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
*        形    参：按键结构变量指针
*        返 回 值: 无
*********************************************************************************************************

1. */
   4 U" z1 M  s8 o5 a( [/ I. O
2. void Button_Detect(BUTTON_T *_pBtn)
   ; J8 c- [$ |" K) {. w
3. {
   ( f: @! g3 d- m$ ]  x) M, T
4.         if (_pBtn->IsKeyDownFunc())
   9 i; P1 q4 z2 p; w0 W
5.         {
   % H9 w- d' k  |* W
6.                 if (_pBtn->Count < _pBtn->FilterTime)
   # O% b9 F0 Z4 [% t' K
7.                 {
   & g3 b$ D: i; U( Z. c( m( |
8.                         _pBtn->Count = _pBtn->FilterTime;
   : [; V2 d/ k& s8 R
9.                 }
   
10.                 else if(_pBtn->Count < 2 * _pBtn->FilterTime)
    
11.                 {
    
12.                         _pBtn->Count++;
    
13.                 }
    2 }( r+ A  {2 h# [* @6 A9 X, V
14.                 else
    6 u6 x& u1 |# w0 \# A" V- U4 s
15.                 {
    ' c( J/ Z1 g1 i9 U  W' C
16.                         if (_pBtn->State == 0)
    " m3 }# {! @  K
17.                         {
    
18.                                 _pBtn->State = 1;
    
19. 
    5 N+ i; V0 j% v: s# \9 `: K5 c4 U
20.                                 /* 发送按钮按下的消息 */
    2 G/ j4 C5 s6 U% L: H
21.                                 if (_pBtn->KeyCodeDown > 0)
    
22.                                 {
    
23.                                         /* 键值放入按键FIFO */
    . m6 ?# {, r' [5 W* w
24.                                         Pannelkey_Put(_pBtn->KeyCodeDown);// 记录按键按下标志，等待释放
    
25. 
    
26.                                 }
    
27.                         }
    , w+ }! a. \5 c
28. 
    , S# p4 x2 O( F2 G5 ^& B
29.                         if (_pBtn->LongTime > 0)
    3 [# B: p8 }1 d
30.                         {
    + A: K7 K4 u7 R' M1 k
31.                                 if (_pBtn->LongCount < _pBtn->LongTime)
    
32.                                 {
    
33.                                         /* 发送按钮持续按下的消息 */
    % P: K. c9 s- n# b3 @( I# D
34.                                         if (++_pBtn->LongCount == _pBtn->LongTime)
    . f5 [7 l; C( Q# c. z# @
35.                                         {
    
36.                                                 /* 键值放入按键FIFO */
    8 {8 g9 l# g& j( h
37.                                                 Pannelkey_Put(_pBtn->KeyCodeLong);        
    
38.                                 
    
39.                                         }
    " M8 `9 E! A' W& {) b' f8 _+ i' w
40.                                 }
    , x3 P# J* c4 u
41.                                 else
    $ Q. `7 R; z# _% l% q4 s
42.                                 {
    
43.                                         if (_pBtn->RepeatSpeed > 0)
    
44.                                         {
    $ K0 Y, U" H/ ?8 r1 H6 u2 d; l# k
45.                                                 if (++_pBtn->RepeatCount >= _pBtn->RepeatSpeed)
    
46.                                                 {
    + h! D5 P( Z$ ~1 Q( o3 x" S1 f
47.                                                         _pBtn->RepeatCount = 0;
    
48.                                                         /* 常按键后，每隔10ms发送1个按键 */
    
49.                                                         Pannelkey_Put(_pBtn->KeyCodeDown);        
    9 ~' u# C0 E5 x& _" }
50.                                 
    4 s5 Q/ p# D& i& `1 Q) D
51.                                                 }
    
52.                                         }
    & D& R) Q( ~7 K, y+ Q$ I* f6 G4 V
53.                                 }
    - i% |5 T; y) r! [, B
54.                         }
    0 f* s, x* I  D
55.                 }
    
56.         }
    
57.         else
    / e! ]4 B% |6 u8 w# x/ k
58.         {
    ( ?- p5 }% o0 ]: V; H) o
59.                 if(_pBtn->Count > _pBtn->FilterTime)
    ( `/ N7 V4 B! F; u1 j: a; N
60.                 {
    
61.                         _pBtn->Count = _pBtn->FilterTime;
    
62.                 }
    6 N: v& U, Z8 e
63.                 else if(_pBtn->Count != 0)
    , g! H* S9 X  B8 f
64.                 {
    
65.                         _pBtn->Count--;
    2 e+ p8 r& @: c1 [0 v0 E7 ?
66.                 }
    
67.                 else
    0 Z! O+ i5 l# g, _3 X/ u& ~
68.                 {
    : h8 f" h: L" w! V: d
69.                         if (_pBtn->State == 1)
    
70.                         {
    1 M. [( B5 w1 i  I6 w  Q
71.                                 _pBtn->State = 0;
    - C  E+ p# V( Z+ ]) N
72. 
    
73.                                 /* 发送按钮弹起的消息 */
    
74.                                 if (_pBtn->KeyCodeUp > 0) /*按键释放*/
    ( I! E  W4 Q6 r( i$ R7 E" D
75.                                 {
    
76.                                         /* 键值放入按键FIFO */
    , S$ E; o4 T( z. k: Q: A
77.                                 Pannelkey_Put(_pBtn->KeyCodeUp);        
    : d, P& O4 Q' h* T  P7 \
78.                         
    
79.                                 }
    1 @- t: C; \% A
80.                         }
    7 q% B7 _. }  x2 |% d) ~
81.                 }
    
82. 
    
83.                 _pBtn->LongCount = 0;
    
84.                 _pBtn->RepeatCount = 0;
    
85.         }
    
86. }
    
87. //功能说明: 检测所有按键。10MS 调用一次
    % d$ e/ c( _* r4 B, M
88. void Pannelkey_Polling(void)
    , ]. o! J2 U6 r  p9 M# R5 m
89. {
    ( @6 `; r5 \  b" z: J7 p4 {+ i
90.         Button_Detect(&s_Powerkey);                /* USER 键 */
    
91. }
    
92. void Pannelkey_Put（void)
    5 P5 p  l9 ?( ^3 g
93. {
    % K8 Z0 M% b# ^- |# J1 y% p/ K
94.         
    
95.   // 定义一个队列 放入按键值        
    / z6 [5 ]+ A1 D
96. }

复制代码

* g  Q/ r$ L4 F3 |( ~3 ^8 G
   
2,遥控器按键，遥控器解码的一般就有两种 脉宽调制和脉冲调制，这里就不细讲解码的过程了。这里详细解码之后，如何处理遥控器按键
   实现遥控器按键的长短按功能和连续按键功能。
1 n( M+ R. [; B3 ]3 k   代码裁剪过，大家根据实际需要改动
  其实AD按键，通过AD采样获得按键值之后，可以采取如下面的一样方法处理，提一个函数接口即可

1.    typedef struct
   
2. {
   
3.   unsigned char count;//
   
4.   unsigned char LongkeyFlag;/*是否长按键，1代表是*/
   
5.   unsigned char  PreKeyValue;/*按键值的一个备份，用于释放按键值*/
   
6.   
   
7. }ScanKeyDef;
   
8. 
   ( O& x. J, `' k* ^, z( C
9. #define SHORT_PRESS_TIME_IR                16 // 10ms
   ( H4 K5 g/ Z# |" W( x0 J
10. #define SERIES_PRESS_TIME_IR            10  
    7 k- H, O5 [9 G  D
11. #define LONG_PRESS_TIME_IR                    22
    
12. #define KEY_RELEASE_TIME_OUT_IR     12  // 10ms
    0 t2 e3 @- P9 z( v
13. //提供5个接口函数，如下。
      C( {9 R- I4 ?7 G
14. unsigned char get_irkey(void);
    
15. unsigned char ISSeriesKey(unsigned char temp);//按键是否需要做连续按键
    
16. unsigned char changeSeriesKey(unsigned char temp);//转换连续按键值
    9 Z7 I3 q  I3 K& L# @  W, ?0 K! a' ?
17. unsigned char ISLongKey(unsigned char temp);//按键是否需要做连续按键
    
18. unsigned char changeToLongKey(unsigned char temp);//转换连续按键值
    
19. 
    
20. 
    . N7 v9 m" }/ p! H- l" p/ B+ V6 s
21. unsigned char KeyScan(void)
    ! _/ Y) ^8 R" ?& O
22. {
    
23.     unsigned char  KeyValue = KEY_NONE,
    
24.                                 KeyValueTemp = KEY_NONE;
    : V. k; P+ K8 |4 A, F) e4 C
25.     static   unsigned char KeyReleaseTimeCount =0;
    
26. 
    9 ~; c3 y" H; V3 C# L4 j! H
27.     KeyValueTemp = get_irkey();
    ( J4 D: H; k) H0 m' m. p& J! V- h
28. 
    ' a3 c( g) S- n0 c: ^/ z
29.     if(KeyValueTemp != KEY_NONE)
    
30.     {
    
31.         ScanKeyDef.count++;
      d2 V5 q* [! C
32.         KeyReleaseTimeCount =0;
    - Y  E. W0 D, |! L, b9 P
33. 
    
34.         if(ScanKeyDef.count < LONG_PRESS_TIME_IR )
    7 b9 B" j& a, _& H' U
35.         {
    . V4 Z8 h- y$ L
36.             ScanKeyDef.LongkeyFlag = 0;
    : [; g9 _* r2 B) |
37.             if((ScanKeyDef.count == SERIES_PRESS_TIME_IR) && ISSeriesKey(KeyValueTemp)) //处理连续按键
    0 f4 D7 G/ f  p$ X( }
38.                 {
    
39.                     KeyValue = changeSeriesKey ( KeyValueTemp );
    1 N/ a1 K0 o" s- y
40.                     ScanKeyDef.PreKeyValue = KEY_NONE;
    
41.                 }
    2 T+ O0 s6 Z; w# D
42.             else if ( ScanKeyDef.count  < SHORT_PRESS_TIME_IR )
    
43.             {
    
44.                 ScanKeyDef.PreKeyValue = KeyValueTemp;
    
45.             }
    ( I! i: J) O. h$ P. T) n/ M
46.             else
    
47.             {
    
48.             
    " y$ F) w; V6 P7 j& ?) i* t
49.                 ScanKeyDef.PreKeyValue  = KEY_NONE; // 无效按键
    
50.             }
    2 [! S9 U% o8 p9 P' {! }, j
51.         }
    
52.         else if ( ScanKeyDef.count  == LONG_PRESS_TIME_IR )
    0 z3 D# }& Y& }) R5 F& k
53.         {
    
54.       
    # f  I. U! i* S/ s1 y3 h6 L
55.            if (ISLongKey(KeyValueTemp))
    
56.             {
    3 ?5 ~# @% M7 n4 i
57.                 {
    # w. M  q0 C. t2 U9 s) S
58.                    ScanKeyDef.LongkeyFlag = 1;
    $ a, T5 l% D& X8 |" t4 K$ S. A
59.                    KeyValue = changeToLongKey ( KeyValueTemp );
    6 |8 n  t! ^1 {
60.                }
    
61.           }
    
62.             ScanKeyDef.PreKeyValue = KEY_NONE;
    
63.          
    
64.         }
    9 G2 N! z7 U8 v. F5 Y% }
65.         else if (ScanKeyDef.count > LONG_PRESS_TIME_IR )
    
66.         {
    
67.       
    
68.             ScanKeyDef.PreKeyValue  = KEY_NONE; //无效按键
    
69.         }
    
70.     }
    + O& f6 T3 U$ o/ P5 d" H
71.     else//release & no press
    * N! R+ S) }$ N% i8 A# V% s
72.     {
    $ Q" m$ z: l6 ?. K; I- }) w9 r
73.         KeyReleaseTimeCount ++;
    4 Q& x1 N1 P) Q* K4 ]8 C! z( _& [
74.         if(KeyReleaseTimeCount >= KEY_RELEASE_TIME_OUT_IR)
    + }0 O; E  }* R8 [4 |5 c9 u% P
75.         {
    
76.   
    
77.             if ( ScanKeyDef.PreKeyValue != KEY_NONE ) //释放按键值
    . F: C2 c3 ^$ R& v$ A3 t7 c
78.             {
    
79.                 if ( ScanKeyDef.LongkeyFlag == 0 )
    
80.                 {
    6 N* I4 C0 j! [1 V+ a. \; g6 s
81.            
    ' U5 E! O0 `% O+ v- C1 ]* y
82.                     KeyValue =ScanKeyDef.PreKeyValue ;
    
83.                 }
    
84.             }         
    
85.             ScanKeyDef.count  = 0;
    0 k7 M' [5 {8 {7 h
86.             ScanKeyDef.LongkeyFlag = 0;
    
87.            ScanKeyDef.PreKeyValue = KEY_NONE;
      I. Z2 O1 X+ ?6 P: J
88.    
    
89.         }
    
90.     }
    
91.     return(KeyValue);
    
92. }     

复制代码

" m/ a- L8 b( w; p6 _! ]  C. `( X

wakup引脚做普通按键两种用途应该都能吧，不过wakup之后需要重新配置各种功能，不知道有没有好的方法。
, x* ~% w+ C; i' E* N1 }4 l

不错                 

确实不错        

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

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

不错，学习了！

不错，学习了！

学习了

学习，感谢楼主分享

可以的，学习一下

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

学习中，谢谢分享。

不错，学习了

学习了