TTQ001 发表于 2020-5-23 04:04
嵌入了许多WHILE条件循环，如果使用IF条件进行替换应加以改进。

谢谢呀，其实我的问题，循环是没有问题的，调试执行循环一次，temp变为0xf0了，就应该出循环呀，为什么它没有出去?选择if也是可以的，但是我看郭天祥师傅也是这么用的，只是端口不一样而已

csmyldl 发表于 2020-5-23 01:44
while(temp!=0xf0)不应该嵌套使用

谢谢呀，其实我的问题，循环是没有问题的，调试执行循环一次，temp变为0xf0了，就应该出循环呀，为什么它没有出去?

多余语句全部注释掉，只做少量修改，楼主只要逐条语句对比就能明白错在哪里。

1. #include "reg52.h"         //此文件中定义了单片机的一些特殊功能寄存器
   
2. typedef unsigned int u16;  //对数据类型进行声明定义
   
3. typedef unsigned char u8;
   
4. char num;
   
5. char  temp;
   
6. u8 code smgduan[17]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
   
7.                                                         0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x40};//显示0~F的值
   
8. u8 keyvalue;
   
9. void delay(u16 i)
   
10. {
    
11.         while(i--);
    
12. }
    
13. 
    
14. void main()
    
15. {
    
16.         num=17;
    
17. //        P2=0;
    
18.         while(1)
    
19.         {
    
20.                 P1=0xfe;
    
21.                 temp=P1;
    
22. //                temp=temp&0xf0;
    
23.                 if(temp!=0xfe)
    
24.                 {
    
25.                         delay(500);
    
26.                         temp=P1; //
    
27. //                        temp= temp&0xf0;
    
28. //                        while(temp!=0xf0)
    
29. //                        {
    
30. //                        temp=P1; //此句非常重要
    
31.                         switch(temp)
    
32.                         {
    
33.                                 case 0xee : num=1;break;
    
34.                                 case 0xde : num=2;break;
    
35.                                 case 0xbe : num=3;break;
    
36.                                 case 0x7e : num=4;break;
    
37.                         }
    
38.                         while(P1!=0xfe); //松手确定
    
39. //                        {
    
40. //                                temp=P1;
    
41. //                                temp=temp&0xf0;
    
42. //                        }        
    
43. //                        P0=0;
    
44. //                        P2=smgduan[num];
    
45. //                        }
    
46.                 }         
    
47.                 P1=0xfd;
    
48.                 temp=P1;
    
49. //                temp=temp&0xf0;
    
50.                 if(temp!=0xfd)
    
51.                 {
    
52.                         delay(500);
    
53.                         temp=P1; //
    
54. //                        temp= temp&0xf0;
    
55. //                        while(temp!=0xf0)
    
56. //                        {
    
57. //                                temp=P1;         //此句非常重要
    
58.                         switch(temp)
    
59.                         {
    
60.                                 case 0xed : num=5;break;
    
61.                                 case 0xdd : num=6;break;
    
62.                                 case 0xbd : num=7;break;
    
63.                                 case 0x7d : num=8;break;
    
64.                         }
    
65.                         while(P1!=0xfd);
    
66. //                        {
    
67. //                                temp=P1;
    
68. //                                temp=temp&0xf0;
    
69. //                        }
    
70. //                        P0=0;
    
71. //                        P2=smgduan[num];
    
72. //                        }
    
73.                 }
    
74.                 P1=0xfb;
    
75.                 temp=P1;
    
76. //                temp=temp&0xf0;
    
77.                 if(temp!=0xfb)
    
78.                 {
    
79.                         delay(500);
    
80.                         temp=P1; //
    
81. //                        temp= temp&0xf0;
    
82. //                        while(temp!=0xf0)
    
83. //                        {
    
84. //                                temp=P1;         //此句非常重要
    
85.                         switch(temp)
    
86.                         {
    
87.                                 case 0xeb : num=9;break;
    
88.                                 case 0xdb : num=10;break;
    
89.                                 case 0xbb : num=11;break;
    
90.                                 case 0x7b : num=12;break;
    
91.                         }
    
92.                         while(P1!=0xfb);
    
93. //                        {
    
94. //                                temp=P1;
    
95. //                                temp=temp&0xf0;
    
96. //                        }
    
97. //                        P0=0;
    
98. //                        P2=smgduan[num];
    
99. //                        }
    
100.                 }
     
101.                 P1=0xf7;
     
102.                 temp=P1;
     
103. //                temp=temp&0xf0;
     
104.                 if(temp!=0xf7)
     
105.                 {
     
106.                         delay(500);
     
107.                         temp=P1; //
     
108. //                        temp=temp&0xf0;
     
109. //                        while(temp!=0xf0)
     
110. //                        {
     
111. //                                temp=P1;         //此句非常重要
     
112.                         switch(temp)
     
113.                         {
     
114.                                 case 0xe7 : num=13;break;
     
115.                                 case 0xd7 : num=14;break;
     
116.                                 case 0xb7 : num=15;break;
     
117.                                 case 0x77 : num=16;break;
     
118.                         }
     
119.                         while(P1!=0xf7);
     
120. //                        {
     
121. //                                temp=P1;
     
122. //                                temp=temp&0xf0;
     
123. //                        }
     
124. //                        P0=0;
     
125. //                        P2=smgduan[num];
     
126. //                        }
     
127.                 }
     
128.                 P0=0;
     
129.                 P2=smgduan[num-1];
     
130.         }
     
131. }        

复制代码

按键处理不是这样写的，正常来说应该根据IO状态的变化做debounce，不要死等。while(temp!=0xf0)你这个嵌套太多，可以 temp=(P0&0xF0),根据IO前后两次的状态不同来检测

嵌入了许多WHILE条件循环，如果使用IF条件进行替换应加以改进。

while(temp!=0xf0)不应该嵌套使用