基于STM32的按键扫描测试程序（学习记录）：
1 @0 h+ J3 A/ F+ t, s" t6 v+ f
4 i3 X2 z' r, l5 t" |+ C' f
! c+ u' K  s+ e3 X! f* L: s& L1、粘贴代码时，粘贴在源文件存放的位置中（如：HARDWARE中的.c和.h文件），用C++编译器打开，而不是kei；最后keil会正常显示中文字符；
2、程序使用嵌套循环实现4x4按键扫描，如果IO口设置过乱时，将循环拆分即可；
key4x4.h源文件

1. #ifndef __KEY4x4_H
   ( |5 m( i" ]" E9 d# U: l0 |4 F
2. #define __KEY4x4_H         
   2 w: i5 q7 w% V0 G& J& B2 i* J# X
3. #include "sys.h"
   % ^& b; N, v; W2 {+ }
4. 
   
5. #define KEY_X(X)        PEin(X)                                // 尽量避免使用PD以上GPIO，便于移植；
   ! n2 O, E2 g- Y/ j8 R
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;}
   0 C) V0 N. _! {' _7 p- X
9. 
   
10. void KEY4x4_Init(void);                // IO口初始化
    . p& r) V" l# A; k2 s. f; B
11. u8 KEY4x4_Scan(void);                  // 矩阵按键反馈函数        // 可配置任意矩阵按键使用！！
    5 h) F5 W* o0 S# d
12. u8 KEY16_Scan(void);
    
13. 
    
14. /**************
    ; o! x9 Z9 Y; }1 s- O6 X; f; J
15. 按键扫描方案二：
    
16. 按键使用8个输入IO口， 且所有IO口一端接VCC/VSS；
    
17. 
    ) D- H0 [- c$ Q' t6 k+ ^
18. 程序框架：       
    
19.         扫描检测哪两个IO口输入高/低电平；VCC/VSS
    " d& [* P% g2 D  |" ^
20.         根据对应坐标，return对应编号；
    
21. **************/
    % K8 ]- O& @% r) ^
22. 
    
23. #endif
    5 [2 R3 m; q! t6 W* W1 r2 C

复制代码

key4x4.c源文件
5 K# \. \3 a6 j: {

1. #include "stm32f10x.h"
   7 g+ J: q# F% }0 O* U* ?7 l
2. #include "key4x4.h"
   
3. #include "sys.h"
   
4. #include "delay.h"
   
5. #include "usart.h"
   
6. 
   
7. 
   ' Z2 V9 Y( f( q: j; m
8. /*************************
   
9. X：
   
10.         PEin        7-10
    4 H+ A! E# X- u0 n" z* t6 L
11. Y：
    ' c  j" G' Z7 w- f3 G
12.         PEout        11-14
    
13. *************************/
    
14. 
    
15. 
    2 T# p8 }; Y) b' W
16. // 矩阵按键初始化函数
    
17. void KEY4x4_Init(void)
    
18. {
      B/ z/ J: C0 i) O1 w
19.                 GPIO_InitTypeDef GPIO_InitStructure;
    
20. 
    
21.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE);
    
22. 
    + Y  W, Y" b& p) v
23.                 GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10;//KEY0-KEY1
    
24.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //设置成下拉输入
    8 S" M2 v; B/ W0 K1 F# N6 D
25.                 GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化GPIOE
    
26. 
    
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;                  //推挽输出
    
29.                 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    & O, t! X" h, j# b( A4 n# E; N
30.                 GPIO_Init(GPIOE, &GPIO_InitStructure);                                                         //根据设定参数初始化GPIOE
    
31. }
    4 V' Y9 X5 e, S$ ~
32. 
    
33. // 使所有输出拉低；初始化；                // 可以使用define宏定义，执行速度更快，不用跳转函数！！
    
34. static void KEY_ALL_Pull_Down(void)
    
35. {
    
36.         KEY_Y(11) = 0;
    
37.         KEY_Y(12) = 0;
    0 W& n4 o5 f; K/ D, B6 A
38.         KEY_Y(13) = 0;
    1 |0 F1 \1 J& }, b% |  x& D
39.         KEY_Y(14) = 0;
    
40. }
    * z7 p" \" o5 Q. e; t" e6 T
41. 
    
42. // 4x4按键扫描函数
    
43. // 使用一个嵌套循环，完成扫描X和Y；
    
44. // 原理： 通过Y 依次输出高电平,
    
45. //                                扫描X 那个IO口输入高电平；
    # `; M& ~: j) s7 Q
46. // X轴：输入检查、扫描；
    9 g, t! U  s- }# I1 [0 Y+ E
47. // Y轴：设置输出状态；
    
48. // 该函数适合任意排列矩阵按键，只需修改循环中对应编号！！
    # I4 |/ t9 N! ^6 r7 j2 D
49. // 注意： 1. 改变IO口时，该函数还需要改变循环中IO口编号；（可以定义好IO口编号，便于修改）
    + D+ E+ Q6 u5 I
50. //                                2. 该函数同样有优先级问题！ 即同时按下时，只反馈先被扫描到的（0-15标号最小的）
    & w5 B3 g/ ^; }& O6 E2 ^
51. //                                3. 函数同一坐标轴的IO口编号必须相邻或能有 规律递增可寻；（否则无法用循环判断）
    ' I) H' Q- j8 f+ {& Y
52. //                                4. 暂时未添加功能（模式）：        按键复用 和 长按；
    * y+ G6 x, L' `. f
53. // 2020-11-13                返回值调整为：1-16
    
54. // 11/14 不支持连按；解决重复反馈的问题；
    * z% m' A7 Y1 X  C/ K
55. u8 KEY4x4_Scan(void)
    
56. {
    
57.         int i,j;
    $ I6 z7 i4 D, a+ N
58.         u8 IO_Sign = 0;                                // 很简便的一个IO反馈方式标签！！！  且嵌套循环特有！！  // 能返回0-15，适合任意排列矩阵按键
    ! R  w+ r; l2 A' E0 L& ^( P
59.         static key_up = 1;
    6 B& ]$ ?" w+ `7 ^
60.        
    
61.         //KEY_ALL_Pull_Down();                                                                                // 初始化所有按键输出拉低；
    % n7 w' B9 u& `; K5 J
62.        
      Q& p! J. m9 G& x) a
63.         for (i = 11; i <= 14; i++)                                                        // Y输出IO口编号；
    3 g, Y4 T$ g% S
64.                 for (j = 7; j <= 10; j++,IO_Sign++)                // X输出IO口编号；  // 递增IO_Sign，反馈对应值（0-15）；
    9 [8 G- B' i* {! Q4 O7 K2 k
65.                 {
    
66.                         KEY_Y(i) = 1;                        // 使PEout(i)输出高电平；
    
67.                        
    
68.                         if (KEY_Y(i))                        // 扫描Y输出高电平， 可以取消此判断； 因为必须输出高电平时，才能正常判断！！
    
69.                         {
    
70.                                 if (KEY_X(j) && key_up)                // 当输入检查到高电平时；
    
71.                                 {
    
72.                                         key_up = 0;
    2 R1 O$ t8 y+ u3 |8 h3 T
73.                                         printf("按键扫描反馈： %d  \r\n",IO_Sign);
    9 k* c; ?8 f$ P9 S2 Q
74.                                         return IO_Sign;
    
75.                                 }
    + K6 I. d7 X0 h6 P
76.                                 else if (!KEY_X(7)&&!KEY_X(8)&&!KEY_X(9)&&!KEY_X(10))                        // 当所有输入检测到低电平时，再次使能按键； 防止重复反馈
    
77.                                 {
    8 @3 y$ }% p) a9 ?, p+ O
78.                                         key_up = 1;
    2 n4 [& Y! c7 i8 [( c+ T
79.                                         KEY_ALL_Pull_Down();                                                                                // 初始化所有按键输出拉低（低电平）；必须在此位置；
    
80.                                 }
    
81.                         }
    
82.                         else
    
83.                                 printf("PEout:IO口%d输出异常！  \r\n ", i);
    ' h/ k; h7 w- z+ ]7 M
84.                 }
    5 {9 m8 |/ c& p9 M" Y+ [% @. ^# o
85.                
    
86.         delay_ms(10);                                        // 按键防抖；
    
87. }
    + B9 m( B* ?# F
88. 
    1 ?: y6 b0 Q6 L! I3 t, V
89. 
    $ [  h4 d6 Y$ C2 _8 ?( h/ ?! V
90. /******************************************标准扫描函数*********************************************/
    0 ?3 T$ R, a% h
91. // 支持连按
    
92. u8 KEY16_Scan(void)
    0 ^9 T2 B& ~; K; h. @, b: d) g
93. {
    5 K+ x5 H. N. }5 @
94.         int i,j;
    : Q! {8 p" p& d$ P
95.         u8 IO_Sign = 0;                                // 很简便的一个IO反馈方式标签！！！  且嵌套循环特有！！  // 能返回0-15，适合任意排列矩阵按键
    
96.        
    
97.         ALL_DOWN_KEY_Y                                                                                                        // 初始化所有按键输出拉低；
    
98.        
    . O% B8 M  u6 m- [$ X
99.         for (i = 11; i <= 14; i++)                                                        // Y输出IO口编号；
    " v& x2 J6 a, o* @1 L* v% q% 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. 
     
104.                         if (KEY_X(j))                        // 当输入检查到高电平时；
     1 s2 s$ g9 i, }
105.                                 return IO_Sign;
     ; v8 [* B9 A% S# @. ^! c
106.                 }
     " l! p3 ^2 x0 m. G
107.                
     
108.         delay_ms(20);                                        // 按键防抖；                // 连按延时；
     
109. }
     ; P3 i. W. N3 |5 C: ?/ W5 |+ j
110. 
     1 n7 u; O! O0 ~" R( a

复制代码

*4x4按键原理图

, {  D( H! u1 J- o( ?3、按键工作原理：
当按键被按下时，相连的电路导通；即S1按下时，位于0行0列的线短路，使标号4和5对应的IO口相连（导通）；
* k- W6 }" l* f; Z% Y8 F4 w$ `3 y1 o最后通过扫描检测输入输出状态即可判断出对应按键被按下；


4、程序设计思路：
  x: d0 r6 [2 m3 ?程序通过依次使标号1、2、3、4（列0-3）输出高电平，判断5/6/7/8（行0-3）状态；完成按键扫描；
2 f( W3 Q& Q4 H& n

8 x- [* u6 I$ `- f( A
# G% f8 p- i# L; p" D' g. r( q
' {, w1 r) c  Q' x) y! `2 p! ~