找回密码
 立即注册

QQ登录

只需一步,快速开始

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

51单片机交通灯设计

[复制链接]
跳转到指定楼层
楼主
51单片机交通灯设计
功能:有数码管倒计时计数,有独立按键可调交通灯


单片机源程序如下:
  1. #include <reg52.h>                 //调用单片机头文件
  2. #define uchar unsigned char   //宏定义"uchar"代替"unsigned char"。
  3. #define uint  unsigned int          //宏定义"uint"用来定义无符号整型数。

  4. ////数码管段选定义  0   1    2    3    4    5         6         7          8           9       
  5. uchar smg_du[]={0x6f,0x03,0x3d,0x4b,0x53,0x75,0x7e,0x28,0x7f,0x7b,
  6. //                                           A        B         C          D           E   F        不显示
  7.                                   0x77,0x5e,0x4a,0x05,0x0a,0x2a,0xff};         //断码

  8. uchar dis_smg[8] = {0};       
  9. uchar smg_i = 4;    //显示数码管的个位数

  10. //数码管位选定义
  11. sbit smg_we1 = P2^1; //数码管位选定义
  12. sbit smg_we2 = P2^0;
  13. sbit smg_we3 = P3^6;
  14. sbit smg_we4 = P3^7;

  15. uint dx_zong   = 0;
  16. uint nb_zong   = 0;

  17. int dx_s = 0,nb_s = 0;        //东西  南北 倒计时变量

  18. sbit dx_red    = P2^7;            //东西红灯
  19. sbit dx_yellow = P2^6;                //东西黄灯
  20. sbit dx_green  = P2^5;                //东西绿灯

  21. sbit nb_red    = P2^4;                //南北红灯
  22. sbit nb_yellow = P2^3;                //南北黄灯       
  23. sbit nb_green  = P2^2;                //南北绿灯

  24. sbit nb_green_ll  = P1^6;                //南北左转绿灯
  25. sbit dx_green_ll  = P1^7;                //东西左转绿灯

  26. sbit dx_h_red = P3^5;        //东西人行横道红灯
  27. sbit dx_h_green = P3^4;      //东西人行横道红灯
  28. sbit nb_h_red = P3^2;        //南北人行横道红灯
  29. sbit nb_h_green = P3^3;      //南北人行横道红灯

  30. uint nb_che_value;
  31. uint dx_che_value;

  32. uchar flag_jtd_mode;  //交通灯的模式 根据时间
  33. bit flag_1s = 0;
  34. bit flag_500ms;
  35. bit flag_dx_nb = 0;                 //东西南北模式
  36. uchar flag_5m_value;
  37. uchar i;
  38. uchar dx_time = 30,nb_time = 20;   //东西、南北的时间
  39. uchar nb_time_ll = 20,dx_time_ll = 20;   //东西、南北左转的时间

  40. uchar yellow_time = 5;
  41. uchar flag_jdgz ;     //交通管制

  42. uchar nb_ll,dx_ll;   //南北 东西加的时间

  43. /***********************数码位选函数*****************************/
  44. void smg_we_switch(uchar i)
  45. {
  46.         switch(i)
  47.         {
  48.                 case 0: smg_we1 = 0;  smg_we2 = 1; smg_we3 = 1;  smg_we4 = 1; break;
  49.                 case 1: smg_we1 = 1;  smg_we2 = 1; smg_we3 = 0;  smg_we4 = 1; break;
  50.                 case 2: smg_we1 = 1;  smg_we2 = 0; smg_we3 = 1;  smg_we4 = 1; break;
  51.                 case 3: smg_we1 = 1;  smg_we2 = 1; smg_we3 = 1;  smg_we4 = 0; break;
  52.         }       
  53. }

  54. /********************************************************************
  55. * 名称 : delay_1ms()
  56. * 功能 : 延时1ms函数
  57. * 输入 : q
  58. * 输出 : 无
  59. ***********************************************************************/
  60. void delay_1ms(uint q)
  61. {
  62.         uint i,j;
  63.         for(i=0;i<q;i++)
  64.                 for(j=0;j<110;j++);
  65. }

  66. /********************************************************************
  67. * 名称 : display()
  68. * 功能 : 数码管显示
  69. * 输入 : 无
  70. * 输出 : 无
  71. ***********************************************************************/
  72. void display()
  73. {
  74.         uchar i;
  75.         for(i=0;i<smg_i;i++)
  76.         {               
  77.                 smg_we_switch(i);            //位选
  78.                 P0 = dis_smg[i];          //段选          
  79.         }
  80. }

  81. /*********************定时器0、定时器1初始化******************/
  82. void time0_init()          
  83. {
  84.         EA  = 1;                   //开总中断
  85.         TMOD = 0X11;          //定时器0、定时器1工作方式1
  86.         ET0 = 1;                  //开定时器0中断
  87.         TR0 = 1;                  //允许定时器0定时
  88. }
  89. uchar flag_csf=1;
  90. uchar f_value=0;
  91.        
  92.         /*********************交通灯处理函数*********************************/
  93. void jiaotongdeng_dis()
  94. {
  95. /***********************南北时间*********************************/
  96.                 if(f_value < nb_ll + nb_time)        //南北绿灯时间
  97.                 {
  98.                         if(flag_csf == 1)          //意思是只初始化一次
  99.                         {       
  100.                                 flag_csf = 2;          
  101.                                 dx_zong = dx_s = nb_ll + nb_time_ll + yellow_time; //是显示南北的总时间                                               
  102.                                 nb_s = nb_ll + nb_time;        //给南北倒计时显示初始化值
  103.                         }
  104.                         dx_red    = 0;     
  105.                         dx_green  =        1;//灭
  106.                         dx_yellow = 1;//灭
  107.                         nb_red    = 1;     
  108.                         nb_green  =        0;          
  109.                         nb_yellow = 1;    //灭

  110.        
  111.                         nb_green_ll = 1;
  112.                         dx_green_ll = 1;
  113.                         flag_5m_value = 0;       
  114.                 }
  115.                 else if(f_value < nb_ll + nb_time + yellow_time)                 //当小于5秒时  黄灯要闪了
  116.                 {
  117.                         if(flag_csf == 2)          //意思是只初始化一次
  118.                         {       
  119.                                 flag_csf = 3;       
  120.                                 dx_s = nb_time_ll + 2*yellow_time; //是显示南北的总时间                                               
  121.                                 nb_s = yellow_time;        //给南北倒计时显示初始化值
  122.                         }   
  123.                         dx_red    = 0;     
  124.                         dx_green  =        1;    //灭
  125.                         dx_yellow = 1;    //灭
  126.                         nb_red    = 1;     
  127.                         nb_green  =        1;    //灭
  128.                         if(flag_500ms == 0)           //黄灯闪烁
  129.                         {
  130.                                 nb_yellow = 0;               
  131.                         }
  132.                         else
  133.                         {
  134.                                 nb_yellow = 1;               
  135.                         }
  136.                         dx_h_green = 1;
  137.                         dx_h_red = 0;
  138.                         nb_h_green = 0;
  139.                         nb_h_red = 1;
  140.                 }
  141.                 else if(f_value < nb_ll + nb_time + nb_time_ll)                 //当左转的绿灯闪
  142.                 {
  143.                         if(flag_csf == 3)          //意思是只初始化一次
  144.                         {       
  145.                                 flag_csf = 4;       
  146.                                 dx_s = nb_time_ll + yellow_time; //是显示南北的总时间                                               
  147.                                 nb_s = nb_time_ll;        //给南北倒计时显示初始化值
  148.                         }   
  149.                         dx_red    = 0;     
  150.                         dx_green  =        1;    //灭
  151.                         dx_yellow = 1;    //灭
  152.                         nb_green  =        1;    //灭
  153.                         nb_yellow = 1;    //灭

  154.                         dx_h_green = 1;
  155.                         dx_h_red = 0;
  156.                         nb_h_green = 1;


  157.                 }
  158.                 else if(f_value < nb_ll + nb_time +  nb_time_ll)                 //当小于5秒时  黄灯要闪了
  159.                 {
  160.                         if(flag_csf == 4)          //意思是只初始化一次
  161.                         {       
  162.                                 flag_csf = 1;       
  163.                                 dx_s = nb_s = yellow_time;        //给南北倒计时显示初始化值
  164.                         }   
  165.                         dx_red    = 0;     
  166.                         dx_green  =        1;    //灭
  167.                         dx_yellow = 1;    //灭
  168.                         if(flag_500ms == 0)           //黄灯闪烁
  169.                         {
  170.                                 nb_yellow = 0;               
  171.                         }
  172.                         else
  173.                         {
  174.                                 nb_yellow = 1;    //灭               
  175.                         }
  176.                         dx_h_green = 1;     //灭
  177.                         nb_h_green = 1;     //灭
  178.                         nb_h_red = 0;
  179.                
  180.                         nb_green_ll = 1;    //灭
  181.                         dx_green_ll = 1;    //灭
  182.                 }               

  183. /***********************东西时间*********************************/
  184.                 if(flag_dx_nb == 1)  
  185.                 {
  186.                         if(f_value < dx_ll + dx_time)        //东西绿灯时间
  187.                         {
  188.                                 if(flag_csf == 1)          //意思是只初始化一次
  189.                                 {       
  190.                                         flag_csf = 2;          
  191.                                         nb_zong = nb_s = dx_ll +  dx_time_ll + 2*yellow_time; //是显示南北的总时间                                               
  192.                                         dx_s = dx_ll + dx_time;        //给南北倒计时显示初始化值
  193.                                 }
  194.                                 dx_red    = 1;    //灭   
  195.                                 dx_green  =        0;       
  196.                                 dx_yellow = 1;    //灭       
  197.                                 nb_red    = 0;  
  198.                                 nb_green  =        1;    //灭       
  199.                                 nb_yellow = 1;    //灭       

  200.                                 dx_h_green = 0;
  201.                                 dx_h_red = 1;    //灭
  202.                                 nb_h_green = 1;    //灭
  203.                                 nb_h_red = 0;

  204.                                 nb_green_ll = 1;    //灭
  205.                                 dx_green_ll = 1;    //灭
  206.                                 flag_5m_value = 0;       

  207.                         }
  208.                         else if(f_value < dx_ll + dx_time+ yellow_time)                 //当小于5秒时  黄灯要闪了
  209.                         {
  210.                                 if(flag_csf == 2)          //意思是只初始化一次
  211.                                 {       
  212.                                         flag_csf = 3;       
  213.                                         nb_s = dx_time_ll + 2*yellow_time; //是显示南北的总时间                                                               
  214.                                         dx_s = yellow_time;        //给南北倒计时显示初始化值
  215. //                                 while(1);
  216.                                 }   
  217.                                 dx_red    = 1;    //灭   
  218.                                 dx_green  =        1;    //灭          
  219.                                 nb_red    = 0;   
  220.                                 nb_green  =        1;    //灭          
  221.                                 nb_yellow = 1;    //灭          
  222.                                 if(flag_500ms == 0)
  223.                                 {
  224.                                         dx_yellow = 0;       
  225.                                 }
  226.                                 else
  227.                                 {
  228.                                         dx_yellow = 1;    //灭       
  229.                                 }
  230.                                 dx_h_green = 0;
  231.                                 dx_h_red = 1;    //灭
  232.                                 nb_h_green = 1;    //灭
  233.                                 nb_h_red = 0;
  234.                         }
  235.                         else if(f_value < dx_ll + dx_time+dx_time_ll+ yellow_time)                 //东西左转
  236.                         {
  237.                                 if(flag_csf == 3)          //意思是只初始化一次
  238.                                 {       
  239.                                         flag_csf = 4;       
  240.                                         nb_s = dx_time_ll + yellow_time; //是显示南北的总时间                                                               
  241.                                         dx_s = dx_time_ll;        //给南北倒计时显示初始化值
  242.                                 }   
  243.                                 dx_red    = 1;    //灭   
  244.                                 dx_green  =        1;    //灭          
  245.                                 dx_yellow = 1;    //灭       
  246.                                 nb_red    = 0;   
  247.                                 nb_green  =        1;    //灭          
  248.                                 nb_yellow = 1;    //灭          

  249.                                 dx_h_green = 1;    //灭
  250.                                 nb_h_green = 1;    //灭
  251.                                 nb_h_red = 0;

  252.                                 nb_green_ll = 1;
  253.                                 dx_green_ll = 0;

  254.                         }
  255.                         else if(f_value < dx_ll + dx_time+dx_time_ll+ yellow_time*2)                 //当小于5秒时  黄灯要闪了
  256.                         {
  257.                                 if(flag_csf == 4)          //意思是只初始化一次
  258.                                 {       
  259.                                         flag_csf = 1;       
  260.                                         nb_s =  yellow_time; //是显示南北的总时间                                                               
  261.                                         dx_s = yellow_time;        //给南北倒计时显示初始化值
  262.                                 }   
  263.                                 dx_red    = 1;    //灭   
  264.                                 dx_green  =        1;    //灭          
  265.                                 nb_red    = 0;   
  266.                                 nb_green  =        1;    //灭          
  267.                                 nb_yellow = 1;    //灭          
  268.                                 if(flag_500ms == 0)
  269.                                 {
  270.                                         dx_yellow = 0;       
  271.                                 }
  272.                                 else
  273.                                 {
  274.                                         dx_yellow = 1;    //灭       
  275.                                 }
  276.                                 dx_h_green = 1;    //灭
  277.                                 dx_h_red = 0;
  278.                                 nb_h_green = 1;    //灭
  279.                                 nb_h_red = 0;

  280.                                 nb_green_ll = 1;    //灭
  281.                                 dx_green_ll = 1;    //灭
  282.                         }
  283.                 }
  284.         if(flag_1s == 1)
  285.         {
  286.                 flag_1s = 0;
  287.                 dx_che_value = 0;
  288.                 dx_s --;
  289.                 nb_s --;
  290.                 f_value ++;
  291.                 if(flag_dx_nb == 0)           //南北时间
  292.                 {
  293.                         if(f_value >= dx_zong)
  294.                         {
  295.                                 f_value = 0;
  296.                                 flag_dx_nb = 1;          //东西绿灯模式
  297.                         }
  298.                 }
  299.                 if(flag_dx_nb == 1)           //东西时间
  300.                 {
  301.                         if(f_value >= nb_zong)
  302.                         {
  303.                                 f_value = 0;
  304.                                 flag_dx_nb = 0;          //南北绿灯模式
  305.                         }
  306.                 }
  307.         }                 
  308.         dis_smg[0] = smg_du[dx_s % 10] ;        //显示
  309.         dis_smg[1] = smg_du[dx_s / 10] ;
  310.         dis_smg[2] = smg_du[nb_s % 10] ;
  311.         dis_smg[3] = smg_du[nb_s / 10] ;
  312. }

  313. /********************独立按键程序*****************/
  314. uchar key_can;         //按键值

  315. void key()         //独立按键程序
  316. {
  317.         static uchar key_new;
  318.         key_can = 20;                   //按键值还原
  319.         P1 |= 0x0f;
  320.         if((P1 & 0x0f) != 0x0f)                //按键按下
  321.         {
  322.                 delay_1ms(1);                     //按键消抖动
  323.                 if(((P1 & 0x0f) != 0x0f) && (key_new == 1))
  324.                 {                                                //确认是按键按下
  325.                         key_new = 0;
  326.                         switch(P1 & 0x0f)
  327.                         {
  328.                                 case 0x0e:  key_can = 4;  break;         //得到按键值
  329.                                 case 0x0d:  key_can = 3;  break;         //得到按键值
  330.                                 case 0x0b:  key_can = 2;  break;         //得到按键值
  331.                                 case 0x07:  key_can = 1;  break;         //得到按键值
  332.                         }
  333.                 }                       
  334.         }
  335.         else
  336.                 key_new = 1;       
  337. }

  338. uchar menu_1,flag_s;


  339. /********************设置函数*****************/
  340. void key_with()
  341. {
  342.         if(key_can == 4)   //交通管制按键
  343.         {
  344.                 flag_jdgz ++;
  345.                 if(flag_jdgz > 6)
  346.                 {
  347.                         flag_jdgz = 0;       
  348.                 }
  349.                 if(flag_jdgz == 1)         //  全部亮红灯
  350.                 {
  351.                         dx_green  =        1;    //灭       
  352.                         dx_yellow = 1;    //灭       
  353.                         nb_green  =        1;    //灭       
  354.                         nb_yellow = 1;    //灭                               


  355.                         nb_green_ll = 1;    //灭
  356.                         dx_green_ll = 1;    //灭
  357.                 }
  358.                 if(flag_jdgz == 2)         //  南北黄灯  东西黄灯
  359.                 {
  360.                         dx_red    = 1;    //灭   
  361.                         dx_green  =        1;    //灭       
  362.                         dx_yellow = 0;    //亮       
  363.                         nb_red    = 1;    //灭   
  364.                         nb_green  =        1;    //灭       
  365.                         nb_yellow = 0;    //亮               
  366.                        

  367.                         nb_green_ll = 1;    //灭
  368.                         dx_green_ll = 1;    //灭
  369.                 }
  370.                 if(flag_jdgz == 3)         //  东西红灯  南北绿灯
  371.                 {
  372.                         dx_red    = 0;    //亮  
  373.                         dx_green  =        1;    //灭       
  374.                         dx_yellow = 1;    //灭       
  375.                         nb_red    = 1;    //灭   
  376.                         nb_green  =        0;    //亮       
  377.                         nb_yellow = 1;    //灭                               
  378.        
  379.                         dx_h_green = 1;    //灭
  380.                         dx_h_red = 1;    //亮
  381.                         nb_h_green = 0;    //亮
  382.                         nb_h_red = 1;    //灭

  383.                         nb_green_ll = 1;    //灭
  384.                         dx_green_ll = 1;    //灭
  385.                 }
  386.                 if(flag_jdgz == 4)         //  南北红灯  东西绿灯
  387.                 {
  388.                         dx_red    = 1;    //灭   
  389.                         dx_green  =        0;    //亮       
  390.                         dx_yellow = 1;    //灭       
  391.                         nb_red    = 0;    //亮  

  392.                         dx_h_green = 0;    //亮
  393.                         dx_h_red = 1;    //灭
  394.                         nb_h_green = 1;    //灭
  395.                         nb_h_red = 0;    //亮
  396.                 }
  397.                 if(flag_jdgz == 5)         //    南北左转绿灯
  398.                 {
  399.                         dx_red    = 0;    //亮   
  400.                         dx_green  =        1;    //灭       
  401.                         nb_green  =        1;    //灭       
  402.                         nb_yellow = 1;    //灭                               

  403.                         dx_h_green = 1;    //灭
  404.                         dx_h_red = 0;    //亮
  405.                         nb_h_green = 1;    //灭
  406.                         nb_h_red = 0;    //亮
  407.                 }
  408.                 if(flag_jdgz == 6)         //  南北红灯  东西左转绿灯
  409.                 {
  410.                         dx_red    = 0;    //亮   
  411.                         dx_green  =        1;    //灭       
  412.                         dx_yellow = 1;    //灭       
  413.                         nb_yellow = 1;    //灭                               

  414.                         dx_h_green = 1;    //灭
  415.                         dx_h_red = 0;    //亮
  416.                         nb_h_green = 1;    //灭
  417.                         nb_h_red = 0;    //亮

  418.                         nb_green_ll = 1;    //灭
  419.                         dx_green_ll = 0;
  420.                 }
  421.         }
  422.         if(key_can == 1)          //设置键
  423.         {
  424.                 menu_1 ++;
  425.                 if(menu_1 > 5)
  426.                 {                          
  427.                         menu_1  = 0;
  428.                 }
  429.         }

  430.         if(menu_1 == 1)           //设置东西的时间
  431.         {
  432.                 if(key_can == 2)
  433.                 {
  434.                         dx_time ++ ;                //加1
  435.                         if(dx_time > 99)
  436.                                 dx_time = 99;
  437.                 }
  438.                 if(key_can == 3)
  439.                 {
  440.                         dx_time -- ;                //减1
  441.                         if(dx_time <= 5)
  442.                                 dx_time = 5;
  443.                 }
  444.                 dis_smg[0] = smg_du[dx_time % 10] ;                //显示东西设置的时候
  445.                 dis_smg[1] = smg_du[dx_time / 10] ;       
  446.         }       
  447.         if(menu_1 == 2)           //设置南北的时间
  448.         {
  449.                 if(key_can == 2)
  450.                 {
  451.                         nb_time ++ ;                //加1
  452.                         if(nb_time > 99)
  453.                                 nb_time = 99;
  454.                 }
  455.                 if(key_can == 3)
  456.                 {
  457.                         nb_time -- ;                //减1
  458.                         if(nb_time <= 5)
  459.                                 nb_time = 5;
  460.                 }
  461.                 dis_smg[2] = smg_du[nb_time % 10] ;                //显示东西设置的时候
  462.                 dis_smg[3] = smg_du[nb_time / 10] ;       
  463.         }
  464.         if(menu_1 == 3)           //设置黄灯的时间
  465.         {
  466.                 if(key_can == 2)
  467.                 {
  468.                         yellow_time ++ ;                //加1
  469.                         if(yellow_time > 99)
  470.                                 yellow_time = 99;
  471.                 }
  472.                 if(key_can == 3)
  473.                 {
  474.                         yellow_time -- ;                //减1
  475.                         if(yellow_time <= 1)
  476.                                 yellow_time = 1;
  477.                 }
  478.                 dis_smg[0] = smg_du[yellow_time % 10] ;                //显示黄灯时间
  479.                 dis_smg[1] = smg_du[yellow_time / 10] ;       
  480.                 dis_smg[2] = smg_du[yellow_time % 10] ;                //显示黄灯时间
  481.                 dis_smg[3] = smg_du[yellow_time / 10] ;       
  482.         }
  483.         if(menu_1 == 4)           //设置东西左边的时间
  484.         {
  485.                 if(key_can == 2)
  486.                 {
  487.                         dx_time_ll ++ ;                //加1
  488.                         if(dx_time_ll > 99)
  489.                                 dx_time_ll = 99;
  490.                 }
  491.                 if(key_can == 3)
  492.                 {
  493.                         dx_time_ll -- ;                //减1
  494.                         if(dx_time_ll <= 5)
  495. ……………………

  496. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
交通灯.7z (561.75 KB, 下载次数: 26)


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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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