基于STM32的按键扫描测试程序（学习记录）：
) y/ L5 ?8 E9 i( _) ?$ Y; H0 l6 W6 O
% d" t+ ]) G/ I0 D0 A) ]
1、粘贴代码时，粘贴在源文件存放的位置中（如：HARDWARE中的.c和.h文件），用C++编译器打开，而不是kei；最后keil会正常显示中文字符；
2、程序使用嵌套循环实现4x4按键扫描，如果IO口设置过乱时，将循环拆分即可；
3 O' N! h# Y; ^) e9 jkey4x4.h源文件
8 f& H! n. U, m$ [; h' ?

1. #ifndef __KEY4x4_H
   
2. #define __KEY4x4_H         
   
3. #include "sys.h"
   8 X$ r: l, t) o9 R: e
4. 
   
5. #define KEY_X(X)        PEin(X)                                // 尽量避免使用PD以上GPIO，便于移植；
   
6. #define KEY_Y(Y)        PEout(Y)
   - F# {  b* L) Y8 F7 B& p
7. 
   
8. #define ALL_DOWN_KEY_Y        {        KEY_Y(11) = 0; KEY_Y(12) = 0; KEY_Y(13) = 0; KEY_Y(14) = 0;}
   
9. 
   ( P  k5 W9 H1 X, y# u. H
10. void KEY4x4_Init(void);                // IO口初始化
    
11. u8 KEY4x4_Scan(void);                  // 矩阵按键反馈函数        // 可配置任意矩阵按键使用！！
    4 v6 Y% ?% h0 U* w5 ^1 z: ^2 u8 t( |
12. u8 KEY16_Scan(void);
    
13. 
    
14. /**************
    & f& @  s/ ]- s: E
15. 按键扫描方案二：
      L6 b, z. l$ ^4 E/ d! R# K4 o
16. 按键使用8个输入IO口， 且所有IO口一端接VCC/VSS；
    . u: n+ U( C2 V0 Z8 D0 i
17. 
    . r! ?2 t% P3 G/ N$ R/ O
18. 程序框架：       
    : z; M/ n( n* S  n. U
19.         扫描检测哪两个IO口输入高/低电平；VCC/VSS
    
20.         根据对应坐标，return对应编号；
    
21. **************/
    9 q# w! L* {, m
22. 
    " n& r( X* s, m8 r4 }/ M& F
23. #endif
    + z3 z' w- ~7 [. m

复制代码

key4x4.c源文件
8 {  }% t4 s0 V' {

1. #include "stm32f10x.h"
   9 L# }2 a7 H' K+ ?% Q
2. #include "key4x4.h"
   
3. #include "sys.h"
   
4. #include "delay.h"
   # C) @: J( i" x7 R6 N/ q) {) |
5. #include "usart.h"
   . e; k3 q, C0 Q( ]+ A! w
6. 
   
7. 
   
8. /*************************
   
9. X：
     i0 [0 c: w/ G2 U* I4 Y( ?
10.         PEin        7-10
    $ Z; I6 e3 ]. C+ m# Q( T
11. Y：
    
12.         PEout        11-14
    
13. *************************/
    
14. 
    , W( x, N, C) k- m+ T2 x" s" \
15. 
    ) \, u4 M/ u% c; X
16. // 矩阵按键初始化函数
    3 y- x$ \+ I& t! o
17. void KEY4x4_Init(void)
    1 Y# N/ i& I: x# _
18. {
    
19.                 GPIO_InitTypeDef GPIO_InitStructure;
    
20. 
    
21.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE);
    & X) u5 [% g4 C- }1 M; {
22. 
    4 \8 e3 W/ u+ ^# I8 Z
23.                 GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10;//KEY0-KEY1
    ; r. M! w5 W: B6 `
24.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //设置成下拉输入
    4 V; _8 W! T, X! |
25.                 GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化GPIOE
    
26. 
    0 E0 _( l* W5 M6 B' `
27.                 GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14;                                 //LED0-->PB.5 端口配置
    6 _! N' f  V; L$ L0 m
28.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
    
29.                 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    
30.                 GPIO_Init(GPIOE, &GPIO_InitStructure);                                                         //根据设定参数初始化GPIOE
    
31. }
    ' k; O( y. Q: p' m$ O; T; w3 C
32. 
    6 \. ?/ R, `2 n- Z7 u( _6 u
33. // 使所有输出拉低；初始化；                // 可以使用define宏定义，执行速度更快，不用跳转函数！！
    9 q  F( }5 _. @* q  `! P! S/ i/ {
34. static void KEY_ALL_Pull_Down(void)
    
35. {
    ; U# [' e- u6 H, j/ a6 j' g
36.         KEY_Y(11) = 0;
    
37.         KEY_Y(12) = 0;
    
38.         KEY_Y(13) = 0;
    7 V% V* k! ^, h
39.         KEY_Y(14) = 0;
    3 O. b; q6 `9 b. S" V& B6 D. I4 V, M
40. }
    
41. 
    
42. // 4x4按键扫描函数
    
43. // 使用一个嵌套循环，完成扫描X和Y；
    
44. // 原理： 通过Y 依次输出高电平,
    9 p. c: Y6 s  u( c. A$ K
45. //                                扫描X 那个IO口输入高电平；
    
46. // X轴：输入检查、扫描；
    2 r5 n- \- S$ z7 h9 C& J8 C- U8 e
47. // Y轴：设置输出状态；
    6 d( ~' }6 R& b  t: A
48. // 该函数适合任意排列矩阵按键，只需修改循环中对应编号！！
    ( U7 }& Z& x" J
49. // 注意： 1. 改变IO口时，该函数还需要改变循环中IO口编号；（可以定义好IO口编号，便于修改）
    
50. //                                2. 该函数同样有优先级问题！ 即同时按下时，只反馈先被扫描到的（0-15标号最小的）
    
51. //                                3. 函数同一坐标轴的IO口编号必须相邻或能有 规律递增可寻；（否则无法用循环判断）
    3 X/ ?3 g) O0 c1 Z4 C( F1 m! x+ D* o
52. //                                4. 暂时未添加功能（模式）：        按键复用 和 长按；
    
53. // 2020-11-13                返回值调整为：1-16
    ( M3 S: E. M+ E3 r6 F
54. // 11/14 不支持连按；解决重复反馈的问题；
    0 f7 d0 N# Z2 Y# h/ D
55. u8 KEY4x4_Scan(void)
      F# H& [' R' |1 g' z# o- w
56. {
    " _; Z* h7 K# ]( W: J
57.         int i,j;
    
58.         u8 IO_Sign = 0;                                // 很简便的一个IO反馈方式标签！！！  且嵌套循环特有！！  // 能返回0-15，适合任意排列矩阵按键
    
59.         static key_up = 1;
    5 k& u4 I  _' H$ w% Q+ ?, i5 w
60.        
    
61.         //KEY_ALL_Pull_Down();                                                                                // 初始化所有按键输出拉低；
    6 v; R1 F: `0 i5 z+ S: ]
62.        
    
63.         for (i = 11; i <= 14; i++)                                                        // Y输出IO口编号；
    
64.                 for (j = 7; j <= 10; j++,IO_Sign++)                // X输出IO口编号；  // 递增IO_Sign，反馈对应值（0-15）；
    # s2 X. b# h  K: z3 C( ?
65.                 {
    
66.                         KEY_Y(i) = 1;                        // 使PEout(i)输出高电平；
    ; Z0 B' C1 |; X2 v. P
67.                        
    ! m' q% K" L0 Y9 z. p; [
68.                         if (KEY_Y(i))                        // 扫描Y输出高电平， 可以取消此判断； 因为必须输出高电平时，才能正常判断！！
    : I, k' n* [' {+ w( s3 j; A8 p
69.                         {
    
70.                                 if (KEY_X(j) && key_up)                // 当输入检查到高电平时；
    4 |3 n- d, `: Z: d
71.                                 {
    
72.                                         key_up = 0;
    
73.                                         printf("按键扫描反馈： %d  \r\n",IO_Sign);
      p3 n/ K7 ~5 _: e3 R+ q; J
74.                                         return IO_Sign;
    7 D$ F% h+ r" f/ S% W
75.                                 }
    - Y4 X( q; ?1 X5 m1 w
76.                                 else if (!KEY_X(7)&&!KEY_X(8)&&!KEY_X(9)&&!KEY_X(10))                        // 当所有输入检测到低电平时，再次使能按键； 防止重复反馈
    3 y1 D$ Z' |' M; p; k6 y
77.                                 {
    
78.                                         key_up = 1;
    
79.                                         KEY_ALL_Pull_Down();                                                                                // 初始化所有按键输出拉低（低电平）；必须在此位置；
    ; B6 q4 c' D- L1 [) L
80.                                 }
    
81.                         }
    ) T/ z! T9 s* S, ~! v$ W+ a
82.                         else
    4 C" J( `$ ]: ?% n
83.                                 printf("PEout:IO口%d输出异常！  \r\n ", i);
    ' T( K' [, W6 E+ J: T* [
84.                 }
    
85.                
    5 I' N& |4 N3 N* `1 V- w/ ^
86.         delay_ms(10);                                        // 按键防抖；
    
87. }
    2 P. g- N$ u) I% W2 N
88. 
    $ k) c( W3 z, W" [2 Z4 V9 G
89. 
    
90. /******************************************标准扫描函数*********************************************/
    ( f8 f( `  z1 E9 z( R) V3 ^) ^4 I
91. // 支持连按
    
92. u8 KEY16_Scan(void)
    / J7 X; l% `* r$ k$ n- s/ z
93. {
    / S  j4 v) ?7 A6 b: b
94.         int i,j;
    
95.         u8 IO_Sign = 0;                                // 很简便的一个IO反馈方式标签！！！  且嵌套循环特有！！  // 能返回0-15，适合任意排列矩阵按键
    , C  P1 c) I4 `7 O
96.        
    
97.         ALL_DOWN_KEY_Y                                                                                                        // 初始化所有按键输出拉低；
    
98.        
    8 P) l  b0 p0 L7 u
99.         for (i = 11; i <= 14; i++)                                                        // Y输出IO口编号；
    
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))                        // 当输入检查到高电平时；
     
105.                                 return IO_Sign;
     7 O! l, Z. [# J! ?  R! Z
106.                 }
     0 y2 e. ~! t( k
107.                
     / D% m* c) i  ^9 {8 N' S0 \" Y( r; A
108.         delay_ms(20);                                        // 按键防抖；                // 连按延时；
     
109. }
     " v' O, A2 u5 B# I% E2 j' g
110. 
     / U) T! F; s4 V" _

复制代码

; b4 ?: v, ]! n3 c. k. I9 V# `+ \
3 `; c; W; @+ m1 K4 S5 n; }*4x4按键原理图

3、按键工作原理：
1 l! i+ i5 S, N5 ?' I, P当按键被按下时，相连的电路导通；即S1按下时，位于0行0列的线短路，使标号4和5对应的IO口相连（导通）；
! d* K6 B1 N* E' c- `) I' A8 o最后通过扫描检测输入输出状态即可判断出对应按键被按下；

& F" _; t& g' k# \6 ~1 H' x; C
8 ?* y- ^$ M* H# S: O4、程序设计思路：
. o) _) l) E6 [# |* V! j3 g$ x程序通过依次使标号1、2、3、4（列0-3）输出高电平，判断5/6/7/8（行0-3）状态；完成按键扫描；


& d) z; @1 h2 Q5 {