程序出了点问题，求解决

2019-03-24 20:12发布

站内问答 / Atmel MCU
9485 3 1432
课设一个星期了，程序和原理图遇到了很多问题，剩这三个还没有解决，麻烦各位大神给点意见，救救孩子！
求解决这三个问题：倒计时不运作，紧急模式没有反应，修改时间也没有反应
  1. #include <iom168v.h>
  2. const unsigned char disp[] ={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90}; //段选码
  3. unsigned char xs[4]= {0xC0,0xC0,0xC0,0xC0};                                                                         

  5. unsigned char gs=0; //绿灯
  6. unsigned char ys=0; //黄灯
  7. unsigned char green_second = 9 , yellow_second = 3 ; //用于修改时间的变量

  9. unsigned char k=0; //显示刷新标志

  11. unsigned char flag=0; //转换红绿灯标志位
  12. unsigned char flag1=0; //切换交通灯模式标志位
  13. unsigned char flag2=0; //紧急模式下的切换模式
  14. unsigned char flag3=0; //修改时间

  16. unsigned int Udelay = 1000;
  17. //主频为1M
  18. void delay_1us(void)      //1us延时，实测8us
  19. {
  20. asm("nop");                  //1时钟周期
  21. }

  23. void delay_3us(void)     //3us,实8us
  24. {  
  25. asm("nop");
  26. }

  28. void delay_10us(void)  //10us,实9us
  29. {
  30.    asm("nop");
  31.    asm("nop");
  32. }

  34. void delay_50us(void)    //50us,实47us
  35. {
  36. delay_10us();
  37. delay_10us();
  38. delay_10us();
  39. delay_10us();
  40. delay_10us();
  41. }

  43. void delay_100us(void)   //100us,实96us
  44. {
  45.   delay_50us();
  46.   delay_50us();
  47. }


  50. void delay_n100us(unsigned char n100us)   //几百us延时
  51. {
  52.   while(n100us--);
  53.   delay_100us();
  54. }
  55. //延时函数
  56. void delay(unsigned int x)
  57. {
  58.    while(x--);
  59. }

  61. //IO配置函数
  62. void io_init(void)
  63. {
  64.    DDRD = 0xFF;
  65.    PORTD = 0xFF;
  66.    
  67.    DDRB = 0b00111111;
  68.    PORTB = 0xFF;
  69.    
  70.    
  71.    DDRC = 0b00111100;
  72.    PORTC = 0b00111111;
  73.    PORTC|=0b00111100;//4位位控总不变
  74.    
  75. }

  77. //EEPROM写入、读取
  78. void EEPROM_WRITE(unsigned int uiAddress, unsigned char ucData)
  79. {
  80.     while(EECR & (1<<EEWE));//等待上一次写操作结束
  81.     EEAR = uiAddress;//设置地址和数据寄存器
  82.     EEDR = ucData;
  83.     EECR |= (1<<EEMWE); //置位EEMWE
  84.     EECR |= (1<<EEWE);//置位EEWE 以启动写操作E
  85. }
  86. void EEPROM_READ(unsigned int uiAddress)
  87. {
  88.     while(EECR & (1<<EEWE)); //等待上一次写操作结束
  89.     EEAR = uiAddress;//设置地址寄存器
  90.     EECR |= (1<<EERE); //设置EERE 以启动读操作
  91.     return /*EEDR*/; //自数据寄存器返回数据
  92. }

  94. //译码函数
  95. void decode(unsigned char a/*, unsigned char b*/)
  96. {  
  97.    /*switch(b)
  98.    {
  99.       case 0 :*/
  100.           xs[0] = disp[a / 10];
  101.           xs[1] = disp[a % 10];
  102.          /*break;
  103.           case 1 :*/
  104.           xs[2] = disp[a / 10];
  105.           xs[3] = disp[a % 10];
  106.          /*break;
  107.    }*/
  108. }

  110. void shutdownLED(void)
  111. {
  112.    xs[0] = 0xff;xs[1] = 0xff;xs[2] = 0xff;xs[3] = 0xff; //关闭显示清空段选段选
  113.    TCCR0B = 0x00;
  114.    TCCR1B = 0x00;
  115.    PORTC|=0b00111100; //关位选
  116. }



  120. //修改时间
  121. /*void changetime(void)
  122. {
  123.    
  124.    //只能在普通模式下改变时间
  125.    if( ((PINB & 0x80) == 0) && ((flag1 == 0)||(flag1 == 3)) )
  126.    {
  127.       PORTB |= 0x3f; //关闭显示灯
  128.           flag3 = (flag3 + 1) % 3;
  129.           if(flag3 == 0)
  130.           {
  131.              flag1 = 0;
  132.                  xs[2] = 0xff;
  133.                  xs[3] = 0xff;
  134.           }
  135.           delay(50000);
  136.    }
  137.    //修改时间
  138.    if(flag3 == 1)
  139.    {
  140.           flag1 = 3;
  141.           //绿灯闪
  142.           PORTB &= ~0x24;
  143.           if((PINC & 0x01) == 0) //+1
  144.           {
  145.              delay_n100us(100);
  146.                  if((PINC & 0x01) == 0)
  147.                  {
  148.                  green_second++;
  149.                      EEPROM_WRITE(0x00, green_second);
  150.                      delay(40000);
  151.                   }
  152.           }
  153.           if((PINC & 0x02) == 0) //-1
  154.           {
  155.              delay_n100us(100);
  156.                  if((PINC & 0x02) == 0)
  157.                  {
  158.                  if(green_second > 0)
  159.                      {
  160.                             green_second--;
  161.                             EEPROM_WRITE(0x00, green_second);
  162.                         delay(40000);
  163.                      }
  164.                   }
  165.           }             
  166.                  
  167.           //数码管2显示绿灯时间
  168.       decode(green_second/*, 1*//*);
  169.    }
  170.    if(flag3 == 2)//2黄灯
  171.    {
  172.       //黄灯闪
  173.           PORTB &= ~0x12;
  174.                  
  175.           if((PINC & 0x01) == 0) //+1
  176.           {
  177.              delay_n100us(100);
  178.                  if((PINC & 0x01) == 0)
  179.                   {
  180.                  yellow_second++;
  181.                      EEPROM_WRITE(0x02, yellow_second);
  182.                      UDR0 = 0x02;
  183.                      delay(10000);
  184.                      UDR0 = yellow_second;
  185.                      delay(40000);
  186.                 }
  187.                 }
  188.           if((PINC & 0x02) == 0) //-1
  189.           {  
  190.              delay_n100us(100);
  191.                  if((PINC & 0x02) == 0)
  192.                    {
  193.                      if(yellow_second > 0)
  194.                      {
  195.                     yellow_second--;
  196.                             EEPROM_WRITE(0x02, yellow_second);
  197.                             UDR0 = 0x02;
  198.                         delay(10000);
  199.                         UDR0 = yellow_second;
  200.                         delay(40000);       
  201.                  }
  202.                         }
  203.           }
  204.           //数码管2显示黄灯时间
  205.           decode(yellow_second/*, 1*//*);
  206.    }
  207. }*/

  209. //红绿灯显示函数
  210. void led(void)
  211. {
  212.    switch(flag1)
  213.    {
  214.       case 0:
  215.           {//日间模式
  216.               TCCR0B = 0x03;
  217.               TCCR1B = 0x0b;
  218.               switch(flag)
  219.               {
  220.                  case 0:        
  221.                         xs[2]= 0xbf;
  222.                             xs[3]= 0xbf;
  223.                             decode(gs/*, 0*/);
  224.                             PORTB |= 0x08; //关闭左右红灯
  225.                     PORTB |= 0x02; //关闭上下黄灯
  226.                 PORTB &= ~0x20; //开启左右绿灯
  227.                             PORTB &= ~0x01; //开启上下红灯
  228.                     
  229.                 break;
  230.              case 1:
  231.                         decode(ys/*, 0*/);
  232.                 PORTB &= ~0x01; //开启上下红灯
  233.                             PORTB |= 0x20; //关闭左右绿灯
  234.                     PORTB &= ~0x10; //开启左右黄灯
  235.                             if(ys <= 3)
  236.                             {
  237.                                decode(ys/*, 1*/);
  238.                             }
  239.                 break;
  240.              case 2:
  241.                         xs[0]= 0xbf;
  242.                             xs[1]= 0xbf;
  243.                             decode(gs/*, 1*/);
  244.                 PORTB |= 0x10; //关闭左右黄灯
  245.                             PORTB |= 0x01; //关闭上下红灯
  246.                     PORTB &= ~0x04; //开启上下绿灯
  247.                             PORTB &= ~0x08; //开启左右红灯
  248.                     
  249.                 break;
  250.              case 3:
  251.                         decode(ys/*, 1*/);
  252.                             PORTB &= ~0x08; //开启左右红灯
  253.                 PORTB |= 0x04; //关闭上下绿灯
  254.                     PORTB &= ~0x02; //开启上下黄灯
  255.                             if(ys <= 3)
  256.                             {
  257.                                decode(ys/*, 0*/);
  258.                             }
  259.                            
  260.                 break;
  261.               }
  262.           break;}
  263.           case 1: //紧急模式
  264.           {
  265.              PORTB |= 0x3f;
  266.                  shutdownLED();
  267.              switch(flag2)
  268.              {  
  269.                 case 0://紧急模式1
  270.                 {
  271.                    PORTB &= ~0x08;//开启左右红灯
  272.                    PORTB &= ~0x01; //开启上下红灯
  273.                    break;
  274.                 }
  275.                 case 1://紧急模式2
  276.                 {
  277.                    PORTB &= ~0x20; //开启左右绿灯
  278.                    PORTB &= ~0x01; //开启上下红灯
  279.                    break;
  280.                 }
  281.                 case 2://紧急模式3
  282.                 {
  283.                            PORTB &= ~0x04;//开启上下绿灯
  284.                            PORTB &= ~0x08;//开启左右红灯
  285.                    break;
  286.                 }
  287.                         //break;//自己加的
  288.              }
  289.              break;
  290.           }
  291.           
  292.           case 2: //夜间模式
  293.           {
  294.              PORTB |= 0x3f;
  295.                  shutdownLED();
  296.                  flag2 = 0;
  297.              PORTB &= ~0x02;//开启上下黄灯
  298.              PORTB &= ~0x10;//开启左右黄灯
  299.              delay(50000);
  300.              PORTB |= 0x02;//关闭上下黄灯
  301.              PORTB |= 0x10;//关闭左右黄灯
  302.              delay(50000);
  303.              break;
  304.       }
  305.           case 3:
  306.           {
  307.                  TCCR1B = 0x00; //关闭计时
  308.                  xs[0] = 0xbf;
  309.                  xs[1] = 0xbf;
  310.                  break;
  311.           }
  312.    }
  313. }


  316. //主函数
  317. void main(void)
  318. {
  319.    gs = green_second;
  320.    ys = yellow_second;
  321.    
  322.    io_init(); //IO口初始化
  323.    
  324.    //定时器初始化
  325.    timer0_init();
  326.    timer1_init();
  327.    
  328.    SREG|=0x80; //开启总中断
  329.    
  330.    //数据写入EEPROM
  331.    EEPROM_READ(0x00/*,green_second*/);delay(10);
  332.    EEPROM_READ(0x02/*,yellow_second*/);delay(10);
  333.    
  334.    if(green_second>50) EEPROM_WRITE(0x00, gs);
  335.    if(yellow_second>50) EEPROM_WRITE(0x02, ys);
  336.    
  337.    
  338.    EEPROM_READ(0x00/*green_second*/);delay(10);
  339.    EEPROM_READ(0x02/* yellow_second*/);delay(10);
  340.    
  341.    gs = green_second;
  342.    ys = yellow_second;
  343.    
  344.    delay(10000);
  345.    while(1)
  346.    {
  347.           //修改模式
  348.       if( ((PINB & 0x40) == 0) && (flag3 == 0))
  349.           {
  350.                    PORTB |= 0x3f;
  351.                  flag1 = (flag1 + 1) % 3;
  352.                  delay(20000);
  353.           }
  354.           //紧急模式下切换
  355.           if( ((PINB & 0x80) == 0) && (flag1 == 1))
  356.           {
  357.              PORTB |= 0x3f;
  358.              flag2 = 0;
  359.                  delay(20000);
  360.           }
  361.           //东西方向
  362.           if( ((PINC & 0x01) == 0) && (flag1 == 1))
  363.           {
  364.              PORTB |= 0x3f;
  365.              flag2 = 1;
  366.                  delay(20000);
  367.           }
  368.           //南北方向
  369.           if( ((PINC & 0x02) == 0) && (flag1 == 1))
  370.           {
  371.              PORTB |= 0x3f;
  372.              flag2 = 2;
  373.                  delay(20000);
  374.           }
  375.           //led显示函数
  376.           led();
  377.           //修改时间函数
  378.           //changetime();
  379.    }
  380. }

  382. // 定时器0的初始化
  383. void timer0_init(void)
  384. {
  385.    TCCR0A = 0x02;  //CTC模式
  386.    TCCR0B = 0x03;  //64分频
  387.    OCR0A = 78;     //5ms 78.125

  389.    TIMSK0 = 0x02;/*比较中断A允许*/
  390.    TIFR0 = 0x02;
  391. }

  393. //定时器1的初始化
  394. void timer1_init(void)
  395. {
  396.    TCCR1A = 0x00; //CTC模式
  397.    TCCR1B = 0x0b; //64分频
  398.    OCR1A = 15625; //1s = 15625
  399.    
  400.    TIMSK1 = 0x02; /*比较中断A允许*/
  401.    TIFR1 = 0x02;
  402. }

  404. extern unsigned char k;
  405. extern unsigned char xs[4];
  406. extern unsigned char green_second, yellow_second;
  407. extern unsigned char gs;
  408. extern unsigned char ys;
  409. extern unsigned char flag;
  410. extern unsigned char flag1; //切换交通灯模式标志位
  411. extern unsigned char flag2; //紧急模式下的切换模式
  412. extern unsigned char flag3; //修改时间

  414. #pragma interrupt_handler Int_TCCR1A:12
  415. void Int_TCCR1A(void)
  416. {
  417.    
  418.    switch(flag)
  419.    {
  420.       case 0 :
  421.              gs--;
  422.                  //decode(gs);//zi+  
  423.                  ys = yellow_second;
  424.                  if(gs == 0)
  425.                  {
  426.                    flag = 1;
  427.                   }
  428.                  break;
  429.           case 1 :
  430.              ys--;
  431.                  //decode(ys);//+
  432.                  gs = green_second;
  433.                  if(ys == 0)
  434.                  {
  435.                    flag = 2;
  436.                   }
  437.                  break;
  438.           case 2 :
  439.              gs--;
  440.                  //decode(gs); //+
  441.              ys = yellow_second;
  442.                  if(gs == 0)
  443.                  {
  444.                    flag = 3;
  445.                   }
  446.                  break;
  447.           case 3 :
  448.              ys--;
  449.                  //decode(ys);//+  
  450.                  gs = green_second;
  451.                  if(ys == 0)
  452.                  {
  453.                    flag = 0;
  454.                    }
  455.                  break;
  456.    }
  457. }
  458. // 中断服务程序的功能：刷新段码与位控制，用变量 K 实现轮流刷新的目的
  459. #pragma interrupt_handler Int_TCCR0A:15
  460. void Int_TCCR0A(void)
  461. {
  462.    k=(++k)%4;
  463.    PORTC|=0b00111100;//关位选   
  464.    PORTD=xs[4];
  465.    switch(k)
  466.    {
  467.       case 0:
  468.           PORTC &= ~0x04;
  469.       //PORTD &= ~0x04;//显示千位
  470.       break;
  471.       case 1:
  472.           PORTC &= ~0x08;
  473.       //PORTD &= ~0x08;//显示百位
  474.       break;
  475.       case 2:
  476.           PORTC &= ~0x10;
  477.       //PORTD &= ~0x80;//显示十位
  478.       break;
  479.       case 3:
  480.           PORTC &= ~0x20;
  481.       //PORTC &= ~0x08;//显示个位
  482.       break;
  483.       default: ;
  484.    }
  485. }


复制代码

此帖出自小平头技术问答
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
该问题目前已经被作者或者管理员关闭, 无法添加新回复
3条回答
y909334873
1楼-- · 2019-03-25 07:40
这种问题就一步步找一个问题，一个功能一个功能注释，倒计时不正常找定时器工作正不正常，显示功能部分正不正常等等，模式切换不了是按键判断问题，还是逻辑上面有冲突，一点点的抠大多数情况下都能定位到大概的的问题位置在想解决办法
Li_Lei
2楼-- · 2019-03-25 08:07
不太好帮,看程序就得看大半天
零三苏九岳志
3楼-- · 2019-03-25 09:56
帮忙你顶一顶

一周热门 更多>

相关问题