基于STM32的按键扫描测试程序（学习记录）：
# N( q. N( r6 u4 P
* |5 f6 M* f/ ?7 }2 c9 s# k9 h
1、粘贴代码时，粘贴在源文件存放的位置中（如：HARDWARE中的.c和.h文件），用C++编译器打开，而不是kei；最后keil会正常显示中文字符；
# W- G4 x/ K. S2、程序使用嵌套循环实现4x4按键扫描，如果IO口设置过乱时，将循环拆分即可；
3 ?* Q7 l: T' E$ h& ?9 ^key4x4.h源文件
4 ^1 }. i0 k" y9 }! j8 a) |

1. #ifndef __KEY4x4_H
   7 D9 I2 H( q2 a7 W8 G' T2 l
2. #define __KEY4x4_H         
   5 x6 G2 {* x" U0 x! X3 U
3. #include "sys.h"
   ) q0 i1 G4 C) k1 B
4. 
   
5. #define KEY_X(X)        PEin(X)                                // 尽量避免使用PD以上GPIO，便于移植；
   1 E9 a* r7 P0 E9 a" Q" T
6. #define KEY_Y(Y)        PEout(Y)
   
7. 
   + E$ H! L  O1 M1 C1 D5 N
8. #define ALL_DOWN_KEY_Y        {        KEY_Y(11) = 0; KEY_Y(12) = 0; KEY_Y(13) = 0; KEY_Y(14) = 0;}
   2 z' L3 c! w) M: Z# D
9. 
   % [) Q' {9 i  S7 h3 [
10. void KEY4x4_Init(void);                // IO口初始化
    
11. u8 KEY4x4_Scan(void);                  // 矩阵按键反馈函数        // 可配置任意矩阵按键使用！！
    0 j8 |% p( a9 z2 K1 s
12. u8 KEY16_Scan(void);
    ) W' y5 @$ x( x. _! d- Y2 V
13. 
    
14. /**************
    
15. 按键扫描方案二：
    
16. 按键使用8个输入IO口， 且所有IO口一端接VCC/VSS；
    + M6 H; e6 x7 V0 V) v
17. 
    
18. 程序框架：       
    . c; |" x: z! S( a; L+ Z
19.         扫描检测哪两个IO口输入高/低电平；VCC/VSS
    
20.         根据对应坐标，return对应编号；
    
21. **************/
    
22. 
    4 S! `  m/ x% D/ k4 F3 ~
23. #endif
    4 P7 o: F/ G/ h

复制代码

key4x4.c源文件

1. #include "stm32f10x.h"
   
2. #include "key4x4.h"
   2 d" V$ t1 R3 r. }* ~
3. #include "sys.h"
   
4. #include "delay.h"
   
5. #include "usart.h"
   
6. 
   ) Q% ]7 r, H0 e- s
7. 
   
8. /*************************
   
9. X：
   
10.         PEin        7-10
    
11. Y：
    
12.         PEout        11-14
    
13. *************************/
    * C% W2 i( x; O& i. z+ j0 ~! N
14. 
    ; v8 j8 v$ e8 z7 s5 A
15. 
    
16. // 矩阵按键初始化函数
    
17. void KEY4x4_Init(void)
    
18. {
    1 |- u8 [* h5 e2 P" [* X" q& f8 e
19.                 GPIO_InitTypeDef GPIO_InitStructure;
    / F% M: l6 f2 a, v& m
20. 
    + V. h  _" P  l, F+ r* y% F
21.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE);
    , ~0 p; p: l! g  k, h) [# [8 l
22. 
    $ @$ c& i0 o3 n" [2 F  I
23.                 GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10;//KEY0-KEY1
    + V; ^; ]/ q' F: }/ w( ~
24.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //设置成下拉输入
    
25.                 GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化GPIOE
    
26. 
      l0 Q# L& D0 G7 p( O
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;                  //推挽输出
    ; E; e& u# s9 v" k9 i  \) z
29.                 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    % e2 E" N/ G. }: P) L
30.                 GPIO_Init(GPIOE, &GPIO_InitStructure);                                                         //根据设定参数初始化GPIOE
    
31. }
    
32. 
    4 Q) i* }% W- ^; d
33. // 使所有输出拉低；初始化；                // 可以使用define宏定义，执行速度更快，不用跳转函数！！
    " P: a% i8 ]1 [
34. static void KEY_ALL_Pull_Down(void)
    
35. {
    
36.         KEY_Y(11) = 0;
    
37.         KEY_Y(12) = 0;
    - }7 a+ d2 v- ^4 J
38.         KEY_Y(13) = 0;
    
39.         KEY_Y(14) = 0;
    0 o% Z/ w# @; [- R3 z
40. }
    
41. 
    $ X- x. N7 z0 x5 V9 i
42. // 4x4按键扫描函数
    9 f7 u9 I5 s0 S( \& ^! a1 P
43. // 使用一个嵌套循环，完成扫描X和Y；
    . |8 W6 }2 Q  _+ L; x8 J8 K
44. // 原理： 通过Y 依次输出高电平,
    & B, j* H4 H' S2 c# t
45. //                                扫描X 那个IO口输入高电平；
    
46. // X轴：输入检查、扫描；
    + R9 [/ n' k# Q, M# a# W5 l
47. // Y轴：设置输出状态；
    * I" X% O% b4 w! a: c1 S1 l
48. // 该函数适合任意排列矩阵按键，只需修改循环中对应编号！！
    ! l9 d& l: `' N. x, W7 y2 o# \
49. // 注意： 1. 改变IO口时，该函数还需要改变循环中IO口编号；（可以定义好IO口编号，便于修改）
    
50. //                                2. 该函数同样有优先级问题！ 即同时按下时，只反馈先被扫描到的（0-15标号最小的）
    ( \' b: x/ O) Q4 W& ]' M# j
51. //                                3. 函数同一坐标轴的IO口编号必须相邻或能有 规律递增可寻；（否则无法用循环判断）
    
52. //                                4. 暂时未添加功能（模式）：        按键复用 和 长按；
    , P* K: w/ B: |5 L; c& E' A
53. // 2020-11-13                返回值调整为：1-16
    
54. // 11/14 不支持连按；解决重复反馈的问题；
    $ N& L: f: ]! Y9 ^
55. u8 KEY4x4_Scan(void)
    - o; E5 C8 @8 |/ V6 j
56. {
    3 W5 Q" ~3 ~/ \: K. y
57.         int i,j;
    ; O8 n) q) o+ ]# n& Z. Q( S! ?( O
58.         u8 IO_Sign = 0;                                // 很简便的一个IO反馈方式标签！！！  且嵌套循环特有！！  // 能返回0-15，适合任意排列矩阵按键
    
59.         static key_up = 1;
    
60.        
    % s' h6 P* k) q# Y' k
61.         //KEY_ALL_Pull_Down();                                                                                // 初始化所有按键输出拉低；
    # s2 G# {8 X) v6 @' \( P# C: ]
62.        
    
63.         for (i = 11; i <= 14; i++)                                                        // Y输出IO口编号；
    ; |3 ^% ~  F* e
64.                 for (j = 7; j <= 10; j++,IO_Sign++)                // X输出IO口编号；  // 递增IO_Sign，反馈对应值（0-15）；
    2 M9 C6 H) U- J' ?; K$ O
65.                 {
    
66.                         KEY_Y(i) = 1;                        // 使PEout(i)输出高电平；
    
67.                        
    
68.                         if (KEY_Y(i))                        // 扫描Y输出高电平， 可以取消此判断； 因为必须输出高电平时，才能正常判断！！
    
69.                         {
    - z  `& @3 V$ H8 x. _" ?  [
70.                                 if (KEY_X(j) && key_up)                // 当输入检查到高电平时；
    - Z* W4 D6 J2 h
71.                                 {
    
72.                                         key_up = 0;
    % C& ]5 v2 A8 J. J
73.                                         printf("按键扫描反馈： %d  \r\n",IO_Sign);
    
74.                                         return IO_Sign;
    
75.                                 }
    
76.                                 else if (!KEY_X(7)&&!KEY_X(8)&&!KEY_X(9)&&!KEY_X(10))                        // 当所有输入检测到低电平时，再次使能按键； 防止重复反馈
    , [) ]; ~6 ?" |& D. C9 T
77.                                 {
    2 q4 G9 K# }# F- [. u. r( ^
78.                                         key_up = 1;
    
79.                                         KEY_ALL_Pull_Down();                                                                                // 初始化所有按键输出拉低（低电平）；必须在此位置；
    7 C# h8 R6 ~8 `) |
80.                                 }
    
81.                         }
    ; p+ C/ f$ J3 d" z6 [
82.                         else
    
83.                                 printf("PEout:IO口%d输出异常！  \r\n ", i);
    
84.                 }
    
85.                
    
86.         delay_ms(10);                                        // 按键防抖；
    7 X. J% [# g* E3 l4 z5 J
87. }
    
88. 
    
89. 
    , j( r  O* ]. P1 P9 x
90. /******************************************标准扫描函数*********************************************/
    & _9 M! Y+ z8 [, y
91. // 支持连按
    
92. u8 KEY16_Scan(void)
    
93. {
    9 e: N% @" n, y& h+ B  |0 n% H, X
94.         int i,j;
    1 E+ ~& ?3 L5 h6 x7 E5 h, F
95.         u8 IO_Sign = 0;                                // 很简便的一个IO反馈方式标签！！！  且嵌套循环特有！！  // 能返回0-15，适合任意排列矩阵按键
    
96.        
    ( f3 d5 l+ `6 d! P
97.         ALL_DOWN_KEY_Y                                                                                                        // 初始化所有按键输出拉低；
    
98.        
    ; A9 R* A9 Y' @5 V  t3 {9 r
99.         for (i = 11; i <= 14; i++)                                                        // Y输出IO口编号；
    ) Y9 t; u& k7 a2 f6 `
100.                 for (j = 7; j <= 10; j++,IO_Sign++)                // X输出IO口编号；  // 递增IO_Sign，反馈对应值（0-15）；
     
101.                 {
     
102.                         KEY_Y(i) = 1;                        // 使PEout(i)输出高电平；
     5 c- g$ j6 W/ Z/ \  C9 _
103. 
     
104.                         if (KEY_X(j))                        // 当输入检查到高电平时；
     . c; ^" _5 s4 A9 g  _) g& ~' x
105.                                 return IO_Sign;
     1 [( f" E9 A& c% k) t
106.                 }
     
107.                
     
108.         delay_ms(20);                                        // 按键防抖；                // 连按延时；
     ' `9 h& T1 G: }
109. }
     1 z$ F; k: R3 @  p! N- C
110. 
     3 C, Y' B1 P9 F) t4 t3 y0 a

复制代码

$ w9 T" L; o8 ~3 ]) r; ]* ~
+ F- D; R/ Y6 F" O9 p*4x4按键原理图

0 H- _" r7 K: U% Q/ P4 B3、按键工作原理：
当按键被按下时，相连的电路导通；即S1按下时，位于0行0列的线短路，使标号4和5对应的IO口相连（导通）；
+ O& S9 n" I: L) n# d: h最后通过扫描检测输入输出状态即可判断出对应按键被按下；


4、程序设计思路：
- Y8 E  N- s% y, E7 ^7 }程序通过依次使标号1、2、3、4（列0-3）输出高电平，判断5/6/7/8（行0-3）状态；完成按键扫描；
" k/ P, Y  T/ C- z" u* R& q
$ D" e* {/ y" k


2 l2 n# t/ N' l9 ~0 N6 k0 a