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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 单片机交通灯调试的时候独立按键按下去没反应,其他正常 ...
返回列表 发新帖
查看: 3308|回复: 6
收起左侧

单片机交通灯调试的时候独立按键按下去没反应,其他正常 求各位前辈指教

[复制链接]
ID:473748 发表于 2019-2-1 17:20 | 显示全部楼层 |阅读模式
无按键按下时红灯和绿灯倒计时时间为30s,黄灯时间为5s，按键1有两种模式：第一种模式是改变宝田路时间，第二种模式（即再按一下按键1），改变前进路时间
按键2和按键3分别是在不同模式下时间加1和时间减1；按键4是交通管制时交通灯的不同状态。
单片机程序在附件中
  1. /**************************************************************************************
  2. *                              交通灯实验                                                                                                  *
  3. 实现现象：下载程序后，按照视频操作正确接线，呈现交通灯现象
  4. 注意事项：                                                                                                                                                                  
  5. ***************************************************************************************/

  7. #include "reg52.h"                         //此文件中定义了单片机的一些特殊功能寄存器

  9. typedef unsigned int u16;          //对数据类型进行声明定义
  10. typedef unsigned char u8;

  12. sbit LSA=P2^5;        //动态数码管位选
  13. sbit LSB=P2^6;
  14. sbit LSC=P2^7;

  16. //--定义使用的IO口--//
  17. #define GPIO_DIG   P0          //数码管段选

  19. #define GPIO_TRAFFIC P1                  
  20. #define        GPIO_TRAFFId P2

  22. sbit RED10   = P1^0;   //上人行道红灯
  23. sbit GREEN10 = P1^1;   //上人行道绿灯
  24. sbit RED11   = P1^2;        //宝田路红灯
  25. sbit YELLOW11= P1^3;        //宝田路黄灯
  26. sbit GREEN11 = P1^4;        //宝田路绿灯
  27. v

  29. sbit RED00   = P3^0;        //右人行道红灯
  30. sbit GREEN00 = P3^1;        //右人行道绿灯
  31. sbit RED01   = P1^5;        //前进路红灯
  32. sbit YELLOW01= P1^6;        //前进路黄灯
  33. sbit GREEN01 = P1^7;        //前进路绿灯
  34. u8 BT,QJ;
  35. u8 time=30;
  36. u8 code smgduan[17]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
  37.                                         0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};//显示0~F的值
  38. u8 DisplayData[8];
  39. u8 Second;                                 //倒计时时间
  40. u8 key_can;                                  //独立按键
  41. u8 men_1;                                   //按键模式
  42. u8  flag_jdgz;                           //交通管制



  46. /*******************************************************************************
  47. * 函 数 名         : delay
  48. * 函数功能                   : 延时函数，i=1时，大约延时10us
  49. *******************************************************************************/
  50. void delay(u16 i)
  51. {
  52.         while(i--);        
  53. }

  55. /*******************************************************************************
  56. * 函 数 名         : DigDisplay
  57. * 函数功能                   : 数码管动态扫描函数，循环扫描8个数码管显示
  58. *******************************************************************************/
  59. void DigDisplay()
  60. {
  61.         u8 i;
  62.         for(i=0;i<8;i++)
  63.         {
  64.                 switch(i)         //位选，选择点亮的数码管，
  65.                 {
  66.                         case(0):
  67.                                 LSA=0;LSB=0;LSC=0; break;//显示第0位
  68.                         case(1):
  69.                                 LSA=1;LSB=0;LSC=0; break;//显示第1位
  70.                         case(2):
  71.                                 LSA=0;LSB=1;LSC=0; break;//显示第2位
  72.                         case(3):
  73.                                 LSA=1;LSB=1;LSC=0; break;//显示第3位
  74.                         case(4):
  75.                                 LSA=0;LSB=0;LSC=1; break;//显示第4位
  76.                         case(5):
  77.                                 LSA=1;LSB=0;LSC=1; break;//显示第5位
  78.                         case(6):
  79.                                 LSA=0;LSB=1;LSC=1; break;//显示第6位
  80.                         case(7):
  81.                                 LSA=1;LSB=1;LSC=1; break;//显示第7位        
  82.                 }
  83.                 GPIO_DIG=DisplayData[i];//发送段码
  84.                 delay(100); //间隔一段时间扫描        
  85.                 GPIO_DIG=0x00;//消隐
  86.         }
  87. }


  90. /*******************************************************************************
  91. * 函 数 名         : Timer0Init
  92. * 函数功能                   : 定时器0初始化
  93. * 输    入         : 无
  94. * 输    出         : 无
  95. *******************************************************************************/
  96. void Timer0Init()
  97. {
  98.         TMOD|=0X01;//选择为定时器0模式，工作方式1，仅用TR0打开启动。

  100.         TH0=0XFC;        //给定时器赋初值，定时1ms
  101.         TL0=0X18;        
  102.         ET0=1;//打开定时器0中断允许
  103.         EA=1;//打开总中断
  104.         TR0=1;//打开定时器                        
  105. }


  108. void jtdzc()                          //正常时交通灯控制函数
  109. {
  110.         if(Second == 70)
  111.         {
  112.                         Second = 1;
  113.         }

  115.         if(Second < 31)
  116.         {
  117.                         DisplayData[0] = 0x00;
  118.                         DisplayData[1] = 0x00;
  119.                         DisplayData[2] = smgduan[(30 - Second) % 100 / 10];
  120.                         DisplayData[3] = smgduan[(30 - Second) %10];
  121.                         DisplayData[4] = 0x00;
  122.                         DisplayData[5] = 0x00;
  123.                         DisplayData[6] = DisplayData[2];
  124.                         DisplayData[7] = DisplayData[3];
  125.                         DigDisplay();

  127.                         //--宝田路通行--//

  129.                         GPIO_TRAFFIC = 0xFF;  //将所有的灯熄灭
  130.                         RED00 = 1;
  131.                         GREEN00 = 1;

  133.                         GREEN11 = 0;    //宝田路绿灯亮                        
  134.                         GREEN10        = 0;    //上人行道绿灯亮

  136.                         RED01 = 0;      //前进路红灯亮
  137.                         RED00 = 0;      //右人行红灯亮
  138.                 }

  140.                 //--黄灯等待切换状态，5秒--//
  141.                 else if(Second < 36)
  142.                 {
  143.                         DisplayData[0] = 0x00;
  144.                         DisplayData[1] = 0x00;
  145.                         DisplayData[2] = smgduan[(35 - Second) % 100 / 10];
  146.                         DisplayData[3] = smgduan[(35 - Second) %10];
  147.                         DisplayData[4] = 0x00;
  148.                         DisplayData[5] = 0x00;
  149.                         DisplayData[6] = DisplayData[2];
  150.                         DisplayData[7] = DisplayData[3];
  151.                         DigDisplay();

  153.                         //--黄灯阶段--//

  155.                         GPIO_TRAFFIC = 0xFF;  //将所有的灯熄灭
  156.                         RED00 = 1;
  157.                         GREEN00 = 1;

  159.                         YELLOW11 = 0;    //宝田路黄灯亮                        
  160.                         RED10        = 0;     //上人行道红灯亮

  162.                         YELLOW01 = 0;    //前进路红灯亮
  163.                         RED00 = 0;       //右人行道红灯亮
  164.                 }

  166.                 //--前进路通行--//
  167.                 else if(Second < 66)
  168.                 {
  169.                         DisplayData[0] = 0x00;
  170.                         DisplayData[1] = 0x00;
  171.                         DisplayData[2] = smgduan[(65 - Second) % 100 / 10];
  172.                         DisplayData[3] = smgduan[(65 - Second) %10];
  173.                         DisplayData[4] = 0x00;
  174.                         DisplayData[5] = 0x00;
  175.                         DisplayData[6] = DisplayData[2];
  176.                         DisplayData[7] = DisplayData[3];
  177.                         DigDisplay();

  179.                         //--黄灯阶段--//

  181.                         GPIO_TRAFFIC = 0xFF;  //将所有的灯熄灭
  182.                         RED00 = 1;
  183.                         GREEN00 = 1;

  185.                         RED11 = 0;       //宝田路红灯亮                        
  186.                         RED10 = 0;       //上人行道红灯亮

  188.                         GREEN01 = 0;     //前进路绿灯亮
  189.                         GREEN00 = 0;     //右人行道绿灯亮
  190.                 }

  192.                 //--黄灯等待切换状态，5秒--//
  193.                 else
  194.                 {
  195.                         DisplayData[0] = 0x00;
  196.                         DisplayData[1] = 0x00;
  197.                         DisplayData[2] = smgduan[(70 - Second) % 100 / 10];
  198.                         DisplayData[3] = smgduan[(70 - Second) %10];
  199.                         DisplayData[4] = 0x00;
  200.                         DisplayData[5] = 0x00;
  201.                         DisplayData[6] = DisplayData[2];
  202.                         DisplayData[7] = DisplayData[3];
  203.                         DigDisplay();

  205.                         //--黄灯阶段--//

  207.                         GPIO_TRAFFIC = 0xFF;  //将所有的灯熄灭
  208.                         RED00 = 1;
  209.                         GREEN00 = 1;

  211.                         YELLOW11 = 0;    //宝田路黄灯亮                        
  212.                         RED10        = 0;     //上人行道红灯亮

  214.                         YELLOW01 = 0;    //前进路红灯亮
  215.                         RED00 = 0;       //右人行道红灯亮
  216.                 }        
  217. }                                       

  219. void DULIANJIAN()               //独立按键模块
  220. {        
  221.         GPIO_TRAFFId|=0x1f;                        //P2口
  222.         if((GPIO_TRAFFId)&(0x0f)!=0x0f)                //判断按键
  223.         {                                                                        //延时
  224.                 delay(100);
  225.                 if((GPIO_TRAFFId)&(0x1f)!=0x1f)
  226.                 {
  227.                         switch((GPIO_TRAFFId)&(0x1f))        //按键键位的确定
  228.                         {
  229.                                 case(0x0e):key_can=1;break;
  230.                                 case(0x0d):key_can=2;break;
  231.                                 case(0x0b):key_can=3;break;
  232.                                 case(0x07):key_can=4;break;

  234.                         }
  235.                
  236.                 }
  237.         }

  239. }
  240. void DULIANJIANCAOZUO()     //各按键所要执行的功能
  241. {
  242.         key_can=20;
  243.         
  244.         if(key_can==4)                   //交通管制状态
  245.         {
  246.                 flag_jdgz ++;
  247.                 if(flag_jdgz>=5)
  248.                 {
  249.                         flag_jdgz=0;
  250.                 }
  251.                 if(flag_jdgz==1)
  252.                 {
  253.                         GPIO_TRAFFIC = 0xFF;  //将所有的灯熄灭
  254.                         RED00 = 1;
  255.                         GREEN00 = 1;


  258.                         RED10 = 0;       //各路所有红灯亮
  259.                         RED11=0;         
  260.                         RED00=0;                 //
  261.                         RED01=0;
  262.                 }
  263.                 if(flag_jdgz==2)
  264.                 {
  265.                         GPIO_TRAFFIC = 0xFF;  //将所有的灯熄灭
  266.                         RED00 = 1;
  267.                         GREEN00 = 1;
  268.                         
  269.                         GREEN10=0;                           //上人行道绿灯亮
  270.                         GREEN11=0;                           //宝田路绿灯亮
  271.                         RED00=0;                           //右人行道红灯
  272.                         RED01=0;                           //前进路红灯
  273.                 }
  274.                 if(flag_jdgz==3)
  275.                 {
  276.                         GPIO_TRAFFIC = 0xFF;  //将所有的灯熄灭
  277.                         RED00 = 1;
  278.                         GREEN00 = 1;
  279.                         
  280.                         RED10=0;                          //上人行红灯
  281.                         RED11=0;                          //宝田路红灯
  282.                         GREEN00=0;                          //右人行道绿灯
  283.                         GREEN01=0;                           //前进路绿灯
  284.                 }
  285.                 if(flag_jdgz==4)
  286.                 {
  287.                         GPIO_TRAFFIC = 0xFF;  //将所有的灯熄灭
  288.                         RED00 = 1;
  289.                         GREEN00 = 1;
  290.                         
  291.                         GREEN10=0;                          //各路绿灯亮
  292.                         GREEN11=0;
  293.                         GREEN00=0;
  294.                         GREEN01=0;
  295.                 }
  296.                 if(flag_jdgz==5)
  297.                 {
  298.                         GPIO_TRAFFIC = 0xFF;  //将所有的灯熄灭
  299.                         RED00 = 1;
  300.                         GREEN00 = 1;
  301.                         
  302.                         RED10=0;                           //人行道红灯 前进路宝田路黄灯
  303.                         YELLOW11=0;
  304.                         RED00=0;
  305.                         YELLOW01=0;                                
  306.                 }                        
  307.                         
  308.         
  309.         }
  310.         if(key_can==1)                                   //键值为1
  311.         {
  312.                
  313.                 men_1++;                                   //模式选择
  314.                 if(men_1>=3)
  315.                 {
  316.                         men_1=0;
  317.                 }
  318.         }
  319.         if(men_1==1)                                   //模式为1时  
  320.         {                                                           //独立按键2功能为宝田路倒计时时间加1
  321.                 if(key_can==2)
  322.                 {
  323.                         time++;
  324.                         if(time>99)
  325.                         {
  326.                                 time=0;
  327.                         }
  328.                 }
  329.                 if(key_can==3)                          //独立按键3功能为宝田路倒计时时间减1
  330.                 {
  331.                         time--;
  332.                         if(time<10)
  333.                         {
  334.                                 time=10;
  335.                         }

  337.                 }
  338.                 DisplayData[0] = 0x00;                                         //显示前进路调整后的时间
  339.                 DisplayData[1] = 0x00;
  340.                 DisplayData[2] = smgduan[time/10];
  341.                 DisplayData[3] = smgduan[time%10];
  342.                 DisplayData[4] = 0x00;
  343.                 DisplayData[5] = 0x00;
  344.                 DisplayData[6] = DisplayData[10];
  345.                 DisplayData[7] = DisplayData[10];
  346.                 DigDisplay();                        
  347.         }
  348.         if(men_1==2)                                                                   //模式2时
  349.         {                                                                                           //前进路时间加1
  350.                 if(key_can==2)
  351.                 {
  352.                         time++;
  353.                         if(time>99)
  354.                         {
  355.                                 time=0;
  356.                         }
  357.                 }
  358.                 if(key_can==3)                                                                //前进路时间减1
  359.                 {
  360.                         time--;
  361.                         if(time<10)
  362.                         {
  363.                                 time=10;
  364.                         }

  366.                 }
  367.                 DisplayData[0] = 0x00;                                                                           //显示调整后的时间
  368.                 DisplayData[1] = 0x00;
  369.                 DisplayData[2] = smgduan[11];
  370.                 DisplayData[3] = smgduan[11];
  371.                 DisplayData[4] = 0x00;
  372.                 DisplayData[5] = 0x00;
  373.                 DisplayData[6] = DisplayData[time/10];
  374.                 DisplayData[7] = DisplayData[time%10];
  375.                 DigDisplay();                        
  376.         }

  378. }


  381. void main()
  382. {
  383.         Timer0Init();
  384.         while(1)
  385.         {
  386.                  if(key_can<20)
  387.                 {
  388.                         
  389.                         DULIANJIANCAOZUO();               
  390.                 }
  391.                
  392.                 if((men_1==0)&&(flag_jdgz == 0))
  393.                 {
  394.                         jtdzc();        
  395.                
  396.                 }
  397.                 DULIANJIAN();
  398.            
  399.         }        

  401. }




  406. /*******************************************************************************
  407. * 函 数 名         : void Timer0() interrupt 1
  408. * 函数功能                   : 定时器0中断函数
  409. * 输    入         : 无
  410. * 输    出         : 无
  411. *******************************************************************************/

  413. void time0()interrupt 1
  414. {
  415.         static u16 i;
  416.         TH0=0XFC;        //给定时器赋初值，定时1ms
  417.         TL0=0X18;
  418.         i++;
  419.         if(i==1000)
  420.         {
  421.                 i=0;
  422.                 Second ++;        
  423.         }        
  424. }
复制代码

交通灯.docx

16.33 KB, 下载次数: 8
回复

使用道具 举报

ID:473186 发表于 2019-2-1 18:54 | 显示全部楼层
电路图也上上来看看,应该不难

评分

参与人数 3黑币 +57 收起 理由
shuisheng60 + 35
找人PK + 12
sheng7533967 + 10

查看全部评分

回复

使用道具 举报

ID:213173 发表于 2019-2-1 20:20 | 显示全部楼层
void DULIANJIAN()               //独立按键模块
{        
        GPIO_TRAFFId=0x0f;                        //P2口
        if(GPIO_TRAFFId!=0x0f)                //判断按键
        {                                 
                delay(100); //延时
                if(GPIO_TRAFFId!=0x0f)
                {
                        switch(GPIO_TRAFFId)        //按键键位的确定
                        {
                                case(0x0e):key_can=1;break;
                                case(0x0d):key_can=2;break;
                                case(0x0b):key_can=3;break;
                                case(0x07):key_can=4;break;
                        }
                        while(!GPIO_TRAFFId);
                }
        }
}
回复

使用道具 举报

ID:473748 发表于 2019-2-3 14:46 | 显示全部楼层
wulin 发表于 2019-2-1 20:20
void DULIANJIAN()               //独立按键模块
{        
        GPIO_TRAFFId=0x0f;                       ...

试过了还是不行，还是要感谢你，新春快乐
回复

使用道具 举报

ID:473748 发表于 2019-2-3 14:55 | 显示全部楼层
zhengchong60 发表于 2019-2-1 18:54
电路图也上上来看看,应该不难

这是我的设计图截屏   有点迟了，如果有时间的话请帮我看看，新春快乐！

QQ截图20190203145108.png
回复

使用道具 举报

ID:473748 发表于 2019-2-3 15:44 | 显示全部楼层
zhengchong60 发表于 2019-2-1 18:54
电路图也上上来看看,应该不难

这个是我仿照开发板的电路设计的，静态数码管，34位显示宝田路时间，78位显示前进路时间
回复

使用道具 举报

ID:213173 发表于 2019-2-4 08:48 | 显示全部楼层
lhblhb 发表于 2019-2-3 14:46
试过了还是不行，还是要感谢你，新春快乐

看了你的电路图，P2高4位还有其他用途，所以判断按键时不能随意改变P2状态。可以这样写：
void DULIANJIAN()                        //独立按键模块
{        
        u8 i;                                        //临时变量
        i=GPIO_TRAFFId;                        //读P2口赋值变量i
        i&=0x0f;                                 //高4位清0，保留低4位
        if(i!=0x0f)                                //判断有键按下
        {
                delay(100);                        //延时
                if(i!=0x0f)                        //确认有键按下
                {
                        switch(i)                //按键键位的确定
                        {
                                case(0x0e):key_can=1;break;
                                case(0x0d):key_can=2;break;
                                case(0x0b):key_can=3;break;
                                case(0x07):key_can=4;break;
                        }
                }
        }
}
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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