设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机智能交通灯 设计方案论证报告 仿真,程序,正式论文 ...
返回列表 发新帖
查看: 8083|回复: 3
打印 上一主题 下一主题
收起左侧

单片机智能交通灯 设计方案论证报告 仿真,程序,正式论文等

[复制链接]
跳转到指定楼层
楼主
ID:157125 发表于 2017-1-20 11:27 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
该文件包括了电路图，仿真，程序，论文，资料等。当时是课设时做得，拿出来与大家分享。

所有资料下载：
智能交通指示灯.rar (4.84 MB, 下载次数: 305)


下面是交通灯设计方案论证报告，压缩包里面还有完整的word格式的正式论文下载，很全面.

专业课程设计设计方案论证报告

一、课题研究的目的和意义
    交通灯在我们的生活中起着非常重要的作用，不仅与人们的生命安全息息相关，同时也关系到交通的正常运行。随着人们安全意识的逐渐增高，人们对安全也有了新的认识，所以交通部门要认识到交通灯控制系统的重要性，努力完善交通控制系统。
二、课题研究的主要任务和预期目标
1．主要任务及要求
①东西、南北方向均有红、黄、绿三种信号灯
②带紧急制动按钮，按钮按下，所有方向亮红灯；再次按下，恢复正常显示
③夜间模式按钮按下，所有方向显示黄灯闪烁
④实时提醒绿灯亮的剩余时间
⑤并可实现通行时间的按键输入。例如（1）南北红灯亮维持25S。在南北红灯亮的同时东西绿灯也亮，并维持20S。到20S时，东西绿灯闪烁，闪烁3S后熄灭。在东西绿灯熄灭时，东西黄灯亮，并维持2S。到2S时，东西黄灯熄，东西红灯亮。同时，南北红灯熄灭，南北绿灯亮。（2）东西红灯亮维持30S。南北绿灯亮维持25S。然后闪烁3S，熄灭。同时南北黄灯亮，维持2S后熄灭，这时南北红灯亮，东西绿灯亮。
2．预期目标
实现主要任务及要求，并在其基础上增添人行指示灯等其他功能。
三、设计方案
1．设计思想(总体的设计思路\想法)
    一个交通指示灯系统分为指示灯显示、倒计时显示两个大部分。指示灯显示部分中各个灯的情况如图所示。
    倒计时部分则利用晶振进行计时，设计一个1s的定时，设置初始值后每1s将初始值-1，并输出给数码管，从而达到倒计时的功能。
2．方案论证(要有多种方案的比较)

方案1：采用标准STC89C51单片机作为控制器通行倒计时显示采用2位LED数码管；指示灯采用发光二极管；LED显示采用动态扫描，以节省端口。紧急情况采用中断完成。以上系统结构框架设计，单片机端口刚好满足要求。该系统具有电路的简单，设计方便，显示清晰等特点。整体框图、流程图如图所示。



方案2：采用SCT89C2051单片机作为控制器，通行倒计时采用16X16点阵LED发光管；列驱动采用74LS595以实现串行端口扩展，行驱动采用4/16译码器74LS154动态扫描；译码器74LS154生成16条行选通信号线，再经过驱动器驱动对应的行线。每条行线上需要较大的驱动电流，应选用大功率三极管作为驱动。这种方案显示可以更加清晰明了，单片机占用端口少，但是需要大量硬件，电路复杂，耗电量大。整体电路如下图




3．设计中要解决的主要问题和措施
问题一：如何实现倒计时与灯的变化相同步
在整个交通系统中，指示灯与倒计时相同步是重要的问题，设定的时间不光是倒计时也是指示灯的显示时间，因此解决此问题就变得尤为重要。
问题二：如何能够调节数码管所显示的数值
任务要求需要使得倒计时时间可调，那就需要将数码管显示的数值进行合理调整，同时还要确保时间和指示灯相对应。
解决方案一：可以看出，无论倒计时数十多少，指示灯发生变化的时间都是最后5s，因此，我们想出的方案是，不用想倒计时一共是多少时间而是仅在最后5s时做出判断，判断出是绿灯闪烁还是黄灯亮起。
解决方案二：对于数码管数值调整，可以想到+1/-1的调整程序，这类程序，我们在单片机的课程中已经学习，通过+1/-1的程序从而实现对数码管数值的调整。
四、课题进度安排
1、第一天至第三天：熟悉课题、查阅资料、合理分工、撰写方案论证报告。
2、第四天至十一天：硬件电路设计及软件设计。
3、十二天至十九天：实物的焊接及调试。
4、二十至二十一天：准备材料答辩。

单片机智能交通指示灯仿真效果图：


智能交通指示灯的单片机源程序：
  1. #include <reg52.h>               
  2. #define uchar unsigned char   
  3. #define uint  unsigned int         



  7. //                                                                                 0     1    2    3           4           5        6                 7          8           9        
  8. uchar code smg_du[]={0xc0,0xf5,0x8c,0x94,0xb1,0x92,0x82,0xf4,0x80,0x90};                 

  10. uchar dis_smg[10] = {0xc0,0xf5,0x8c,0x94,0xb1,0x92,0x82,0xf4,0x80,0x90};        
  11. uchar smg_i = 4;    //位数


  14. sbit smg_we1 = P2^0;         
  15. sbit smg_we2 = P2^1;
  16. sbit smg_we3 = P3^6;
  17. sbit smg_we4 = P3^7;
  18. sbit LE1                 = P3^3;
  19. sbit LE2                 = P3^3;

  21. char dx_s = 0;                                                        //倒计时开始
  22. char nb_s = 0;        
  23. sbit dx_red    = P2^4;            //东西红灯
  24. sbit dx_green  = P2^3;                        //东西绿灯
  25. sbit dx_yellow = P2^2;                        //东西黄灯

  27. sbit nb_red    = P2^7;                        //南北红灯
  28. sbit nb_green  = P2^6;                        //南北绿灯
  29. sbit nb_yellow = P2^5;                        //南北黄灯


  32. bit flag_1s = 0;                                                //延时标志
  33. bit flag_500ms;
  34. bit flag_dx_nb;                 
  35. uchar flag_5m_value;
  36. uchar i;
  37. uchar nb_time = 10,dx_time = 15;   //东西南北时间初值
  38. uchar flag_jdgz ;                             //交通灯


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



  55. // 延时程序

  57. void delay_01ms(uint q)
  58. {
  59.         uint i,j;
  60.         for(i=0;i<q;i++)
  61.                 for(j=0;j<110;j++);
  62. }


  65. // 数码管显示

  67. void display()
  68. {
  69.         uchar i;
  70.         for(i=0;i<smg_i;i++)
  71.         {               
  72.                 P0 = 0xff;                  
  73.                 smg_we_switch(i);            
  74.                 P0 = dis_smg[i];            
  75.                 delay_01ms(3);
  76.         }
  77. }

  79. // 定时器初始化

  81. void time0_init()         
  82. {
  83.         EA  = 1;                  
  84.         TMOD = 0X11;         
  85.         ET0 = 1;                  
  86.         TR0 = 1;                  
  87.         ET1 = 0;                  
  88.         TR1 = 0;                  
  89. }

  91. // 交通灯管理

  93. void jiaotongdeng_dis()
  94. {
  95.         if(flag_1s == 1)
  96.         {
  97.                 flag_1s = 0;
  98.                 if(dx_s == 0)
  99.                 {
  100.                         if(flag_dx_nb == 1)
  101.                                 {
  102.                                 dx_s = nb_time;          //南北时间
  103.                                 nb_s = dx_time;
  104.                                 }
  105.                         else
  106.                                 {
  107.                                 dx_s = dx_time;          //东西时间
  108.                                 nb_s = nb_time;
  109.                                 }
  110.                         flag_dx_nb = ~flag_dx_nb;
  111.                 }
  112.                 dx_s --;
  113.                 nb_s --;
  114.         }
  115.         dis_smg[0] = smg_du[dx_s % 10] ;
  116.         dis_smg[1] = smg_du[dx_s / 10] ;
  117.         dis_smg[2] = smg_du[nb_s % 10] ;
  118.         dis_smg[3] = smg_du[nb_s / 10] ;

  120. // 东西时间
  121.                 if(flag_dx_nb == 0)  
  122. {               
  123.                         if(nb_s > 5)
  124. {
  125.                                 dx_red    = 1;  //东西红灯灭
  126.                                 dx_green  =        0;        //东西绿灯亮
  127.                                 dx_yellow = 1;        //东西黄灯灭
  128.                                 nb_red    = 0;  //南北红灯亮
  129.                                 nb_green  =        1;        //南北绿灯灭
  130.                                 nb_yellow = 1;        //南北绿灯亮
  131.                                 flag_5m_value = 0;        
  132.                         }
  133.                          if(nb_s >= 0&&nb_s <= 5)                 //绿灯闪烁
  134. {
  135.                                 dx_red    = 1;            //东西红灯灭
  136.                                 dx_yellow  =        1;          //东西黄灯灭
  137.                                 nb_red    = 0;            //南北红灯亮
  138.                                 nb_green  =        1;                  //南北绿灯灭
  139.                                 nb_yellow = 1;                  //南北黄灯灭
  140.                                 if(flag_500ms == 0) //绿灯闪烁
  141. {
  142.                                         dx_green = 0;
  143.                                 }
  144.                                 else
  145. {
  146.                                         dx_green = 1;
  147.                                 }
  148.                         }
  149.                         
  150.                         if(nb_s==0)
  151. {
  152.                                 dx_red    = 1;  //东西红灯灭
  153.                                 dx_green  =        1;        //东西绿灯灭
  154.                                 dx_yellow = 0;        //东西黄灯亮
  155.                                 nb_red    = 0;  //南北红灯亮
  156.                                 nb_green  =        1;        //南北绿灯灭
  157.                                 nb_yellow = 1;        //南北黄灯灭
  158.                                 }
  159.                         

  161.                 }

  163. // 南北时间
  164.                 if(flag_dx_nb == 1)  
  165. {                        LE1=1;
  166.                         if(dx_s > 5)
  167. {
  168.                                 dx_red    = 0;     //东西红灯亮
  169.                                 dx_green  =        1;           //东西绿灯灭
  170.                                 dx_yellow = 1;           //东西黄灯灭
  171.                                 nb_red    = 1;     //南北红灯灭
  172.                                 nb_green  =        0;           //南北绿灯亮
  173.                                 nb_yellow = 1;           //南北黄灯灭
  174.                                 flag_5m_value = 0;        
  175.                         }
  176.                         if(dx_s >= 0&&dx_s <= 5)                 //绿灯闪烁
  177. {
  178.                                 dx_red    = 0;     //东西红灯亮
  179.                                 dx_green  =        1;           //东西绿灯灭
  180.                                 dx_yellow = 1;           //东西黄灯灭
  181.                                 nb_red    = 1;     //南北红灯灭
  182.                                 nb_yellow =        1;           //男别黄灯灭
  183.                                 if(flag_500ms == 0)           //绿灯闪烁
  184. {
  185.                                         nb_green = 0;        
  186.                                 }
  187.                                 else
  188. {
  189.                                         nb_green = 1;        
  190.                                 }
  191.                         }

  193.                         
  194. }
  195. }
  196. // 按键设置
  197. uchar key_can;         //定义按键键值

  199. void key()         //按键
  200. {
  201.         static uchar key_new;
  202.         key_can = 5;                   //键值最大
  203.         P1 |= 0x1f;
  204.         if((P1 & 0x1f) != 0x1f)                //确定按键
  205.         {
  206.                 delay_01ms(1);                     //消除抖动
  207.                 if(((P1 & 0x1f) != 0x1f) && (key_new == 1))
  208.                 {                                                //确定键值按下
  209.                         key_new = 0;
  210.                         switch(P1 & 0x1f)
  211.                         {
  212.                                 case 0x1e:  key_can = 1;  break;         //模式键
  213.                                 case 0x1d:  key_can = 2;  break;         //加键
  214.                                 case 0x1b:  key_can = 3;  break;         //减键
  215.                                 case 0x17:  key_can = 4;  break;         //紧急模式键
  216.                         }
  217.                 }                        
  218.         }
  219.         else
  220.                 key_new = 1;        
  221. }

  223. uchar menu_1,flag_s;


  226. // 四种键值
  227. void key_with()
  228. {
  229.         if(key_can == 4)   //紧急模式
  230.         {
  231.                 flag_jdgz ++;
  232.                 if(flag_jdgz > 1)
  233.                         flag_jdgz = 0;        
  234.                 if(flag_jdgz == 1)         //  全部红灯亮
  235.                 {
  236.                         dx_red    = 0;  
  237.                         dx_green  =        1;        
  238.                         dx_yellow = 1;        
  239.                         nb_red    = 0;   
  240.                         nb_green  =        1;        
  241.                         nb_yellow = 1;                        
  242.                 }

  244.         
  245.         }
  246.         if(key_can == 1)          //模式键
  247.         {
  248.                 menu_1 ++;
  249.                 if(menu_1 > 3)
  250.                 {
  251.                         menu_1  = 0;
  252.                 }
  253.         }

  255.         if(menu_1 == 2)           //东西时间调整
  256.         {
  257.                 if(key_can == 2)
  258.                 {
  259.                         dx_time ++ ;                //+1
  260.                         if(dx_time > 99)
  261.                                 dx_time = 99;
  262.                 }
  263.                 if(key_can == 3)
  264.                 {
  265.                         dx_time -- ;                //-1
  266.                         if(dx_time <= 10)
  267.                                 dx_time = 10;
  268.                 }
  269.                 dis_smg[0] = smg_du[dx_time % 10] ;        //显示时间
  270.                 dis_smg[1] = smg_du[dx_time / 10] ;        
  271.                 dis_smg[2] = smg_du[10] ;               
  272.                 dis_smg[3] = smg_du[10] ;        

  274.         }        
  275.         if(menu_1 == 3)           //南北时间调整
  276.         {
  277.                 if(key_can == 2)
  278.                 {
  279.                         nb_time ++ ;                //+1
  280.                         if(nb_time > 99)
  281.                                 nb_time = 99;
  282.                 }
  283.                 if(key_can == 3)
  284.                 {
  285.                         nb_time -- ;                //-1
  286.                         if(nb_time <= 10)
  287.                                 nb_time = 10;
  288.                 }
  289.                 dis_smg[0] = smg_du[10] ;
  290.                 dis_smg[1] = smg_du[10] ;        
  291.                 dis_smg[2] = smg_du[nb_time % 10] ;                //显示时间        
  292.                 dis_smg[3] = smg_du[nb_time / 10] ;        

  294.         }
  295. }


  298. //主函数
  299. void main()
  300. {
  301.         time0_init();

  303.         dx_s = nb_time;          //初始时间为南北时间
  304.         nb_s = dx_time;
  305.         while(1)
  306.         {
  307.                 key();
  308.                 if(key_can < 5)
  309.                         key_with();
  310.                                 if(menu_1 == 1)         //  夜间模式
  311.         {
  312.                         dx_red    = 1;  
  313.                         dx_green  =        1;        
  314.                         nb_red    = 1;  //红绿灯不亮
  315.                         nb_green  =        1;        
  316.                         
  317.                         if(flag_500ms == 0)  //黄灯闪烁

  319. {
  320.                                         dx_yellow = 0;
  321.                                         nb_yellow = 0;
  322.                                 }
  323.                                 else
  324. {
  325.                                         dx_yellow = 1;
  326.                                         nb_yellow = 1;        
  327.                                 }

  329.                 }

  331.                 if((menu_1 == 0) && (flag_jdgz == 0))
  332.                         jiaotongdeng_dis();
  333.                 display();        
  334.         }
  335. }  

  337. // 定时器中断服务
  338. void time0_int() interrupt 1  
  339. {                                                   
  340.         static uchar value;                         //延时10ms
  341.         TH0 = 0x3c;
  342.         TL0 = 0xb0;     //50ms
  343.         value ++;
  344.         flag_5m_value++;
  345.         if(flag_5m_value % 10 == 0)
  346.                 flag_500ms = ~flag_500ms;
  347.         if(value >= 20)
  348.         {
  349.                 value = 0;
  350.                 flag_1s = 1;
  351.         }
  352. }
复制代码


红绿灯, 单片机
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏5 分享淘帖 顶顶 踩踩

相关帖子
回复

使用道具 举报

沙发
ID:1 发表于 2017-2-12 22:44 | 只看该作者
好资料，51黑有你更精彩！！！
回复

使用道具 举报

板凳
ID:26572 发表于 2017-10-13 11:35 | 只看该作者
不错，谢谢LZ
回复

使用道具 举报

地板
ID:467919 发表于 2019-3-26 10:01 | 只看该作者
谢谢LZ
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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