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

4 W9 f& n. ^. _" n* I3 I) i5 S8 ]
/ M7 v2 A" |: V6 L1、粘贴代码时，粘贴在源文件存放的位置中（如：HARDWARE中的.c和.h文件），用C++编译器打开，而不是kei；最后keil会正常显示中文字符；
2、程序使用嵌套循环实现4x4按键扫描，如果IO口设置过乱时，将循环拆分即可；
2 G# C; I& S5 ]  h/ l1 ekey4x4.h源文件
9 ~# Y: r% x* c. ~" ^

1. #ifndef __KEY4x4_H
   
2. #define __KEY4x4_H         
   2 V! a# T  P6 x: U" ]) }
3. #include "sys.h"
   
4. 
   $ C3 c% K! o# t* y
5. #define KEY_X(X)        PEin(X)                                // 尽量避免使用PD以上GPIO，便于移植；
   
6. #define KEY_Y(Y)        PEout(Y)
   0 w9 C: S: c, T' ]+ h1 M# \/ h" T9 p
7. 
   5 ?% C# `6 x& H( T$ T, o
8. #define ALL_DOWN_KEY_Y        {        KEY_Y(11) = 0; KEY_Y(12) = 0; KEY_Y(13) = 0; KEY_Y(14) = 0;}
   
9. 
   
10. void KEY4x4_Init(void);                // IO口初始化
    
11. u8 KEY4x4_Scan(void);                  // 矩阵按键反馈函数        // 可配置任意矩阵按键使用！！
    0 G; V* Q% g, O; d! A' B  {
12. u8 KEY16_Scan(void);
    3 k, {  \. ?2 p
13. 
    6 }7 T4 ?! ^. A6 T8 l$ v
14. /**************
    & i0 a0 [8 Z+ |
15. 按键扫描方案二：
    
16. 按键使用8个输入IO口， 且所有IO口一端接VCC/VSS；
    # O6 n5 j3 ?6 l2 V5 g2 v
17. 
    ! x% a  ?" X' S. C+ {
18. 程序框架：       
    * {) Z! f3 g- A, E) j9 A# q
19.         扫描检测哪两个IO口输入高/低电平；VCC/VSS
    
20.         根据对应坐标，return对应编号；
    $ O+ |! N, a$ \
21. **************/
    
22. 
    : b, R7 C3 A7 C) ]; O
23. #endif
    

复制代码

key4x4.c源文件
8 K, ]6 c5 m1 B

1. #include "stm32f10x.h"
   
2. #include "key4x4.h"
   . K9 d7 V" g) ?: G6 R* N3 |% s/ R
3. #include "sys.h"
   
4. #include "delay.h"
   
5. #include "usart.h"
   
6. 
   
7. 
   
8. /*************************
   * g# e( B) m% L+ S7 A
9. X：
   ) s6 F$ {- m1 U# @
10.         PEin        7-10
    9 J& q7 M1 e/ {( T/ d( H
11. Y：
    7 K* x) Y  z" h' P! [
12.         PEout        11-14
    
13. *************************/
    
14. 
    ' L: U& N. Y5 W4 Y; o
15. 
    
16. // 矩阵按键初始化函数
    
17. void KEY4x4_Init(void)
    
18. {
    4 n  B! b" C: n$ K# ?
19.                 GPIO_InitTypeDef GPIO_InitStructure;
    * \2 c8 _$ F0 W; J  }) z
20. 
    
21.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE);
    
22. 
    1 Q  v3 U8 V( I# ]# |
23.                 GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10;//KEY0-KEY1
      S4 a, a7 E7 h7 h/ N. Q
24.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //设置成下拉输入
    / p* n* e; `  v5 w5 b# |
25.                 GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化GPIOE
    ( q6 f- T0 r6 k- D& G
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
    " y: {$ k/ v$ a$ K' T- M+ C! M' z1 x
30.                 GPIO_Init(GPIOE, &GPIO_InitStructure);                                                         //根据设定参数初始化GPIOE
    
31. }
    
32. 
    
33. // 使所有输出拉低；初始化；                // 可以使用define宏定义，执行速度更快，不用跳转函数！！
    ( s* N5 T7 t- m2 ]
34. static void KEY_ALL_Pull_Down(void)
    # r5 U: H- y9 q( I; g
35. {
    ; I# a9 P# {  X
36.         KEY_Y(11) = 0;
    6 d, c% D* A$ A" ?# ^7 v
37.         KEY_Y(12) = 0;
    
38.         KEY_Y(13) = 0;
    
39.         KEY_Y(14) = 0;
    
40. }
    % j/ \5 O. s0 R& ?, i  g
41. 
    
42. // 4x4按键扫描函数
    
43. // 使用一个嵌套循环，完成扫描X和Y；
    
44. // 原理： 通过Y 依次输出高电平,
    
45. //                                扫描X 那个IO口输入高电平；
    9 ], u* M0 r1 Q# U7 o
46. // X轴：输入检查、扫描；
    : P1 e9 h( @+ K
47. // Y轴：设置输出状态；
    
48. // 该函数适合任意排列矩阵按键，只需修改循环中对应编号！！
    
49. // 注意： 1. 改变IO口时，该函数还需要改变循环中IO口编号；（可以定义好IO口编号，便于修改）
    
50. //                                2. 该函数同样有优先级问题！ 即同时按下时，只反馈先被扫描到的（0-15标号最小的）
    ( x+ C) x  E0 h, n% E
51. //                                3. 函数同一坐标轴的IO口编号必须相邻或能有 规律递增可寻；（否则无法用循环判断）
    2 O4 @, x! W3 J' b% c: y
52. //                                4. 暂时未添加功能（模式）：        按键复用 和 长按；
    
53. // 2020-11-13                返回值调整为：1-16
    
54. // 11/14 不支持连按；解决重复反馈的问题；
    + {5 `& S: Q) A/ k8 f& n
55. u8 KEY4x4_Scan(void)
    $ `; d1 m0 r+ [
56. {
    
57.         int i,j;
      P* a. F6 Q: s
58.         u8 IO_Sign = 0;                                // 很简便的一个IO反馈方式标签！！！  且嵌套循环特有！！  // 能返回0-15，适合任意排列矩阵按键
    
59.         static key_up = 1;
    6 P# U5 c1 G! J# W8 H
60.        
    / v  |7 _# z( T6 M  y
61.         //KEY_ALL_Pull_Down();                                                                                // 初始化所有按键输出拉低；
    
62.        
      N3 @* ?# y1 ~- d) b  D* \
63.         for (i = 11; i <= 14; i++)                                                        // Y输出IO口编号；
    , {3 S9 i( N) |. i
64.                 for (j = 7; j <= 10; j++,IO_Sign++)                // X输出IO口编号；  // 递增IO_Sign，反馈对应值（0-15）；
    & \( q: `: f5 L5 {$ d% k8 d$ d
65.                 {
    
66.                         KEY_Y(i) = 1;                        // 使PEout(i)输出高电平；
    . k6 v) `' ]3 |. d! f
67.                        
    9 \' T$ G6 |7 R9 X
68.                         if (KEY_Y(i))                        // 扫描Y输出高电平， 可以取消此判断； 因为必须输出高电平时，才能正常判断！！
    
69.                         {
    : R) k# Z6 m% r: `. i4 h
70.                                 if (KEY_X(j) && key_up)                // 当输入检查到高电平时；
    - j, ?  E- r! C# W/ j8 S0 \
71.                                 {
    " B, p: B/ v  C- ~3 ^0 c! r  ~
72.                                         key_up = 0;
    ' k7 c2 \* w5 I* j7 P$ Y
73.                                         printf("按键扫描反馈： %d  \r\n",IO_Sign);
    
74.                                         return IO_Sign;
    
75.                                 }
    9 f. Y- Z$ K( |
76.                                 else if (!KEY_X(7)&&!KEY_X(8)&&!KEY_X(9)&&!KEY_X(10))                        // 当所有输入检测到低电平时，再次使能按键； 防止重复反馈
    7 Y1 _2 j  u9 ], y2 }% t
77.                                 {
    
78.                                         key_up = 1;
    / [3 J  o! k- k+ A6 ?* p
79.                                         KEY_ALL_Pull_Down();                                                                                // 初始化所有按键输出拉低（低电平）；必须在此位置；
    9 T7 A- \) C- ]' Q
80.                                 }
    $ v6 S9 r& ?7 q( c8 `' @; n
81.                         }
    
82.                         else
    5 O  n, T* \% b# P1 l8 ?3 Q
83.                                 printf("PEout:IO口%d输出异常！  \r\n ", i);
    
84.                 }
    
85.                
    
86.         delay_ms(10);                                        // 按键防抖；
    # Y: G! Z+ E, `" T
87. }
    / \0 y9 u% ]8 l/ u6 W# _! z: l
88. 
    % {! B7 }4 q, L: Z* s- z
89. 
    
90. /******************************************标准扫描函数*********************************************/
    1 X: W" c( q# R3 ?* j2 A8 _
91. // 支持连按
    
92. u8 KEY16_Scan(void)
    6 o, d; ]3 @7 x" v8 W( z; g" A7 S: g
93. {
    
94.         int i,j;
    5 u) X7 P+ l1 ]) y  t7 k3 V
95.         u8 IO_Sign = 0;                                // 很简便的一个IO反馈方式标签！！！  且嵌套循环特有！！  // 能返回0-15，适合任意排列矩阵按键
    " R2 H. M3 E+ |0 w3 f- u
96.        
    
97.         ALL_DOWN_KEY_Y                                                                                                        // 初始化所有按键输出拉低；
    ' b! ?: U3 _" r; z" T2 k2 P
98.        
    8 r2 m! @" I5 y# X/ h
99.         for (i = 11; i <= 14; i++)                                                        // Y输出IO口编号；
    
100.                 for (j = 7; j <= 10; j++,IO_Sign++)                // X输出IO口编号；  // 递增IO_Sign，反馈对应值（0-15）；
     % }1 M* `: }- s: P: t
101.                 {
     
102.                         KEY_Y(i) = 1;                        // 使PEout(i)输出高电平；
     ' [2 D" _5 Q% Q8 U4 S
103. 
     ; E& z" N) p9 X& y( Y5 S7 v) N9 L
104.                         if (KEY_X(j))                        // 当输入检查到高电平时；
     
105.                                 return IO_Sign;
     ) Y2 K0 h0 z3 d, ~" q' }+ ?( a
106.                 }
     
107.                
     
108.         delay_ms(20);                                        // 按键防抖；                // 连按延时；
     ) B' l' V7 ?3 ]
109. }
     ' q, [3 D; }8 H! F% M
110. 
     $ B' H$ ~# A: H0 x! S* y+ U

复制代码

" F! u% B4 M' R% k+ ^) f5 n*4x4按键原理图

. a# S" [5 `( s, b: R# f# n3、按键工作原理：
) H1 j7 H% }$ F当按键被按下时，相连的电路导通；即S1按下时，位于0行0列的线短路，使标号4和5对应的IO口相连（导通）；
最后通过扫描检测输入输出状态即可判断出对应按键被按下；

* O7 g6 I) k2 k1 p' r: _: i3 Y
6 O9 }1 y5 K4 E- ]* v+ t; w4、程序设计思路：
( M1 f' }8 U5 z1 z程序通过依次使标号1、2、3、4（列0-3）输出高电平，判断5/6/7/8（行0-3）状态；完成按键扫描；
* S% p* \/ X$ t6 z6 x
% V! |7 K. w/ N0 U: z$ P