单片机热释电自动门控系统C语言程序,电机一直停顿在一个角度

这是我的仿真原理图，现在的问题就是热释电开关按下后电机会一直停顿在一个角度，然后我设置的限位开关k1-k4按了后没有反应，并且程序设置好的关门程序也没有启动。


下面是我写的程序，求各位大神看看逻辑在哪里出错了，我设置的k1和k3由于减速一个正向一个反向，k2和k4用于停止，rs是热释电红外传感器检测人体热信号的检测开门，hw是防夹伤的，大概的程序是想表达，人来开门，延时一段时间后自动关门，关门途中检测红外传感器信号有没有人，有人就开门，没人继续关门，直到k4发出停止信号。

单片机源程序如下:

1. #include "reg51.h"
   
2. 
   
3. //电机IO
   
4. #define GPIO_MOTOR P1
   
5. 
   
6. //按键IO
   
7. sbit rs=P3^0;        //热释电传感器
   
8. sbit hw=P3^1;        //红外传感器
   
9. sbit K1=P3^2;                 //正转
   
10. sbit K2=P3^3;                 //反转
    
11. sbit K3=P3^5;        //加速
    
12. sbit K4=P3^6;        //减速
    
13. 
    
14. 
    
15. unsigned char code FFW[8]={0xf4,0xf5,0xf1,0xf9,0xf8,0xfa,0xf2,0xf6}; //逆时针
    
16. unsigned char code FFZ[8]={0xf2,0xfa,0xf8,0xf9,0xf1,0xf5,0xf4,0xf6}; //顺时针
    
17. 
    
18. unsigned char Direction=0,Speed=0;
    
19. void Delay(unsigned int t);
    
20. void kaimen(void);
    
21. void guanmen(void);
    
22. void motor(void);
    
23. 
    
24. 
    
25. void main(void)
    
26. {
    
27.   while(1)
    
28.         {
    
29.             kaimen();
    
30. 
    
31.                         Delay(1000);
    
32.                         if(K2==0)
    
33.                         {
    
34.                          guanmen();
    
35.                         }
    
36. 
    
37.                         motor();      
    
38.         }
    
39. }
    
40. 
    
41. void motor (void)
    
42. {
    
43.                  unsigned char i;
    
44.                 for(i=0;i<8;i++)
    
45.                 {
    
46.                 if(Direction==1)
    
47.                 {
    
48.                         GPIO_MOTOR = FFW[i];
    
49.                 }
    
50.                 if(Direction==2)
    
51.                 {
    
52.                         GPIO_MOTOR = FFZ[i];
    
53.                 }
    
54.                                 if(Direction==3)
    
55.                 {
    
56.                         GPIO_MOTOR = 0x00;
    
57.                 }
    
58.                 Delay(Speed);        //调节转速      
    
59.                 }
    
60. 
    
61. }
    
62. 
    
63. 
    
64. void kaimen(void)
    
65. {
    
66.   unsigned char j;   
    
67. 
    
68.                 if(rs==0)                //检测按键rs是否按下
    
69.                 {
    
70.                         Delay(1);        //消除抖动
    
71.                         if(rs==0)
    
72.                         {
    
73.                                 Speed=180;                 //默认初始速度     数字越小 延时时间越短 速度越快
    
74.                                                                 Direction=1;
    
75.                         }
    
76.                         while((j<200)&&(rs==0))         //检测按键rs是否松开
    
77.                         {
    
78.                                 Delay(1);
    
79.                                 j++;
    
80.                         }
    
81.                         j=0;
    
82.                 }
    
83.                                 if(K1==0)
    
84.                                 {
    
85.                                                 {
    
86.                                                                 Speed=300;
    
87.                                                                 Direction=1;
    
88.                                                 }
    
89.                                                 while((j<200)&&(K1==0))         //检测按键K1是否松开
    
90.                         {
    
91.                                 Delay(1);
    
92.                                 j++;
    
93.                         }
    
94.                         j=0;
    
95.                                 }
    
96.                                 if(K2==0)
    
97.                                  {
    
98.                                                 {
    
99.                                                                 Speed=300;
    
100.                                                                 Direction=3;
     
101.                                                 }
     
102.                                                 while((j<200)&&(K2==0))         //检测按键K2是否松开
     
103.                         {
     
104.                                 Delay(1);
     
105.                                 j++;
     
106.                         }
     
107.                         j=0;
     
108.                                   }
     
109.                 }
     
110. 
     
111. void guanmen (void)
     
112. {
     
113.         
     
114.         unsigned char j;
     
115.         
     
116.                 if(hw==1)
     
117.                 {
     
118.                          Delay(1);
     
119.                         if(hw==1)
     
120.                         {
     
121.                                  Speed=180;                        //默认初始速度     数字越小 延时时间越短 速度越快
     
122.                                  Direction=2;
     
123.                         }
     
124.                         while((j<200)&&(hw==1))         //检测按键hw是否断开
     
125.               {
     
126.                       Delay(1);
     
127.                       j++;
     
128.               }        
     
129.                 }
     
130.                 if(K3==0)
     
131.                 {
     
132.                         {
     
133.                                 Speed=300;
     
134.                                 Direction=2;
     
135.                         }
     
136.                         while((j<200)&&(K3==0))         //检测按键K3是否松开
     
137.                {
     
138.                     Delay(1);
     
139.                     j++;
     
140.                }
     
141.           j=0;
     
142.                 }
     
143.                 if(K4==0)
     
144.                 {
     
145.                         {
     
146.                                 Speed=300;
     
147.                                 Direction=3;
     
148.                         }
     
149.                 while((j<200)&&(K4==0))         //检测按键K4是否松开
     
150.             {
     
151.                 Delay(1);
     
152.                 j++;
     
153.             }
     
154.                 j=0;
     
155.                 }
     
156.                 if(hw==0)
     
157.                                    {
     
158.                         Delay(1);        //消除抖动
     
159.                         if(hw==0)
     
160.                         {
     
161.                                 Speed=180;
     
162.                                                                 Direction=1;
     
163.                         }
     
164.                         while((j<200)&&(hw==0))         //检测按键rs是否松开
     
165.                         {
     
166.                                 Delay(1);
     
167.                                 j++;
     
168.                         }
     
169.                         j=0;
     
170.                    }
     
171.         }
     
172. 
     
173. void Delay(unsigned int t)
     
174. {                           
     
175.         while(t--)
     
176.         {
     
177.       ;
     
178.         }
     
179. }

复制代码

补一个原理图