程序出了点问题，求解决

2019-03-24 20:12发布

站内问答 / Atmel MCU
9532 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条回答
Li_Lei
2019-03-25 08:07
不太好帮,看程序就得看大半天

一周热门 更多>

相关问题