基于STM32的按键扫描测试程序（学习记录）：

+ m; _4 f1 N4 k, W7 v$ w
1、粘贴代码时，粘贴在源文件存放的位置中（如：HARDWARE中的.c和.h文件），用C++编译器打开，而不是kei；最后keil会正常显示中文字符；
2、程序使用嵌套循环实现4x4按键扫描，如果IO口设置过乱时，将循环拆分即可；
) ]0 O* b: z; \( Okey4x4.h源文件

1. #ifndef __KEY4x4_H
   
2. #define __KEY4x4_H         
   ; A' i. n- M6 \1 T
3. #include "sys.h"
   / S' H6 L0 }; R
4. 
   
5. #define KEY_X(X)        PEin(X)                                // 尽量避免使用PD以上GPIO，便于移植；
   
6. #define KEY_Y(Y)        PEout(Y)
   
7. 
   
8. #define ALL_DOWN_KEY_Y        {        KEY_Y(11) = 0; KEY_Y(12) = 0; KEY_Y(13) = 0; KEY_Y(14) = 0;}
     T6 p$ m8 q# @7 w, Z7 L
9. 
   ( y: G& O( p% n% Q; |
10. void KEY4x4_Init(void);                // IO口初始化
    1 D+ ~; J! w/ ~: l! v
11. u8 KEY4x4_Scan(void);                  // 矩阵按键反馈函数        // 可配置任意矩阵按键使用！！
    6 x' P: F/ X& L" z1 P- y7 ]
12. u8 KEY16_Scan(void);
    
13. 
    $ ?4 ]) x' g5 @
14. /**************
    ; \8 Q; b. w( L1 o3 l3 j
15. 按键扫描方案二：
    & d! u% z) R. _  O+ S5 u! i
16. 按键使用8个输入IO口， 且所有IO口一端接VCC/VSS；
    
17. 
    
18. 程序框架：       
    
19.         扫描检测哪两个IO口输入高/低电平；VCC/VSS
    
20.         根据对应坐标，return对应编号；
    / q4 a, d+ N9 `8 T" ?' j( K
21. **************/
    " g& ]7 X$ l$ v1 Y# T" N$ K
22. 
    
23. #endif
    

复制代码

key4x4.c源文件

1. #include "stm32f10x.h"
   
2. #include "key4x4.h"
   
3. #include "sys.h"
   
4. #include "delay.h"
   ( {2 z+ G6 l3 a: b0 w# y0 [
5. #include "usart.h"
   
6. 
   
7. 
   , i1 U  q2 ?0 [3 p
8. /*************************
   
9. X：
   
10.         PEin        7-10
    
11. Y：
    5 n  R! X5 [. Z( ?
12.         PEout        11-14
    : a/ I( ]3 ]" C9 w
13. *************************/
    
14. 
    
15. 
    
16. // 矩阵按键初始化函数
    
17. void KEY4x4_Init(void)
    9 R, k6 |" v" o
18. {
    $ Y1 P' @! V6 |8 Y
19.                 GPIO_InitTypeDef GPIO_InitStructure;
    ; p8 Z3 N: s4 C2 S, C' b, D$ n
20. 
    8 F0 \: b/ h+ x5 J
21.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE);
    
22. 
    
23.                 GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10;//KEY0-KEY1
    - u& J/ e; K9 F; v) }. @
24.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //设置成下拉输入
    
25.                 GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化GPIOE
    - c. D8 a. D3 y; X/ d  F
26. 
    / _0 Q' |0 J5 A, D! c/ Q
27.                 GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14;                                 //LED0-->PB.5 端口配置
    
28.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
    0 `, |7 ~6 h" ]
29.                 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    
30.                 GPIO_Init(GPIOE, &GPIO_InitStructure);                                                         //根据设定参数初始化GPIOE
    
31. }
    6 ^  B- [5 b3 [8 u& M: x
32. 
    
33. // 使所有输出拉低；初始化；                // 可以使用define宏定义，执行速度更快，不用跳转函数！！
    3 c! }( @; K/ w- p$ ]
34. static void KEY_ALL_Pull_Down(void)
    
35. {
    
36.         KEY_Y(11) = 0;
    
37.         KEY_Y(12) = 0;
    
38.         KEY_Y(13) = 0;
    ) ~3 v/ M+ \/ C3 h7 j% l" K
39.         KEY_Y(14) = 0;
    " Z7 @- v. g# L7 S% Y2 o! x: t. v" E
40. }
    
41. 
    4 O$ G6 E! u6 g/ X# e' M; R
42. // 4x4按键扫描函数
    
43. // 使用一个嵌套循环，完成扫描X和Y；
    
44. // 原理： 通过Y 依次输出高电平,
    
45. //                                扫描X 那个IO口输入高电平；
    
46. // X轴：输入检查、扫描；
    / t: V9 q) {4 D3 Y! P- C
47. // Y轴：设置输出状态；
    $ |  c6 B4 d- w2 F
48. // 该函数适合任意排列矩阵按键，只需修改循环中对应编号！！
    ' M9 |" h& U- g+ x% g8 M
49. // 注意： 1. 改变IO口时，该函数还需要改变循环中IO口编号；（可以定义好IO口编号，便于修改）
    
50. //                                2. 该函数同样有优先级问题！ 即同时按下时，只反馈先被扫描到的（0-15标号最小的）
    4 m* R! n5 |# `: h/ h3 Q8 v
51. //                                3. 函数同一坐标轴的IO口编号必须相邻或能有 规律递增可寻；（否则无法用循环判断）
    % ?) \" ?; {2 [% i* o
52. //                                4. 暂时未添加功能（模式）：        按键复用 和 长按；
    7 [5 F# ?8 o0 L: ?+ E" w) C
53. // 2020-11-13                返回值调整为：1-16
    . ^* z. U% u- o; \" C( R8 X3 U0 ?7 V
54. // 11/14 不支持连按；解决重复反馈的问题；
    8 r6 g7 D( n# I  d! z, Z
55. u8 KEY4x4_Scan(void)
    
56. {
    
57.         int i,j;
    / e; b1 R# e8 J! y
58.         u8 IO_Sign = 0;                                // 很简便的一个IO反馈方式标签！！！  且嵌套循环特有！！  // 能返回0-15，适合任意排列矩阵按键
    , o* s" v0 R0 T4 n' r$ {) ?3 m
59.         static key_up = 1;
    % A4 n4 y# J! N( r7 I, @
60.        
    
61.         //KEY_ALL_Pull_Down();                                                                                // 初始化所有按键输出拉低；
    
62.        
    9 w4 m8 h6 l1 J1 e  p7 `( Q
63.         for (i = 11; i <= 14; i++)                                                        // Y输出IO口编号；
    
64.                 for (j = 7; j <= 10; j++,IO_Sign++)                // X输出IO口编号；  // 递增IO_Sign，反馈对应值（0-15）；
    
65.                 {
    # m6 F& }; \, ^: p4 b9 a; ~2 [$ H9 w
66.                         KEY_Y(i) = 1;                        // 使PEout(i)输出高电平；
    ; C9 j- V* f2 G
67.                        
    # Q3 {" k! n. K2 ~1 |* @5 k
68.                         if (KEY_Y(i))                        // 扫描Y输出高电平， 可以取消此判断； 因为必须输出高电平时，才能正常判断！！
    - l2 v9 s8 a' ~- c/ ]; e$ l  d# v
69.                         {
    
70.                                 if (KEY_X(j) && key_up)                // 当输入检查到高电平时；
    
71.                                 {
    
72.                                         key_up = 0;
    
73.                                         printf("按键扫描反馈： %d  \r\n",IO_Sign);
    % {- V: K# _- r$ d2 {6 Y
74.                                         return IO_Sign;
    
75.                                 }
    
76.                                 else if (!KEY_X(7)&&!KEY_X(8)&&!KEY_X(9)&&!KEY_X(10))                        // 当所有输入检测到低电平时，再次使能按键； 防止重复反馈
    " [2 p; {7 t0 W( ?
77.                                 {
    7 e6 Y& F+ {9 y( J& C3 K* T* ?
78.                                         key_up = 1;
    
79.                                         KEY_ALL_Pull_Down();                                                                                // 初始化所有按键输出拉低（低电平）；必须在此位置；
    ( l8 Q3 M- u- f6 d" u
80.                                 }
    
81.                         }
    
82.                         else
    1 I: q7 {0 }- n
83.                                 printf("PEout:IO口%d输出异常！  \r\n ", i);
    6 n8 W' J' O  }( z
84.                 }
    % A! z9 w0 Z5 [% |/ a9 m" }
85.                
    : d0 Y( f# w8 w+ i$ s
86.         delay_ms(10);                                        // 按键防抖；
    
87. }
    
88. 
    , y9 K1 q6 R" C9 u, H
89. 
    ) `2 I3 z8 _9 `) G8 `4 B: g
90. /******************************************标准扫描函数*********************************************/
    1 y/ M6 u' y3 r% |; [: C
91. // 支持连按
    9 k4 s3 h( x! Q& f: _. l
92. u8 KEY16_Scan(void)
    
93. {
    " x: X# g1 x4 C3 {: O
94.         int i,j;
      r8 L% ?3 B# o. {0 Z$ J
95.         u8 IO_Sign = 0;                                // 很简便的一个IO反馈方式标签！！！  且嵌套循环特有！！  // 能返回0-15，适合任意排列矩阵按键
    ( |" j" a% T& N& L3 I' ^
96.        
    
97.         ALL_DOWN_KEY_Y                                                                                                        // 初始化所有按键输出拉低；
    $ z( K, Q: T6 z7 X: C" I
98.        
    
99.         for (i = 11; i <= 14; i++)                                                        // Y输出IO口编号；
    , T0 |* N7 s/ N1 D7 p
100.                 for (j = 7; j <= 10; j++,IO_Sign++)                // X输出IO口编号；  // 递增IO_Sign，反馈对应值（0-15）；
     
101.                 {
     
102.                         KEY_Y(i) = 1;                        // 使PEout(i)输出高电平；
     
103. 
     * e! s* ^( M% _+ z" S! d& c
104.                         if (KEY_X(j))                        // 当输入检查到高电平时；
     5 r2 ~; i9 y4 o8 ]# X, F8 p/ G
105.                                 return IO_Sign;
     : s6 `' P; K+ g8 l% l* y9 I/ ~( C
106.                 }
     ' @5 V/ Q  e- V' i
107.                
     
108.         delay_ms(20);                                        // 按键防抖；                // 连按延时；
     - z$ |- q7 P8 ?
109. }
     0 U$ ?4 R6 F. ^" D' g
110. 
     

复制代码

$ A) v8 K9 I6 `( F
9 N- g5 `. e2 |8 z. d$ f2 M. C$ o*4x4按键原理图
+ U! e7 H% v# ~( V% D* s" o) G
3、按键工作原理：
当按键被按下时，相连的电路导通；即S1按下时，位于0行0列的线短路，使标号4和5对应的IO口相连（导通）；
最后通过扫描检测输入输出状态即可判断出对应按键被按下；
7 @9 c  U" r% U* r5 P
" ^! @% e  ]# K9 J. l/ _# ^
4、程序设计思路：
( Q- I1 a! @2 e1 q6 |8 ~程序通过依次使标号1、2、3、4（列0-3）输出高电平，判断5/6/7/8（行0-3）状态；完成按键扫描；
1 P# B' f: w+ x. D! Q; c* l5 m$ I2 X

$ t/ g0 A: ?* ^+ V
( I) j9 C# s! M
) d- T$ [" O$ D3 D  N( h