交通灯系统 原理图，PCB(AD格式)单片机程序都有

51单片机左的交通灯控制系统 原理图，PCB，程序都有.

交通灯的原理图（ad画的 需要用ad打开，里面也有pdf版本）

交通灯的pcb图（有2个版本）：


交通灯的单片机源程序：

1. #include<reg52.h>
   
2. #define uchar unsigned char
   
3. #define uint unsigned int
   
4. sbit dongxi_red=P1^3;                                        //东西方向红灯定义
   
5. sbit dongxi_yellow=P3^6;                                //东西方向黄灯定义
   
6. sbit dongxi_green=P3^7;                                        //东西方向绿灯定义
   
7. sbit nanbei_red=P1^2;                                        //南北方向红灯定义
   
8. sbit nanbei_yellow=P1^1;                                //南北方向黄灯定义
   
9. sbit nanbei_green=P1^0;                                        //南北方向绿灯定义
   
10. uchar tab[]={0xbf,0x7f,0xef,0xdf};                //数码管位选
    
11. uchar IRtime;                                                        //红外解码时间次数
    
12. uchar IRbyte[4];                                                //红外一字节
    
13. uchar IRdate[33];                                                //红外数据码，用户码，停止码共33位
    
14. uchar IRbyte_ok,IRdate_ok;                                //接收一字节完成标志位，解码完成标志位
    
15. 
    
16. bit flag=0;
    
17. uchar num=45,num1=40,shi,ge,shi1,ge1,i;
    
18. uchar table[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};//共阴数码管段选
    
19. 
    
20. void delay(uchar z)                                //延时
    
21. {
    
22.         uchar k,l;
    
23.         for(k=0;k<110;k++)
    
24.                 for(l=0;l<z;l++);
    
25. }
    
26. 
    
27. void dongxi__red()           //东西方向红灯亮，黄绿灯都灭，南北方向绿灯亮，红黄灯灭
    
28. {
    
29.         dongxi_red=0;
    
30.         dongxi_yellow=1;
    
31.         dongxi_green=1;
    
32.         nanbei_red=1;
    
33.         nanbei_yellow=1;
    
34.         nanbei_green=0;
    
35. }
    
36. 
    
37. void nanbei__yellow()  //东西方向红灯亮，黄绿灯都灭，南北方向黄灯亮，红绿灯灭
    
38. {
    
39.         dongxi_red=0;
    
40.         dongxi_yellow=1;
    
41.         dongxi_green=1;
    
42.         nanbei_red=1;
    
43.         nanbei_yellow=0;
    
44.         nanbei_green=1;
    
45. }
    
46. 
    
47. void nanbei__red()          //南北方向红灯亮，黄绿灯都灭，东西方向绿灯亮，红黄灯灭
    
48. {
    
49.         dongxi_red=1;
    
50.         dongxi_yellow=1;
    
51.         dongxi_green=0;
    
52.         nanbei_red=0;
    
53.         nanbei_yellow=1;
    
54.         nanbei_green=1;
    
55. }
    
56. 
    
57. void dongxi__yellow()  //南北方向红灯亮，黄绿灯都灭，东西方向黄灯亮，红绿灯灭
    
58. {
    
59.         dongxi_red=1;
    
60.         dongxi_yellow=0;
    
61.         dongxi_green=1;
    
62.         nanbei_red=0;
    
63.         nanbei_yellow=1;
    
64.         nanbei_green=1;
    
65. }
    
66. 
    
67. void number(uchar num,num1)                   //两个数码管分别求个位和十位
    
68. {
    
69.         shi=num/10;
    
70.         ge=num%10;
    
71.         shi1=num1/10;
    
72.         ge1=num1%10;
    
73. }
    
74. 
    
75. void display(uchar shi,ge)                  //数码管显示
    
76. {
    
77.         P2=tab[1];
    
78.         P0=0x00;
    
79.         P0=table[shi];
    
80.         delay(5);
    
81. 
    
82.         P2=tab[0];
    
83.         P0=0x00;
    
84.         P0=table[ge];
    
85.         delay(5);
    
86. }
    
87. 
    
88. void display1(uchar shi1,ge1)         //数码管显示
    
89. {
    
90.         P2=tab[3];
    
91.         P0=0x00;
    
92.         P0=table[shi1];
    
93.         delay(5);
    
94. 
    
95.         P2=tab[2];
    
96.         P0=0x00;
    
97.         P0=table[ge1];
    
98.         delay(5);
    
99. }
    
100. 
     
101. void start()                           //定时器0、1，外中断0初始化
     
102. {
     
103.         EA=1;
     
104.         EX0=1;
     
105.         EX1=1;
     
106.         IT0=1;
     
107.         IT1=1;
     
108.         ET0=ET1=1;
     
109.         TMOD=0X21;                 
     
110.         TH1=0X00;
     
111.         TL1=0X00;
     
112.         TH0=(65536-50000)/256;
     
113.         TL0=(65536-50000)%256;
     
114.         TR0=TR1=1;
     
115. }
     
116. 
     
117. void first()                                //一开始东西方向亮红灯45秒，南北绿灯40秒
     
118. {
     
119.         if(num>5)
     
120.                 {
     
121.                         dongxi__red();
     
122.                         number(num,num1);
     
123.                         display(shi,ge);
     
124.                         display1(shi1,ge1);
     
125.                 }
     
126.                 if(num<=5)                        //南北绿灯亮完了亮黄灯5秒
     
127.                 {
     
128.                         nanbei__yellow();
     
129.                         number(num,num1);
     
130.                         display(shi,ge);
     
131.                         display1(shi1,ge1);
     
132.                         if(num==0){num=45;num1=40;flag=1;}
     
133.                 }
     
134. }
     
135. 
     
136. void second()                                //南北红灯45秒，东西绿灯40秒
     
137. {
     
138.         if(num>5)
     
139.                 {
     
140.                         nanbei__red();
     
141.                         number(num1,num);
     
142.                         display(shi,ge);
     
143.                         display1(shi1,ge1);
     
144.                 }
     
145.                         if(num<=5)                //东西绿灯结束，亮黄灯5秒
     
146.                         {
     
147.                                 dongxi__yellow();
     
148.                                 number(num1,num);
     
149.                                 display(shi,ge);
     
150.                                 display1(shi1,ge1);
     
151.                                 if(num==0){num=45;num1=40;flag=0;}
     
152.                         }                        
     
153. }
     
154. 
     
155. void all_red()                           //双向禁行，亮红灯，数码管关闭
     
156. {
     
157.         dongxi_red=0;
     
158.         dongxi_yellow=1;
     
159.         dongxi_green=1;
     
160.         nanbei_red=0;
     
161.         nanbei_yellow=1;
     
162.         nanbei_green=1;
     
163.         P2=0x00;
     
164.         P0=0x00;
     
165. }
     
166. 
     
167. void nanbei_all_red()           //南北方向禁行，亮红灯数码管关闭，东西方向正常工作
     
168. {
     
169.         for(num=45;num>0;)
     
170.         {
     
171.                 dongxi_red=0;
     
172.                 dongxi_yellow=1;
     
173.                 dongxi_green=1;
     
174.                 nanbei_red=0;
     
175.                 nanbei_yellow=1;
     
176.                 nanbei_green=1;
     
177.                 number(num,num1);
     
178.                 display(shi,ge);
     
179.         }
     
180.         for(num=40;num>0;)
     
181.         {
     
182.                 nanbei__red();
     
183.                 number(num,num1);
     
184.                 display(shi,ge);
     
185.         }
     
186.         for(num=5;num>0;)
     
187.         {
     
188.                 dongxi__yellow();
     
189.                 number(num,num1);
     
190.                 display(shi,ge);
     
191.         }
     
192.         
     
193. }
     
194. 
     
195. void dongxi_all_red()                 //东西方向禁行，亮红灯数码管关闭，南北方向正常工作
     
196. {
     
197.         for(num=45;num>0;)
     
198.         {
     
199.                 dongxi_red=0;
     
200.                 dongxi_yellow=1;
     
201.                 dongxi_green=1;
     
202.                 nanbei_red=0;
     
203.                 nanbei_yellow=1;
     
204.                 nanbei_green=1;
     
205.                 number(num,num1);
     
206.                 display1(shi,ge);
     
207.         }
     
208.         for(num=40;num>0;)
     
209.         {
     
210.                 dongxi__red();
     
211.                 number(num,num1);
     
212.                 display1(shi,ge);
     
213.         }
     
214.         for(num=5;num>0;)
     
215.         {
     
216.                 nanbei__yellow();
     
217.                 number(num,num1);
     
218.                 display1(shi,ge);
     
219.         }
     
220.         
     
221. }
     
222. 
     
223.                                                                   
     
224. void jiema()                          //红外解码
     
225. {
     
226.         uchar i,j,k=1;
     
227.         for(i=0;i<4;i++)
     
228.         {
     
229.                 for(j=0;j<8;j++)
     
230.                 {
     
231.                         if(IRdate[k]>5)
     
232.                                 IRbyte[i] |=0x80;
     
233.                         if(j<7)
     
234.                                 IRbyte[i]>>=1;
     
235.                         k++;
     
236.                 }
     
237.         }
     
238.         IRbyte_ok=1;
     
239. }
     
240. 
     
241. void display2()                         //比对收到的信号
     
242. {
     
243.         switch(IRbyte[2])         
     
244.         {
     
245.                 case 0x45 :while(1) all_red();                 //按下该键两个方向都持续亮红灯
     
246.             case 0x46 :while(1) dongxi_all_red();          //按下该键东西方向持续亮红灯
     
247.             case 0x47 :while(1) nanbei_all_red();           //按下该键南北方向持续亮红灯
     
248.         }  
     
249. }
     
250. 
     
251. 
     
252. void main()
     
253. {
     
254.         start();                          //初始化
     
255.         while(1)
     
256.         {        
     
257.                 if(!flag)
     
258.                 first();
     
259.                 if(flag)
     
260.                 second();
     
261.                 if(IRdate_ok)                          //红外接收完成
     
262.                 {
     
263.                         jiema();                           //解码
     
264.                         IRdate_ok=0;                   //标志位清零
     
265.                         if(IRbyte_ok)                   //如果解码完成，做相关指令
     
266.                         {
     
267.                                 display2();
     
268.                                 IRbyte_ok=0;            //解码完成标志清零
     
269.                         }
     
270.                 }
     
271.         }
     
272. }
     
273. 
     
274. void ex0() interrupt 0                           //外中断0用来接收红外脉冲
     
275. {
     
276.         static uchar i;                                   //静态变量i
     
277.         static bit flag;
     
278.         if(flag)                                           //如果flag为1执行一下操作
     
279.         {                                 
     
280.                 if((IRtime<53)&&(IRtime>=32))        //IRtime在此范围内说明接收到红外起始信号           
     
281.                 i=0;
     
282.                 IRdate[i]=IRtime;                                //将IRtime的值保存到数组中
     
283.                 IRtime=0;
     
284.                 i++;
     
285.                 if(i==33)                                                //如果i=33接收到停止位
     
286.                 {
     
287.                         i=0;
     
288.                         IRdate_ok=1;
     
289.                 }
     
290.         }
     
291.         else                                                                //flag不为1时执行
     
292.         {
     
293.                 IRtime=0;                                                //IRtime数值清零
     
294.                 flag=1;                                                        //flag置1
     
295.         }
     
296. }
     
297. 
     
298. void et0() interrupt 1                                        //定时器0用来控制交通灯的时间
     
299. {
     
300.         TH0=(65536-50000)/256;                                //重装初值
     
301.         TL0=(65536-50000)%256;
     
302.         i++;
     
303.         if(i==20)
     
304.         {
     
305.                 i=0;
     
306.                 num--;
     
307.                 num1--;
     
308.                 if(num1==0)
     
309.                 num1=5;
     
310.         }
     
311. }
     
312. 
     
313. 
     
314. void time0() interrupt 3                                //定时器1用来计算收到的红外脉宽
     
315. 
     
316. …………余下代码请下载附件…………
     

复制代码

交通灯源码和pcb原理图资料下载：http://www.51hei.com/bbs/dpj-54314-1.html