求STM32矩阵按键状态机程序

qinglong

现有个产品需要矩阵按键状态机程序，写了几天，还是有问题，哪位大神给分享一个历程

xld826

目前支持抬起识别。可以修改支持短按按下识别，短按抬起识别，长按按下识别，长按抬起识别。

1. void MatrixKeyScan(unsigned char ucKeyValue[4][4])
   
2. {
   
3.         static unsigned char ucKeyState[4][4] = {KEY_STATE_0, KEY_STATE_0, KEY_STATE_0, KEY_STATE_0};
   
4.         static unsigned char ucKeyTime[4][4] = {0, 0, 0, 0};
   
5.         unsigned char ucKeyPress[4], i = 0, j = 0;
   
6.        
   
7.           for(j = 0; j < 4; j++)
   
8.           {
   
9.                 LineOutCtrl(j, SET);
   
10.                   for(i = 0; i < 4; i++)
    
11.                   {
    
12.                         ColumnScan(i, ucKeyPress);
    
13.                         //printf("\r\n %d %d %d", j, i, ucKeyPress[i]);
    
14.                        
    
15.                         switch (ucKeyState[j][i])
    
16.                         {
    
17.                                 case KEY_STATE_0:
    
18.                                 if (!ucKeyPress[i])
    
19.                                 {
    
20.                                         ucKeyState[j][i] = KEY_STATE_1;
    
21.                                 }
    
22.                                 break;
    
23. 
    
24.                                 case KEY_STATE_1:
    
25.                                 if (!ucKeyPress[i])
    
26.                                 {
    
27.                                         ucKeyTime[j][i] = 0;
    
28.                                         ucKeyState[j][i] = KEY_STATE_2;
    
29.                                 }
    
30.                                 else
    
31.                                 {
    
32.                                         ucKeyState[j][i] = KEY_STATE_0;
    
33.                                 }
    
34.                                 break;
    
35. 
    
36.                                 case KEY_STATE_2:
    
37.                                 if(ucKeyPress[i])
    
38.                                 {
    
39.                                         ucKeyState[j][i] = KEY_STATE_0;
    
40.                                 }
    
41.                                 else
    
42.                                 {
    
43.                                         ucKeyTime[j][i]++;
    
44.                                         if(ucKeyTime[j][i] == 1)
    
45.                                         {
    
46.                                                 ucKeyState[j][i] = KEY_STATE_3;
    
47.                                         }
    
48.                                 }
    
49.                                 break;
    
50.                                 case KEY_STATE_3:
    
51.                                 if (ucKeyPress[i])
    
52.                                 {
    
53.                                         ucKeyValue[j][i] = (i + j * 4 + 1);
    
54.                                         ucKeyState[j][i] = KEY_STATE_0;
    
55.                                 }
    
56.                                 else
    
57.                                 {
    
58.                                 }
    
59.                                 break;
    
60.                                 default:
    
61.                                 break;
    
62.                         }
    
63.                   }
    
64.                 LineOutCtrl(j, RESET);
    
65.           }
    
66. }
    
67. 
    
68. 
    
69. void ColumnScan(U8 Index, U8 *KeyPress)
    
70. {
    
71.         switch(Index)
    
72.         {
    
73.                 case 0:
    
74.                         if(GPIO_ReadInputDataBit(KEYIN1_PORT, KEYIN1_PIN) == RESET)
    
75.                         KeyPress[Index] = 0;//按下
    
76.                         else
    
77.                         KeyPress[Index] = 1;//抬起
    
78.                 break;
    
79.                 case 1:
    
80.                         if(GPIO_ReadInputDataBit(KEYIN2_PORT, KEYIN2_PIN) == RESET)
    
81.                         KeyPress[Index] = 0;
    
82.                         else
    
83.                         KeyPress[Index] = 1;
    
84.                 break;
    
85.                 case 2:
    
86.                         if(GPIO_ReadInputDataBit(KEYIN3_PORT, KEYIN3_PIN) == RESET)
    
87.                         KeyPress[Index] = 0;
    
88.                         else
    
89.                         KeyPress[Index] = 1;
    
90.                 break;
    
91.                 case 3:
    
92.                         if(GPIO_ReadInputDataBit(KEYIN4_PORT, KEYIN4_PIN) == RESET)
    
93.                         KeyPress[Index] = 0;
    
94.                         else
    
95.                         KeyPress[Index] = 1;
    
96.                 break;
    
97.                 default:
    
98.                 break;
    
99.         }
    
100.         //printf("\r\n %d %d", Index, KeyPress[Index]);
     
101. }
     
102. 
     
103. void LineOutCtrl(U8 Index, U8 en)
     
104. {
     
105.         switch(Index)
     
106.         {
     
107.                 case 0:
     
108.                         if(!en)
     
109.                         GPIO_SetBits(KEYOUT1_PORT, KEYOUT1_PIN);
     
110.                         else
     
111.                         GPIO_ResetBits(KEYOUT1_PORT, KEYOUT1_PIN);
     
112.                 break;
     
113.                 case 1:
     
114.                         if(!en)
     
115.                         GPIO_SetBits(KEYOUT2_PORT, KEYOUT2_PIN);
     
116.                         else
     
117.                         GPIO_ResetBits(KEYOUT2_PORT, KEYOUT2_PIN);
     
118.                 break;
     
119.                 case 2:
     
120.                         if(!en)
     
121.                         GPIO_SetBits(KEYOUT3_PORT, KEYOUT3_PIN);
     
122.                         else
     
123.                         GPIO_ResetBits(KEYOUT3_PORT, KEYOUT3_PIN);
     
124.                 break;
     
125.                 case 3:
     
126.                         if(!en)
     
127.                         GPIO_SetBits(KEYOUT4_PORT, KEYOUT4_PIN);
     
128.                         else
     
129.                         GPIO_ResetBits(KEYOUT4_PORT, KEYOUT4_PIN);
     
130.                 break;
     
131.                
     
132.                 default:
     
133.                 break;
     
134.         }
     
135.        
     
136. }
     
137. 
     
138. #define KEYOUT1_PORT                        GPIOA
     
139. #define KEYOUT1_PIN                                GPIO_Pin_0
     
140. #define KEYOUT2_PORT                        GPIOA
     
141. #define KEYOUT2_PIN                                GPIO_Pin_1
     
142. #define KEYOUT3_PORT                        GPIOA
     
143. #define KEYOUT3_PIN                                GPIO_Pin_2
     
144. #define KEYOUT4_PORT                        GPIOA
     
145. #define KEYOUT4_PIN                                GPIO_Pin_3
     
146. 
     
147. #define KEYIN1_PORT                                GPIOA
     
148. #define KEYIN1_PIN                                GPIO_Pin_4
     
149. #define KEYIN2_PORT                                GPIOA
     
150. #define KEYIN2_PIN                                GPIO_Pin_5
     
151. #define KEYIN3_PORT                                GPIOA
     
152. #define KEYIN3_PIN                                GPIO_Pin_6
     
153. #define KEYIN4_PORT                                GPIOA
     
154. #define KEYIN4_PIN                                GPIO_Pin_7
     
155. 
     
156. #define KEY_STATE_0 0
     
157. #define KEY_STATE_1 1
     
158. #define KEY_STATE_2 2
     
159. #define KEY_STATE_3 3
     
160. #define KEY_STATE_4 4
     
161. 
     
162. #define N_KEY       0xFE
     
163. 
     
164. void Task_10ms(void)
     
165. {
     
166.         static U8 ucCount = 0;
     
167.         U8 ucKeyValue[4][4] = {
     
168.         {N_KEY, N_KEY, N_KEY, N_KEY},
     
169.         {N_KEY, N_KEY, N_KEY, N_KEY},
     
170.         {N_KEY, N_KEY, N_KEY, N_KEY},
     
171.         {N_KEY, N_KEY, N_KEY, N_KEY}
     
172.         }, i = 0, j = 0;
     
173. 
     
174.         MatrixKeyScan(ucKeyValue);
     
175.         for(j = 0; j < 4; j++)
     
176.         {
     
177.                 for(i = 0; i < 4; i++)
     
178.                 {
     
179.                         if(ucKeyValue[j][i] != N_KEY)
     
180.                         {
     
181.                                 printf("\r\n ucKeyValue 测试计数:%d %d",ucCount++, ucKeyValue[j][i]);
     
182.                         }
     
183.                 }
     
184.         }
     
185. }

复制代码

lnskngdc

坛子里很多类似的状态机，自己搜一下，取长补短

ztrx

xld826 发表于 2019-7-9 10:29
目前支持抬起识别。可以修改支持短按按下识别，短按抬起识别，长按按下识别，长按抬起识别。

有乱码                     

angler12

按照安福莱的单个按键驱动改一下按键的的扫描函数就好，支持短按，长按，连发，弹起。

cslrd

可以借鉴一下这个程序
https://www.amobbs.com/forum.php ... =%E6%8C%89%E9%94%AE