基于计数器的交通灯应用

本次分为两个版本：
基础版
加强版


基础版只是利用定时器去实现相应的功能模块

加强版使用了两个中断（功能：1，绿灯时，每按一下，时间+2s，最高9s，功能2：相反）

说明：
基础版和加强版可共用一个电路图，此帖只附加了加强版的压缩包，想要基础版的可留言+邮件地址，谢谢阅读！多多支持

电路图



基础版主函数代码

1. #include <config.h>
   
2. sbit RED_NANBEIZHI=P1^0;          //南北方向直行红灯
   
3. sbit YELLOW_NANBEIZHI=P1^1;  //南北方向直行黄灯
   
4. sbit GREEN_NANBEIZHI=P1^2;          //南北方向直行绿灯
   
5. sbit RED_DONGXIZHI=P1^3;          //东西方向直行红灯
   
6. sbit YELLOW_DONGXIZHI=P1^4;        //东西方向直行黄灯
   
7. sbit GREEN_DONGXIZHI=P1^5;          //东西方向直行绿灯
   
8. sbit RED_NANBEIZUO=P2^0;          //南北方向左转红灯
   
9. sbit YELLOW_NANBEIZUO=P2^1;  //南北方向左转黄灯
   
10. sbit GREEN_NANBEIZUO=P2^2;          //南北方向左转绿灯
    
11. sbit RED_DONGXIZUO=P2^3;          //东西方向左转红灯
    
12. sbit YELLOW_DONGXIZUO=P2^4;        //东西方向左转黄灯
    
13. sbit GREEN_DONGXIZUO=P2^5;          //东西方向左转绿灯
    
14. sbit NBZHI=P1^6;
    
15. sbit NBZUO=P1^7;
    
16. sbit DXZHI=P2^6;
    
17. sbit DXZUO=P2^7;
    
18. 
    
19. u16 n;
    
20. u16 tt,bai,shi,ge,bb;       
    
21. u8 code table[]={
    
22. 0x3f,0x06,0x5b,0x4f,
    
23. 0x66,0x6d,0x7d,0x07,
    
24. 0x7f,0x6f};
    
25. 
    
26. void delay_ms(u16 t);
    
27. 
    
28. void xtimer0();
    
29. //1
    
30. void chushi0();
    
31. //2
    
32. void nbzhi1();
    
33. void nbzhi2();
    
34. void nbzhi3();
    
35. //3
    
36. void nbzuo2();
    
37. void nbzuo3();
    
38. void nbzuo4();
    
39. //4
    
40. void dxzhi1();
    
41. void dxzhi2();
    
42. void dxzhi3();
    
43. //5
    
44. void dxzuo2();
    
45. void dxzuo3();
    
46. void dxzuo4();
    
47. 
    
48. 
    
49. void main()
    
50. {
    
51.    P0=0xff;
    
52.    P1=0xc9;
    
53.    P2=0xc0;
    
54.    P3=0xff;
    
55.    EA=1;
    
56.    EX0=1;
    
57.    IT0=0;
    
58.    delay_ms(250);
    
59. 
    
60.    chushi0();                // ①南北向直行绿灯亮，延时5秒
    
61. 
    
62.    while(1)
    
63.    {
    
64. 
    
65.             //2 南北向直行：
    
66.          nbzhi1(); // ②启动南北向左转数码管显示：倒计时6秒；同时南北向直行绿灯闪烁3下，灭亮灭亮灭亮共3秒，
    
67.          nbzhi2(); // 然后南北向直行绿灯灭，南北向直行黄灯亮，延时3秒
    
68.          nbzhi3(); // ③南北向左转数码管倒计时显示结束，关闭；同时南北向直行黄灯灭，南北向直行红灯亮    ①南北向左转绿灯亮，延时若干秒
    
69. //         //3 南北向左转
    
70.          nbzuo2(); // ②启动东西向直行数码管显示：倒计时6秒；同时南北向左转绿灯闪烁3下，灭亮灭亮灭亮共3秒，
    
71.          nbzuo3(); // 然后南北向左转绿灯灭，南北向左转黄灯亮，延时3秒
    
72.          nbzuo4();        //③东西向直行数码管倒计时显示结束，关闭；同时南北向左转黄灯灭，南北向左转红灯亮           ①东西向直行绿灯亮，延时若干秒
    
73.          //4 东西向直行：
    
74.          dxzhi1();        //②启动东西向左转数码管显示：倒计时6秒；同时东西向直行绿灯闪烁3下，灭亮灭亮灭亮共3秒，
    
75.          dxzhi2();        //然后东西向直行绿灯灭，东西向直行黄灯亮，延时3秒
    
76.          dxzhi3();        //③东西向左转数码管倒计时显示结束，关闭；同时东西向直行黄灯灭，东西向直行红灯亮          ①东西向左转绿灯亮，延时若干秒
    
77.          //5 东西向左转：
    
78.          dxzuo2();         //②启动南北向直行数码管显示：倒计时6秒；同时东西向左转绿灯闪烁3下，灭亮灭亮灭亮共3秒，
    
79.          dxzuo3();         //然后东西向左转绿灯灭，东西向左转黄灯亮，延时3秒
    
80.          dxzuo4();         //③南北向直行数码管倒计时显示结束，关闭；同时东西向左转黄灯灭，东西向左转红灯亮
    
81.    }
    
82. }
    
83. ////////1、初始时：南北向、东西向直行左转均为红灯
    
84. void chushi0()          // ①南北向直行绿灯亮，延时5秒
    
85. {
    
86.     u16 temp1;
    
87.          temp1=5;
    
88.          TMOD|=0x01;
    
89.          TH0=(65535-50000)/256;
    
90.          TL0=(65535-50000)%256;
    
91.          EA=1;
    
92.          ET0=1;
    
93.          TR0=1;
    
94.          while(1)
    
95.          {
    
96.                  RED_NANBEIZHI=0;         
    
97.                  GREEN_NANBEIZHI=1;
    
98.                                   
    
99.                  if(tt==20)//20*50us=1s
    
100.                  {
     
101.                         tt=0;
     
102.                         temp1--;         
     
103.                  }
     
104.                   
     
105.              n=(temp1)%10;
     
106. 
     
107.                  if(temp1==0)
     
108.                  {
     
109.                           temp1=5;
     
110.                         break;
     
111.                  }
     
112.                  NBZHI=0;         //南北直行
     
113.                  NBZUO=1;
     
114.                  DXZHI=1;
     
115.                  DXZUO=1;
     
116.                  P0=table[n];
     
117.                  delay_ms(5);
     
118.          }
     
119. }
     
120. 
     
121. 
     
122. //////2、南北向直行：
     
123. void nbzhi1()                 //②启动南北向左转数码管显示：倒计时6秒；同时南北向直行绿灯闪烁3下，灭亮灭亮灭亮共3秒，
     
124. {                       
     
125.         u16 temp1;       
     
126.         temp1=6;
     
127.         TMOD=0x01;
     
128.         TH0=(65535-50000)/256;
     
129.         TL0=(65535-50000)%256;
     
130.         EA=1;
     
131.         ET0=1;
     
132.         TR0=1;
     
133.         while(1)
     
134.         {
     
135.                  RED_NANBEIZHI=0;             
     
136.                  RED_NANBEIZUO=1;          
     
137.                  
     
138.                  RED_DONGXIZUO=1;
     
139.                 if(tt==20)
     
140.                 {
     
141.                          tt=0;
     
142.                         temp1--;
     
143.                         if(temp1>=2)
     
144.                         {
     
145.                         GREEN_NANBEIZHI=~GREEN_NANBEIZHI;
     
146.                     }                               
     
147.                 }
     
148.                 n=(temp1)%10;
     
149.                                                  
     
150.                 if(temp1==3)
     
151.                 {
     
152.                  temp1=6;
     
153.                  break;       
     
154.                 }
     
155.             NBZHI=1;         //南北左转
     
156.                 NBZUO=0;
     
157.                 DXZHI=1;
     
158.                 DXZUO=1;
     
159.                 P0=table[n];
     
160.                 delay_ms(5);
     
161.         }
     
162. }
     
163. 
     
164. void nbzhi2()                 // 然后南北向直行绿灯灭，南北向直行黄灯亮，延时3秒
     
165. {                       
     
166.         u16 temp1;       
     
167.         temp1=3;
     
168.         TMOD=0x01;
     
169.         TH0=(65535-50000)/256;
     
170.         TL0=(65535-50000)%256;
     
171.         EA=1;
     
172.         ET0=1;
     
173.         TR0=1;
     
174.         while(1)
     
175.         {
     
176.                  GREEN_NANBEIZHI=0;
     
177.                  YELLOW_NANBEIZHI=1;
     
178.                 if(tt==20)
     
179.                 {
     
180.                          tt=0;
     
181.                         temp1--;
     
182.                                                
     
183.                        
     
184.                        
     
185.                 }
     
186.                 n=(temp1)%10;
     
187.                                                          
     
188.                 if(temp1==0)
     
189.                 {
     
190.                  temp1=3;
     
191.                  break;       
     
192.                 }
     
193.             NBZHI=1;         //南北左转
     
194.                 NBZUO=0;
     
195.                 DXZHI=1;
     
196.                 DXZUO=1;
     
197.                 P0=table[n];
     
198.                 delay_ms(5);       
     
199.         }
     
200. }
     
201. 
     
202. void nbzhi3()                 //③南北向左转数码管倒计时显示结束，关闭；同时南北向直行黄灯灭，南北向直行红灯亮    ①南北向左转绿灯亮，延时若干秒
     
203. {                       
     
204.         u16 temp1;       
     
205.         temp1=5;
     
206.         TMOD=0x01;
     
207.         TH0=(65535-50000)/256;
     
208.         TL0=(65535-50000)%256;
     
209.         EA=1;
     
210.         ET0=1;
     
211.         TR0=1;
     
212.         while(1)
     
213.         {
     
214.                  RED_NANBEIZHI=1;
     
215.                  RED_NANBEIZUO=0;            
     
216.                  GREEN_NANBEIZUO=1;;
     
217.                  YELLOW_NANBEIZHI=0;
     
218. 
     
219.                 if(tt==20)
     
220.                 {
     
221.                          tt=0;
     
222.                         temp1--;
     
223.                                 
     
224.                 }
     
225.                 n=(temp1)%10;                                                         
     
226.                 if(temp1==0)
     
227.                 {
     
228.                  temp1=5;
     
229.                  break;       
     
230.                 }
     
231.             NBZHI=1;         
     
232.                 NBZUO=0;
     
233.                 DXZHI=1;
     
234.                 DXZUO=1;
     
235.                 P0=table[n];
     
236.                 delay_ms(5);
     
237.         }       
     
238. }
     
239. 
     
240. ////////3、南北向左转：
     
241. 
     
242. void nbzuo2()           //②启动东西向直行数码管显示：倒计时6秒；同时南北向左转绿灯闪烁3下，灭亮灭亮灭亮共3秒，
     
243. {                       
     
244.         u16 temp1,temp2;       
     
245.         temp1=6;
     
246.         temp2=3;
     
247.         TMOD=0x01;
     
248.         TH0=(65535-50000)/256;
     
249.         TL0=(65535-50000)%256;
     
250.         EA=1;
     
251.         ET0=1;
     
252.         TR0=1;
     
253.         while(1)
     
254.         {
     
255.                  RED_DONGXIZHI=0;
     
256.                  RED_DONGXIZHI=1;
     
257.                  RED_DONGXIZUO=1;          
     
258.                  GREEN_NANBEIZHI=0;
     
259.                  YELLOW_NANBEIZHI=0;
     
260.                 if(tt==20)
     
261.                 {
     
262.                          tt=0;
     
263.                         temp1--;
     
264.                         if(temp1>=2)
     
265.                         {
     
266.                         GREEN_NANBEIZUO=~GREEN_NANBEIZUO;
     
267.                     }                       
     
268.                          
     
269.                        
     
270.                 }
     
271.                 n=(temp1)%10;                                                         
     
272.                 if(temp1==3)
     
273.                 {
     
274.                  temp1=6;
     
275.                  break;       
     
276.                 }
     
277.             NBZHI=1;         //南北左转
     
278.                 NBZUO=1;
     
279.                 DXZHI=0;
     
280.                 DXZUO=1;
     
281.                 P0=table[n];
     
282.                 delay_ms(5);       
     
283.         }       
     
284. }
     
285. 
     
286. void nbzuo3()           // 然后南北向左转绿灯灭，南北向左转黄灯亮，延时3秒
     
287. {                       
     
288.         u16 temp1;       
     
289.         temp1=3;
     
290.         TMOD=0x01;
     
291.         TH0=(65535-50000)/256;
     
292.         TL0=(65535-50000)%256;
     
293.         EA=1;
     
294.         ET0=1;
     
295.         TR0=1;
     
296.         while(1)
     
297.         {
     
298.                
     
299.                  GREEN_NANBEIZUO=0;
     
300.                  GREEN_DONGXIZUO=0;
     
301.                  GREEN_DONGXIZHI=0;
     
302.                  YELLOW_NANBEIZUO=1;
     
303.                  YELLOW_DONGXIZHI=0;
     
304.                  
     
305.                 if(tt==20)
     
306.                 {
     
307.                          tt=0;
     
308.                         temp1--;
     
309.                                                
     
310.                  
     
311.                        
     
312.                 }         
     
313.                 n=(temp1)%10;
     
314.                                                          
     
315.                 if(temp1==0)
     
316.                 {
     
317.                  temp1=3;
     
318.                  break;       
     
319.                 }        
     
320.             NBZHI=1;         //南北左转
     
321.                 NBZUO=1;
     
322.                 DXZHI=0;
     
323.                 DXZUO=1;
     
324.                 P0=table[n];
     
325.                 delay_ms(5);       
     
326.         }       
     
327. }
     
328. 
     
329. void nbzuo4()                   //③东西向直行数码管倒计时显示结束，关闭；同时南北向左转黄灯灭，南北向左转红灯亮           ①东西向直行绿灯亮，延时若干秒
     
330. {                       
     
331.         u16 temp1;       
     
332.         temp1=5;
     
333.         TMOD=0x01;
     
334.         TH0=(65535-50000)/256;
     
335.         TL0=(65535-50000)%256;
     
336.         EA=1;
     
337.         ET0=1;
     
338.         TR0=1;
     
339.         while(1)
     
340.         {
     
341.                  RED_NANBEIZHI=1;             
     
342.                  RED_NANBEIZUO=1;
     
343.                  RED_DONGXIZHI=0;          
     
344.                  GREEN_DONGXIZHI=1;
     
345.                  YELLOW_DONGXIZHI=0;
     
346.                  YELLOW_NANBEIZUO=0;
     
347.                         if(tt==20)
     
348.                 {
     
349.                          tt=0;
     
350.                         temp1--;
     
351.                         
     
352.                 }
     
353.                 n=(temp1)%10;                                                         
     
354.                 if(temp1==0)
     
355.                 {
     
356.                  temp1=5;
     
357.                  break;       
     
358.                 }
     
359.             NBZHI=1;         
     
360.                 NBZUO=1;
     
361.                 DXZHI=0;
     
362.                 DXZUO=1;
     
363.                 P0=table[n];
     
364.                 delay_ms(5);
     
365.         }       
     
366. }
     
367. 
     
368. ////////4、东西向直行：
     
369. 
     
370. void dxzhi1()           //②启动东西向左转数码管显示：倒计时6秒；同时东西向直行绿灯闪烁3下，灭亮灭亮灭亮共3秒，
     
371. {                       
     
372.         u16 temp1;       
     
373.         temp1=6;
     
374.         TMOD=0x01;
     
375.         TH0=(65535-50000)/256;
     
376.         TL0=(65535-50000)%256;
     
377.         EA=1;
     
378.         ET0=1;
     
379.         TR0=1;
     
380.         while(1)
     
381.         {
     
382.                  RED_NANBEIZHI=1;            
     
383.                  RED_NANBEIZUO=1;          
     
384.                  RED_DONGXIZUO=1;
     
385.                  RED_DONGXIZHI=0;
     
386.                 if(tt==20)
     
387.                 {
     
388.                          tt=0;
     
389.                         temp1--;
     
390.                         if(temp1>=2)
     
391.                         {
     
392.                         GREEN_DONGXIZHI=~GREEN_DONGXIZHI;
     
393.                     }                       
     
394.                                 
     
395.                 }
     
396.                 n=(temp1)%10;                                 
     
397.                 if(temp1==3)
     
398.                 {
     
399.                  temp1=6;
     
400.                  break;       
     
401.                 }
     
402.             NBZHI=1;         //南北左转
     
403.                 NBZUO=1;
     
404.                 DXZHI=1;
     
405.                 DXZUO=0;
     
406.                 P0=table[n];
     
407.                 delay_ms(5);
     
408.         }       
     
409. }
     
410. 
     
411. void dxzhi2()                   //然后东西向直行绿灯灭，东西向直行黄灯亮，延时3秒
     
412. {                       
     
413.         u16 temp1;       
     
414.         temp1=3;
     
415.         TMOD=0x01;
     
416.         TH0=(65535-50000)/256;
     
417.         TL0=(65535-50000)%256;
     
418.         EA=1;
     
419.         ET0=1;
     
420.         TR0=1;
     
421.         while(1)
     
422.         {
     
423.                  RED_NANBEIZHI=1;            
     
424.                  RED_NANBEIZUO=1;
     
425.                  RED_DONGXIZHI=0;          
     
426.                  GREEN_DONGXIZHI=0;
     
427.                  YELLOW_DONGXIZHI=1;
     
428.                 if(tt==20)
     
429.                 {
     
430.                          tt=0;
     
431.                         temp1--;                                                       
     
432.                 }
     
433.                 n=(temp1)%10;                                                          
     
434.                 if(temp1==0)
     
435.                 {
     
436.                  temp1=3;
     
437.                  break;       
     
438.                 }
     
439.             NBZHI=1;         //南北左转
     
440.                 NBZUO=1;
     
441.                 DXZHI=1;
     
442.                 DXZUO=0;
     
443.                 P0=table[n];
     
444.                 delay_ms(5);
     
445.         }               
     
446. }
     
447. 
     
448. void dxzhi3()                //③东西向左转数码管倒计时显示结束，关闭；同时东西向直行黄灯灭，东西向直行红灯亮          ①东西向左转绿灯亮，延时若干秒
     
449. {                       
     
450.         u16 temp1;       
     
451.         temp1=5;
     
452.         TMOD=0x01;
     
453.         TH0=(65535-50000)/256;
     
454.         TL0=(65535-50000)%256;
     
455.         EA=1;
     
456.         ET0=1;
     
457.         TR0=1;
     
458.         while(1)
     
459.         {
     
460.                  RED_NANBEIZHI=0;             
     
461.                  RED_DONGXIZHI=1;          
     
462.                  RED_DONGXIZUO=0;
     
463.                  GREEN_DONGXIZUO=1;
     
464.                  YELLOW_DONGXIZHI=0;
     
465.                 if(tt==20)
     
466.                 {
     
467.                          tt=0;
     
468.                         temp1--;
     
469.                                
     
470.                 }
     
471.                 n=(temp1)%10;                                                         
     
472.                 if(temp1==0)
     
473.                 {
     
474.                  temp1=5;
     
475.                  break;       
     
476.                 }
     
477.             NBZHI=1;         //南北左转
     
478.                 NBZUO=1;
     
479.                 DXZHI=1;
     
480.                 DXZUO=0;
     
481.                 P0=table[n];
     
482.                 delay_ms(5);
     
483.         }       
     
484. }
     
485. 
     
486. ////////5、东西向左转：
     
487. 
     
488. void dxzuo2()                //②启动南北向直行数码管显示：倒计时6秒；同时东西向左转绿灯闪烁3下，灭亮灭亮灭亮共3秒，
     
489. {                       
     
490.         u16 temp1,temp2;       
     
491.         temp1=6;
     
492.         temp2=3;
     
493.         TMOD=0x01;
     
494.         TH0=(65535-50000)/256;
     
495.         TL0=(65535-50000)%256;
     
496.         EA=1;
     
497.         ET0=1;
     
498.         TR0=1;
     
499.         while(1)
     
500.         {
     
501.              
     
502.                  RED_NANBEIZUO=1;          
     
503. 
     
504.                 if(tt==20)
     
505.                 {
     
506.                          tt=0;
     
507.                         temp1--;
     
508.                         if(temp1>=2)
     
509.                         {
     
510.                         GREEN_DONGXIZUO=~GREEN_DONGXIZUO;
     
511.                     }        
     
512.                 }  
     
513.                 n=(temp1)%10;                                                          
     
514.                 if(temp1==3)
     
515.                 {
     
516.                  temp1=6;
     
517.                  break;       
     
518.                 }
     
519.             NBZHI=0;         //南北左转
     
520.                 NBZUO=1;
     
521.                 DXZHI=1;
     
522.                 DXZUO=1;
     
523.                 P0=table[n];
     
524.                 delay_ms(5);                
     
525.         }       
     
526. }
     
527. 
     
528. void dxzuo3()                 //然后东西向左转绿灯灭，东西向左转黄灯亮，延时3秒
     
529. {                       
     
530.         u16 temp1;       
     
531.         temp1=3;
     
532.         TMOD=0x01;
     
533.         TH0=(65535-50000)/256;
     
534.         TL0=(65535-50000)%256;
     
535.         EA=1;
     
536.         ET0=1;
     
537.         TR0=1;
     
538.         while(1)
     
539.         {
     
540.                  RED_NANBEIZHI=1;             
     
541.                  RED_NANBEIZUO=1;
     
542.                  GREEN_DONGXIZUO=0;          
     
543.                  YELLOW_DONGXIZUO=1;
     
544.                 if(tt==20)
     
545.                 {
     
546.                          tt=0;
     
547.                         temp1--;
     
548.                                                
     
549.                          
     
550.                        
     
551.                 }
     
552.                 n=(temp1)%10;                                 
     
553.                 if(temp1==0)
     
554.                 {
     
555.                  temp1=3;
     
556.                  break;       
     
557.                 }
     
558.             NBZHI=0;         //南北左转
     
559.                 NBZUO=1;
     
560.                 DXZHI=1;
     
561.                 DXZUO=1;
     
562.                 P0=table[n];
     
563.                 delay_ms(5);       
     
564.         }       
     
565. }
     
566. 
     
567. void dxzuo4()                  //③南北向直行数码管倒计时显示结束，关闭；同时东西向左转黄灯灭，东西向左转红灯亮          ①南北向直行绿灯亮，延时5秒
     
568. {                       
     
569.         u16 temp1;       
     
570.         temp1=5;
     
571.         TMOD=0x01;
     
572.         TH0=(65535-50000)/256;
     
573.         TL0=(65535-50000)%256;
     
574.         EA=1;
     
575.         ET0=1;
     
576.         TR0=1;
     
577.         while(1)
     
578.         {         
     
579.                  RED_NANBEIZHI=0;             
     
580.                  RED_DONGXIZHI=1;
     
581.                  RED_DONGXIZUO=1;
     
582.                  GREEN_NANBEIZHI=1;
     
583.                  YELLOW_DONGXIZUO=0;
     
584.                         if(tt==20)
     
585.                 {
     
586.                          tt=0;
     
587.                         temp1--;
     
588.                                 
     
589.                 }
     
590.                 n=(temp1)%10;                                                         
     
591.                 if(temp1==0)
     
592.                 {
     
593.                  temp1=5;
     
594.                  break;       
     
595.                 }
     
596.             NBZHI=0;         //南北左转
     
597.                 NBZUO=1;
     
598.                 DXZHI=1;
     
599.                 DXZUO=1;
     
600.                 P0=table[n];
     
601.                 delay_ms(5);
     
602.         }       
     
603. }
     
604. 
     
605. void delay_ms(u16 t)
     
606. {                       
     
607.         u8 i,j;
     
608.         for(i=0;i<t;i++)
     
609.         for(j=0;j<110;j++);       
     
610. }
     
611. 
     
612. 
     
613. 
     
614. void xtimer1() interrupt 1
     
615. {                       
     
616.         TH0=(65535-50000)/256;
     
617.         TL0=(65535-50000)%256;
     
618.         tt++;
     
619. }
     
620. 
     

复制代码

加强版主函数

1. #include <config.h>
   
2. sbit RED_NANBEIZHI=P1^0;          //南北方向直行红灯
   
3. sbit YELLOW_NANBEIZHI=P1^1;  //南北方向直行黄灯
   
4. sbit GREEN_NANBEIZHI=P1^2;          //南北方向直行绿灯
   
5. sbit RED_DONGXIZHI=P1^3;          //东西方向直行红灯
   
6. sbit YELLOW_DONGXIZHI=P1^4;        //东西方向直行黄灯
   
7. sbit GREEN_DONGXIZHI=P1^5;          //东西方向直行绿灯
   
8. sbit RED_NANBEIZUO=P2^0;          //南北方向左转红灯
   
9. sbit YELLOW_NANBEIZUO=P2^1;  //南北方向左转黄灯
   
10. sbit GREEN_NANBEIZUO=P2^2;          //南北方向左转绿灯
    
11. sbit RED_DONGXIZUO=P2^3;          //东西方向左转红灯
    
12. sbit YELLOW_DONGXIZUO=P2^4;        //东西方向左转黄灯
    
13. sbit GREEN_DONGXIZUO=P2^5;          //东西方向左转绿灯
    
14. sbit NBZHI=P1^6;
    
15. sbit NBZUO=P1^7;
    
16. sbit DXZHI=P2^6;
    
17. sbit DXZUO=P2^7;
    
18. u16 n,tt,temp1,temp=5;
    
19. u8 code table[]={
    
20. 0x3f,0x06,0x5b,0x4f,
    
21. 0x66,0x6d,0x7d,0x07,
    
22. 0x7f,0x6f};
    
23. //函数
    
24. void delay_ms(u16 t);
    
25. void xtimer0();
    
26. //1
    
27. void chushi0();
    
28. void chushi1();
    
29. //2
    
30. void nbzhi1();
    
31. void nbzhi2();
    
32. void nbzhi3();
    
33. //3
    
34. void nbzuo2();
    
35. void nbzuo3();
    
36. void nbzuo4();
    
37. //4
    
38. void dxzhi1();
    
39. void dxzhi2();
    
40. void dxzhi3();
    
41. //5
    
42. void dxzuo2();
    
43. void dxzuo3();
    
44. void dxzuo4();
    
45. void sys_unit()
    
46. {
    
47.          TMOD|=0x01;
    
48.          TH0=(65535-50000)/256;
    
49.          TL0=(65535-50000)%256;
    
50.             EA=1;
    
51.          IT0=1;
    
52.          IT1=1;         
    
53.          ET0=1;
    
54.          ET1=1;
    
55.          EX0=1;
    
56.          EX1=1;
    
57.          TR0=1;
    
58.          TR1=0;
    
59. 
    
60. }
    
61. 
    
62. void main()
    
63. {  
    
64.    P0=0xff;
    
65.    P1=0xc9;
    
66.    P2=0xc9;
    
67.    P3=0xff;
    
68.             
    
69.    sys_unit();
    
70.    chushi0();
    
71.    chushi1();                // ①南北向直行绿灯亮，延时5秒
    
72.    while(1)
    
73.    {
    
74.           
    
75.             //2 南北向直行：
    
76.          nbzhi1(); // ②启动南北向左转数码管显示：倒计时6秒；同时南北向直行绿灯闪烁3下，灭亮灭亮灭亮共3秒，
    
77.          nbzhi2(); // 然后南北向直行绿灯灭，南北向直行黄灯亮，延时3秒
    
78.          nbzhi3(); // ③南北向左转数码管倒计时显示结束，关闭；同时南北向直行黄灯灭，南北向直行红灯亮    ①南北向左转绿灯亮，延时若干秒
    
79. //         //3 南北向左转
    
80.          nbzuo2(); // ②启动东西向直行数码管显示：倒计时6秒；同时南北向左转绿灯闪烁3下，灭亮灭亮灭亮共3秒，
    
81.          nbzuo3(); // 然后南北向左转绿灯灭，南北向左转黄灯亮，延时3秒
    
82.          nbzuo4();        //③东西向直行数码管倒计时显示结束，关闭；同时南北向左转黄灯灭，南北向左转红灯亮           ①东西向直行绿灯亮，延时若干秒
    
83.          //4 东西向直行：
    
84.          dxzhi1();        //②启动东西向左转数码管显示：倒计时6秒；同时东西向直行绿灯闪烁3下，灭亮灭亮灭亮共3秒，
    
85.          dxzhi2();        //然后东西向直行绿灯灭，东西向直行黄灯亮，延时3秒
    
86.          dxzhi3();        //③东西向左转数码管倒计时显示结束，关闭；同时东西向直行黄灯灭，东西向直行红灯亮          ①东西向左转绿灯亮，延时若干秒
    
87.          //5 东西向左转：
    
88.          dxzuo2();         //②启动南北向直行数码管显示：倒计时6秒；同时东西向左转绿灯闪烁3下，灭亮灭亮灭亮共3秒，
    
89.          dxzuo3();         //然后东西向左转绿灯灭，东西向左转黄灯亮，延时3秒
    
90.          dxzuo4();         //③南北向直行数码管倒计时显示结束，关闭；同时东西向左转黄灯灭，东西向左转红灯亮
    
91.    }
    
92. }
    
93. ////////1、初始时：南北向、东西向直行左转均为红灯
    
94. void chushi0()          // ①红灯亮2秒
    
95. {
    
96.          temp1=5;
    
97.          while(1)
    
98.          {
    
99.                  RED_NANBEIZHI=1;
    
100.                  RED_NANBEIZUO=1;
     
101.                  RED_DONGXIZHI=1;
     
102.                  RED_DONGXIZUO=1;         
     
103.                  if(tt==20)//20*50us=1s
     
104.                  {
     
105.                         tt=0;
     
106.                         temp1--;         
     
107.                  }
     
108.                  if(temp1==3)
     
109.                  {
     
110.                           temp1=5;
     
111.                         break;
     
112.                  }
     
113.          }
     
114. }
     
115. void chushi1()          // ①南北向直行绿灯亮，延时5秒
     
116. {                 
     
117.          while(1)
     
118.          {                    
     
119.                  RED_NANBEIZHI=0;         
     
120.                  GREEN_NANBEIZHI=1;                                  
     
121.                  if(tt==20)//20*50us=1s
     
122.                  {
     
123.                         tt=0;
     
124.                         temp--;         
     
125.                  }                   
     
126.              n=temp%10;                 
     
127.                  if(temp==0)
     
128.                  {
     
129.                           temp=5;
     
130.                         break;
     
131.                  }
     
132.                  NBZHI=0;         //南北直行
     
133.                  NBZUO=1;
     
134.                  DXZHI=1;
     
135.                  DXZUO=1;
     
136.                  P0=table[n];
     
137.                  delay_ms(5);
     
138.          }
     
139. }
     
140. //////2、南北向直行：
     
141. void nbzhi1()                 //②启动南北向左转数码管显示：倒计时6秒；同时南北向直行绿灯闪烁3下，灭亮灭亮灭亮共3秒，
     
142. {                               
     
143.         temp1=6;
     
144.         while(1)
     
145.         {
     
146.                  RED_NANBEIZHI=0;             
     
147.                  RED_NANBEIZUO=1;                  
     
148.                  RED_DONGXIZUO=1;
     
149.                 if(tt==20)
     
150.                 {
     
151.                          tt=0;
     
152.                         temp1--;
     
153.                         if(temp1>=2)
     
154.                         {
     
155.                         GREEN_NANBEIZHI=~GREEN_NANBEIZHI;
     
156.                     }                               
     
157.                 }
     
158.                 n=temp1%10;                                                 
     
159.                 if(temp1==3)
     
160.                 {
     
161.                  temp1=6;
     
162.                  break;       
     
163.                 }
     
164.             NBZHI=1;         //南北左转
     
165.                 NBZUO=0;
     
166.                 DXZHI=1;
     
167.                 DXZUO=1;
     
168.                 P0=table[n];
     
169.                 delay_ms(5);
     
170.         }
     
171. }
     
172. 
     
173. void nbzhi2()                 // 然后南北向直行绿灯灭，南北向直行黄灯亮，延时3秒
     
174. {                               
     
175.         temp1=3;
     
176.         while(1)
     
177.         {
     
178.                  GREEN_NANBEIZHI=0;
     
179.                  YELLOW_NANBEIZHI=1;
     
180.                 if(tt==20)
     
181.                 {
     
182.                          tt=0;
     
183.                         temp1--;       
     
184.                 }
     
185.                 n=(temp1)%10;                                                         
     
186.                 if(temp1==0)
     
187.                 {
     
188.                  temp1=3;
     
189.                  break;       
     
190.                 }
     
191.             NBZHI=1;         //南北左转
     
192.                 NBZUO=0;
     
193.                 DXZHI=1;
     
194.                 DXZUO=1;
     
195.                 P0=table[n];
     
196.                 delay_ms(5);       
     
197.         }
     
198. }
     
199. 
     
200. void nbzhi3()                 //③南北向左转数码管倒计时显示结束，关闭；同时南北向直行黄灯灭，南北向直行红灯亮    ①南北向左转绿灯亮，延时若干秒
     
201. {       
     
202.         while(1)
     
203.         {
     
204.                  RED_NANBEIZHI=1;
     
205.                  RED_NANBEIZUO=0;            
     
206.                  GREEN_NANBEIZUO=1;;
     
207.                  YELLOW_NANBEIZHI=0;
     
208.                 if(tt==20)
     
209.                 {
     
210.                          tt=0;
     
211.                         temp--;                                
     
212.                 }
     
213.                 n=temp%10;                                                         
     
214.                 if(temp==0)
     
215.                 {
     
216.                  temp=5;
     
217.                  break;       
     
218.                 }
     
219.             NBZHI=1;         
     
220.                 NBZUO=0;
     
221.                 DXZHI=1;
     
222.                 DXZUO=1;
     
223.                 P0=table[n];
     
224.                 delay_ms(5);
     
225.         }       
     
226. }
     
227. 
     
228. ////////3、南北向左转：
     
229. void nbzuo2()           //②启动东西向直行数码管显示：倒计时6秒；同时南北向左转绿灯闪烁3下，灭亮灭亮灭亮共3秒，
     
230. {                               
     
231.         temp1=6;
     
232.         while(1)
     
233.         {
     
234.                  RED_DONGXIZHI=0;
     
235.                  RED_DONGXIZHI=1;
     
236.                  RED_DONGXIZUO=1;          
     
237.                  GREEN_NANBEIZHI=0;
     
238.                  YELLOW_NANBEIZHI=0;
     
239.                 if(tt==20)
     
240.                 {
     
241.                          tt=0;
     
242.                         temp1--;
     
243.                         if(temp1>=2)
     
244.                         {
     
245.                         GREEN_NANBEIZUO=~GREEN_NANBEIZUO;
     
246.                     }               
     
247.                 }
     
248.                 n=temp1%10;                                                         
     
249.                 if(temp1==3)
     
250.                 {
     
251.                  temp1=6;
     
252.                  break;       
     
253.                 }
     
254.             NBZHI=1;         //南北左转
     
255.                 NBZUO=1;
     
256.                 DXZHI=0;
     
257.                 DXZUO=1;
     
258.                 P0=table[n];
     
259.                 delay_ms(5);       
     
260.         }       
     
261. }
     
262. 
     
263. void nbzuo3()           // 然后南北向左转绿灯灭，南北向左转黄灯亮，延时3秒
     
264. {                               
     
265.         temp1=3;
     
266.         while(1)
     
267.         {                         
     
268.                  GREEN_NANBEIZUO=0;
     
269.                  GREEN_DONGXIZUO=0;
     
270.                  GREEN_DONGXIZHI=0;
     
271.                  YELLOW_NANBEIZUO=1;
     
272.                  YELLOW_DONGXIZHI=0;                 
     
273.                 if(tt==20)
     
274.                 {
     
275.                          tt=0;
     
276.                         temp1--;                                                       
     
277.                 }         
     
278.                 n=(temp1)%10;                                                         
     
279.                 if(temp1==0)
     
280.                 {
     
281.                  temp1=3;
     
282.                  break;       
     
283.                 }        
     
284.             NBZHI=1;         //南北左转
     
285.                 NBZUO=1;
     
286.                 DXZHI=0;
     
287.                 DXZUO=1;
     
288.                 P0=table[n];
     
289.                 delay_ms(5);       
     
290.         }       
     
291. }
     
292. void nbzuo4()                   //③东西向直行数码管倒计时显示结束，关闭；同时南北向左转黄灯灭，南北向左转红灯亮           ①东西向直行绿灯亮，延时若干秒
     
293. {       
     
294.         while(1)
     
295.         {
     
296.                  RED_NANBEIZHI=1;             
     
297.                  RED_NANBEIZUO=1;
     
298.                  RED_DONGXIZHI=0;          
     
299.                  GREEN_DONGXIZHI=1;
     
300.                  YELLOW_DONGXIZHI=0;
     
301.                  YELLOW_NANBEIZUO=0;
     
302.                 if(tt==20)
     
303.                 {
     
304.                          tt=0;
     
305.                         temp--;                        
     
306.                 }
     
307.                 n=temp%10;                                                         
     
308.                 if(temp==0)
     
309.                 {
     
310.                  temp=5;
     
311.                  break;       
     
312.                 }
     
313.             NBZHI=1;         
     
314.                 NBZUO=1;
     
315.                 DXZHI=0;
     
316.                 DXZUO=1;
     
317.                 P0=table[n];
     
318.                 delay_ms(5);
     
319.         }       
     
320. }
     
321. 
     
322. ////////4、东西向直行：
     
323. void dxzhi1()           //②启动东西向左转数码管显示：倒计时6秒；同时东西向直行绿灯闪烁3下，灭亮灭亮灭亮共3秒，
     
324. {                               
     
325.         temp1=6;
     
326.         while(1)
     
327.         {
     
328.                  RED_NANBEIZHI=1;            
     
329.                  RED_NANBEIZUO=1;          
     
330.                  RED_DONGXIZUO=1;
     
331.                  RED_DONGXIZHI=0;
     
332.                 if(tt==20)
     
333.                 {
     
334.                          tt=0;
     
335.                         temp1--;
     
336.                         if(temp1>=2)
     
337.                         {
     
338.                         GREEN_DONGXIZHI=~GREEN_DONGXIZHI;
     
339.                     }                
     
340.                 }
     
341.                 n=(temp1)%10;                                 
     
342.                 if(temp1==3)
     
343.                 {
     
344.                  temp1=6;
     
345.                  break;       
     
346.                 }
     
347.             NBZHI=1;         //南北左转
     
348.                 NBZUO=1;
     
349.                 DXZHI=1;
     
350.                 DXZUO=0;
     
351.                 P0=table[n];
     
352.                 delay_ms(5);
     
353.         }       
     
354. }
     
355. 
     
356. void dxzhi2()                   //然后东西向直行绿灯灭，东西向直行黄灯亮，延时3秒
     
357. {                               
     
358.         temp1=3;
     
359.         while(1)
     
360.         {
     
361.                  RED_NANBEIZHI=1;            
     
362.                  RED_NANBEIZUO=1;
     
363.                  RED_DONGXIZHI=0;          
     
364.                  GREEN_DONGXIZHI=0;
     
365.                  YELLOW_DONGXIZHI=1;
     
366.                 if(tt==20)
     
367.                 {
     
368.                          tt=0;
     
369.                         temp1--;                                                       
     
370.                 }
     
371.                 n=(temp1)%10;                                                          
     
372.                 if(temp1==0)
     
373.                 {
     
374.                  temp1=3;
     
375.                  break;       
     
376.                 }
     
377.             NBZHI=1;         //南北左转
     
378.                 NBZUO=1;
     
379.                 DXZHI=1;
     
380.                 DXZUO=0;
     
381.                 P0=table[n];
     
382.                 delay_ms(5);
     
383.         }               
     
384. }
     
385. 
     
386. void dxzhi3()                //③东西向左转数码管倒计时显示结束，关闭；同时东西向直行黄灯灭，东西向直行红灯亮          ①东西向左转绿灯亮，延时若干秒
     
387. {       
     
388.         while(1)
     
389.         {
     
390.                  RED_NANBEIZHI=0;             
     
391.                  RED_DONGXIZHI=1;          
     
392.                  RED_DONGXIZUO=0;
     
393.                  GREEN_DONGXIZUO=1;
     
394.                  YELLOW_DONGXIZHI=0;
     
395.                 if(tt==20)
     
396.                 {
     
397.                          tt=0;
     
398.                         temp--;                               
     
399.                 }
     
400.                 n=temp%10;                                                         
     
401.                 if(temp==0)
     
402.                 {
     
403.                  temp=5;
     
404.                  break;       
     
405.                 }
     
406.             NBZHI=1;         //南北左转
     
407.                 NBZUO=1;
     
408.                 DXZHI=1;
     
409.                 DXZUO=0;
     
410.                 P0=table[n];
     
411.                 delay_ms(5);
     
412.         }       
     
413. }
     
414. 
     
415. ////////5、东西向左转：
     
416. void dxzuo2()                //②启动南北向直行数码管显示：倒计时6秒；同时东西向左转绿灯闪烁3下，灭亮灭亮灭亮共3秒，
     
417. {                               
     
418.         temp1=6;
     
419.         while(1)
     
420.         {               
     
421.                 RED_NANBEIZUO=1;          
     
422.                 if(tt==20)
     
423.                 {
     
424.                          tt=0;
     
425.                         temp1--;
     
426.                         if(temp1>=2)
     
427.                         {
     
428.                         GREEN_DONGXIZUO=~GREEN_DONGXIZUO;
     
429.                     }        
     
430.                 }  
     
431.                 n=(temp1)%10;                                                          
     
432.                 if(temp1==3)
     
433.                 {
     
434.                  temp1=6;
     
435.                  break;       
     
436.                 }
     
437.             NBZHI=0;         //南北左转
     
438.                 NBZUO=1;
     
439.                 DXZHI=1;
     
440.                 DXZUO=1;
     
441.                 P0=table[n];
     
442.                 delay_ms(5);                
     
443.         }       
     
444. }
     
445. 
     
446. void dxzuo3()                 //然后东西向左转绿灯灭，东西向左转黄灯亮，延时3秒
     
447. {                               
     
448.         temp1=3;
     
449.         while(1)
     
450.         {
     
451.                  RED_NANBEIZHI=1;             
     
452.                  RED_NANBEIZUO=1;
     
453.                  GREEN_DONGXIZUO=0;          
     
454.                  YELLOW_DONGXIZUO=1;
     
455.                 if(tt==20)
     
456.                 {
     
457.                          tt=0;
     
458.                         temp1--;       
     
459.                 }
     
460.                 n=(temp1)%10;                                 
     
461.                 if(temp1==0)
     
462.                 {
     
463.                  temp1=3;
     
464.                  break;       
     
465.                 }
     
466.             NBZHI=0;         //南北左转
     
467.                 NBZUO=1;
     
468.                 DXZHI=1;
     
469.                 DXZUO=1;
     
470.                 P0=table[n];
     
471.                 delay_ms(5);       
     
472.         }       
     
473. }
     
474. 
     
475. void dxzuo4()                  //③南北向直行数码管倒计时显示结束，关闭；同时东西向左转黄灯灭，东西向左转红灯亮          ①南北向直行绿灯亮，延时5秒
     
476. {         
     
477.         while(1)
     
478.         {         
     
479.                  RED_NANBEIZHI=0;             
     
480.                  RED_DONGXIZHI=1;
     
481.                  RED_DONGXIZUO=1;
     
482.                  GREEN_NANBEIZHI=1;
     
483.                  YELLOW_DONGXIZUO=0;
     
484.                         if(tt==20)
     
485.                 {
     
486.                          tt=0;
     
487.                         temp--;                                
     
488.                 }
     
489.                 n=temp%10;                                                         
     
490.                 if(temp==0)
     
491.                 {
     
492.                  temp=5;
     
493.                  break;       
     
494.                 }
     
495.             NBZHI=0;         //南北左转
     
496.                 NBZUO=1;
     
497.                 DXZHI=1;
     
498.                 DXZUO=1;
     
499.                 P0=table[n];
     
500.                 delay_ms(5);
     
501.         }       
     
502. }
     
503. 
     
504. void delay_ms(u16 t)
     
505. {                       
     
506.         u8 i,j;
     
507.         for(i=0;i<t;i++)
     
508.         for(j=0;j<110;j++);       
     
509. }
     
510. void int0() interrupt 0          //外部中断0
     
511. {          
     
512.         if(temp<10&&temp>=0)
     
513.         {
     
514.                   temp=temp+2;
     
515.         }
     
516. }
     
517. void int1() interrupt 2          //外部中断1
     
518. {
     
519.         if(temp>=0&&temp<10)
     
520.         {
     
521.           temp=temp-2;
     
522.         }
     
523. }
     
524. void xtimer1() interrupt 1
     
525. {                       
     
526.         TH0=(65535-50000)/256;
     
527.         TL0=(65535-50000)%256;
     
528.         tt++;
     
529. }

复制代码