基本介绍
最近做了一个门禁卡小玩意，用到了4X4矩阵按键，在这里也单独的记录一下。
矩阵按键图

# n3 l0 R# x7 a/ {, K* M3 r
( p, t, ~8 F7 J& |2 F9 t9 Z思路:
矩阵按键读取键值写法多样，有一行一行的检测，也有是全部行检测，我这里是全部去扫。
* v2 ?! c8 R+ z先扫描4列是否有按下，有 再切换 扫描所有行。
; H' G/ g/ E6 D9 O  {
1 o6 I1 @: @' @" u% K/ [8 S0 C第一步:先让行拉低(输出模式),去检测列(输入模式 拉高)
% V4 x/ L5 ?* x9 j9 ~5 c' M6 J+ u                        如果检测到有
第二步:让列拉低(输出模式), 去检测行(输入模式 拉高)
; ?- b( p  W; k6 q1 z1 T第三步:这样就可以获取到哪按键按下了。

& ], u/ J( }( {& R, v代码
2 l- v3 u( k0 h9 x1 s0 \+ Imatrix_key.c
0 e6 z! I' f! a8 b( Q

1. #include "matrix_key.h"
   9 _) E% J; j$ H6 o5 ]/ p: `0 J
2. #include "usart.h"
   
3. 
   9 j( _& A' J- k0 _
4. uint8_t key_flag;               
   6 Z2 U, E' T6 _" D
5. 
   ! ?- v1 y: n* x5 a8 L4 i
6. 
   
7. 
   & e2 H8 s% G- h2 j" `, ^! R
8. /*4X4矩阵按键的表盘设置*/
   
9. const uint8_t matrix_key_tab[4][4] =
   . \6 m! u+ a# i$ |7 Q- B8 B
10. {
    
11.         '1', '2', '3', 'A',
    / G  \, Y7 ]0 W. Y3 u" O/ w; h6 L0 Y
12.         '4', '5', '6', 'B',
    
13.         '7', '8', '9', 'C',
    
14.         '*', '0', '#', 'D',
    
15. };
    
16. 
    + V( d& d" f' q% O
17. 
    
18. 
    ; z+ ]0 e2 w3 r. o& }% n, I. u+ @8 U
19. 
    9 `1 o9 z% L* b: T
20. /***********************************************************************
    
21. 描述: 按键 列 设置输入模式（前4个）
    
22. ************************************************************************/
    
23. void key_set_list_input_mode(void)
    1 o4 e4 k- D7 O8 t1 M( J+ ^
24. {
    
25.         GPIO_InitTypeDef KEY_InitStruction;
    
26.         RCC_APB2PeriphClockCmd(KEY_RCC, ENABLE);
    ; T2 I) w' H- U1 c
27.         
    
28.         //列引脚
    
29.         KEY_InitStruction.GPIO_Pin   = KEY5_PIN | KEY6_PIN | KEY7_PIN | KEY8_PIN;        //引脚
    
30.         KEY_InitStruction.GPIO_Mode  = GPIO_Mode_IPU;                                                                 //上拉输入        
    % Q# r2 p: D9 _1 x* ^) ~
31.         GPIO_Init(KEY_PORT, &KEY_InitStruction);
    3 S# r! G6 P7 p, S! d. w" B
32.         
    
33. }
    ( g4 A$ g5 w* H* i  w
34. 
    
35. 
    
36. /***********************************************************************
    $ u7 G  A5 ]! a* T
37. 描述: 按键 列 设置输出模式
    $ L& h( G  l5 m- n
38. ************************************************************************/
    + g; e* S( o  f/ G: z$ D
39. void key_set_list_output_mode(void)
    & T! J  b# [7 }/ h8 K$ A
40. {
    4 N- S  E$ X' s, H; |; c+ m" ~
41.         GPIO_InitTypeDef KEY_InitStruction;
    
42.         RCC_APB2PeriphClockCmd(KEY_RCC, ENABLE);
    
43.         
    
44.         //列引脚
    
45.         KEY_InitStruction.GPIO_Pin   = KEY5_PIN | KEY6_PIN | KEY7_PIN | KEY8_PIN;        //引脚
    : j$ S0 `! t2 Z$ E7 ^
46.         KEY_InitStruction.GPIO_Mode  = GPIO_Mode_Out_PP;                                                         //推挽输出        
    
47.         KEY_InitStruction.GPIO_Speed = GPIO_Speed_50MHz;                                                        //速率
    
48.         
    7 B; G$ E$ b% b: t0 E6 }# V
49.         GPIO_Init(KEY_PORT, &KEY_InitStruction);
    
50. }
    
51. 
    
52. 
    $ W) {' C( K$ Q' L! f, E9 B! l
53. 
    
54. 
    
55. /***********************************************************************
    $ G- l3 P- O# a( f% Z" s8 f& t
56. 描述: 按键 行 设置输入模式
      U  _6 e0 r& @" e  K) D9 E9 A1 R
57. ************************************************************************/
    
58. void key_set_row_input_mode(void)
    
59. {
    2 B' q! G( @0 X* `% A& l( q1 C$ q
60.         GPIO_InitTypeDef KEY_InitStruction;
    + ~( C. Q1 m1 O4 T9 @+ Z( c
61.         RCC_APB2PeriphClockCmd(KEY_RCC, ENABLE);
    ( U  E4 s% p  r. s/ d, x
62.         
    
63.         //列引脚
    
64.         KEY_InitStruction.GPIO_Pin   = KEY1_PIN | KEY2_PIN | KEY3_PIN | KEY4_PIN;        //引脚
    : ]3 e! g+ M4 Z) C7 E
65.         KEY_InitStruction.GPIO_Mode  = GPIO_Mode_IPU;                                                                 //上拉输入        
    
66.         GPIO_Init(KEY_PORT, &KEY_InitStruction);
    9 Z+ D3 M9 L' @6 |
67. }
    9 R; N; \8 j" u5 G' m1 f' V
68. 
    
69. 
    
70. /***********************************************************************
    
71. 描述: 按键 行 设置输出模式
    
72. ************************************************************************/
    6 o/ P8 M* q2 I
73. void key_set_row_output_mode(void)
    
74. {
    
75.         GPIO_InitTypeDef KEY_InitStruction;
    
76.         RCC_APB2PeriphClockCmd(KEY_RCC, ENABLE);
    ' T' s* B- D( w5 o5 G( L' Y
77.         
      V. w/ K8 @" U5 G
78.         //列引脚
    3 |" V6 f; ]# x3 `# g1 ?) I
79.         KEY_InitStruction.GPIO_Pin   = KEY1_PIN | KEY2_PIN | KEY3_PIN | KEY4_PIN;        //引脚
    
80.         KEY_InitStruction.GPIO_Mode  = GPIO_Mode_Out_PP;                                                         //推挽输出        
    9 n( S* @1 Q( [4 i4 [; V
81.         KEY_InitStruction.GPIO_Speed = GPIO_Speed_50MHz;                                                        //速率
    
82.         
    
83.         GPIO_Init(KEY_PORT, &KEY_InitStruction);
    
84. 
    
85. }
    2 k) h4 U1 y5 Q0 ]+ N: p% r) h0 F5 T
86. 
    
87. 
    
88. /***********************************************************************
    # s( N& m- D2 t8 }
89. 描述: 按键初始化函数
    
90. ************************************************************************/
    ' E5 s4 H$ N2 n9 ?2 B. Y
91. void matrix_key_init(void)
    
92. {        
    
93.         ROW_OUT_MODE;                //行设置输出模式
    9 K% T* C' T& ~' e
94.         LIST_INT_MODE;                //列设置输入模式
    
95. }
    , ]# c7 m0 y0 f9 ^; E: Y
96. 
    
97. 
    6 Z5 @; `- L- j
98. /***********************************************************************
    
99. 描述: 获取键值 函数
    " c! s9 Y; u, s
100. 返回: 返回表盘对应键值
     
101. ************************************************************************/
     % K) P- p8 i+ C. G; F! Y1 r
102. uint8_t matrix_key_scanf(void)
     3 h! V# t3 A( i6 o" j% \
103. {
     
104.         static uint8_t key_status;        
     : z, O6 ]- `" w
105.         uint8_t R,L;
     / s; U8 R# K1 {/ `
106.         uint8_t key_temp;
     
107.         
     # t1 D5 f2 H5 T
108.         //检测列 所以我们让行拉低 列拉高
     $ X1 j( h4 L: x. v, O
109.         LIST_INT_MODE;        LIST_SET_HIGH;
     
110.         ROW_OUT_MODE;        ROW_SET_LOW;
     $ B% Z3 T* i1 s0 ]* q
111.         
     ( p: D" p: Z, P0 W8 h1 p/ k. f; t3 O
112.         key_temp = ~GPIO_ReadInputData(KEY_PORT) & 0XF0;
     * Q5 S8 O" I1 J2 }; |
113.         if(key_temp == 0) {key_status = 0; return 0;}
     ; B% [& R- i* ]9 \( D- H: G
114.         
     
115.         //第一次检测到
     ; P- s! x8 h, g9 @
116.         if(key_status == 0)
     
117.         {
     / I1 O( L$ i* @9 S! p0 G+ p+ ~8 m7 F2 k
118.                 key_status = 1;        
     
119.                 return 0;
     
120.         }
     6 U# H+ r3 A4 c3 `& l0 A5 J
121.         //第二次检测到
     ' V8 F- E9 |7 |, O5 I+ C3 d
122.         else if(key_status == 1)
     ; W* v$ q- z, n$ h! W
123.         {
       {! O0 M/ O. W/ X% J1 p
124.                 key_status = 2;
     5 P$ F# n# Z& m+ O; D/ L) `. O/ F+ s
125.                
     7 ~7 ~! a! d% {# k: c  F9 ]3 ]
126.                 //读取列
     2 {$ d9 [5 V" G$ e& C9 }
127.                 switch(key_temp)
     
128.                 {
     
129.                         case 0x10:        L = 0;        break;
     8 i6 o6 ^. N7 y* _; l# I
130.                         case 0x20:        L = 1;        break;
     
131.                         case 0x40:        L = 2;        break;
     
132.                         case 0x80:        L = 3;        break;               
     
133.                         default:        return 0;
     
134.                 }
     * ]! y) b3 d6 ?3 t- ^% O6 v" X
135.                 //快速转换模式
     ) Y- g: g) p1 [/ a( T1 [
136.                 //再检测行是否有按键按下 所以先让列拉低 行拉高
     
137.                 LIST_OUT_MODE;        LIST_SET_LOW;        //PA4 ~ PA7
     
138.                 ROW_INT_MODE;        ROW_SET_HIGH;        //PA0 ~ PA3
     5 b/ x* }  E* |* I  f
139. 
     
140.                 key_temp = ~GPIO_ReadInputData(KEY_PORT) & 0X0F;
     
141.                 //读取行
     
142.                 switch(key_temp)
     
143.                 {
     
144.                         
     
145.                         case 0x01:        R = 0;        break;
     8 a' y- t1 B/ ~5 K, I
146.                         case 0x02:        R = 1;        break;
     4 ]7 |( d6 _7 L6 f: Y
147.                         case 0x04:        R = 2;        break;
     
148.                         case 0x08:        R = 3;        break;
     ! y8 o# ?# E" n; ?/ a7 q
149.                         default:        return 0;
     
150.                 }
     6 ~, D5 j) Z6 O3 v0 x' Q
151. 
     
152.                 return matrix_key_tab[R][L];;
     1 `2 x5 J: d- _# b9 v' `0 J
153.         }
     , s) T& [" Z8 |0 l
154.         //证明没松开按键
     ! |; I. E. `- V+ `' T/ H
155.         else if(key_status == 2)
     % y$ y& [" s- b: _. i5 F7 K- I
156.         {
     
157.                 return 0;
     . W0 v% ^1 u! u$ Q" u. x
158.         }
     * }, }2 ?$ R! \0 Z
159.         key_status = 0;
     
160.         return 0;
     ) [( Q4 K% j% z, D2 G
161. 
     
162. }
     6 m7 T0 |. T+ |. v4 @5 }
163. 
     7 ~/ @! E" V3 f9 a/ r
164. 
     4 `: F& Y8 B! P" H
165. 
     4 ^7 M9 U7 `% E
166. /***********************************************************************
     $ {3 J; I/ b* P  c' }5 U
167. 描述: 矩阵键盘处理 函数
     
168. ************************************************************************/
     
169. void matrix_key_process(void)
     
170. {
     
171.         uint8_t key_val;
     ! {) x* @5 ]( p+ P+ p0 {
172.         
     
173.         if(key_flag)
     - |5 l7 k8 U6 i) X' `/ ?* I; x0 f0 \
174.         {
     
175.                 key_flag = 0;
     5 f( |, t6 u* a+ H( `& ^7 S% Z
176.                 key_val = matrix_key_scanf();                        //获取键值
     
177.                 if(key_val == 0) return;        
     : K- k8 [) V7 k
178.                 printf("KEY:%c\r\n",key_val);
     + s8 j8 w& C- \  R& d, \) c+ [
179.         }        
     2 u  @5 t3 b1 Z% ^+ c7 L/ y
180. }
     , B( T- z& U/ p5 @# K  I" P/ _
181. 
     ' v$ n0 q) `  \' b8 M

复制代码

) }! M  o+ X% P: z! a$ v' wmatrix_key.h
; N& ]; p6 }) e

1. #ifndef __MATRIX_KEY_H
   
2. #define __MATRIX_KEY_H
   
3. #include "stm32f10x.h"
   
4. 
   + g3 V1 p/ ^. X$ V0 `4 `* k
5. #define         KEY_RCC                        RCC_APB2Periph_GPIOA                //时钟
   9 W8 M" M' F' h- T, Y0 K
6. #define         KEY_PORT                GPIOA                                                //端口
   
7. 
   8 @2 q# c: K" b. w8 o- N; p5 @) f5 Y- [. d
8. 
   
9. #define         KEY1_RCC                RCC_APB2Periph_GPIOA                //时钟
   * ^  e  _: P: p* I, ?
10. #define         KEY1_PORT                GPIOA                                                //端口
    
11. #define         KEY1_PIN                GPIO_Pin_0                                        //引脚
    
12. 
    7 `' D5 R2 x% ?; |- R& f
13. #define         KEY2_RCC                RCC_APB2Periph_GPIOA                //时钟
    
14. #define         KEY2_PORT                GPIOA                                                //端口
    ' x4 P  |* d  K; W
15. #define         KEY2_PIN                GPIO_Pin_1                                        //引脚
    * T1 _( J, O7 s/ f- P3 n6 J5 P
16. 
    
17. #define         KEY3_RCC                RCC_APB2Periph_GPIOA                //时钟
    
18. #define         KEY3_PORT                GPIOA                                                //端口
    
19. #define         KEY3_PIN                GPIO_Pin_2                                        //引脚
    - g" V: @! W7 z, U8 G% _9 B
20. 
    
21. #define         KEY4_RCC                RCC_APB2Periph_GPIOA                //时钟
    $ E4 ?$ n/ _9 N& v& P
22. #define         KEY4_PORT                GPIOA                                                //端口
    * l, v1 Y6 F2 _& N
23. #define         KEY4_PIN                GPIO_Pin_3                                        //引脚
    + i( x/ d, [: G. P( W
24. 
    
25. #define         KEY5_RCC                RCC_APB2Periph_GPIOA                //时钟
    
26. #define         KEY5_PORT                GPIOA                                                //端口
    
27. #define         KEY5_PIN                GPIO_Pin_4                                        //引脚
    
28. 
    
29. #define         KEY6_RCC                RCC_APB2Periph_GPIOA                //时钟
    & R; }8 C* Y5 T8 b( ~9 x% }2 P
30. #define         KEY6_PORT                GPIOA                                                //端口
    
31. #define         KEY6_PIN                GPIO_Pin_5                                        //引脚
    + s- V9 H3 U2 }
32. 
    ; M8 t9 T' V* A+ \' }6 A3 q
33. #define         KEY7_RCC                RCC_APB2Periph_GPIOA                //时钟
    
34. #define         KEY7_PORT                GPIOA                                                //端口
    
35. #define         KEY7_PIN                GPIO_Pin_6                                        //引脚
    ) i  ~; n' U0 W( ?) k( j. D
36. 
    ( o- q/ v- N5 J2 U, }0 H  D1 j* F
37. #define         KEY8_RCC                RCC_APB2Periph_GPIOA                //时钟
    2 j7 }  m2 B: n, Z
38. #define         KEY8_PORT                GPIOA                                                //端口
    
39. #define         KEY8_PIN                GPIO_Pin_7                                        //引脚
    % ~& D) T* b- f7 B
40. 
    
41. 
    7 k' j) t8 A, M( x6 ?+ H
42. #define                ROW_INT_MODE        key_set_row_input_mode()
    
43. #define                ROW_OUT_MODE        key_set_row_output_mode()
    
44. 
    # }! b$ w) D" l; x+ R# Z! X9 X
45. #define                LIST_INT_MODE        key_set_list_input_mode()
    ( a7 D5 `! y; W
46. #define                LIST_OUT_MODE        key_set_list_output_mode()
    ! |0 C0 }2 J) O( i( x( c
47. 
    ! q+ I1 r, p" X5 T- R0 a
48. #define         LIST_SET_HIGH        {GPIO_SetBits(KEY_PORT,KEY5_PIN);GPIO_SetBits(KEY_PORT,KEY6_PIN);GPIO_SetBits(KEY_PORT,KEY7_PIN);GPIO_SetBits(KEY_PORT,KEY8_PIN);}
    
49. #define         LIST_SET_LOW        {GPIO_ResetBits(KEY_PORT,KEY5_PIN);GPIO_ResetBits(KEY_PORT,KEY6_PIN);GPIO_ResetBits(KEY_PORT,KEY7_PIN);GPIO_ResetBits(KEY_PORT,KEY8_PIN);}
      b4 `0 [% [7 ?: n  _# N- F
50. 
    
51. #define         ROW_SET_HIGH        {GPIO_SetBits(KEY_PORT,KEY1_PIN);GPIO_SetBits(KEY_PORT,KEY2_PIN);GPIO_SetBits(KEY_PORT,KEY3_PIN);GPIO_SetBits(KEY_PORT,KEY4_PIN);}
    & U$ x4 u/ D/ V* q5 A
52. #define         ROW_SET_LOW                {GPIO_ResetBits(KEY_PORT,KEY1_PIN);GPIO_ResetBits(KEY_PORT,KEY2_PIN);GPIO_ResetBits(KEY_PORT,KEY3_PIN);GPIO_ResetBits(KEY_PORT,KEY4_PIN);}
    
53. 
    
54. 
    
55. 
      a& X7 C; k' Y
56. extern const uint8_t key_tab[4][5];
    1 {6 X' a/ }6 N* Z; J$ S
57. extern uint8_t key_flag;
    
58. 
    
59. 
    
60. 
    5 V2 T7 [2 w9 O* |, }
61. void key_set_list_input_mode(void);                //按键 列 设置输入模式
    
62. void key_set_list_output_mode(void);        //按键 列 设置输出模式
    3 W1 O/ \. @( K! R2 I( \
63. void key_set_row_input_mode(void);                //按键 行 设置输入模式
    / \% w& V& B  u+ M
64. void key_set_row_output_mode(void);                //按键 行 设置输出模式
    ) T3 D$ B7 K7 j0 V0 h' l4 _
65. 
    
66. void matrix_key_init(void);                //按键初始化
    $ }- B- g  F& ~7 Q3 ?
67. uint8_t matrix_key_scanf(void);        //获取按键键值
    9 }8 ^$ |! c) e; ?$ i: Z
68. void matrix_key_process(void);
    8 D4 y3 t6 m6 |" R
69. #endif
    ) M6 ?6 ^& L/ m% X, g6 o+ b& C

复制代码

main.c
& g# F& c$ g) r

1. #include "stm32f10x.h"
   * v! K+ H' o; u$ G2 S2 s0 F+ R+ S
2. #include "timer.h"
   , B- f& J3 u  h
3. #include "matrix_key.h"
   
4. #include "usart.h"
   
5. 
   
6. /*
   
7. 接线:
   
8. 4X4矩阵按键
     J" x7 ^5 }- m. Q+ J! j
9. 行:        PA0 ~ PA3
   4 s0 o& |" `, w5 O0 k8 ~: @
10. 列: PA4 ~ PA7
    
11. */
    + K3 H: B8 k. Z$ z
12. 
    
13. 
    ! q; R+ p; U8 f7 ?( n* `! G
14. int  main()
    
15. {
    
16. 
    : Q! u7 a% t/ C9 S! A  G/ @8 I
17.         usart1_init(115200);        //串口1初始化   用于输出键值
    ) Y' P/ h0 i! d
18.         matrix_key_init();                //矩阵按键初始化
    9 P' M0 M1 x( }: v" V6 ^2 O
19.         timer3_init();                        //定时器3初始化 用于去检测按键
    4 B7 c0 i2 W- v& H
20. 
      R3 K  n( Z, J0 ^! z2 q
21.         while(1)
    7 S- P/ \/ u$ B6 u7 a
22.         {        
    
23.                 matrix_key_process();        //矩阵按键检测和处理
    ( [$ T9 x+ L; |, R0 g
24.         }  
    
25. }
    

复制代码

6 ^/ L3 y/ v8 F项目演示
0 t9 |" a4 H2 a4 j+ H3 b' X5 h
  k; u2 C& d! h$ N7 ?& |- C
9 c9 E' H: O; P- u4 T+ y& \
& d5 m: _/ S3 w+ j0 _# x$ V0 Y- b如果我哪里写的有问题，或者不好，请大家多多指教

1. #整个工程代码。
   ; ~0 g9 r7 U) `5 J+ m$ c9 k- M
2. printf("+meQ：844797079\n")

复制代码

. b- z; E7 }1 c0 S# }————————————————
转载：皮卡丘吉尔

" g  o" I* t8 |2 s
1 A7 K1 Y0 j$ R, P% B8 H5 _! A) z2 Z; J