Fatal编程技术网
  • c/
  • C 当变量发生变化时，如何打破if

C 当变量发生变化时，如何打破if

c

C 当变量发生变化时，如何打破if,c,pic,C,Pic,我需要帮助我有一个基本的程序，根据我按下的开关，按顺序播放LED，我想知道的是：当我切换其他开关并运行新的顺序，而不是之前的顺序时，如何中断一个（或停止）并运行另一个顺序，我想知道其他需要中止操作的程序是如何做到的，因为它会在“循环”中出现延迟等情况，我想在每个led的行之间设置if可以做到这一点，但我认为这不是正确/有效的方法。。谢谢 #include <16f876.h> #use delay(clock=4M) #fuses XT,NOWDT #use standard_io(

我需要帮助我有一个基本的程序，根据我按下的开关，按顺序播放LED，我想知道的是：当我切换其他开关并运行新的顺序，而不是之前的顺序时，如何中断一个（或停止）并运行另一个顺序，我想知道其他需要中止操作的程序是如何做到的，因为它会在“循环”中出现延迟等情况，我想在每个led的行之间设置if可以做到这一点，但我认为这不是正确/有效的方法。。谢谢

#include <16f876.h>
#use delay(clock=4M)
#fuses XT,NOWDT
#use standard_io(A)
#use standard_io(B)

int16 t0=2000;
int16 t1=1000;
int16 t2=1000;
int16 t3=500;

void main(){
   output_b(0b00000000);
   while(TRUE){
      if(input(PIN_A0)==0){   
         output_b(0b00000000);
         output_b(0b00011000);
         delay_ms(t0);
         output_b(0b00100100);
         delay_ms(t0);
         output_b(0b01000010);
         delay_ms(t0);
         output_b(0b10000001);
         delay_ms(t0);
      }
      if(input(PIN_A1)==0){
         output_b(0b00000000);
         output_b(0b00000001);
         delay_ms(t1);
         output_b(0b00000011);
         delay_ms(t1);
         output_b(0b00000111);
         delay_ms(t1);
         output_b(0b00001111);
         delay_ms(t1);
         output_b(0b00011111);
         delay_ms(t1);
         output_b(0b00111111);
         delay_ms(t1);
         output_b(0b01111111);
         delay_ms(t1);
         output_b(0b11111111);
         delay_ms(t1);
      }
      if(input(PIN_A2)==0){
         output_b(0b10000000);
         delay_ms(t2);
         output_b(0b11000000);
         delay_ms(t2);
         output_b(0b11100000);
         delay_ms(t2);
         output_b(0b11110000);
         delay_ms(t2);
         output_b(0b11111000);
         delay_ms(t2);
         output_b(0b11111100);
         delay_ms(t2);
         output_b(0b11111110);
         delay_ms(t2);
         output_b(0b11111111);
         delay_ms(t2);
      }
      if(input(PIN_A3)==0){
         output_b(0b00000000);
         output_b(0b00000001);
         delay_ms(t3);
         output_b(0b00000000);
         delay_ms(t3);
         output_b(0b00000011);
         delay_ms(t3);
         output_b(0b00000000);
         delay_ms(t3);
         output_b(0b00000111);
         delay_ms(t3);
         output_b(0b00000000);
         delay_ms(t3);
         output_b(0b00001111);
         delay_ms(t3);
         output_b(0b00000000);
         delay_ms(t3);
         output_b(0b00011111);
         delay_ms(t3);
         output_b(0b00000000);
         delay_ms(t3);
         output_b(0b00111111);
         delay_ms(t3);
         output_b(0b00000000);
         delay_ms(t3);
         output_b(0b01111111);
         delay_ms(t3);
         output_b(0b00000000);
         delay_ms(t3);
         output_b(0b11111111);
         delay_ms(t3);
      }
   }
}

#包括
#使用延迟（时钟=4M）
#保险丝XT，NOWDT
#使用标准io（A）
#使用标准io（B）
int16 t0=2000；
int16 t1=1000；
int16 t2=1000；
int16 t3=500；
void main（）{
输出b（0b0000000）；
while（TRUE）{
如果（输入（引脚A0）=0）{
输出b（0b0000000）；
输出_b（0b00011000）；
延迟μms（t0）；
输出_b（0B00100）；
延迟μms（t0）；
输出_b（0b01000010）；
延迟μms（t0）；
输出_b（0b10000001）；
延迟μms（t0）；
}
如果（输入（引脚A1）==0）{
输出b（0b0000000）；
输出_b（0b0000001）；
延迟μms（t1）；
输出_b（0b00000011）；
延迟μms（t1）；
输出_b（0b0000111）；
延迟μms（t1）；
输出_b（0b00001111）；
延迟μms（t1）；
输出_b（0b00011111）；
延迟μms（t1）；
输出_b（0B0011111）；
延迟μms（t1）；
输出_b（0b01111111）；
延迟μms（t1）；
输出_b（0b11111111）；
延迟μms（t1）；
}
如果（输入（引脚A2）==0）{
输出b（0b10000000）；
延迟时间（t2）；
输出（0b11000000）；
延迟时间（t2）；
输出_b（0b11100000）；
延迟时间（t2）；
输出_b（0b11110000）；
延迟时间（t2）；
输出_b（0b11111000）；
延迟时间（t2）；
输出_b（0b11111100）；
延迟时间（t2）；
输出_b（0b11111110）；
延迟时间（t2）；
输出_b（0b11111111）；
延迟时间（t2）；
}
如果（输入（引脚A3）==0）{
输出b（0b0000000）；
输出_b（0b0000001）；
延迟时间（t3）；
输出b（0b0000000）；
延迟时间（t3）；
输出_b（0b00000011）；
延迟时间（t3）；
输出b（0b0000000）；
延迟时间（t3）；
输出_b（0b0000111）；
延迟时间（t3）；
输出b（0b0000000）；
延迟时间（t3）；
输出_b（0b00001111）；
延迟时间（t3）；
输出b（0b0000000）；
延迟时间（t3）；
输出_b（0b00011111）；
延迟时间（t3）；
输出b（0b0000000）；
延迟时间（t3）；
输出_b（0B0011111）；
延迟时间（t3）；
输出b（0b0000000）；
延迟时间（t3）；
输出_b（0b01111111）；
延迟时间（t3）；
输出b（0b0000000）；
延迟时间（t3）；
输出_b（0b11111111）；
延迟时间（t3）；
}
}
}
您可以编写自己的延迟函数，如下所示：

bool my_delay_ms(int mstime) {
    int current = 0;
    while (current < mstime) {
        delay_ms(10);
        current += 10;
        if (something?) {
            return true;
        }
    }
    return false;
}

bool my\u delay\u ms（int mstime）{
int电流=0；
while（当前<毫秒时间）{
延迟时间（10）；
电流+=10；
如果（某事？）{
返回true；
}
}
返回false；
}
如果（my_delay_ms（t0））继续，则用
替换每个延迟_ms


您可以将10更改为您想要轮询中断信号的频率。该条件检测到中断信号，
continue
允许您的while循环跳到下一个循环，以便在适当的情况下更改顺序。
您可以编写自己的延迟函数，如下所示：


bool my_delay_ms(int mstime) {
    int current = 0;
    while (current < mstime) {
        delay_ms(10);
        current += 10;
        if (something?) {
            return true;
        }
    }
    return false;
}



bool my\u delay\u ms（int mstime）{
int电流=0；
while（当前<毫秒时间）{
延迟时间（10）；
电流+=10；
如果（某事？）{
返回true；
}
}
返回false；
}


如果（my_delay_ms（t0））继续，则用
替换每个延迟_ms


您可以将10更改为您想要轮询中断信号的频率。该条件检测到中断信号，
continue
允许您的while循环跳到下一个周期，以便在适当的情况下更改顺序。
您可以设置一个每毫秒触发一次的计时器，然后将代码重写为状态机。这样，您就不会在延迟例程中浪费cpu周期，并且您能够立即响应按钮按下，至少在一毫秒之内，这对用户来说是即时的

状态机跟踪变量。数字代表它所处的状态。每次执行一个状态时，该状态可能会改变。更改后的状态将在下次计时器触发时执行。每个触发器还检查按钮/去抖动等

确保您的代码在计时器周期内运行，因此不要使用任何延迟，而是使用状态机来执行延迟，或者如果您需要不同的分辨率/计时，则使用另一个计时器

我会让你来设置定时器和中断寄存器


  /* global variables */
  int state = 0;
  unsigned char delaycnt = 0;
  char millisecond_flag = 0;

  void DoStateMachine()
  {    
     switch( state )
     {
        case 100:
           output_b(0b00000000);
           output_b(0b00011000);
           state++;
           delaycnt = 10;
           break;
        case 101:
           delaycnt--;
           if(delaycnt == 0) state = 102;
           break;
           case 200:
           output_b(0b00000000);
           output_b(0b00000001);
           state++;
           delaycnt = 10;
           break;
        case 201:
           delaycnt--;
           if(delaycnt == 0) state = 202;
           break;
        default: 
           state = 0; // do nothing
           break;
      }
  }

  void CheckButtons()
  {
     // Do button debounce here
     if( BUTTON1 == 1)
        state = 100;
     if( BUTTON2 == 1) 
        state = 200;
  }

  void main()
  {
     //Setup timer here

     while(1)
     {
        if( millisecond_flag == 1)
        {
           CheckButtons();
           DoStateMachine();
           millisecond_flag = 0;
        }
        //sleep device?
     }
  }

  // Handle interrupt
  void interrupt ISR()
  {
     if( TMR1IF == 1)
     {
        millisecond_flag = 1;
        TMR1IF = 0;
     }
  }



您可以设置一个每毫秒触发一次的计时器，然后将代码重写为状态机。这样，您就不会在延迟例程中浪费cpu周期，并且您能够立即响应按钮按下，至少在一毫秒之内，这对用户来说是即时的

状态机跟踪变量。数字代表它所处的状态。每次执行一个状态时，该状态可能会改变。更改后的状态将在下次计时器触发时执行。每个触发器还检查按钮/去抖动等

确保您的代码在计时器周期内运行，因此不要使用任何延迟，而是使用状态机来执行延迟，或者如果您需要不同的分辨率/计时，则使用另一个计时器

我会让你来设置定时器和中断寄存器


  /* global variables */
  int state = 0;
  unsigned char delaycnt = 0;
  char millisecond_flag = 0;

  void DoStateMachine()
  {    
     switch( state )
     {
        case 100:
           output_b(0b00000000);
           output_b(0b00011000);
           state++;
           delaycnt = 10;
           break;
        case 101:
           delaycnt--;
           if(delaycnt == 0) state = 102;
           break;
           case 200:
           output_b(0b00000000);
           output_b(0b00000001);
           state++;
           delaycnt = 10;
           break;
        case 201:
           delaycnt--;
           if(delaycnt == 0) state = 202;
           break;
        default: 
           state = 0; // do nothing
           break;
      }
  }

  void CheckButtons()
  {
     // Do button debounce here
     if( BUTTON1 == 1)
        state = 100;
     if( BUTTON2 == 1) 
        state = 200;
  }

  void main()
  {
     //Setup timer here

     while(1)
     {
        if( millisecond_flag == 1)
        {
           CheckButtons();
           DoStateMachine();
           millisecond_flag = 0;
        }
        //sleep device?
     }
  }

  // Handle interrupt
  void interrupt ISR()
  {
     if( TMR1IF == 1)
     {
        millisecond_flag = 1;
        TMR1IF = 0;
     }
  }



可以同时打开多个灯，还是一次只能打开一个灯？如果使用if/else分支而不是使用3个if语句，会发生什么情况？它是