51单片机按键之思考

yaoyong

51单片机按键之思考 [复制链接]

按键在编码显示时大都加了延时，去抖动，还有松手检测；
但是关于松手检测我好像有点纠结的地方
既然按键没有松那么程序势必就停在松手检测处；
或者说一直在while循环当中，那么换句话说就是当我一直按着
被检测的按键时其他的显示或者数据传输都应该停止了才对啊！
可事实却不尽相同：
1.首先看实际开发板的调试：
在矩阵键盘扫描电路中：
测试方法1：一直按着其中的某个键；
测试结果1：数码管上仅显示一个数值，就是该键所代表的数字个位；
测试方法2：在按着A键的同时按下B键，先松开A然后松开B；
测试结果2：显示B；
测试方法3：在按着A键的同时按下B键，先松开B然后松开A
测试结果3：显示A；
2.Proteus软件52单片机的直流电机调速：
每当按下按键DB8输出的都是高电平，按着不动也是一样；
请问这要作何解释呢？

huo_hu

原帖由 yaoyong 于 2013-3-29 12:56 发表
按键在编码显示时大都加了延时，去抖动，还有松手检测；
但是关于松手检测我好像有点纠结的地方
既然按键没有松那么程序势必就停在松手检测处；
或者说一直在while循环当中，那么换句话说就是当我一直按着
被检测 ...

按键时你不该占尽所有的cpu.
应该把按键功能独立的设计成一个模块,调用函数完成全部功能.否则程序很容易混乱.
具体的按下抬起哪个键是状态的问题,能区分复合的按键功能可以更强大而且也并不难,然后怎么处理就不再是按键的问题了.

龙少飞天

按键时你不该占尽所有的cpu

yaoyong

你所说的不会占尽CPU，那么程序在执行时难道还有一部分
CPU在执行主程序其余的部分，只分出一部分执行子程序
里面的东西？这不是跟程序里面的分支结构，还有控制语句
冲突了吗？

247153481

可以根据程序单个语句仿真试试

yaoyong

1. #include
   
2. 
   
3. typedef unsigned char uchar;
   
4. typedef unsigned int uint;
   
5. 
   
6. sbit dula=P2^6;
   
7. sbit wela=P2^7;
   
8. 
   
9. uchar Num;
   
10. 
    
11. uchar code table[]={
    
12. 0x3f,0x06,0x5b,0x4f,
    
13. 0x66,0x6d,0x7d,0x07,
    
14. 0x7f,0x6f,0x77,0x7c,
    
15. 0x39,0x5e,0x79,0x71};
    
16. 
    
17. 
    
18. void delay(uint z)
    
19. {
    
20.         uint x,y;
    
21.         for(x=z;x>0;x--)
    
22.                 for(y=110;y>0;y--);
    
23. }
    
24. 
    
25. void
    
26. DigitalDisplay(uchar );
    
27. void
    
28. KeyBoardScan();
    
29. 
    
30. void
    
31. main()
    
32. {
    
33.         while(1)
    
34.         {
    
35.                 DigitalDisplay(Num);
    
36.                 KeyBoardScan();
    
37.         }
    
38. }
    
39. void
    
40. keyBoardScan()
    
41. {
    
42.         uchar temp;
    
43.         P3=0xfe;
    
44.         temp=P3;
    
45.         temp=temp&0xf0;
    
46.         while(temp!=0xf0)
    
47.         {
    
48.                 delay(5);
    
49.                 temp=P3;
    
50.                 temp=temp&0xf0;
    
51.                 while(temp!=0xf0)
    
52.                 {
    
53.                         temp=P3;                           //千万记得在此读回来判断的是P3端口的值而不是temp&0xf0的值
    
54.                         switch (temp)
    
55.                         {
    
56.                         case 0xee:
    
57.                                 Num=1;
    
58.                                 break;
    
59. 
    
60.                         case 0xde:
    
61.                                 Num=2;
    
62.                                 break;
    
63. 
    
64.                         case 0xbe:
    
65.                                 Num=3;
    
66.                                 break;
    
67. 
    
68.                         case 0x7e:
    
69.                                 Num=4;
    
70.                                 break;
    
71.                         }
    
72.                         temp=temp&0xf0;
    
73.                         while(temp!=0xf0)                         //松手检测，
    
74.                         {
    
75.                                 temp=P3;
    
76.                                 temp=temp&0xf0;
    
77.                         }
    
78.                 }
    
79.         }
    
80. 
    
81.         P3=0xfd;
    
82.         temp=P3;
    
83.         temp=temp&0xf0;
    
84.         while(temp!=0xf0)
    
85.         {
    
86.                 delay(5);
    
87.                 temp=P3;
    
88.                 temp=temp&0xf0;
    
89.                 while(temp!=0xf0)
    
90.                 {
    
91.                         temp=P3;
    
92.                         switch(temp)
    
93.                         {
    
94.                         case 0xed:
    
95.                                 Num=5;
    
96.                                 break;
    
97. 
    
98.                         case 0xdd:
    
99.                                 Num=6;
    
100.                                 break;
     
101. 
     
102.                         case 0xbd:
     
103.                                 Num=7;
     
104.                                 break;
     
105. 
     
106.                         case 0x7d:
     
107.                                 Num=8;
     
108.                                 break;
     
109.                         }
     
110.                           temp=temp&0xf0;
     
111. 
     
112.                         while(temp!=0xf0)
     
113.                         {
     
114.                                 temp=P3;
     
115.                                 temp=temp&0xf0;
     
116.                         }
     
117.                 }
     
118.         }
     
119. 
     
120.         P3=0xfb;
     
121.         temp=P3;
     
122.         temp=temp&0xf0;
     
123.         while(temp!=0xf0)
     
124.         {
     
125.                 delay(5);
     
126.                 temp=P3;
     
127.                 temp=temp&0xf0;
     
128.                 while(temp!=0xf0)
     
129.                 {
     
130.                         temp=P3;
     
131.                         switch(temp)
     
132.                         {
     
133.                         case 0xeb:
     
134.                                 Num=9;
     
135.                                 break;
     
136. 
     
137.                         case 0xdb:
     
138.                                 Num=10;
     
139.                                 break;
     
140. 
     
141.                         case 0xbb:
     
142.                                 Num=11;
     
143.                                 break;
     
144. 
     
145.                         case 0x7b:
     
146.                                 Num=12;
     
147.                                 break;
     
148.                         }
     
149.                         temp=temp&0xf0;
     
150.                         while(temp!=0xf0)
     
151.                         {
     
152.                                 temp=P3;
     
153.                                 temp=temp&0xf0;
     
154.                         }
     
155.                 }
     
156.         }
     
157. 
     
158.         P3=0xf7;
     
159.         temp=P3;
     
160.         temp=temp&0xf0;
     
161.         while(temp!=0xf0)
     
162.         {
     
163.                 delay(5);
     
164.                 temp=P3;
     
165.                 temp=temp&0xf0;
     
166.                 while(temp!=0xf0)
     
167.                 {
     
168.                         temp=P3;
     
169.                         switch(temp)
     
170.                         {
     
171.                         case 0xe7:
     
172.                                 Num=13;
     
173.                                 break;
     
174. 
     
175.                         case 0xd7:
     
176.                                 Num=14;
     
177.                                 break;
     
178. 
     
179.                         case 0xb7:
     
180.                                 Num=15;
     
181.                                 break;
     
182. 
     
183.                         case 0x77:
     
184.                                 Num=16;
     
185.                                 break;
     
186.                         }
     
187.                         temp=temp&0xf0;
     
188.                         while(temp!=0xf0)
     
189.                         {
     
190.                                 temp=P3;
     
191.                                 temp=temp&0xf0;
     
192.                         }
     
193.                 }
     
194.         }
     
195. }
     
196. 
     
197. void
     
198. DigitalDisplay(uchar DisplayNum)
     
199. {
     
200.         uchar Shi,Ge;
     
201.         Shi=DisplayNum/10;
     
202.         Ge=DisplayNum%10;
     
203. 
     
204.         P0=table[Shi];
     
205.         dula=1;
     
206.         dula=0;
     
207.         P0=0xef;
     
208.         wela=1;
     
209.         wela=0;
     
210.         delay(1);
     
211. 
     
212.         P0=table[Ge];
     
213.         dula=1;
     
214.     dula=0;
     
215.         P0=0xdf;
     
216.         wela=1;
     
217.         wela=0;
     
218.         delay(1);     
     
219. }

复制代码

以上是我的源程序，键盘扫描确实是封装在子程序里，KeyboardScan（）；
而数码管的显示也在函数DigitalDisplay（）当中；主函数一直调用这两个函数
根据全局变量Num的变化改变显示的数据；

[ 本帖最后由 yaoyong 于 2013-4-1 09:39 编辑 ]

huo_hu

既然按键没有松那么程序势必就停在松手检测处；

是这句话感觉你的程序不够合理
定时察看io状态,按键抬起和按下只是状态有分别,不用特别处理.

辛昕

先不纠结楼主用的死循环方式检查按键，这当然完全不合理，理由，正是楼主怀疑的地方，那岂不是独占了 cpu
关键是楼主却没观察到独占。

我只想确定，你的这个死循环检查松手的动作 和 显示的扫描函数是不是在同一个线程里

这里解释一下线程，
单单一个主函数这叫一个线程，开了一个中断就多了一个线程。
线程的存在就是一种并行处理机制
我怀疑你的显示扫描不在主循环里，而死循环检测则在，所以看到有显示很正常

yaoyong

关于线程和进程记得以前翻操作系统的时候有过一面之缘，表示不懂
不过辛哥用在这里用它解释程序的执行过程还是第一次听到，这又让我有了新的理解：
1.中断是独立于主程序而执行的，定时器在计数时，主程序依然在执行，这里的所说的中断
应该有硬件支持；
2.这里的键盘是靠程序来实现的，不是编码键盘，键盘的松按也不像电脑一样会启用中断
所以不会产生新的线程。
3.死循环在子函数中，显示扫描程序也在子函数中，调用子函数应该是不会增加线程的；
这样说来程序还是会停在按键未松处。

yaoyong

没有特别处理啊！都是最基本的环节，只是在重新再看的时候有些不一样的想法

yaoyong

你好，能具体说说吗？

huo_hu

void Task_Run(void) {
        if (SF_AD1RES_FLAG|SF_AD2RES_FLAG) {
                StoreADData();                               
        }
        if (SF_TASKRUN_FLAG==0) return;
        SF_TASKRUN_FLAG=0;        //300hz
        TimeBase16++;
                //分时
        switch ((uint8)TimeBase16 & 0x3) {//75hz
                case 0:
                        WarmCtrl();
                break;
                case 1:
                        Key_Scan();
                        if (++Second>=75) {
                                Second=0;
                                Sound_Ctrl();
                        }                       
                break;
                case 2:
                        if (SF_DISABLE_DISPLAY_FLAG==0) Display();
                break;
                case 3:
                        AD_START;
                break;
        }//end switch

}

int main(void) {
        AD_Init();
        PCA_Init();
        Com_Init();
        TimerInit();
        LCD1602_Init(0x0c);
        EA=1;
        DispScreen();
        while (TimeBase16 <1500) Task_Run(); //上电延时5秒
        Clear_Memory();
        while (1) {
               
                Task_Run();
                switch (Key_Get()) {
                        case KEY_LEFT:
                                PWM_OpenBit^=0x0f;         //OPEN or CLOSE        PWM
                        break;
                        case KEY_RIGHT:
                                PWM_OpenBit^=0xf0;        //加热辅助开关
                        break;
                        case KEY_UP:
                                C1Temp_Setting+=1;
                        break;
                        case KEY_DOWN:
                                C1Temp_Setting-=1;
                        break;
                        case PRESS_KEY_LONGTIME_FLAG|KEY_UP:        //长按温度设置快加
                                C1Temp_Setting+=10;
                        break;
                        case PRESS_KEY_LONGTIME_FLAG|KEY_DOWN:        //长按温度设置快-
                                C1Temp_Setting-=10;
                        break;
                        case KEY_SHIFT:
                               
                        break;
                        case KEY_ENTER:                               
                                SF_SOUND_FLAG^=1;                                   //短按关闭声音
                                Sound_Bit=1;                                           //关闭
                        break;
                        case PRESS_KEY_LONGTIME_FLAG|KEY_ENTER:                               
                                SF_DISPLAY0_FLAG^=1;                                //长按显示第二屏
                                DispScreen();
                        break;

                        case KEY_SHIFT|KEY_LEFT:        //组合键置温度设置
                                LCD_Display_String(0,   "Input Tempature");
                                LCD_Display_String(0x40,"Setting:       ");
                                LCD_Display_Pretend_Float(0x49,Chg_Tempature(C1Temp_Setting),1);
                                C1Temp_Setting=UnChg_Tempature(Key_Input(0x49,5,2));//5-mask
                                DispScreen();                               
                        break;
                        case KEY_SHIFT|KEY_RIGHT:        //组合键置温度报警范围
                                LCD_Display_String(0,   "InputAlarmRange");
                                LCD_Display_String(0x40,"Setting:       ");
                                LCD_Display_DEC_uint8(0x49,Temp_Alarm_Range,1);
                                Temp_Alarm_Range=(uint8)Key_Input(0x49,2,1);//5-mask                               
                                DispScreen();                               
                        break;
                        case KEY_SHIFT|KEY_UP:                //组合键置延时
                               
                        break;
                        case KEY_SHIFT|KEY_DOWN:        //组合键置
                               
                        break;
                }//end switch       
       
        }//end while
        return 0;
}

这个是以前做的温控,按键部分包含两部分,定时的扫描置状态在taskrun里key_scan()函数完成这部分功能.另外一部分是对案件的处理在switch(key_get()){...}中,key_Get返回按键已经消抖处理过的有效按键状态,对返回值分别处理就行了.
任何时候都不应该while...来等一个很长时间才会发生的事件,1ms以上都应该算长的.

辛昕

线程和进程的概念只是看使用的空间资源的关系。
这里，中断计数和主程序执行同时，和线程无关。
我说的线程是指主程序和中断后切入中断服务程序，重点在于，它其实还是cpu的时间，这个和主程序实际上不是并行的，两者是互相抢占，只是，由于执行速度极快，使得一些宏观动作如同并行一般。

这里被我不小心扯远了，回正题，我只想问一下，你的显示扫描函数和读键这个等待死循环分别放在哪里调用？主程序里还是中断里？

yaoyong

程序我在六楼已经给出
我没有采用中断的方法，而实用软件检测什么时候按下，
显示程序和扫描程序都作为子程序被主函数调用

huo_hu

DB8在哪里?

季夏木槿

辛昕，请问一下，关于你说的线程的知识是在哪学的？

yaoyong

操作系统方面的书上都有

huo_hu

单片机里谈不上线程和进程,因为没有操作系统.即便有像uclinux,vxworks这样的操作系统也顶多是个分时系统,没有mmu也就没有地址映射,进程和线程切换是个颇麻烦的事情基本无可能.

yaoyong

呵呵，我没有接触这方面的东西，我是电气方面的，能把51搞好就不错了

季夏木槿

谢了