找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 3520|回复: 1
打印 上一主题 下一主题
收起左侧

带人行横道和行人的单片机六车道交通灯Proteus仿真源程序 注释很详细

[复制链接]
跳转到指定楼层
楼主
一个非常牛逼的51单片机交通灯仿真原理图如下(proteus仿真工程文件可到本帖附件中下载)


双向六车道模拟,人行横道也有倒计时:


人行横道:


SN方向急车通行按键(例如120)
EW方向急车通行按键(例如119)
系统控制开关,闭合系统停止工作,断开系统继续工作

1、系统上电工作时,SN方向绿灯亮,进入SN通车模式,通车时间40S,SN人行道开通,EW方向红灯亮,禁止通行,
2、SN方向倒计时剩5秒时,黄灯闪烁,此时切换到SN左拐模式,左拐灯亮,左拐的维持时间是20S
3、左拐倒计时5秒时,黄灯闪烁,进入EW通车模式,通车时间40S,此时SN人行道绿灯灭,EW绿灯亮,EW人行道灯亮,SN红灯亮,禁止通车
4、EW通车倒计时5秒时,黄灯闪烁,进入左拐模式,左拐灯亮,左拐维持时间20S
5、左拐倒计时5秒时,黄灯闪烁,再次进入SN通车模式,通车时间40S,此时EW人行道绿灯灭,SN绿灯亮,SN人行道灯亮,EW红灯亮,禁止通车
周而复始,维持上面的过程

1、繁忙按键按下时,道路的通行时间得到调整会减少,这样可以增加红绿灯切换的频率,方便通行
2、时间+和时间-分别是增加和减少绿灯开通时间
3、SN急车通行按键第一次按下时,表示有急车通行,无论SN方向的状态如何,都应亮绿灯,EW亮红灯,数字暂停倒数,方便急车通过当SN急车按键第二次按下时,表示急车通过了,此时SN绿灯灭,SN方向的黄灯闪烁,恢复原来的状态
4、EW急车通行按键第一次按下时,表示EW有急车通行,无论EW方向的状态如何,都应亮绿灯,SN亮红灯,数字暂停倒数,方便急车通过当EW急车按键第二次按下时,表示急车通过了,此时EW绿灯灭,EW方向的黄灯闪烁,恢复原来的状态

系统控制开关,闭合系统停止工作,断开系统继续工作

单片机源程序如下,代码也有详细的中文注释:
  1.   /*****************************************************
  2.        十字路口交通灯控制 C 程序

  3. ******************************************************/

  4. #define        uchar        unsigned char
  5. #define        uint        unsigned int
  6. #include        <reg52.h>
  7. /*****定义控制位**********************/
  8. sbit    XIANSHI_SHIJIAN_ZHISHIDENG2=P2^5;
  9. sbit    XIANSHI_SHIJIAN_ZHISHIDENG1=P2^4;
  10. sbit        DONGXI_ZHISHIDENG2=P2^3;        
  11. sbit        DONGXI_ZHISHIDENG1=P2^2;        
  12. sbit        NANBEI_ZHISHIDENG2=P2^1;        
  13. sbit        NANBEI_ZHISHIDENG1=P2^0;        
  14. sbit    NANBEI_HUANGDENG=P1^6;
  15. sbit    DONGXI_HUANGDENG=P1^2;
  16. sbit    DONGXI_HONGDENG=P1^3;
  17. sbit    NANBEI_HONGDENG=P1^7;
  18. sbit    DONGXI_PEOPLE=P3^0;
  19. sbit    NANBEI_PEOPLE=P3^1;
  20. sbit    kongzhi=P2^6;
  21. //sbit    Busy_LED=P2^7;//交通繁忙指示灯
  22. sbit    ZHENGCANG_ANJIAN=P3^5;//交通正常按键
  23. sbit    FANMANG_ANJIAN=P3^6;//交通繁忙按键
  24. sbit    NANBEI_JICHE_ANJIAN=P3^7;//南北方向急车通行按键
  25. sbit    DONGXI_JICHE_ANJIAN=P2^7;//东西方向急车通行按键
  26. sbit    SHIJIAN_JIAJIA=P3^3;//时间加
  27. sbit    SHIJIAN_JIANJIAN=P3^4;//时间减

  28. bit     NANBEI_HUANGDENG_BIAOZHI; //SN黄灯标志位
  29. bit     DONGXI_HUANGDENG_BIAOZHI;//EW黄灯标志位
  30. char        DONGXI_DAOJISHI;//东西方向倒计时单元
  31. char        NANBEI_DAOJISHI;//南北方向倒计时单元
  32. uchar DONGXI=60,NANBEI=40,EWL=19,SNL=19; //程序初始化赋值,正常模式
  33. uchar EW1=60,SN1=40,EWL1=19,SNL1=19;//用于存放修改值的变量
  34. uchar code table[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};//1~~~~9段选码
  35. uchar code S[8]={0X28,0X48,0X18,0X48,0X82,0X84,0X81,0X84};//交通信号灯控制代码
  36. uchar code S1[8]={0X28,0X08,0X82,0X80,0X82,0X84,0X81,0X84};//交通信号灯控制代码
  37. /**********************延时子程序************************/
  38. void        Delay(uchar         a)
  39.         {
  40.                 uchar        i;
  41.                 i=a;
  42.                 while(i--){;}
  43.         }
  44. /*****************显示子函数**************************/
  45. void        Display(void)
  46.         {
  47.                 char h,l;
  48.                 h=DONGXI_DAOJISHI/10;
  49.                 l=DONGXI_DAOJISHI%10;
  50.               P0=table[l];
  51.                 DONGXI_ZHISHIDENG2=1;
  52.                 Delay(2);
  53.                 DONGXI_ZHISHIDENG2=0;
  54.             P0=table[h];
  55.                 DONGXI_ZHISHIDENG1=1;
  56.                 Delay(2);
  57.                 DONGXI_ZHISHIDENG1=0;

  58.                 h=NANBEI_DAOJISHI/10;
  59.                 l=NANBEI_DAOJISHI%10;
  60.                 P0=table[l];
  61.                 NANBEI_ZHISHIDENG2=1;
  62.                 Delay(2);
  63.                 NANBEI_ZHISHIDENG2=0;
  64.             P0=table[h];
  65.                 NANBEI_ZHISHIDENG1=1;
  66.                 Delay(2);
  67.                 NANBEI_ZHISHIDENG1=0;
  68.                

  69.                 h= EW1/10;
  70.                 l= EW1%10;
  71.                 P0=table[l];
  72.                 XIANSHI_SHIJIAN_ZHISHIDENG1=1;
  73.                 Delay(2);
  74.         XIANSHI_SHIJIAN_ZHISHIDENG1=0;
  75.                 P0=table[h];
  76.                 XIANSHI_SHIJIAN_ZHISHIDENG2=1;
  77.                 Delay(2);
  78.             XIANSHI_SHIJIAN_ZHISHIDENG2=0;
  79. }
  80. /**********************外部0中断服务程序************************/

  81. unsigned char FastCar_Flag_SN=0;
  82. unsigned char FastCar_Flag_EW=0;
  83. unsigned char Start_Flag=0;
  84. void        EXINT0(void)interrupt 0 using 1
  85.         {
  86.                 EX0=0; //关中断

  87. if(SHIJIAN_JIAJIA==0) //时间加
  88.        {
  89.             EW1+=5;
  90.             SN1+=5;
  91.               if(EW1>=100)
  92.                            {
  93.                              EW1=99;
  94.                              SN1=79;
  95.                }
  96.             }
  97. if(SHIJIAN_JIANJIAN==0) //时间减
  98.        {
  99.             EW1-=5;
  100.             SN1-=5;
  101.             if(EW1<=40)
  102.               {
  103.                              EW1=40;
  104.                  SN1=20;
  105.                }
  106.                                 
  107.                     }

  108. if(ZHENGCANG_ANJIAN==0)//测试按键是否按下,按下为正常状态
  109.         {
  110.             EW1=60;
  111.             SN1=40;
  112.                         EWL1=19;
  113.                         SNL1=19;
  114. //                        Busy_LED=0;//关繁忙信号灯
  115. //                        Special_LED =0;//关特殊信号灯
  116.             }
  117. if(FANMANG_ANJIAN==0) //测试按键是否按下,按下为繁忙状态
  118.         {
  119.                     EW1=45;
  120.             SN1=30;
  121.                         EWL1=14;
  122.                         SNL1=14;
  123. //                        Special_LED=0;//关特殊信号灯
  124. //                        Busy_LED=1;//开繁忙信号灯               
  125.         }

  126. if(NANBEI_JICHE_ANJIAN==0)//测试按键是否按下,按下为南北方向急车通行特殊状态
  127.         {
  128.                     FastCar_Flag_SN++;
  129.                         if(FastCar_Flag_SN==1)        //南北方向有急车通行
  130.                                 {
  131.                                     Start_Flag=1;
  132.                                         ET0=0;             //关闭定时器
  133.                                        
  134.                                 }
  135.                         else if(FastCar_Flag_SN==2)
  136.                         {
  137.                            FastCar_Flag_SN=0;
  138.                            Start_Flag=0;
  139.                            ET0=1;
  140.                         }                                      
  141.             }
  142.                
  143. if(DONGXI_JICHE_ANJIAN==0)//测试按键是否按下,按下为特殊状态
  144.         {

  145.                     FastCar_Flag_EW++;
  146.                         if(FastCar_Flag_EW==1)        //南北方向有急车通行
  147.                                 {
  148.                                     Start_Flag=1;
  149.                                         ET0=0;             //关闭定时器
  150.                                        
  151.                                 }
  152.                    else if(FastCar_Flag_EW==2)
  153.                         {
  154.                            FastCar_Flag_EW=0;
  155.                            Start_Flag=0;
  156.                            ET0=1;
  157.                         }
  158.                                       
  159.             }                                                                        
  160.                 EX0=1;//开中断
  161.         }
  162. /**********************T0中断服务程序*******************/

  163. char TIME_YELLOW_COUNT=3;
  164. char SN_YELLOW_COUNT_Flag=0;
  165. char EW_YELLOW_COUNT_Flag=0;
  166. void timer0(void)interrupt 1 using 1
  167. {
  168.         static uchar count;
  169.         TH0=(65536-50000)/256;
  170.         TL0=(65536-50000)%256;
  171.         count++;
  172.                 if(kongzhi==0)
  173.                         {
  174.                                 while(1)
  175.                                 {
  176.                                         EA=0;
  177.                                         if(kongzhi==1)
  178.                                         {
  179.                                                 EA=1;
  180.                                                 break;
  181.                                         }
  182.                                        
  183.                                        
  184.                                 }
  185.                         }
  186.         if(count==10)
  187.         {
  188.           if(NANBEI_HUANGDENG_BIAOZHI==1) //测试南北黄灯标志位
  189.           NANBEI_HUANGDENG=~NANBEI_HUANGDENG;

  190.           if(DONGXI_HUANGDENG_BIAOZHI==1)  //测试东西黄灯标志位
  191.           DONGXI_HUANGDENG=~DONGXI_HUANGDENG;
  192.    
  193.          

  194.         }
  195.         if(count==20)
  196.         {
  197.         DONGXI_DAOJISHI--;
  198.         NANBEI_DAOJISHI--;
  199.         TIME_YELLOW_COUNT--;
  200.         if(NANBEI_HUANGDENG_BIAOZHI==1)//测试南北黄灯标志位
  201.             {NANBEI_HUANGDENG=~NANBEI_HUANGDENG;}
  202.         if(DONGXI_HUANGDENG_BIAOZHI==1)//测试东西黄灯标志位
  203.             {DONGXI_HUANGDENG=~DONGXI_HUANGDENG;}

  204.         count=0;
  205.         }
  206.         
  207. }
  208. /*********************主程序开始**********************/

  209. void        main(void)

  210. {
  211. //        Busy_LED=0;
  212. //        Special_LED=0;
  213.         IT0=1;        //INT0负跳变触发        
  214.     TMOD=0x01;//定时器工作于方式1
  215.         TH0=(65536-50000)/256;//定时器赋初值
  216.         TL0=(65536-50000)%256;
  217.         EA=1; //CPU开中断总允许
  218.         ET0=1;//开定时中断
  219.         EX0=1;//开外部INTO中断
  220.     TR0=1;//启动定时
  221.          
  222. while(1)
  223. {                                
  224.                 if(Start_Flag==0)
  225.                 {        

  226.          
  227.                                 /*******S0状态**********/
  228.                                 DONGXI_PEOPLE=0;        //EW人行道禁止
  229.                     NANBEI_PEOPLE=1;//SN人行道通行
  230.                 DONGXI_HUANGDENG_BIAOZHI=0;           //EW关黄灯显示信号
  231.                                 DONGXI_DAOJISHI=DONGXI;        
  232.                                 NANBEI_DAOJISHI=NANBEI;        
  233.                                  
  234.                                 while(NANBEI_DAOJISHI>=5)
  235.                             {
  236.                                 
  237.                                 if(Start_Flag==1&&FastCar_Flag_SN==1)                            //SN急车通行后会置Start_Flag为1 ,用来判断是否急车通过
  238.                                 {
  239.                                   TIME_YELLOW_COUNT=3;                   //给急车过后的黄灯闪时间置3秒
  240.                                   P1=S1[0];                                            //SN通行,EW红灯
  241.                                   SN_YELLOW_COUNT_Flag=1;    //黄灯闪标志
  242.                                   Display();                                   //显示当前时间
  243.                                 }
  244.                            else if(Start_Flag==1&&FastCar_Flag_EW==1)                   //EW急车通行后会置Start_Flag为1 ,用来判断是否急车通过
  245.                                 {
  246.                                   TIME_YELLOW_COUNT=3;                   //给急车过后的绿灯闪时间置3秒
  247.                                   P1=S1[2];                                            //EW通行,SN红灯
  248.                                   EW_YELLOW_COUNT_Flag=1;    //黄灯闪标志
  249.                                   Display();                                   //显示当前时间
  250.                                 }

  251.                 if(Start_Flag==0)
  252.                                 {
  253.                                         if( SN_YELLOW_COUNT_Flag==1)  //SN急车过后开始闪SN黄灯
  254.                                         {
  255.                                            P1=S1[1];                                     //SN灯全灭,EW红灯
  256.                                          while(TIME_YELLOW_COUNT>=0)   //黄灯闪的时间是3秒
  257.                                                  {
  258.                                                   NANBEI_HUANGDENG_BIAOZHI=1;               //SN开黄灯信号位
  259.                                                   Display();                          //开始显示当前数字
  260.                                                  }
  261.                                             SN_YELLOW_COUNT_Flag=0;        //关急车通行黄灯闪标志
  262.                                             NANBEI_HUANGDENG_BIAOZHI=0;               //SN关黄灯信号位
  263.                                         }

  264.                                     else if(EW_YELLOW_COUNT_Flag==1) //EW急车过后开始闪EW黄灯
  265.                                         {
  266.                                              P1=S1[3];                                     //EW灯全灭,SN红灯
  267.                                             while(TIME_YELLOW_COUNT>=0)   //黄灯闪的时间是3秒
  268.                                                  {
  269.                                                   DONGXI_HUANGDENG_BIAOZHI=1;               //EW开黄灯信号位
  270.                                                   Display();                          //开始显示当前数字
  271.                                                  }
  272.                                             EW_YELLOW_COUNT_Flag=0;        //关急车通行黄灯闪标志
  273.                                             DONGXI_HUANGDENG_BIAOZHI=0;               //EW关黄灯信号位
  274.                                        
  275.                                        
  276.                                         }
  277.                                          P1=S[0];                                                 //恢复初始状态
  278.                                  Display();
  279.                                  }


  280.                                  }     //SN黄灯亮,等待左拐信号,EW红灯                        


  281.                                 /*******S1状态**********/
  282.                             P1=0x00;
  283.                                 while(NANBEI_DAOJISHI>=0)
  284.                            {
  285.                             NANBEI_HUANGDENG_BIAOZHI=1;         //SN开黄灯信号位
  286.                             DONGXI_HONGDENG=1;      //SN黄灯亮,等待左拐信号,EW红灯         
  287.                             Display();
  288.                                 }
  289.                                   DONGXI_PEOPLE=0;        //EW人行道禁止
  290.                     NANBEI_PEOPLE=0;//SN人行道通行
  291.                                 /*******S2状态**********/
  292.                             NANBEI_HUANGDENG_BIAOZHI=0; //SN关黄灯显示信号
  293.                                 NANBEI_DAOJISHI=SNL;
  294.                                 while(NANBEI_DAOJISHI>=5)
  295.                                 {

  296.                                 if(Start_Flag==1&&FastCar_Flag_SN==1)                            //SN急车通行后会置Start_Flag为1 ,用来判断是否急车通过
  297.                                 {
  298.                                   TIME_YELLOW_COUNT=3;                   //给急车过后的黄灯闪时间置3秒
  299.                                   P1=S1[0];                                            //SN通行,EW红灯
  300.                                   SN_YELLOW_COUNT_Flag=1;    //黄灯闪标志
  301.                                   Display();                                   //显示当前时间
  302.                                 }
  303.                            else if(Start_Flag==1&&FastCar_Flag_EW==1)                   //EW急车通行后会置Start_Flag为1 ,用来判断是否急车通过
  304.                                 {
  305.                                   TIME_YELLOW_COUNT=3;                   //给急车过后的绿灯闪时间置3秒
  306.                                   P1=S1[2];                                            //EW通行,SN红灯
  307.                                   EW_YELLOW_COUNT_Flag=1;    //黄灯闪标志
  308.                                   Display();                                   //显示当前时间
  309.                                 }

  310.                 if(Start_Flag==0)
  311.                                 {
  312.                                         if( SN_YELLOW_COUNT_Flag==1)  //SN急车过后开始闪SN黄灯
  313.                                         {
  314.                                            P1=S1[1];                                     //SN灯全灭,EW红灯
  315.                                          while(TIME_YELLOW_COUNT>=0)   //黄灯闪的时间是3秒
  316.                                                  {
  317.                                                   NANBEI_HUANGDENG_BIAOZHI=1;               //SN开黄灯信号位
  318.                                                   Display();                          //开始显示当前数字
  319.                                                  }
  320.                                             SN_YELLOW_COUNT_Flag=0;        //关急车通行黄灯闪标志
  321.                                             NANBEI_HUANGDENG_BIAOZHI=0;               //SN关黄灯信号位
  322.                                         }

  323.                                     else if(EW_YELLOW_COUNT_Flag==1) //EW急车过后开始闪EW黄灯
  324.                                         {
  325.                                              P1=S1[3];                                     //EW灯全灭,SN红灯
  326.                                             while(TIME_YELLOW_COUNT>=0)   //黄灯闪的时间是3秒
  327.                                                  {
  328.                                                   DONGXI_HUANGDENG_BIAOZHI=1;               //EW开黄灯信号位
  329.                                                   Display();                          //开始显示当前数字
  330.                                                  }
  331.                                             EW_YELLOW_COUNT_Flag=0;        //关急车通行黄灯闪标志
  332.                                             DONGXI_HUANGDENG_BIAOZHI=0;               //EW关黄灯信号位
  333.                                        
  334.                                        
  335.                                         }
  336.                                          P1=S[2];//SN左拐绿灯亮,EW红灯
  337.                                          Display();
  338.                                  }
  339.                                           
  340.                                           
  341.                                 
  342.                                  }

  343.                           /*******S3状态**********/
  344.                                 P1=0x00;
  345.                                 while(NANBEI_DAOJISHI>=0)
  346.                            {
  347.                             NANBEI_HUANGDENG_BIAOZHI=1;        //SN开黄灯信号位
  348.                             DONGXI_HONGDENG=1;      //SN黄灯亮,等待停止信号,EW红灯
  349.                                    
  350.                             Display();}


  351.                            /***********赋值**********/
  352.                                 DONGXI=EW1;
  353.                                 NANBEI=SN1;
  354.                                 EWL=EWL1;
  355.                                 SNL=SNL1;


  356.                                 /*******S4状态**********/
  357.                                 DONGXI_PEOPLE=1;        //EW人行道禁止
  358.                     NANBEI_PEOPLE=0;//SN人行道通行
  359.                             NANBEI_HUANGDENG_BIAOZHI=0;  //SN关黄灯显示信号
  360.                                 DONGXI_DAOJISHI=NANBEI;
  361.                                 NANBEI_DAOJISHI=DONGXI;
  362.                             while(DONGXI_DAOJISHI>=5)
  363.                             {
  364.                                          if(Start_Flag==1&&FastCar_Flag_SN==1)                            //SN急车通行后会置Start_Flag为1 ,用来判断是否急车通过
  365.                                         {
  366.                                           TIME_YELLOW_COUNT=3;                   //给急车过后的黄灯闪时间置3秒
  367.                                           P1=S1[0];                                            //SN通行,EW红灯
  368.                                           SN_YELLOW_COUNT_Flag=1;    //黄灯闪标志
  369.                                           Display();                                   //显示当前时间
  370.                                         }
  371.                                    else if(Start_Flag==1&&FastCar_Flag_EW==1)                   //EW急车通行后会置Start_Flag为1 ,用来判断是否急车通过
  372.                                         {
  373.                                           TIME_YELLOW_COUNT=3;                   //给急车过后的绿灯闪时间置3秒
  374.                                           P1=S1[2];                                            //EW通行,SN红灯
  375.                                           EW_YELLOW_COUNT_Flag=1;    //黄灯闪标志
  376.                                           Display();                                   //显示当前时间
  377.                                         }
  378.         
  379.                         if(Start_Flag==0)
  380.                                         {
  381.                                                 if( SN_YELLOW_COUNT_Flag==1)  //SN急车过后开始闪SN黄灯
  382.                                                 {
  383.                                                    P1=S1[1];                                     //SN灯全灭,EW红灯
  384.                                                  while(TIME_YELLOW_COUNT>=0)   //黄灯闪的时间是3秒
  385.                                                          {
  386.                                                          NANBEI_HUANGDENG_BIAOZHI=1;               //SN开黄灯信号位
  387.                                                           Display();                          //开始显示当前数字
  388.                                                          }
  389.                                                     SN_YELLOW_COUNT_Flag=0;        //关急车通行黄灯闪标志
  390.                                                     NANBEI_HUANGDENG_BIAOZHI=0;               //SN关黄灯信号位
  391.                                                 }
  392.         
  393.                                             else if(EW_YELLOW_COUNT_Flag==1) //EW急车过后开始闪EW黄灯
  394.                                                 {
  395.                                                      P1=S1[3];                                     //EW灯全灭,SN红灯
  396.                                                     while(TIME_YELLOW_COUNT>=0)   //黄灯闪的时间是3秒
  397.                                                          {
  398.                                                           DONGXI_HUANGDENG_BIAOZHI=1;               //EW开黄灯信号位
  399.                                                           Display();                          //开始显示当前数字
  400.                                                          }
  401.                                                     EW_YELLOW_COUNT_Flag=0;        //关急车通行黄灯闪标志
  402.                                                     DONGXI_HUANGDENG_BIAOZHI=0;               //EW关黄灯信号位        
  403.                                                 
  404.                                                 }
  405.                                                 P1=S[4];                               //恢复EW通行,SN红灯
  406.                                                  Display();
  407.                                          }
  408.         
  409.                                 
  410.                                  }
  411.                                 /*******S5状态**********/
  412.                                 P1=0X00;
  413.                                 while(DONGXI_DAOJISHI>=0)
  414.                            {
  415.                             DONGXI_HUANGDENG_BIAOZHI=1;//EW开黄灯信号位
  416.                             NANBEI_HONGDENG=1;//EW黄灯亮,等待左拐信号,SN红灯        
  417.                             Display();}

  418.                                 /*******S6状态**********/
  419.                                 DONGXI_PEOPLE=0;        //EW人行道禁止
  420.                     NANBEI_PEOPLE=0;//SN人行道通行
  421.                                 DONGXI_HUANGDENG_BIAOZHI=0;            //EW关黄灯显示信号
  422.                                 DONGXI_DAOJISHI=EWL;
  423.                                 while(DONGXI_DAOJISHI>=5)
  424.                                 {
  425.                                 if(Start_Flag==1&&FastCar_Flag_SN==1)                            //SN急车通行后会置Start_Flag为1 ,用来判断是否急车通过
  426.                                 {
  427.                                   TIME_YELLOW_COUNT=3;                   //给急车过后的黄灯闪时间置3秒
  428.                                   P1=S1[0];                                            //SN通行,EW红灯
  429.                                   SN_YELLOW_COUNT_Flag=1;    //黄灯闪标志
  430.                                   Display();                                   //显示当前时间
  431.                                 }
  432.                            else if(Start_Flag==1&&FastCar_Flag_EW==1)                   //EW急车通行后会置Start_Flag为1 ,用来判断是否急车通过
  433.                                 {
  434.                                   TIME_YELLOW_COUNT=3;                   //给急车过后的绿灯闪时间置3秒
  435.                                   P1=S1[2];                                            //EW通行,SN红灯
  436.                                   EW_YELLOW_COUNT_Flag=1;    //黄灯闪标志
  437.                                   Display();                                   //显示当前时间
  438.                                 }

  439.                 if(Start_Flag==0)
  440.                                 {
  441.                                         if( SN_YELLOW_COUNT_Flag==1)  //SN急车过后开始闪SN黄灯
  442.                                         {
  443.                                            P1=S1[1];                                     //SN灯全灭,EW红灯
  444.                                          while(TIME_YELLOW_COUNT>=0)   //黄灯闪的时间是3秒
  445.                                                  {
  446.                                                   NANBEI_HUANGDENG_BIAOZHI=1;               //SN开黄灯信号位
  447.                                                   Display();                          //开始显示当前数字
  448.                                                  }
  449.                                             SN_YELLOW_COUNT_Flag=0;        //关急车通行黄灯闪标志
  450.                                             NANBEI_HUANGDENG_BIAOZHI=0;               //SN关黄灯信号位
  451.                                         }

  452.                                     else if(EW_YELLOW_COUNT_Flag==1) //EW急车过后开始闪EW黄灯
  453.                                         {
  454.                                              P1=S1[3];                                     //EW灯全灭,SN红灯
  455.                                             while(TIME_YELLOW_COUNT>=0)   //黄灯闪的时间是3秒
  456.                                                  {
  457.                                                   DONGXI_HUANGDENG_BIAOZHI=1;               //EW开黄灯信号位
  458.                                                   Display();                          //开始显示当前数字
  459.                                                  }
  460.                                             EW_YELLOW_COUNT_Flag=0;        //关急车通行黄灯闪标志
  461.                                             DONGXI_HUANGDENG_BIAOZHI=0;               //EW关黄灯信号位
  462.                                        
  463.                                        
  464.                                         }
  465.                                     P1=S[6];//EW左拐绿灯亮,SN红灯
  466.                                     Display();
  467.                                         }

  468.                                 }
  469.                                  

  470.                                 /*******S7状态**********/
  471.                                 P1=0X00;
  472.                                 while(DONGXI_DAOJISHI>=0)
  473.                            {
  474.                             DONGXI_HUANGDENG_BIAOZHI=1; //EN开黄灯信号位
  475.                             NANBEI_HONGDENG=1;//EW黄灯亮,等待停止信号,SN红灯        
  476.                             Display();}
  477.                         
  478.                                     /***********赋值**********/
  479.                             DONGXI=EW1;
  480.                                 NANBEI=SN1;
  481.                                 EWL=EWL1;
  482.                                 SNL=SNL1;
  483.            
  484.          
  485.                         }
  486.                 }
  487.         }
复制代码

所有资料51hei提供下载:
交通灯电路.zip (386.5 KB, 下载次数: 99)

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏4 分享淘帖 顶 踩
回复

使用道具 举报

沙发
ID:798125 发表于 2020-7-6 08:10 | 只看该作者
仿真图上那些白色的人行横道是怎么画的呀?
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表