stm32 4*4 matrix keyboard

stm32f030 development board.

Use HAL library.

The state machine performs debounce.

col column, Pin is configured as PP push-pull output mode;

row, the Pin is configured as Input mode and the internal pull-up resistor is enabled.

code show as below:

.h files

1. /* 

2. * 

3. * Name: keypad.h 

4. * Faq: www.mazclub.com 

5. */  

6. #ifndef KEYPAD_H  

7. #define KEYPAD_H  

8.   

9. #include "stm32f0xx_hal.h"  

10. //#include "pinname.h"  

11.   

12.   

13.   

14.   

15. #define COLS (GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6)  

16.   

17. #define PORT_COL GPIOB  

18. #define KEYy0    GPIO_PIN_6  

19. #define KEYy1    GPIO_PIN_5  

20. #define KEYy2    GPIO_PIN_4  

21. #define KEYy3    GPIO_PIN_3  

22.   

23. #define PORT_ROW GPIOA  

24. #define KEYx0    GPIO_PIN_12  

25. #define KEYx1    GPIO_PIN_11  

26. #define KEYx2    GPIO_PIN_10  

27. #define KEYx3    GPIO_PIN_9  

28.   

29. // Read pin  

30. //#define In(GPIO_Pin) (PORT_KEY->IDR & GPIO_Pin)  

31. #define In(GPIO_Pin) HAL_GPIO_ReadPin(PORT_ROW, GPIO_Pin)  

32. // Write 1 to Pin  

33. //#define High(GPIO_Pin) PORT_KEY->BSRR = GPIO_Pin  

34. #define High(GPIO_Pin) HAL_GPIO_WritePin(PORT_COL, GPIO_Pin, GPIO_PIN_SET)  

35. // Write 0 to Pin  

36. //#define Low(GPIO_Pin) PORT_KEY->BSRR = (uint32_t)GPIO_Pin << 16   

37. #define Low(GPIO_Pin) HAL_GPIO_WritePin(PORT_COL, GPIO_Pin, GPIO_PIN_RESET)  

38.   

39. /*  

40. *  0  1  2   3 

41. *  4  5  6   7 

42. *  8  9  10  11 

43. *  12 13 14  15 

44. */  

45.   

46. typedef enum {  

47.     Key_Up = 0x02,  

48.     Key_Left = 0x03,  

49.     Key_Right = 0x04,  

50.     Key_Down = 0x08,  

51.     Key_Power =  0x09,  

52.     Key_Mode = 0x0a,  

53.     Key_None = 0xFF  

54. } KeyPressed;  

55.       

56. static const int row_count = 4;  

57. static const int col_count = 4;  

58.   

59. uint16_t bus_out(void);  

60.   

61. void Keypad(void);  

62. char AnyKey(void);  

63. char SameKey(void);  

64. char ScanKey(void);  

65. void FindKey(void);  

66. void ClearKey(void);  

67. void Read(void);  

68. /** Start the keypad interrupt routines */  

69. void Start(void);  

70. /** Stop the keypad interrupt routines */  

71. void Stop(void);  

72. void Cols_out(uint16_t v);  

73. void Scan_Keyboard(void);  

74. KeyPressed getKey(void);  

75. #endif // KEYPAD_H  

.c files

1. /* 

2. * 

3. * Name: keypad.cpp 

4. * Faq: www.mazclub.com 

5. * 

6. */  

7.   

8. #include "keypad.h"  

9.   

10. // State:  

11. char KeyState;  

12. // Bit pattern after each scan:  

13. char KeyCode;  

14. // Output value from the virtual 74HC922:  

15. KeyPressed KeyValue;  

16. // KeyDown is set if key is down:  

17. char KeyDown;  

18. // KeyNew is set every time a new key is down:  

19. char KeyNew;  

20. // Mapping table  

21. char KeyTable[12][2];    

22. // Pin of Row  

23. uint16_t _rows[] = {KEYx0, KEYx1, KEYx2, KEYx3};  

24. uint16_t _cols[] = {KEYy0, KEYy1, KEYy2, KEYy3};  

25.   

26. //Constructor  

27. void Keypad(void)  

28. {  

29.        

30.    Stop();     

31.    KeyState = 0; // The initial key state is 0  

32. }  

33.   

34.   

35. //Scan the keyboard  

36. void Scan_Keyboard(void){  

37. switch (KeyState) {  

38.   case 0: {  

39.   if (AnyKey()) {      

40.     char scankey = ScanKey();  

41.     if (scankey != 0xff)  

42.         KeyCode = scankey;  

43.       

44.     KeyState = 1;  

45.   }  

46.     

47.   break;  

48.   }  

49.   case 1: {  

50.   if (SameKey()) {  

51.     FindKey();  

52.     KeyState = 2;    

53.   }  

54.   else   

55.     KeyState = 0;  

56.     

57.   break;  

58.   }  

59.   case 2: {  

60.     if (SameKey()) {  

61.     }  

62.     else   

63.       KeyState = 3;  

64.       

65.     break;  

66.     }  

67.   case 3: {  

68.     if (SameKey()) {  

69.       KeyState = 2;  

70.     }  

71.     else {  

72.       ClearKey();  

73.       KeyState = 0;  

74.     }  

75.       

76.     break;  

77.    }  

78.   }  

79. // func end  

80. }  

81.   

82. // A key is pressed  

83. char AnyKey(void) {  

84.  //Start(); //Pull down  

85.    

86.  int r = -1;  

87.  for (r = 0; r < row_count; r++) {  

88.      if (In(_rows[r]) == 0)  // In macro  

89.          break;    

90.  }  

91.    

92.  //Stop(); //Resume  

93.    

94.  if (!(0 <= r && r < row_count))  

95.     return 0;  

96.  else  

97.     return 1;  

98. }  

99.   

100. //Key pressed, key value is the same  

101. char SameKey(void) {  

102.     

103.   // char KeyCode_new = KeyCode;  

104.   char KeyCode_new = ScanKey();  

105.   if (KeyCode == KeyCode_new)    

106.     return 1;  

107.   else  

108.     return 0;  

109. }  

110.   

111. // Scan key  

112. char ScanKey(void) {  

113.   

114.  /* Line scan */  

115.     int r = -1;  

116.     for (r = 0; r < row_count; r++) {  

117.         if (In(_rows[r]) == 0)  // In macro  

118.             break;  

119.     }  

120.   

121.     /* If no valid row is found, return */  

122.     if (!(0 <= r && r < row_count)) {  

123.       return 0xff;  

124.           

125.     }  

126.   

127.     /* Scan the columns to find out which row is pulled low */  

128.     int c = -1;  

129.     for (c = 0; c < col_count; c++) {  

130.         // Output column lines in turn  

131.         Cols_out(~(1 << c));  

132.           

133.         if (In(_rows[r]) == 0)  // In macro  

134.             break;  

135.     }  

136.   

137.     /* Recharge all columns */  

138.     Start();  

139.   

140.     /* If no valid column is found, return */  

141.     if (!(0 <= c && c < col_count))  

142.         return 0xff;  

143.   

144.     return r * col_count + c;  

145.    

146. }  

147.   

148. // FindKey compares KeyCode to values in KeyTable.  

149. // If match, KeyValue, KeyDown and KeyNew are updated.  

150. void FindKey(void) {  

151.  KeyValue = (KeyPressed)KeyCode;  

152.  KeyDown = 1;  

153.  KeyNew = 1;  

154. }  

155.   

156.   

157. void ClearKey(void) {  

158.  KeyDown = 0;  

159. }  

160.   

161. KeyPressed getKey(void) {  

162.   if(KeyNew)  

163.   {  

164.     KeyNew = 0;  

165.     return KeyValue;  

166.   }  

167.   else  

168.     return Key_None;  

169. }  

170.   

171. void Start(void)  

172. {  

173.     /* Output 0 for the column, pull the row down */  

174.     PORT_COL->BRR = COLS;  

175. }  

176.   

177. void Stop(void)  

178. {  

179.     /* Column output 1 so that the row is not pulled low */  

180.     PORT_COL->BSRR = COLS;  

181. }  

182.   

183. // cols bus output  

184. void Cols_out(uint16_t v)  

185. {  

186.   if ((v & 0x01) > 0) //0b001  

187.     High(_cols[0]);  

188.   else  

189.     Low(_cols[0]);  

190.     

191.   if ((v & 0x02) > 0) //0b010  

192.     High(_cols[1]);  

193.   else  

194.     Low(_cols[1]);  

195.     

196.   if ((v & 0x04) > 0) //0b100  

197.     High(_cols[2]);  

198.   else  

199.     Low(_cols[2]);  

200.     

201.   if ((v & 0x08) > 0) //0b100  

202.     High(_cols[3]);  

203.   else  

204.     Low(_cols[3]);  

205.                                              

206. }