小玩意，3个普通IO识别22个按键试验。有实物和程序

在51hei论坛吸取各位前辈的经验，将之前二极管用量多的问题优化一下，目前不用二极管能接6键，2只二极管能接12键，6只二极管能接18键，9只二极管能接21键，第22键要单独占用3只二极管最不化算。

实验用89S51作试验，电路接线就是P1.2,P1.3,P1.4接键盘，P1.0接显示器。

1. /*==================================================================*
   
2. 
   
3. * 3个IO接识别22键测试程序 *
   
4. 
   
5. * ------------------------------------------------ *
   
6. 
   
7. * MCU: AT89C2051 *
   
8. 
   
9. * OSC: 12M cysytel *
   
10. 
    
11. * 程序设计:Cowboy *
    
12. 
    
13. * 程序版本:V1.0 *
    
14. 
    
15. *==================================================================*/
    
16. 
    
17. 
    
18. 
    
19. #include<reg52.h>
    
20. 
    
21. 
    
22. 
    
23. //================== IO口线连接 ==================
    
24. 
    
25. sbit Bus = P1^0;
    
26. 
    
27. sbit IO_a = P1^4;
    
28. 
    
29. sbit IO_b = P1^3;
    
30. 
    
31. sbit IO_c = P1^2;
    
32. 
    
33. 
    
34. 
    
35. //================== 变量声明 ====================
    
36. 
    
37. unsigned char Disp_buf[3];
    
38. 
    
39. unsigned char Dig;
    
40. 
    
41. unsigned char Key_count;
    
42. 
    
43. unsigned char bdata Key_state;
    
44. 
    
45. sbit KB0 = Key_state^0;
    
46. 
    
47. sbit KB1 = Key_state^1;
    
48. 
    
49. sbit KB2 = Key_state^2;
    
50. 
    
51. sbit KB3 = Key_state^3;
    
52. 
    
53. sbit KB4 = Key_state^4;
    
54. 
    
55. sbit KB5 = Key_state^5;
    
56. 
    
57. 
    
58. 
    
59. //================== 表格数据 ====================
    
60. 
    
61. code unsigned char LED_font[24]=
    
62. 
    
63. {
    
64. 
    
65. 0x84,0x9f,0xa2,0x8a,0x99,0xc8,0xc0,0x9e,0x80, //012345678
    
66. 
    
67. 0x88,0x90,0xc1,0xe4,0x83,0xe0,0xf0,0xff,0xfb, //9abcdef -
    
68. 
    
69. };
    
70. 
    
71. 
    
72. 
    
73. code unsigned char Key_tab[64]= //键码映射表
    
74. 
    
75. {// 0 1 2 3 4 5 6 7 8 9
    
76. 
    
77. 22, 0, 2, 0, 0, 0, 0, 0, 4, 0, //0
    
78. 
    
79. 0, 0, 0, 0, 0,18, 0, 0, 0, 0, //1X
    
80. 
    
81. 0, 0, 0, 0, 0, 0, 3,14, 0, 0, //2X
    
82. 
    
83. 20,10, 6, 0, 0, 0, 0, 0, 1,19, //3X
    
84. 
    
85. 0, 5, 0, 0, 0,15, 0,11, 0, 0, //4X
    
86. 
    
87. 0,17, 0, 0,13, 8, 0,21, 0, 9, //5X
    
88. 
    
89. 16,12, 7, 0 //6X
    
90. 
    
91. };
    
92. 
    
93. 
    
94. 
    
95. //=============== 检测按键 =================
    
96. 
    
97. void Key_scan()
    
98. 
    
99. {
    
100. 
     
101. unsigned char i;
     
102. 
     
103. Key_count --; //扫描次序
     
104. 
     
105. Key_count &= 3;
     
106. 
     
107. switch (Key_count) //按次序处理
     
108. 
     
109. {
     
110. 
     
111. case 2: //第一轮扫描
     
112. 
     
113. KB0 = IO_b;
     
114. 
     
115. KB1 = IO_c;
     
116. 
     
117. IO_a = 1;
     
118. 
     
119. IO_b = 0;
     
120. 
     
121. break;
     
122. 
     
123. 
     
124. 
     
125. case 1: //每二轮扫描
     
126. 
     
127. KB2 = IO_c;
     
128. 
     
129. KB3 = IO_a;
     
130. 
     
131. IO_b = 1;
     
132. 
     
133. IO_c = 0;
     
134. 
     
135. break;
     
136. 
     
137. 
     
138. 
     
139. case 0: //每三轮扫描
     
140. 
     
141. KB4 = IO_a;
     
142. 
     
143. KB5 = IO_b;
     
144. 
     
145. IO_c = 1;
     
146. 
     
147. break;
     
148. 
     
149. 
     
150. 
     
151. default: //每四轮扫描
     
152. 
     
153. if (!IO_a) KB0 = 0;
     
154. 
     
155. if (!IO_b) KB2 = 0;
     
156. 
     
157. if (!IO_c) KB4 = 0;
     
158. 
     
159. IO_a = 0;
     
160. 
     
161. 
     
162. 
     
163. //======更新显示缓冲区=======
     
164. 
     
165. i = Key_tab[Key_state];
     
166. 
     
167. if (i == 0)
     
168. 
     
169. {
     
170. 
     
171. Disp_buf[2] = 0x11; //显示三横
     
172. 
     
173. Disp_buf[1] = 0x11;
     
174. 
     
175. Disp_buf[0] = 0x11;
     
176. 
     
177. }
     
178. 
     
179. else
     
180. 
     
181. {
     
182. 
     
183. Disp_buf[2] = 0x0c; //字符"C"
     
184. 
     
185. Disp_buf[1] = i / 10; //键码十位
     
186. 
     
187. Disp_buf[0] = B;于 //键码个位
     
188. 
     
189. }
     
190. 
     
191. Key_state = 0;
     
192. 
     
193. }
     
194. 
     
195. }
     
196. 
     
197. 
     
198. 
     
199. 
     
200. 
     
201. /*===================================================================
     
202. 
     
203. ONE WIRE 显示总线驱动程序
     
204. 
     
205. ===================================================================*/
     
206. 
     
207. 
     
208. 
     
209. //=============== 发送一位 =================
     
210. 
     
211. void Send_bit(bit Dat)
     
212. 
     
213. {
     
214. 
     
215. unsigned char i = 3;
     
216. 
     
217. if (!Dat) Bus = 0;
     
218. 
     
219. else
     
220. 
     
221. {
     
222. 
     
223. Bus = 0;
     
224. 
     
225. Bus = 1;
     
226. 
     
227. }
     
228. 
     
229. while(--i); //延时8us
     
230. 
     
231. Bus = 1;
     
232. 
     
233. }
     
234. 
     
235. 
     
236. 
     
237. //=============== 总线驱动 =================
     
238. 
     
239. void Bus_drive()
     
240. 
     
241. {
     
242. 
     
243. unsigned char i = 0;
     
244. 
     
245. unsigned char Sdat;
     
246. 
     
247. Send_bit(1); //Bit6消隐
     
248. 
     
249. do Bus = 1; while(--i); //延时768us
     
250. 
     
251. do Bus = 0; while(--i); //延时768us
     
252. 
     
253. Bus = 1;
     
254. 
     
255. Sdat = LED_font[Disp_buf[Dig++]]; //获取显示数据
     
256. 
     
257. Send_bit(Sdat & 0x01); //发送位0
     
258. 
     
259. Send_bit(Sdat & 0x02); //发送位1
     
260. 
     
261. Send_bit(Sdat & 0x04); //发送位2
     
262. 
     
263. Send_bit(Sdat & 0x08); //发送位3
     
264. 
     
265. Send_bit(Sdat & 0x10); //发送位4
     
266. 
     
267. Send_bit(Sdat & 0x20); //发送位5
     
268. 
     
269. Send_bit(Dig & 0x01); //发送位选1
     
270. 
     
271. Send_bit(Dig & 0x02); //发送位选2
     
272. 
     
273. while(--i); //延时512us
     
274. 
     
275. Send_bit(Sdat & 0x40); //发送位6
     
276. 
     
277. for (i = 7;i> 0;i--) Send_bit(1); //位6移至Dout
     
278. 
     
279. if (Dig == 3) Dig = 0;
     
280. 
     
281. }
     
282. 
     
283. 
     
284. 
     
285. /*===================================================================
     
286. 
     
287. 延时 5ms 程序
     
288. 
     
289. ===================================================================*/
     
290. 
     
291. void Delay_5ms()
     
292. 
     
293. {
     
294. 
     
295. while(!TF1);
     
296. 
     
297. TF1 = 0;
     
298. 
     
299. TH1 = (- 5000) / 256;
     
300. 
     
301. TL1 = (- 5000) % 256;
     
302. 
     
303. }
     
304. 
     
305. 
     
306. 
     
307. /*===================================================================
     
308. 
     
309. 主程序
     
310. 
     
311. ===================================================================*/
     
312. 
     
313. void main()
     
314. 
     
315. {
     
316. 
     
317. TMOD = 0x10; //定时器1，16位模式
     
318. 
     
319. TCON = 0xc0; //TR1=1;TF1=1;
     
320. 
     
321. while(1) //主循环
     
322. 
     
323. {
     
324. 
     
325. Bus_drive(); //显示总线驱动
     
326. 
     
327. Key_scan(); //检测按键
     
328. 
     
329. Delay_5ms(); //延时5MS
     
330. 
     
331. }
     
332. 
     
333. }

复制代码

下次焊个四面体的4IO玩玩看

-----------------------------------------------------

二极管数量

6条楞，每楞两个，12个

中间星型，4个

共16个

作为试验目的，没有接按键，只焊了个键盘框架，用镊子短路相应的节点来当按键。图中接二极管阵列的三根线是3个IO，单独的一根是地线。MCU发送串行数据给HC595驱动数码管作键码显示。

对于这种方式的按键识别方法,很多朋友担心编程会很复杂,其实仔细分析后也很简单.比如上面例子,其本的思路是依次把三个IO拉低,然后记录另外两个IO的状态,最后三个IO都不下拉,再记录一次,就可得出的结果.对于按下不同的按键,就有不同的结果.如果只扫18键,那么最后一次扫描可以省掉,即扫描三次即可.实际应用时5MS的扫描间隔可以用定时中断来实现,这样就只占用很少的MCU时间.

楼主，两点请求：
1、能否给我单总线数码管显示那块的电路图
2、我移植到AVR下，按键值不变，错在哪里呢？
   //=============== 检测按键 =================
void Key_scan()
{   
    unsigned char i;
    Key_count --;                        //扫描次序
    Key_count &= 3;
    switch (Key_count)                //按次序处理
    {
        case 2:                                //第一轮扫描
        KB0 = PINA&0X02;  
        KB1 = PINA&0X04;  
        PORTA |= (1<<0);
        PORTA &= ~(1<<1);
        break;
     
        case 1:                                //每二轮扫描
        KB2 = PINA&0X04;
        KB3 = PINA&0X01;
        PORTA |= (1<<1);  
        PORTA &= ~(1<<2);
        break;
     
        case 0:                                //每三轮扫描
        KB4 = PINA&0X01;
        KB5 = PINA&0X02;
        PINA &= ~(1<<0);
        PORTA |= (1<<0);  
        break;
     
        default:                        //每四轮扫描
        if (!(PINA&0X01)) KB0 = 0;
        if (!(PINA&0X02)) KB2 = 0;
        if (!(PINA&0X04)) KB4 = 0;
         

        //======更新显示缓冲区=======
        Key_state = KB0<<5 + KB1<<4 + KB2<<3 + KB3<<2 + KB4<<1 + KB5;
        i = Key_tab[Key_state];
        if (i == 0)
        {
            Disp_buf[2] = 0x11;                //显示三横
            Disp_buf[1] = 0x11;
            Disp_buf[0] = 0x11;
        }
        else
        {
            Disp_buf[2] = 0x0c;     //字符"C"
            Disp_buf[1] = i / 10;   //键码十位
            Disp_buf[0] = i % 10;      //键码个位
        }
        Key_state = 0;
    }
}

还有，你那个笔段代码是BCD码吗？

h333 发表于 2013-7-10 00:21
楼主，两点请求：
1、能否给我单总线数码管显示那块的电路图
2、我移植到AVR下，按键值不变，错在哪里 ...

首先，AVR的IO不是准双向口，在作为输入时，需要开上拉电阻，当切换到输出0时，需要改变PORTA和DDRA，你程序里没有更改DDRA，因而不能动作。
其次，没看到你对KB0~KB5的变量类型声明，51中声明为bit，AVR中的位操作比较麻烦，建议读入时直接更新Key_state,取消KB0~KB5。
至于显示的问题，我打算迟些开个新帖，因为和这主题关系不大。键码已从 i= Key_tab[Key_state] 获得，需要送显示可自行处理。

unsigned char KB0,KB1,KB2,KB3,KB4,KB5;


//=============== 检测按键 =================
void Key_scan()
{   
    unsigned char i;
    Key_count --;                        //扫描次序
    Key_count &= 3;
    switch (Key_count)                //按次序处理
    {
        case 2:                                //第一轮扫描
        KB0 = PINA&0X02;  
        KB1 = PINA&0X04;  
        PORTA |= (1<<0);
                DDRA |= (1<<0);
        PORTA &= ~(1<<1);
                DDRA &= ~(1<<1);
        break;
     
        case 1:                                //每二轮扫描
        KB2 = PINA&0X04;
        KB3 = PINA&0X01;
        PORTA |= (1<<1);
                DDRA |= (1<<1);
        PORTA &= ~(1<<2);
                DDRA &= ~(1<<2);
        break;
     
        case 0:                                //每三轮扫描
        KB4 = PINA&0X01;
        KB5 = PINA&0X02;
        PORTA &= ~(1<<0);
                DDRA &= ~(1<<0);
        PORTA |= (1<<2);
                DDRA |= (1<<2);
        break;
     
        default:                        //每四轮扫描
        if (!(PINA&0X01)) KB0 = 0;
        if (!(PINA&0X02)) KB2 = 0;
        if (!(PINA&0X04)) KB4 = 0;
         

        //======更新显示缓冲区=======
        Key_state = (KB0<<5 + KB1<<4 + KB2<<3 + KB3<<2 + KB4<<1 + KB5);
        i = Key_tab[Key_state];
        if (i == 0)
        {
            Disp_buf[2] = 0x11;                //显示三横
            Disp_buf[1] = 0x11;
            Disp_buf[0] = 0x11;
        }
        else
        {
            Disp_buf[2] = 0x0c;     //字符"C"
            Disp_buf[1] = i / 10;   //键码十位
            Disp_buf[0] = i % 10;      //键码个位
        }
        Key_state = 0;
    }
}     

void main()
{
   // TMOD = 0x10;            //定时器1，16位模式
    //TCON = 0xc0;            //TR1=1;TF1=1;
        init_devices();
    while(1)                //主循环
    {
        //Bus_drive();        //显示总线驱动
        PORTB = LED_font[Disp_buf[2]];
        PORTC = LED_font[Disp_buf[1]];
        PORTD = LED_font[Disp_buf[0]];
        Key_scan();         //检测按键
        delay_ms(5);        //延时5MS     
    }
}

怎么按，都是显示C22

楼上还是没搞明白，举例说明一下

        case 2:                                //第一轮扫描
        if (PINA & 0x02) Key_state |= 0x01;    //读入PINA.1,记录于Key_state.0
        if (PINA & 0x04) Key_state |= 0x02;    //读入PINA.2,记录于Key_state.1
        DDRA  &= ~(1<<0);  //A口位0先改为输入
        PORTA |=  (1<<0);  //A口位0上拉有效
        PORTA &=  (1<<1);  //A口位1设定为0
        DDRA  |=  (1<<1);  //A口位1改为输出0
        break;             //以上端口变化顺序不要更改，否则可以出现短路

为什么 不是：
        case 2:                //第一轮扫描  
        DDRA  &= ~(1<<0);  //A口位0先改为输入
        PORTA |=  (1<<0);  //A口位0上拉有效
        PORTA &=  ~(1<<1);  //A口位1设定为0
        DDRA  |=  (1<<1);  //A口位1改为输出0                               //第一轮扫描  
        if (PINA & 0x02) Key_state |= 0x01;    //读入PINA.1,记录于Key_state.0
        if (PINA & 0x04) Key_state |= 0x02;    //读入PINA.2,记录于Key_state.1        
        break;  
       先改变IO口状态，再做键值判断？
       我那个 Key_state = (KB5<<5 + KB4<<4 + KB3<<3 + KB2<<2 + KB1<<1 + KB0);效果也应该是一样呀，只不过繁琐了一些

4个IO口，能扫多少键呢？ ^_^

先改变IO状态，立刻回读IO，有时会出错，IO外部受分布参数影响会有延时，特别是AVR上拉电阻较大，如果立该回读可能出错。
这里看似先读再改变IO输出，其实读的时候，上一轮扫描中已经把IO改变，到现在已过了5ms,IO状态足够稳定了，这时读入就可靠。
读完了，再改变IO状态，其实是为下一次做好准备。

Key_state用组合生成，效果是一样，只是处理繁琐且占内存也多。你先前的程序IO切换过程不正确才可能导致没效果。

h333 发表于 2013-7-10 00:43
4个IO口，能扫多少键呢？ ^_^

51的四个IO能扫65个键（或可以再多6个，但这6个可靠性不太好）.
AVR的，2个IO就可以扫15键，4个IO可能超100了，你可以搜索一下h2feo4的贴子。

四个IO扫3次，那Key_state就不止8位了，咋办呢？
另外，default语句是不是漏了break?
楼主，能否把QQ号给我？我直接把仿真文件给你，就能直观地看到错误了

你没细看程序，Key_state只用了6位，defalt那次的位用压缩方或与前面6位中的3位相与。如果真的用到9位，键码表占512字节就不好了。
至于dafalt后的break，在这里可用可不用，因为defalt后已经是switch的未端。
你可以把文件传到这里，或发至cowboy3@163.com

const unsigned char Key_tab[]=     //键码映射表
{//  0  1  2  3  4  5  6  7  8  9   
        22, 0, 2, 0, 0, 0, 0, 0, 4, 0, //0
         0, 0, 0, 0, 0,18, 0, 0, 0, 0, //1X
         0, 0, 0, 0, 0, 0, 3,14, 0, 0, //2X
        20,10, 6, 0, 0, 0, 0, 0, 1,19, //3X
         0, 5, 0, 0, 0,15, 0,11, 0, 0, //4X
         0,17, 0, 0,13, 8, 0,21, 0, 9, //5X
        16,12, 7, 0                    //6X
};

//=============== 检测按键 =================
void Key_scan()
{   
    unsigned char i;
    Key_count --;                        //扫描次序
    Key_count &= 3;
    switch (Key_count)                //按次序处理
    {
        case 2:                //第一轮扫描                                   
        if (PINA & 0x02) Key_state |= 0x01;    //读入PINA.1,记录于Key_state.0  
        if (PINA & 0x04) Key_state |= 0x02;    //读入PINA.2,记录于Key_state.1
                DDRA  &= ~(1<<0);  //A口位0先改为输入  
        PORTA |=  (1<<0);  //A口位0上拉有效
                DDRA  &= ~(1<<2);  //A口位2先改为输入  
        PORTA |=  (1<<2);  //A口位2上拉有效  
        PORTA &=  ~(1<<1);  //A口位1设定为0  
        DDRA  |=  (1<<1);  //A口位1改为输出0         
        break;
     
        case 1:                                //每二轮扫描
        if (PINA & 0x01) Key_state |= 0x04;    //读入PINA.0,记录于Key_state.2  
        if (PINA & 0x04) Key_state |= 0x08;    //读入PINA.2,记录于Key_state.3
        PORTA |= (1<<1);
                DDRA &= ~(1<<1);
        PORTA &= ~(1<<2);
                DDRA  |= (1<<2);
                DDRA  &= ~(1<<0);   
        PORTA |=  (1<<0);  
        break;
     
        case 0:                                //每三轮扫描
        if (PINA & 0x02) Key_state |= 0x10;    //读入PINA.1,记录于Key_state.4  
        if (PINA & 0x01) Key_state |= 0x20;    //读入PINA.0,记录于Key_state.5
        PORTA |= (1<<2);
                DDRA &= ~(1<<2);
        PORTA &= ~(1<<0);
                DDRA  |= (1<<0);
                DDRA  &= ~(1<<1);   
        PORTA |=  (1<<1);  
        break;
     
        default:                        //每四轮扫描
        if (!(PINA&0X01)) Key_state &= ~(1<<0);
        if (!(PINA&0X02)) Key_state &= ~(1<<1);
        if (!(PINA&0X04)) Key_state &= ~(1<<2);
               
        break;
     }

        //======更新显示缓冲区=======
        i = Key_tab[Key_state];                 
        if (i == 0)
        {
            Disp_buf[2] = 0x11;                //显示三横
            Disp_buf[1] = 0x11;
            Disp_buf[0] = 0x11;
        }
        else
        {
            Disp_buf[2] = 0x0c;     //字符"C"
            Disp_buf[1] = i / 10;   //键码十位
            Disp_buf[0] = i % 10;      //键码个位                        
        }
                //Key_state = 0;                        
}
Key_state什么时候清零才合适？要是4IO口的话，键码又如何扩展呢？

今天太晚了，下次再弄吧

由于还是新人 只有跟在高手后面慢慢做了！

有套件卖吗？我要

楼主，我没看见按键啊？

看看学习学习。。

支持支持！！

支持一下

学习。。。。。。。。。。。。。

好东西，揽下试试，谢谢！

高手呀，收藏一下

谢谢分享

这真是大神啊

高手啊，掌握了精髓，所以可以随心所欲了。

超级赞！ 新手 目前写个 点亮一个LED都带写错的。。。。直接膜拜！

6膜拜大佬

楼主辛苦  回复的很仔细

这是深夜逛论坛翻到宝了！！！