单片机矩阵键盘扫描驱动程序与电路分析

以4X4键盘为例，首先按照下图制作电路。

然后将HOR1-HOR4连接到单片机的输入引脚上去；LON1-LON4连接到单片机的开漏输出引脚上去，注意这4个引脚必须设置为开漏模式！

程序上首先将LON1所连接的IO输出低电平其余3个IO输出高电平，同时检测HOR1-HOR4的电平来获取K1-K4的按键状态；然后将LON2所连接的IO输出低电平其余3个IO输出高电平，同时检测HOR1-HOR4的电平来获取K5-K8的按键状态；依次类推。

但是这个电路是有BUG的，比如同时按下K1、K5和K6，当LON1为低电平的时HOR1检测到是低电平没有问题；因为K2没有被按下所以我们希望HOR2是高电平，但是由于K1、K5、K6同时按下电流从VCC通过R2再通过K6再通过K5再通过K1流到LON1，所以实际上HOR2也是低电平这时候程序就认为K2被按下了导致出错。

解决这个问题很简单只需要在合适的位置加一个二极管，利用其单向导电性阻挡电流跨列流动就行了。

好了，接下来是单片机代码时间：

1. #ifndef __Key_matrix_H
   

2. #define __Key_matrix_H
   

3. 
   

4. #include "gpio.h"
   

5. #include "gpio_bool.h"
   

6. 
   

7. /*务必把这4个输出IO设置为上拉输入*/
   

8. #define KEY_HOR1 PAin(7)
   

9. #define KEY_HOR2 PAin(6)
   

10. #define KEY_HOR3 PAin(5)
    

11. #define KEY_HOR4 PAin(4)
    

12. /*务必把这4个输出IO设置为开漏*/
    

13. #define KEY_LON1 PBout(0)
    

14. #define KEY_LON2 PCout(5)
    

15. #define KEY_LON3 PCout(4)
    

16. #define KEY_LON4 PCout(3)
    

17. 
    

18. #define KEY_PRESS_TIME 20//消抖常数
    

19. #define KEY_LONG_PRESS_TIME 3000//单个按键长按阈值3s
    

20. /*通过读取(只读)这三个变量即可获得按键的单按、长按和组合键信息*/
    

21. extern volatile uint16_t Key_Phy_Num;
    

22. extern volatile uint8_t Key_Pulse_Num;
    

23. extern volatile uint16_t Key_LP_Num;
    

24. 
    

25. typedef enum
    

26. {
    

27. KPL_DISABLE=0,
    

28. KPL_ENABLE
    

29. }K_L_P;//按键的长按状态
    

30. typedef struct
    

31. {
    

32. K_L_P KEY_LONG_PRESS;
    

33. uint16_t KeyOpenCount;
    

34. uint8_t KOC_EN;
    

35. uint16_t KeyCloseCount;
    

36. uint8_t KCC_EN;
    

37. }Key_Para;
    

38. 
    

39. exter Key_Par Key_1,Key_2,Key_3,Key_4,Key_5,Key_6,Key_7,Key_8,Key_9,Key_10,Key_11,Key_12,Key_13,Key_14,Key_15,Key_16;
    

40. 
    

41. void Clear_Key_Pulse_Num(void);//当读取完Key_Pulse_Num后调用
    

42. void KeyCount_Run(void);//在1ms滴答里调用
    

43. void Key_Scan(void);//大循环或者滴答里边都行
    

44. 
    

45. #endif
    

复制代码

1. #include "Key_matrix.h"
   

2. 
   

3. Key_Par Key_1,Key_2,Key_3,Key_4,Key_5,Key_6,Key_7,Key_8,Key_9,Key_10,Key_11,Key_12,Key_13,Key_14,Key_15,Key_16;
   

4. volatile uint16_t Key_Phy_Num=0; //Key_Phy_Num每一个bit代表一个按键的状态
   

5. volatile uint8_t Key_Pulse_Num=0;//当某一个按键从按下到弹起的过程中(非长按)始终只有该按键被操作，则Key_Pulse_Num被修改为该键的序号
   

6. volatile uint16_t Key_LP_Num=0; //Key_LP_Num每一个bit代表一个按键的长按状态
   

7. uint8_t KeyCom=0;//组合键是否出现
   

8. 
   

9. static void Key_Num_Read(Key_Para* Key,uint16_t KPN,uint8_t Pulse,uint8_t Key_Hor)
   

10. {
    

11. if(Key_Hor == 0)
    

12. {
    

13. Key->KOC_EN=0;//按键按下立即清除(松开)计数
    

14. if(Key->KeyCloseCount > KEY_PRESS_TIME)
    

15. {
    

16. /*消抖方法为检测到按键被(持续)按下超过20ms*/
    

17. Key_Phy_Num|=KPN;//消抖完毕后记录被按下的按键的键值
    

18. if(Key->KeyCloseCount > KEY_LONG_PRESS_TIME)
    

19. {
    

20. /*检测到按键被(持续)按下超过3秒*/
    

21. Key->KEY_LONG_PRESS=KPL_ENABLE;
    

22. Key_LP_Num|=KPN;
    

23. Key->KCC_EN=0;
    

24. }
    

25. else
    

26. {
    

27. /*时间不够启动计数*/
    

28. Key->KCC_EN=1;
    

29. }
    

30. }
    

31. else
    

32. {
    

33. /*时间不够启动计数*/
    

34. Key->KCC_EN=1;
    

35. }
    

36. }
    

37. else
    

38. {
    

39. Key->KCC_EN=0;//按键松开立即清除(按下)计数
    

40. if(Key->KeyOpenCount > KEY_PRESS_TIME)
    

41. {
    

42. if((Key_Phy_Num==KPN)&&(KeyCom==0)&&(Key->KEY_LONG_PRESS!=KPL_ENABLE))
    

43. {
    

44. //按键被按下过&&非长按&&不是在组合键周期,该按键释放时发出生命周期为直到被读取或者直到有新按键被按下的脉冲
    

45. Key_Pulse_Num=Pulse;
    

46. }
    

47. //清除该位
    

48. Key_Phy_Num&=(~KPN);
    

49. Key_LP_Num&=(~KPN);
    

50. /*检测到(持续)松开20ms*/
    

51. Key->KEY_LONG_PRESS=KPL_DISABLE;
    

52. Key->KOC_EN=0;
    

53. }
    

54. else
    

55. {
    

56. Key->KOC_EN=1;
    

57. }
    

58. }
    

59. }
    

60. /********************************************************/
    

61. static void Key_Count(Key_Para *Key)
    

62. {
    

63. if(Key->KOC_EN==0)
    

64. {
    

65. Key->KeyOpenCount=0;
    

66. }
    

67. else if(Key->KeyOpenCount>=50000)
    

68. {
    

69. Key->KeyOpenCount=50000;
    

70. }
    

71. else
    

72. {
    

73. Key->KeyOpenCount++;
    

74. }
    

75. 
    

76. if(Key->KCC_EN==0)
    

77. {
    

78. Key->KeyCloseCount=0;
    

79. }
    

80. else if(Key->KeyCloseCount>=50000)
    

81. {
    

82. Key->KeyCloseCount=50000;
    

83. }
    

84. else
    

85. {
    

86. Key->KeyCloseCount++;
    

87. }
    

88. }
    

89. /********************************************************/
    

90. void Clear_Key_Pulse_Num(void)
    

91. {
    

92. Key_Pulse_Num=0;
    

93. }
    

94. /********************************************************/
    

95. void KeyCount_Run(void)
    

96. {
    

97. Key_Count(&Key_1);
    

98. Key_Count(&Key_2);
    

99. Key_Count(&Key_3);
    

100. Key_Count(&Key_4);
     

101. Key_Count(&Key_5);
     

102. Key_Count(&Key_6);
     

103. Key_Count(&Key_7);
     

104. Key_Count(&Key_8);
     

105. Key_Count(&Key_9);
     

106. Key_Count(&Key_10);
     

107. Key_Count(&Key_11);
     

108. Key_Count(&Key_12);
     

109. Key_Count(&Key_13);
     

110. Key_Count(&Key_14);
     

111. Key_Count(&Key_15);
     

112. Key_Count(&Key_16);
     

113. }
     

114. /********************************************************/
     

115. static void Recognition_KeyCombination(void)
     

116. {
     

117. uint8_t i=0,j=0;
     

118. uint16_t Data=0;
     

119. 
     

120. Data=Key_Phy_Num;
     

121. for(i=0;i<16;i++)
     

122. {
     

123. if(Data&0x8000)
     

124. {
     

125. j++;
     

126. }
     

127. Data<<=1;
     

128. }
     

129. /*发现多个bit为1，那指定多个按键按下了*/
     

130. if(j>1)
     

131. {
     

132. KeyCom=1;
     

133. }
     

134. /*一切归于平静，又是一个因果循环*/
     

135. if(Key_Phy_Num==0x0)
     

136. {
     

137. KeyCom=0;
     

138. }
     

139. }
     

140. /********************************************************/
     

141. void Key_Scan(void)
     

142. {
     

143. static uint8_t ScanCount=0;
     

144. 
     

145. Recognition_KeyCombination();
     

146. switch(ScanCount)
     

147. {
     

148. case 0:
     

149. {
     

150. KEY_LON1=0;KEY_LON2=1;KEY_LON3=1;KEY_LON4=1;
     

151. Key_Num_Read(&Key_1,(uint16_t)0x0001 ,1,KEY_HOR1);
     

152. Key_Num_Read(&Key_2,(uint16_t)0x0001<<1,2,KEY_HOR2);
     

153. Key_Num_Read(&Key_3,(uint16_t)0x0001<<2,3,KEY_HOR3);
     

154. Key_Num_Read(&Key_4,(uint16_t)0x0001<<3,4,KEY_HOR4);
     

155. KEY_LON1=1;KEY_LON2=0;KEY_LON3=1;KEY_LON4=1;
     

156. ScanCount++;
     

157. }break;
     

158. case 1:
     

159. {
     

160. KEY_LON1=1;KEY_LON2=0;KEY_LON3=1;KEY_LON4=1;
     

161. Key_Num_Read(&Key_5,(uint16_t)0x0001<<4,5,KEY_HOR1);
     

162. Key_Num_Read(&Key_6,(uint16_t)0x0001<<5,6,KEY_HOR2);
     

163. Key_Num_Read(&Key_7,(uint16_t)0x0001<<6,7,KEY_HOR3);
     

164. Key_Num_Read(&Key_8,(uint16_t)0x0001<<7,8,KEY_HOR4);
     

165. KEY_LON1=1;KEY_LON2=1;KEY_LON3=0;KEY_LON4=1;
     

166. ScanCount++;
     

167. }break;
     

168. case 2:
     

169. {
     

170. KEY_LON1=1;KEY_LON2=1;KEY_LON3=0;KEY_LON4=1;
     

171. Key_Num_Read(&Key_9 ,(uint16_t)0x0001<<8 , 9,KEY_HOR1);
     

172. Key_Num_Read(&Key_10,(uint16_t)0x0001<<9 ,10,KEY_HOR2);
     

173. Key_Num_Read(&Key_11,(uint16_t)0x0001<<10,11,KEY_HOR3);
     

174. Key_Num_Read(&Key_12,(uint16_t)0x0001<<11,12,KEY_HOR4);
     

175. KEY_LON1=1;KEY_LON2=1;KEY_LON3=1;KEY_LON4=0;
     

176. ScanCount++;
     

177. }break;
     

178. case 3:
     

179. {
     

180. KEY_LON1=1;KEY_LON2=1;KEY_LON3=1;KEY_LON4=0;
     

181. Key_Num_Read(&Key_13,(uint16_t)0x0001<<12,13,KEY_HOR1);
     

182. Key_Num_Read(&Key_14,(uint16_t)0x0001<<13,14,KEY_HOR2);
     

183. Key_Num_Read(&Key_15,(uint16_t)0x0001<<14,15,KEY_HOR3);
     

184. Key_Num_Read(&Key_16,(uint16_t)0x0001<<15,16,KEY_HOR4);
     

185. KEY_LON1=0;KEY_LON2=1;KEY_LON3=1;KEY_LON4=1;
     

186. ScanCount=0;
     

187. }break;
     

188. default:
     

189. {
     

190. ScanCount=0;
     

191. }break;
     

192. }
     

193. }