! d6 v2 i2 b' L$ }6 X【MCU实战经验】+基于STM32和PID算法的小车车速控制

【MCU实战经验】+ STM32F103RBT6三个USART发送与接收设置

) q! S2 o8 x& E! j* f* j$ s* p1 w【MCU实战经验】+用stm32单片机做J-Link和ST-Link（PCB工程+固件库+资料工具）


8 x: |0 B0 p; L! O& b. h之前的一个项目按键比较多，面板上面有按键，遥控器，处理的稍微复杂一点，MCU使用的是STM8S005K6.
关于按键部分的处理，现在拿处理来和大家分享一下，说的不对的地方还请各位大侠请教，大家共同进步。
' @) j1 n+ c( r/ \' K
按键通常分有IO口按键（BUTTON),AD按键（通过AD采样电压），IR（遥控器）
按按键功能分：有短按键，长按键，连续按键。打个比方，遥控电视机，按一下音量键，音量增加1，这个就是短按键。
- f% |9 _7 c, V! V/ Q3 N( s按住音量键不放，音量连续加，这个就是连续按键。按住一个按键5s,系统会复位，这个是长按键。

) i. \+ ]7 q1 j- C5 y  E. T. z怎么去处理这些不同的按键了，下面我们就细细来说
0 }3 s' T! J$ M, O7 a
1,IO口按键，就是我们比较常见的一个IO接一个按键，或者是一个矩阵键盘。很多新人的处理方法可能是采样延时的方法，当年我也是这样的，如下
& B" H5 y9 w1 S/ |9 }1 W+ s$ E

1.     if(GETIO==low)
   
2.     {
   
3.       delay_10ms()
   
4.       if(GETIO==low)
   ; o( |" P! q( B! V3 |! V
5.       {
   2 x7 ?: p. A! p
6.         //得到按键值
   0 |8 e  A1 a  u  f3 Q, A% X2 a6 M$ t
7.       }
   * f* ~- a( C2 j7 ~& A* b6 e  b1 v" u
8.     }

复制代码

   
   这种方法虽然简单，但是有很大弊端。
% V) `. J. C* Y/ ?9 v   首先 Delay 浪费很多时间，影响系统。
* o* D4 C- q2 d' H9 I% @" N1 `  S   第二，无法判断长短按键，连续按键。
   第三，如果这个按键是开关机按键系统在低功耗状态下，需要中断唤醒，这种方法比较容易出问题，如STM8S系列的 halt 模式。
# P* ]  E; F! Q- ~6 J   
+ o  f/ |. ~! V9 {3 a   所以我们一般在产品开发的过程中，采用扫描的方法，就是每隔10ms 去检测IO的状态，看是否有按键，然后去抖动，判断按键功能。
   
   参考代码如下，这段代码是之前在一个论坛看到的比我自己写的更加优秀，所以拿出来和大家分享一下，也顺便感谢一下作者。
! X- D- d1 o( B   这段代码，容易修改，可以根据自己的时间需要，进行长短按键，连续按键,还有组合按键的判断。
' y* ?1 d' P; e- T   
   
; f7 Y0 a# t" w5 B7 u

1. /* 按键滤波时间50ms, 单位10ms
   
2. 只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   
3. */
   . `( P2 ?- E  @, q; T
4. #define BUTTON_FILTER_TIME         5
   3 K+ N( S# x% @, X! m
5. #define BUTTON_LONG_TIME         300                /* 持续1秒，认为长按事件 */
   
6. 
   ; A( N0 @: V) B3 D; v
7. /*
   
8.         每个按键对应1个全局的结构体变量。
   3 ?5 K" n+ C6 g: P+ u8 S1 H$ I& N
9.         其成员变量是实现滤波和多种按键状态所必须的
   
10. */
    ' g( d% P2 L- b5 v* {
11. typedef struct
    : {/ T% {- m4 o- Q
12. {
    
13.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
    ! P; L# \$ c, J% u% F5 k) m& _
14.         unsigned char  (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
    1 e. b9 w5 Y. E# r( X, |- k) U* S0 C
15. 
    ' ^- f  ^# r0 y4 H
16.         unsigned char  Count;                        /* 滤波器计数器 */
    
17.         unsigned char  FilterTime;                /* 滤波时间(最大255,表示2550ms) */
    * Z8 v& `: ~+ a( U9 k& \
18.         unsigned short LongCount;                /* 长按计数器 */
    3 f. {. y, T2 F+ U/ F* b7 Y
19.         unsigned short LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    6 ~% R) V, f4 _
20.         unsigned char   State;                        /* 按键当前状态（按下还是弹起） */
    ) Z! m; D% x' r( s* D7 |, D
21.         unsigned char  KeyCodeUp;                /* 按键弹起的键值代码, 0表示不检测按键弹起 */
      d# X. n* v7 y$ n) F1 n( Q( m
22.         unsigned char  KeyCodeDown;        /* 按键按下的键值代码, 0表示不检测按键按下 */
    / {% H  m; O6 E4 R7 k
23.         unsigned char  KeyCodeLong;        /* 按键长按的键值代码, 0表示不检测长按 */
    
24.         unsigned char  RepeatSpeed;        /* 连续按键周期 */
    
25.         unsigned char  RepeatCount;        /* 连续按键计数器 */
    
26. }BUTTON_T;
    
27. 
    5 D/ I/ b6 r& N5 _- i
28. typedef enum
    
29. {
    ! h' G4 h; T9 j
30.         KEY_NONE = 0,                        /* 0 表示按键事件 */
    
31. 
    5 Z& M+ ?) P7 J; U4 X& d( ?# A
32.         KEY_DOWN_Power,                        /* 按键键按下 */
    
33.         KEY_UP_Power,                        /* 按键键弹起 */
    
34.         KEY_LONG_Power,                        /* 按键键长按 */
    
35.         
    ; N; E0 k, e7 w
36.         KEY_DOWN_Power_TAMPER        /* 组合键，Power键和WAKEUP键同时按下 */
    0 [2 \/ p# h, U. s. Q4 d
37. }KEY_ENUM;
    7 M8 |& b6 z+ e, G9 F
38. 
    
39. BUTTON_T s_Powerkey;               
    : H& M5 ]: X# K; K( ?! l
40. //是否有按键按下接口函数
    
41. unsigned char  IsKeyDownUser(void)                 
    6 P/ K6 }- V2 [
42. {if (0==GPIO_ReadInputPin(POWER_KEY_PORT, POWER_KEY_PIN) ) return 1;return 0;}
    
43. 
    + V' O: e2 O) A; Z8 H; l
44. 
    
45. void  PanakeyHard_Init(void)
      g6 S0 D( ]" t' R; E5 w
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按键变量，支持按下、弹起、长按 */
    : R7 {6 F+ o  T2 {, ]3 N0 F: x, R
52.         s_Powerkey.IsKeyDownFunc = IsKeyDownUser;                /* 判断按键按下的函数 */
    - j5 O* E  w9 w/ `* T7 W
53.         s_Powerkey.FilterTime = BUTTON_FILTER_TIME;                /* 按键滤波时间 */
    : U7 `" H' N' M
54.         s_Powerkey.LongTime = BUTTON_LONG_TIME;                        /* 长按时间 */
    
55.         s_Powerkey.Count = s_Powerkey.FilterTime / 2;                /* 计数器设置为滤波时间的一半 */
    # {( U9 t1 {- V2 y7 F
56.         s_Powerkey.State = 0;                                                        /* 按键缺省状态，0为未按下 */
    2 Z% ~: m6 H1 S9 Y5 A5 z
57.         s_Powerkey.KeyCodeDown = KEY_DOWN_Power;                        /* 按键按下的键值代码 */
    8 D* g% [* c2 c% b  s0 d& {
58.         s_Powerkey.KeyCodeUp =KEY_UP_Power;                                /* 按键弹起的键值代码 */
    - I" U7 w7 U# ~+ O( _! D( ]9 T
59.         s_Powerkey.KeyCodeLong = KEY_LONG_Power;                        /* 按键被持续按下的键值代码 */
    ( m. `( \/ N- I5 P2 K
60.         s_Powerkey.RepeatSpeed = 0;                                                /* 按键连发的速度，0表示不支持连发 */
    & ^/ B  b8 {7 V; Q- v( w& z
61.         s_Powerkey.RepeatCount = 0;                                                /* 连发计数器 */               
    7 `3 l2 v% @7 L4 r
62. }
    . D6 {& h) F- N2 G
63. void Panakey_Init(void)
    ( |6 P0 e5 E9 W7 M5 \% K. U, n
64. {
    
65.         PanakeyHard_Init();                /* 初始化按键变量 */
    4 v* v+ y6 w& `% Q4 T
66.         PanakeyVar_Init();                /* 初始化按键硬件 */
    / Y) T8 S9 d: [; b) P
67. }

复制代码

4 p6 c3 }; o0 Y' v*********************************************************************************************************
% l* W; O+ A6 N  J% q*        函 数 名: bsp_DetectButton
( H) P" P5 S* }' |! n*        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
*        形    参：按键结构变量指针
3 n- B  T$ L+ d*        返 回 值: 无
4 Q  w, K& {  V4 `*********************************************************************************************************

1. */
   
2. void Button_Detect(BUTTON_T *_pBtn)
   
3. {
   ! V: D$ ^; p; |/ L- b. h) q5 C
4.         if (_pBtn->IsKeyDownFunc())
   
5.         {
   
6.                 if (_pBtn->Count < _pBtn->FilterTime)
   6 X& c8 v+ H; P4 ?
7.                 {
   7 d9 y" C$ O$ ~
8.                         _pBtn->Count = _pBtn->FilterTime;
   + y9 \* O2 ]  @# _
9.                 }
   
10.                 else if(_pBtn->Count < 2 * _pBtn->FilterTime)
    
11.                 {
    
12.                         _pBtn->Count++;
    
13.                 }
    7 ^2 t8 ^6 [4 R7 m: W
14.                 else
    % J# b. d3 C" W/ Z4 I
15.                 {
    
16.                         if (_pBtn->State == 0)
    " N. N/ s9 ]/ w/ M9 E
17.                         {
    
18.                                 _pBtn->State = 1;
    
19. 
    
20.                                 /* 发送按钮按下的消息 */
    
21.                                 if (_pBtn->KeyCodeDown > 0)
    # C9 O3 J% }$ D1 z, ~
22.                                 {
    
23.                                         /* 键值放入按键FIFO */
    4 K+ P: L; r( b5 l
24.                                         Pannelkey_Put(_pBtn->KeyCodeDown);// 记录按键按下标志，等待释放
      ]* @) H1 H: d9 a/ G9 P" k$ _
25. 
    0 I+ n8 R/ Y% T9 ^: j- S9 F
26.                                 }
    0 E# D; x0 s1 P' B, r8 m+ _0 y
27.                         }
    % _9 _& ^) l3 Z- y1 s6 X
28. 
    
29.                         if (_pBtn->LongTime > 0)
    + q* Q- D9 x4 h3 B" n8 n1 g; m& f
30.                         {
    " V+ z( c+ t! t0 ]+ N
31.                                 if (_pBtn->LongCount < _pBtn->LongTime)
    . X* L6 R) q) z7 V) F
32.                                 {
    - h5 g  j7 s8 o1 A& R7 j# a
33.                                         /* 发送按钮持续按下的消息 */
    - H9 p" O2 t! o. P& w
34.                                         if (++_pBtn->LongCount == _pBtn->LongTime)
    4 |+ V% C5 ]2 W- C( P: I
35.                                         {
    
36.                                                 /* 键值放入按键FIFO */
    
37.                                                 Pannelkey_Put(_pBtn->KeyCodeLong);        
    
38.                                 
    
39.                                         }
    % O3 c) i; f/ x, U
40.                                 }
    
41.                                 else
    
42.                                 {
    7 t- D! u( o/ @* f
43.                                         if (_pBtn->RepeatSpeed > 0)
    3 E( C/ j. M. M) o3 l
44.                                         {
    , ]% \# x9 }- I, s
45.                                                 if (++_pBtn->RepeatCount >= _pBtn->RepeatSpeed)
    
46.                                                 {
    
47.                                                         _pBtn->RepeatCount = 0;
    
48.                                                         /* 常按键后，每隔10ms发送1个按键 */
    
49.                                                         Pannelkey_Put(_pBtn->KeyCodeDown);        
    2 j3 Q5 s( T- K
50.                                 
    , [" \7 t- ?5 }+ G* k3 S" q
51.                                                 }
    ; y* y/ l2 y1 P% u" R, G
52.                                         }
    
53.                                 }
    2 Y( L7 k4 n- P' T# R  N
54.                         }
    0 N% x  z. N: }# r$ f5 m
55.                 }
    5 [7 B2 |/ u. R- S& Y
56.         }
    
57.         else
    6 W, L; z; U7 U
58.         {
    ' m2 S) N7 a2 s. S  s3 U; G
59.                 if(_pBtn->Count > _pBtn->FilterTime)
    
60.                 {
    
61.                         _pBtn->Count = _pBtn->FilterTime;
    
62.                 }
    
63.                 else if(_pBtn->Count != 0)
    
64.                 {
    
65.                         _pBtn->Count--;
    
66.                 }
    , h5 a% @# U! k# U
67.                 else
    
68.                 {
    2 |; a" l0 e7 {: z
69.                         if (_pBtn->State == 1)
    
70.                         {
    0 }. V/ u. e: ]5 G8 P, g0 Y9 p# X
71.                                 _pBtn->State = 0;
    + \5 x0 Q  Z5 q0 h  N5 q
72. 
    
73.                                 /* 发送按钮弹起的消息 */
    9 C3 y0 ?% C, p4 z! `' I1 G1 Y! E
74.                                 if (_pBtn->KeyCodeUp > 0) /*按键释放*/
    ! e: [. x8 U# J" ]3 i
75.                                 {
    5 M' `' }4 i, N* B7 m0 P
76.                                         /* 键值放入按键FIFO */
    9 R$ B# W6 [/ m5 T# J" X- q
77.                                 Pannelkey_Put(_pBtn->KeyCodeUp);        
    . x9 r6 u' b( D+ p' I
78.                         
      D! D& C! N- i7 _# @
79.                                 }
    
80.                         }
    ! r5 c& G9 q. n" R$ Z4 Q
81.                 }
    
82. 
    % P0 t4 _' @. r" b$ A6 Q5 K
83.                 _pBtn->LongCount = 0;
    
84.                 _pBtn->RepeatCount = 0;
    % t& P( J6 R/ M0 I% ~( N* j; o
85.         }
    
86. }
    
87. //功能说明: 检测所有按键。10MS 调用一次
    5 x. Z& Z' |  O6 Q& B
88. void Pannelkey_Polling(void)
    
89. {
    : C4 Z5 z1 U' B  R/ ~2 L; Z
90.         Button_Detect(&s_Powerkey);                /* USER 键 */
    
91. }
    
92. void Pannelkey_Put（void)
    ' H/ ~1 E8 O5 Y* K& _. t
93. {
    
94.         
    6 z' _. m5 x# ]6 `: e
95.   // 定义一个队列 放入按键值        
    
96. }

复制代码

8 X  j+ o* I! F7 @   
2,遥控器按键，遥控器解码的一般就有两种 脉宽调制和脉冲调制，这里就不细讲解码的过程了。这里详细解码之后，如何处理遥控器按键
   实现遥控器按键的长短按功能和连续按键功能。
   代码裁剪过，大家根据实际需要改动
  其实AD按键，通过AD采样获得按键值之后，可以采取如下面的一样方法处理，提一个函数接口即可

1.    typedef struct
   ' ^2 J2 Z1 q% S: A, n, M& g
2. {
   
3.   unsigned char count;//
   ' K% U7 ]* J7 C" z) [0 x4 C
4.   unsigned char LongkeyFlag;/*是否长按键，1代表是*/
   $ a0 m; b" A0 q3 }2 ~7 a
5.   unsigned char  PreKeyValue;/*按键值的一个备份，用于释放按键值*/
   , B  c$ p; L! U# v7 y. ?9 P; h% _
6.   
   . i2 P( ?& v5 J$ y  O! |6 }
7. }ScanKeyDef;
   ( u6 ?+ E  h. c! N, D+ P
8. 
   7 Z8 r* _; r: T
9. #define SHORT_PRESS_TIME_IR                16 // 10ms
     [$ ?& n7 P$ n* n, k0 V/ I3 U
10. #define SERIES_PRESS_TIME_IR            10  
    
11. #define LONG_PRESS_TIME_IR                    22
    
12. #define KEY_RELEASE_TIME_OUT_IR     12  // 10ms
    % q7 }0 s, O8 d/ R! i
13. //提供5个接口函数，如下。
    
14. unsigned char get_irkey(void);
    
15. unsigned char ISSeriesKey(unsigned char temp);//按键是否需要做连续按键
    4 @1 g( o2 J4 D1 v) L
16. unsigned char changeSeriesKey(unsigned char temp);//转换连续按键值
    
17. unsigned char ISLongKey(unsigned char temp);//按键是否需要做连续按键
    
18. unsigned char changeToLongKey(unsigned char temp);//转换连续按键值
    
19. 
    & m2 t) B5 H( \% @; G" r5 Z
20. 
    , \0 _% U1 I6 D
21. unsigned char KeyScan(void)
    2 \+ E- j8 ]& R7 b, I. e
22. {
    
23.     unsigned char  KeyValue = KEY_NONE,
    
24.                                 KeyValueTemp = KEY_NONE;
    
25.     static   unsigned char KeyReleaseTimeCount =0;
    
26. 
    
27.     KeyValueTemp = get_irkey();
    % c/ z- m5 H, Y! r, [5 w, n' W
28. 
    3 ^) U! j0 x8 I$ X! r$ R
29.     if(KeyValueTemp != KEY_NONE)
    $ C8 I0 q/ u* ~9 C0 u4 M
30.     {
    % I+ Z" y3 j, S
31.         ScanKeyDef.count++;
    
32.         KeyReleaseTimeCount =0;
    
33. 
    
34.         if(ScanKeyDef.count < LONG_PRESS_TIME_IR )
    
35.         {
    
36.             ScanKeyDef.LongkeyFlag = 0;
    
37.             if((ScanKeyDef.count == SERIES_PRESS_TIME_IR) && ISSeriesKey(KeyValueTemp)) //处理连续按键
    3 F; r7 V3 P6 W( O9 B% I  N
38.                 {
      y5 W1 r( _8 t1 m3 c: V
39.                     KeyValue = changeSeriesKey ( KeyValueTemp );
    7 A# g$ J* h; F; m6 k" {
40.                     ScanKeyDef.PreKeyValue = KEY_NONE;
    3 K; ?, I2 O; k, q" B: n8 `. z8 t1 W
41.                 }
    
42.             else if ( ScanKeyDef.count  < SHORT_PRESS_TIME_IR )
    7 r! }1 l& Z2 w$ A$ @7 F6 P. Q
43.             {
    
44.                 ScanKeyDef.PreKeyValue = KeyValueTemp;
    + D5 |4 I; L+ x% J
45.             }
    
46.             else
    
47.             {
    
48.             
    * |% \; K+ G: v
49.                 ScanKeyDef.PreKeyValue  = KEY_NONE; // 无效按键
    
50.             }
    
51.         }
    
52.         else if ( ScanKeyDef.count  == LONG_PRESS_TIME_IR )
    # _0 F9 f, x4 o+ n2 F+ Z8 l
53.         {
    
54.       
    " M( q! b- o# E+ H
55.            if (ISLongKey(KeyValueTemp))
    
56.             {
    3 a9 [# p3 {* g/ J8 B
57.                 {
    
58.                    ScanKeyDef.LongkeyFlag = 1;
    5 ?% ?' V: k3 \
59.                    KeyValue = changeToLongKey ( KeyValueTemp );
    
60.                }
    
61.           }
    5 _" A8 X# u9 b2 R1 B  b
62.             ScanKeyDef.PreKeyValue = KEY_NONE;
    
63.          
    
64.         }
    ( l+ m4 ?# J/ h" P) B' l+ B' F7 p) q
65.         else if (ScanKeyDef.count > LONG_PRESS_TIME_IR )
    ; T, ]- J+ m6 b( }
66.         {
    
67.       
    ) \; j) e2 l) ?7 @9 D/ a
68.             ScanKeyDef.PreKeyValue  = KEY_NONE; //无效按键
    2 j1 d% q) b! ?
69.         }
    + [, R- @7 g7 {- C6 s; q4 m
70.     }
    
71.     else//release & no press
    8 M- X- S2 M8 y  @
72.     {
    
73.         KeyReleaseTimeCount ++;
    9 ]; E+ e# @+ J% w3 d! s- _
74.         if(KeyReleaseTimeCount >= KEY_RELEASE_TIME_OUT_IR)
    
75.         {
    + b. ~1 b6 Q" x/ t% T$ d( S4 f
76.   
    + ^0 g$ k( A% @/ g8 v# A0 Q
77.             if ( ScanKeyDef.PreKeyValue != KEY_NONE ) //释放按键值
    
78.             {
    
79.                 if ( ScanKeyDef.LongkeyFlag == 0 )
    
80.                 {
    ; h* N# O  c5 h. z$ j" l
81.            
    - O6 O2 v" h* J+ k; o
82.                     KeyValue =ScanKeyDef.PreKeyValue ;
    : O7 n. ?3 Q6 W# Y7 }5 v# R
83.                 }
    
84.             }         
    3 \* a/ {& U+ F  e3 `: s
85.             ScanKeyDef.count  = 0;
    % H1 ~% E4 J' v: O& k: \
86.             ScanKeyDef.LongkeyFlag = 0;
    
87.            ScanKeyDef.PreKeyValue = KEY_NONE;
    $ d, N. A. B* L- i' k
88.    
    ) `6 H) ]5 U9 T6 G' J$ J3 H
89.         }
    ' a. X- D) ?9 f( W# w- j
90.     }
    ; f( y* V; E* Q, S8 V& W6 j( y% K1 O
91.     return(KeyValue);
    
92. }     

复制代码

+ ^( R. t9 L2 F8 E% [- |
# o# ?- \5 g, e' K; b
# G" @+ w2 L9 a  \+ @" M2 p. t

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

不错                 

确实不错        

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

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

不错，学习了！

不错，学习了！

学习了
% _4 ]2 V4 @+ k7 @. E

学习，感谢楼主分享

可以的，学习一下

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

学习中，谢谢分享。

不错，学习了

学习了