【MCU实战经验】+基于STM32和PID算法的小车车速控制

0 ^) F) r& a" n5 p【MCU实战经验】+ STM32F103RBT6三个USART发送与接收设置

  L, I" T/ x. B: F: k【MCU实战经验】+用stm32单片机做J-Link和ST-Link（PCB工程+固件库+资料工具）
7 [( V. m6 F" o6 V

之前的一个项目按键比较多，面板上面有按键，遥控器，处理的稍微复杂一点，MCU使用的是STM8S005K6.
$ x; `" T' Z! e8 @3 I3 F- L' R7 h关于按键部分的处理，现在拿处理来和大家分享一下，说的不对的地方还请各位大侠请教，大家共同进步。

按键通常分有IO口按键（BUTTON),AD按键（通过AD采样电压），IR（遥控器）
9 B! h/ l' Y! L0 L按按键功能分：有短按键，长按键，连续按键。打个比方，遥控电视机，按一下音量键，音量增加1，这个就是短按键。
2 b: \% d. A9 S- {+ c, T& j, O按住音量键不放，音量连续加，这个就是连续按键。按住一个按键5s,系统会复位，这个是长按键。

1 c0 j" g4 |; d. }+ A& j0 ^$ _怎么去处理这些不同的按键了，下面我们就细细来说
% }; t5 b  r/ S, a! H6 R2 _' f
8 T( E7 D' C+ j1,IO口按键，就是我们比较常见的一个IO接一个按键，或者是一个矩阵键盘。很多新人的处理方法可能是采样延时的方法，当年我也是这样的，如下

1.     if(GETIO==low)
   5 t- u% a, H( F' g% M
2.     {
   
3.       delay_10ms()
   
4.       if(GETIO==low)
   
5.       {
   6 A- N  L8 T- h# z/ W
6.         //得到按键值
   
7.       }
   
8.     }

复制代码

   
   这种方法虽然简单，但是有很大弊端。
1 {0 |; ]; ?8 g) R  q( W# x$ W; P   首先 Delay 浪费很多时间，影响系统。
   第二，无法判断长短按键，连续按键。
   第三，如果这个按键是开关机按键系统在低功耗状态下，需要中断唤醒，这种方法比较容易出问题，如STM8S系列的 halt 模式。
# e: c0 z5 A2 R   
2 F! E" Q; K4 {   所以我们一般在产品开发的过程中，采用扫描的方法，就是每隔10ms 去检测IO的状态，看是否有按键，然后去抖动，判断按键功能。
7 t0 p' B/ Z5 n. p5 f* R/ H   
( @6 v& j6 S) d7 _6 W   参考代码如下，这段代码是之前在一个论坛看到的比我自己写的更加优秀，所以拿出来和大家分享一下，也顺便感谢一下作者。
* Z- @& K' Q4 W% d% H6 A0 w   这段代码，容易修改，可以根据自己的时间需要，进行长短按键，连续按键,还有组合按键的判断。
8 \+ V! X! d+ N, k5 b" o2 V   
   
, {$ }# \3 N8 e0 J/ C

1. /* 按键滤波时间50ms, 单位10ms
   
2. 只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   
3. */
   
4. #define BUTTON_FILTER_TIME         5
   
5. #define BUTTON_LONG_TIME         300                /* 持续1秒，认为长按事件 */
   ! X# j4 C) E9 E/ ?8 B& b6 l% B
6. 
   
7. /*
   * Q4 l( A$ d4 r1 F
8.         每个按键对应1个全局的结构体变量。
   # z# }! M3 Z" D2 X: q# N( Z
9.         其成员变量是实现滤波和多种按键状态所必须的
   2 z9 h$ v% L- [+ U* a7 n
10. */
    , v6 B* X& t# ]& o1 c+ i
11. typedef struct
    , U9 Z- V: U3 W8 [5 A
12. {
    
13.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
    
14.         unsigned char  (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
      d9 G. o+ X( P) J( L
15. 
    ! _( h/ s0 N8 G6 b2 `) B
16.         unsigned char  Count;                        /* 滤波器计数器 */
    
17.         unsigned char  FilterTime;                /* 滤波时间(最大255,表示2550ms) */
    
18.         unsigned short LongCount;                /* 长按计数器 */
    ( [, \4 d. k* y1 n3 Q, d
19.         unsigned short LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    
20.         unsigned char   State;                        /* 按键当前状态（按下还是弹起） */
    
21.         unsigned char  KeyCodeUp;                /* 按键弹起的键值代码, 0表示不检测按键弹起 */
    / }! z1 m6 I) f2 E- T! ~* P, _
22.         unsigned char  KeyCodeDown;        /* 按键按下的键值代码, 0表示不检测按键按下 */
    
23.         unsigned char  KeyCodeLong;        /* 按键长按的键值代码, 0表示不检测长按 */
    # R' a. |( a0 g4 X
24.         unsigned char  RepeatSpeed;        /* 连续按键周期 */
    
25.         unsigned char  RepeatCount;        /* 连续按键计数器 */
    8 Y8 G) ?1 C# a0 z+ `  ^6 p
26. }BUTTON_T;
    
27. 
    
28. typedef enum
    , P0 _# O. S' T; N, T" b
29. {
    ; j8 W) v2 _, _, f7 k
30.         KEY_NONE = 0,                        /* 0 表示按键事件 */
    
31. 
    ! U0 S0 y6 g) e4 Q
32.         KEY_DOWN_Power,                        /* 按键键按下 */
    0 Z" M8 {2 R# `; K3 }- u
33.         KEY_UP_Power,                        /* 按键键弹起 */
    
34.         KEY_LONG_Power,                        /* 按键键长按 */
    
35.         
    5 d0 [* L- a3 r3 w+ N" ^
36.         KEY_DOWN_Power_TAMPER        /* 组合键，Power键和WAKEUP键同时按下 */
    
37. }KEY_ENUM;
    
38. 
    
39. BUTTON_T s_Powerkey;               
    + f, E4 Q) [. S. z5 ^& f
40. //是否有按键按下接口函数
    / \. R* G& Z; V; \9 u  J
41. unsigned char  IsKeyDownUser(void)                 
      r# X8 v& h; O; F( p
42. {if (0==GPIO_ReadInputPin(POWER_KEY_PORT, POWER_KEY_PIN) ) return 1;return 0;}
    
43. 
    2 n0 v5 [1 P: y( {+ K! D' j
44. 
    ; H' |% o2 G1 s7 C) N% A/ N- {
45. void  PanakeyHard_Init(void)
    
46. {
    3 e  Z1 t8 j* \, a- c3 \
47.    GPIO_Init (POWER_KEY_PORT, POWER_KEY_PIN, GPIO_MODE_IN_FL_NO_IT);//power key
    
48. }
    # i+ I+ ?9 v8 B1 d- k% C
49. void  PanakeyVar_Init(void)
    
50. {
    
51.         /* 初始化USER按键变量，支持按下、弹起、长按 */
    
52.         s_Powerkey.IsKeyDownFunc = IsKeyDownUser;                /* 判断按键按下的函数 */
    
53.         s_Powerkey.FilterTime = BUTTON_FILTER_TIME;                /* 按键滤波时间 */
    
54.         s_Powerkey.LongTime = BUTTON_LONG_TIME;                        /* 长按时间 */
    
55.         s_Powerkey.Count = s_Powerkey.FilterTime / 2;                /* 计数器设置为滤波时间的一半 */
    $ C0 P8 o1 m0 e; K# z
56.         s_Powerkey.State = 0;                                                        /* 按键缺省状态，0为未按下 */
    3 D2 g/ }4 @) w9 L1 j- Y. F& F3 R
57.         s_Powerkey.KeyCodeDown = KEY_DOWN_Power;                        /* 按键按下的键值代码 */
    
58.         s_Powerkey.KeyCodeUp =KEY_UP_Power;                                /* 按键弹起的键值代码 */
    " p  T4 x) j3 T4 h) Y( W$ {
59.         s_Powerkey.KeyCodeLong = KEY_LONG_Power;                        /* 按键被持续按下的键值代码 */
    
60.         s_Powerkey.RepeatSpeed = 0;                                                /* 按键连发的速度，0表示不支持连发 */
    % P$ b# q* U6 Q7 L4 c; |8 w
61.         s_Powerkey.RepeatCount = 0;                                                /* 连发计数器 */               
    
62. }
      H8 h* S) k" D: H: \# Z! W
63. void Panakey_Init(void)
    / U  C1 [! p4 m% q" h. |, E' |
64. {
    
65.         PanakeyHard_Init();                /* 初始化按键变量 */
    6 a, Y+ c- [: P9 U% {% C
66.         PanakeyVar_Init();                /* 初始化按键硬件 */
    
67. }

复制代码

5 q: b% p( O. v7 ~" s7 G7 ]*********************************************************************************************************
*        函 数 名: bsp_DetectButton
*        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
*        形    参：按键结构变量指针
8 e+ y5 ]( B# Z4 \' B*        返 回 值: 无
6 E  {7 w! v9 t* E; t1 a*********************************************************************************************************
; h/ n5 X) `# ~# w" {6 c

1. */
   $ |7 k) u6 c8 f2 e2 M
2. void Button_Detect(BUTTON_T *_pBtn)
   1 {; m/ |& d3 Q* j; ]( C: N3 C
3. {
   . u. N. J, i1 d. Q( g
4.         if (_pBtn->IsKeyDownFunc())
   
5.         {
   
6.                 if (_pBtn->Count < _pBtn->FilterTime)
   " P( k& M& G. |" X0 g9 V4 U% f
7.                 {
   8 m. E0 D* c# E- n9 f& G7 y
8.                         _pBtn->Count = _pBtn->FilterTime;
   
9.                 }
   & @" t( `" x0 n/ g/ y# t! W+ ]
10.                 else if(_pBtn->Count < 2 * _pBtn->FilterTime)
    1 s& P+ |; Z, S% r1 x/ t$ F8 W1 s
11.                 {
    ; w; `) c7 T6 t1 g9 m- ?
12.                         _pBtn->Count++;
    
13.                 }
    
14.                 else
    
15.                 {
    ( V0 j: Z& N! J! Y
16.                         if (_pBtn->State == 0)
    9 H# ?- v" v* Q% E, c4 V, Q. u
17.                         {
    8 O4 x( N; e9 @* J5 o) ~
18.                                 _pBtn->State = 1;
    
19. 
    
20.                                 /* 发送按钮按下的消息 */
    . K" p- K# y7 G& q
21.                                 if (_pBtn->KeyCodeDown > 0)
    
22.                                 {
    
23.                                         /* 键值放入按键FIFO */
    ' ~+ P" _. f  Q6 S8 L& i& e
24.                                         Pannelkey_Put(_pBtn->KeyCodeDown);// 记录按键按下标志，等待释放
    
25. 
      ?% r( D7 k4 a: K- d$ e8 N* F
26.                                 }
    
27.                         }
    
28. 
    8 U/ S0 \" L* w( _
29.                         if (_pBtn->LongTime > 0)
    7 j+ L! E  f- z
30.                         {
    # P* ~" N6 V  V" ?; z  f
31.                                 if (_pBtn->LongCount < _pBtn->LongTime)
    / Z& f; g. j7 c# _. s. `) N
32.                                 {
    ; q6 [: r* @- Q3 y
33.                                         /* 发送按钮持续按下的消息 */
    % n. o3 g. r) ]1 t  g! e
34.                                         if (++_pBtn->LongCount == _pBtn->LongTime)
    & l) i7 W) Q- t! G9 x1 l" p; v- Z3 Z
35.                                         {
    
36.                                                 /* 键值放入按键FIFO */
    
37.                                                 Pannelkey_Put(_pBtn->KeyCodeLong);        
    
38.                                 
    
39.                                         }
    1 c+ r6 X5 [% S3 ]
40.                                 }
    
41.                                 else
    
42.                                 {
    . R- f" c" Z& B
43.                                         if (_pBtn->RepeatSpeed > 0)
    
44.                                         {
    
45.                                                 if (++_pBtn->RepeatCount >= _pBtn->RepeatSpeed)
    : d$ ]& x" I  M. J+ _% u  I; ~
46.                                                 {
    " E5 g6 V4 F" j6 _
47.                                                         _pBtn->RepeatCount = 0;
    6 b& H5 c/ B' O+ r
48.                                                         /* 常按键后，每隔10ms发送1个按键 */
    9 t5 t' v) [9 u1 @) f! n
49.                                                         Pannelkey_Put(_pBtn->KeyCodeDown);        
    . R8 p1 M5 u6 a9 M) C6 m
50.                                 
    8 B7 c' n1 c: m/ _/ l: o
51.                                                 }
    ) q4 O' }# \5 ?  i
52.                                         }
      t7 j' k) Y; N! }( S5 P# v5 X
53.                                 }
    
54.                         }
    
55.                 }
    
56.         }
    
57.         else
    
58.         {
    
59.                 if(_pBtn->Count > _pBtn->FilterTime)
    
60.                 {
    7 J7 z3 e, H3 ~& r; U; T0 f( t2 c3 Z
61.                         _pBtn->Count = _pBtn->FilterTime;
    7 p0 e7 h" O' Q& f+ w0 C$ O
62.                 }
    
63.                 else if(_pBtn->Count != 0)
    
64.                 {
    
65.                         _pBtn->Count--;
    
66.                 }
    ; J9 G1 {" \' ]: R5 e
67.                 else
    8 O  ]! }/ ^4 V' A8 U6 U# G$ s5 N& L
68.                 {
    6 W2 R4 j8 g4 |( X& ?8 r! k9 C1 K
69.                         if (_pBtn->State == 1)
    
70.                         {
    ! g& _6 z% V% `& T& z: {
71.                                 _pBtn->State = 0;
    3 T$ b2 S3 q, f# j4 d+ T
72. 
    
73.                                 /* 发送按钮弹起的消息 */
    
74.                                 if (_pBtn->KeyCodeUp > 0) /*按键释放*/
    
75.                                 {
    ' {/ F! M) {) V' p
76.                                         /* 键值放入按键FIFO */
    
77.                                 Pannelkey_Put(_pBtn->KeyCodeUp);        
    
78.                         
    
79.                                 }
    
80.                         }
    
81.                 }
    
82. 
    
83.                 _pBtn->LongCount = 0;
    
84.                 _pBtn->RepeatCount = 0;
    ) u$ E/ m1 n7 p% I0 C2 b) n
85.         }
    
86. }
    
87. //功能说明: 检测所有按键。10MS 调用一次
    
88. void Pannelkey_Polling(void)
    * H% Y1 y( F+ X
89. {
    . m1 g( O2 a1 f9 G$ }" j# G
90.         Button_Detect(&s_Powerkey);                /* USER 键 */
    8 D; N/ I5 _# I+ X
91. }
    
92. void Pannelkey_Put（void)
    . i; A0 C9 A4 k; l
93. {
    
94.         
    
95.   // 定义一个队列 放入按键值        
    
96. }

复制代码

" n8 n: p( m0 x$ G
   
$ n+ Q: u4 i+ m0 I2 C2,遥控器按键，遥控器解码的一般就有两种 脉宽调制和脉冲调制，这里就不细讲解码的过程了。这里详细解码之后，如何处理遥控器按键
   实现遥控器按键的长短按功能和连续按键功能。
' M% j7 E3 e$ T   代码裁剪过，大家根据实际需要改动
  其实AD按键，通过AD采样获得按键值之后，可以采取如下面的一样方法处理，提一个函数接口即可

1.    typedef struct
   5 M3 z( G7 f% j: }! w3 x
2. {
   % b1 ]. ]- l7 x- K; ]2 D% {
3.   unsigned char count;//
   
4.   unsigned char LongkeyFlag;/*是否长按键，1代表是*/
   " a; x- W9 U. d" b8 w/ D
5.   unsigned char  PreKeyValue;/*按键值的一个备份，用于释放按键值*/
   : ^5 H8 _* l$ y/ Q
6.   
   ! A: m# o& V% \0 Y6 `0 D% R, a' w
7. }ScanKeyDef;
   
8. 
   7 a2 u$ y: m) V3 Y( _
9. #define SHORT_PRESS_TIME_IR                16 // 10ms
   
10. #define SERIES_PRESS_TIME_IR            10  
    5 n) B, F8 I' z1 O1 C
11. #define LONG_PRESS_TIME_IR                    22
    % I+ _: r3 J9 j% [0 n: _, [
12. #define KEY_RELEASE_TIME_OUT_IR     12  // 10ms
    * z* @+ ?9 K7 t, w' t! x
13. //提供5个接口函数，如下。
    
14. unsigned char get_irkey(void);
    
15. unsigned char ISSeriesKey(unsigned char temp);//按键是否需要做连续按键
    
16. unsigned char changeSeriesKey(unsigned char temp);//转换连续按键值
    6 o2 t2 G. ~; q& n' S4 Q
17. unsigned char ISLongKey(unsigned char temp);//按键是否需要做连续按键
      G. e' ^/ H/ ^# X# U/ s* d
18. unsigned char changeToLongKey(unsigned char temp);//转换连续按键值
    5 }  \& P) j* {5 L* f& H' e0 {
19. 
    
20. 
    
21. unsigned char KeyScan(void)
    ' L2 \0 ?7 F' i- x) V; Z1 t! R
22. {
    1 s" M- {* U3 J8 a
23.     unsigned char  KeyValue = KEY_NONE,
    7 ?% [6 M; t: n
24.                                 KeyValueTemp = KEY_NONE;
    + N. m8 l  m9 I0 E' H0 ~. ^9 r- X
25.     static   unsigned char KeyReleaseTimeCount =0;
    
26. 
    " ^, F* N/ \: ]3 G
27.     KeyValueTemp = get_irkey();
    ! A. P. L% w. p2 [9 f- `' r: C* Z  ^
28. 
    % `# q$ G6 q' F8 D
29.     if(KeyValueTemp != KEY_NONE)
    ; x! U9 s# q# x3 {
30.     {
    
31.         ScanKeyDef.count++;
    
32.         KeyReleaseTimeCount =0;
    
33. 
    2 A+ _5 y9 ]/ s0 u3 L  z
34.         if(ScanKeyDef.count < LONG_PRESS_TIME_IR )
    
35.         {
    " g  j5 A# k4 z" u% ~: Z. k$ O
36.             ScanKeyDef.LongkeyFlag = 0;
    
37.             if((ScanKeyDef.count == SERIES_PRESS_TIME_IR) && ISSeriesKey(KeyValueTemp)) //处理连续按键
    3 d. n6 P  ~7 b' Z
38.                 {
    
39.                     KeyValue = changeSeriesKey ( KeyValueTemp );
    
40.                     ScanKeyDef.PreKeyValue = KEY_NONE;
    
41.                 }
    
42.             else if ( ScanKeyDef.count  < SHORT_PRESS_TIME_IR )
    * T2 w5 S4 d: h! o5 f$ I8 \6 x
43.             {
    
44.                 ScanKeyDef.PreKeyValue = KeyValueTemp;
    
45.             }
    
46.             else
    # n/ ^: S6 n1 H! k) r" O% @2 ?+ G! o
47.             {
    % d0 C* O* ~3 M9 `# n, E
48.             
    
49.                 ScanKeyDef.PreKeyValue  = KEY_NONE; // 无效按键
    ) l2 s6 @) ?, F. G  F' G
50.             }
    $ F% ?( S" d8 z* K( a6 Z) K* X; v
51.         }
    3 H7 F) j( O9 R. k$ A
52.         else if ( ScanKeyDef.count  == LONG_PRESS_TIME_IR )
    
53.         {
    
54.       
    
55.            if (ISLongKey(KeyValueTemp))
    
56.             {
    
57.                 {
    ' U0 }. r) _. ^3 g/ h" a8 s
58.                    ScanKeyDef.LongkeyFlag = 1;
    
59.                    KeyValue = changeToLongKey ( KeyValueTemp );
    
60.                }
    
61.           }
    
62.             ScanKeyDef.PreKeyValue = KEY_NONE;
    
63.          
    
64.         }
    
65.         else if (ScanKeyDef.count > LONG_PRESS_TIME_IR )
    
66.         {
    
67.       
    
68.             ScanKeyDef.PreKeyValue  = KEY_NONE; //无效按键
    
69.         }
    3 l% s! U8 `7 G, O9 w
70.     }
    - U! Z: q: W% b. A9 C* h
71.     else//release & no press
    
72.     {
    
73.         KeyReleaseTimeCount ++;
    
74.         if(KeyReleaseTimeCount >= KEY_RELEASE_TIME_OUT_IR)
    
75.         {
    " y# a% S9 a6 [: G) h- s1 m: q
76.   
    
77.             if ( ScanKeyDef.PreKeyValue != KEY_NONE ) //释放按键值
    
78.             {
    0 E$ |9 Y/ G7 D) x
79.                 if ( ScanKeyDef.LongkeyFlag == 0 )
    0 g6 @' i1 C& y6 v7 b
80.                 {
    
81.            
    
82.                     KeyValue =ScanKeyDef.PreKeyValue ;
    
83.                 }
    
84.             }         
    # k9 {: [+ y8 {* H' s2 O& K. N
85.             ScanKeyDef.count  = 0;
    
86.             ScanKeyDef.LongkeyFlag = 0;
    
87.            ScanKeyDef.PreKeyValue = KEY_NONE;
    3 K  p7 t. v) |6 [% `7 O" r  w
88.    
    * y: M, T9 R0 N' z1 U6 g; _
89.         }
    - @; W4 G% h% ]2 n+ M* _% u
90.     }
    
91.     return(KeyValue);
    . [: e8 X; n+ M5 X0 [
92. }     

复制代码

2 u5 f5 J: u' H
. \( i2 t! W/ D4 J

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

不错                 

确实不错        

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

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

不错，学习了！

不错，学习了！

学习了

学习，感谢楼主分享

可以的，学习一下

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

学习中，谢谢分享。

不错，学习了

学习了