ARDUINO ir& attachInterrupt

Песочница. Раздел для новичков
1

Здравствуйте. Код работает, но, results.value принимает предыдущую кодироку. Т.е. если я нажал сначала на “кнопку 1”, он не прймет никаких значений. Затем, если нажал на “кнопку 2” он приймет кодировку кнопки 1

#include <IRremote.h>

IRrecv reciver(2); 
decode_results results;

void setup(){
  Serial.begin(9600);

  reciver.enableIRIn();

  attachInterrupt(0, decoder, FALLING);
}

void loop(){
  Serial.println(results.value);
}

void decoder(){
  if(reciver.decode(&results)){
    reciver.resume();
  }
}
2 
attachInterrupt(0, decoder, RISING);

Значит попробуй так

3

А почему “но”? Как написал, так и работает.

2 лайка
4

Вроде бы и понятно почему FALLING, сигнал упал он принял, а в идеале нужно когда сигнал поднялся. Но увы пока что не понимаю почему не работает даже при RASING. По-логике: данные пришли, сигнал упал, он принял их, потом сигнал поднимаеться и я их куда-то беру. Увы пока что не вдупляю. Куда копать?

5

По какой такой логике? Может ты посмотришь на реальный сигнал?

1 лайк
6

Имеешь ввиду? Если брать елементарщину, то все что я проверил это банальный analogRead(); увидел что сигнал упал с ~1023 на ~0. Вот и пишу. Извиняй за мои возможно столь не разумные слова. Но я пока головой не понимаю как мне еще можно посмотреть “реальный сигнал”

7

Осциллографом же, чем ещё? )))

1 лайк
8

Сигнал там фактически скачет. Прерывание срабатывает несколько раз. Все что смог допереть

9

Так ладно. Вопрос в лоб. То что стоит после условия “if(reciver.decode(&results))”, вот то все и мешает?? Этот вопрос уже не о прерываниях.

/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
/*-----------------PROGRAMM_SETTING-------------------------------------------------------------------------------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/

/*--IR_SETTINGS---------->*/
#define IR_PIN A1

/*--STRIP_SETTINGS------->*/
#define STRIP_PIN 6
#define STRIP_LED_NUM 25

/*--STRIP_INITIAL-------->*/
#define STRIP_BIRGHT_STEP 15

#define MAX_BRIGHT_VALUE 255
#define MIN_BRIGHT_VALUE 0

/*--IR_BUTTONS_SETTINGS-->*/
#define COMMON_BRIGHTNESS_UP 16769055
#define COMMON_BRIGHTNESS_DOWN 16736415

#define LEDS_BRIGHTNESS_UP 16752735
#define LEDS_BRIGHTNESS_DOWN 16720095

#define RED_SETTING_BUTTON 16748655
#define GREEN_SETTING_BUTTON 16716015 
#define BLUE_SETTING_BUTTON 16732335
#define WHITE_SETTING_BUTTON 16764975

#define RED_B 16756815
#define GREEN_B 16724175
#define BLUE_B 16740495

#define L_ORANGE_B 16754775
#define L_TURQUISE_B 16722135
#define D_VIOLET_B 16738455

#define ORANGE_B 16750695
#define TURQUISE_B 16718055
#define VIOLET_B 16734375

#define YELLLOW_B 16746615
#define D_TURQUISE_B 16713975
#define L_VIOLET_B 16730295

/*BUTTON_FOR_EFFECTS*/
#define RAINBOW_B 16762935

/*--COLORS_ARRAY----------------------------------------------->*/
uint8_t COLORS[12][3]
{
  {255, 0,   0},    /* 1x1 - RED              */
  {0,   255, 0},    /* 1x2 - GREEN            */
  {0,   0,   255},  /* 1x3 - BLUE             */

  {255, 30,  0},    /* 2x1 - LIGHT_ORANGE     */
  {0,   255, 255},  /* 2x2 - IGHT_TURQUISE    */
  {45,  0,   35},   /* 2x3 - DARK_VIOLET      */

  {255, 45,  0},    /* 3x1 - ORANGE_BUTTON    */
  {0,   105, 135},  /* 3x2 - TURQUISE_BUTTON  */
  {90,  0,   75},   /* 3x3 - VIOLET_BUTTON    */

  {200, 90, 0},     /* 4x1 - YELLOW_BUTTON        */
  {0,   0,  165},   /* 4x2 - DARK_TURQUISE_BUTTON */
  {255, 0,  75}     /* 4x3 - LIGHT_VIOLET_BUTTON  */
};

/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
/*-----------------MAIN-CODE--------------------------------------------------------------------------------------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/

/*LIBRARIES----------------------------------------------------->*/
#include "Adafruit_NeoPixel.h"
#include <IRremote.h>

/*INITIALIZATION------------------------------------------------>*/
Adafruit_NeoPixel strip(STRIP_LED_NUM, STRIP_PIN, NEO_GRB + NEO_KHZ800); /*--STRIP--->*/
IRrecv reciver(IR_PIN); /*---------------------------------------------------REMOTE-->*/
decode_results results; /*---------------------------------------------------REMOTE-->*/

/*VARIABLES----------------------------------------------------->*/
/*STRIP--------->*/
uint8_t bright, redBright, greenBright, blueBright, whiteBright;
uint8_t commonBrightCounter;
bool stripMode;

/*MODES--------->*/
/*RGBW------->*/
bool RGBW_MODES[] = 
{ 0, 0, 0, 0 };

bool brightSettingMode = true;

/*COLORS----->*/
bool COLOR_MODE[] = 
{
  0, 0, 0,
  0, 0, 0,
  0, 0, 0,
  0, 0, 0
};

/*EFFECTS---->*/
bool EFFECTS_MODES[] = 
{ 0, 0, 0, 0 };

/*RAINBOW-->*/
uint8_t rainbowModeSwitcher;
bool rainbowLoopMode;

uint8_t rainbowTimeCounter = 0;
uint16_t rainbowTimeStep = 16;

unsigned long rainbowLastTime;

uint8_t rainbowModesCounter;

/*---------------------------SETUP-----------------------------------------------------------*/
void setup() {

/*SERIAL------------------>*/
Serial.begin(9600);

/*IR_RECIVER-------------->*/
reciver.enableIRIn();

/*STRIP------------------->*/
strip.begin();
strip.setBrightness(0);
strip.show();

}
/*---------------------------LOOP------------------------------------------------------------*/
void loop() {
  if(reciver.decode(&results)){ Serial.println(results.value);
    
    if(results.value == COMMON_BRIGHTNESS_UP or results.value == COMMON_BRIGHTNESS_DOWN){
      if(results.value == COMMON_BRIGHTNESS_UP){
        if(commonBrightCounter >= 0 and commonBrightCounter < 5){ commonBrightCounter++; }
        else{ commonBrightCounter = 0; }
      }
      else{
        if(commonBrightCounter <= 5 and commonBrightCounter > 0){ commonBrightCounter--; }
        else{ commonBrightCounter = 5; }
      }

      switch(commonBrightCounter){
        case 0: stripMode = false; COMMON_MODES_RESET(); break;
        case 1: strip.setBrightness(51); stripMode = true; break;
        case 2: strip.setBrightness(102); stripMode = true; break;
        case 3: strip.setBrightness(153); stripMode = true; break;
        case 4: strip.setBrightness(204); stripMode = true; break;
        case 5: strip.setBrightness(255); stripMode = true; break;
      }
    }

      if(stripMode == true){
        
        /*BRIGHT_SETTING------------------------------------------------>*/
        if(results.value == LEDS_BRIGHTNESS_UP or results.value == LEDS_BRIGHTNESS_DOWN){
          if(brightSettingMode == true){
            if(results.value == LEDS_BRIGHTNESS_UP){
              if(bright >= 0 and bright <= MAX_BRIGHT_VALUE - STRIP_BIRGHT_STEP){
                bright += STRIP_BIRGHT_STEP;
              }
            }
            else{
              if(bright <= 255 and bright >= MIN_BRIGHT_VALUE + STRIP_BIRGHT_STEP){
                bright -= STRIP_BIRGHT_STEP;
              }
            }
          }
          else{
            if(results.value == LEDS_BRIGHTNESS_UP){
              if(rainbowTimeCounter >= 0 and rainbowTimeCounter < 7){
                rainbowTimeCounter++;
              }
            }
            else{
              if(rainbowTimeCounter <= 7 and rainbowTimeCounter >= 1){
                rainbowTimeCounter--;
              }
            }

            switch(rainbowTimeCounter){
              case 0: rainbowTimeStep = 16; break;
              case 1: rainbowTimeStep = 32; break;
              case 2: rainbowTimeStep = 64; break;
              case 3: rainbowTimeStep = 128; break;
              case 4: rainbowTimeStep = 256; break;
              case 5: rainbowTimeStep = 512; break;
              case 6: rainbowTimeStep = 1024; break;
              case 7: rainbowTimeStep = 0; rainbowTimeCounter = 0; break;
            }
          }

          Serial.println(rainbowTimeCounter);
        }

        /*RGBW-SETTING-------------------------------------------------->*/
        switch(results.value){
          case RED_SETTING_BUTTON:
            COMMON_MODES_RESET(); RGBW_mode_setter(1, 0, 0, 0); 
            bright = redBright; 
            break;
          case GREEN_SETTING_BUTTON:
            COMMON_MODES_RESET(); RGBW_mode_setter(0, 1, 0, 0); 
            bright = greenBright;
            break;
          case BLUE_SETTING_BUTTON:
            COMMON_MODES_RESET(); RGBW_mode_setter(0, 0, 1, 0); 
            bright = blueBright; 
            break;
          case WHITE_SETTING_BUTTON:
            COMMON_MODES_RESET(); RGBW_mode_setter(0, 0, 0, 1);
            bright = whiteBright;
            break;
        }

        if(RGBW_MODES[0] or RGBW_MODES[1] or RGBW_MODES[2] or RGBW_MODES[3]){  brightSettingMode = true;
          if(RGBW_MODES[0]){ redBright = bright;
            strip.fill(strip.Color(redBright, greenBright, blueBright), 0, STRIP_LED_NUM);
          }
          else if(RGBW_MODES[1]){ greenBright = bright;
            strip.fill(strip.Color(redBright, greenBright, blueBright), 0, STRIP_LED_NUM);
          }
          else if(RGBW_MODES[2]){ blueBright = bright;
            strip.fill(strip.Color(redBright, greenBright, blueBright), 0, STRIP_LED_NUM);
          }
          else if(RGBW_MODES[3]){ whiteBright = bright;
            strip.fill(strip.Color(whiteBright, whiteBright/1.2, whiteBright), 0, STRIP_LED_NUM);
          }
        }

        /*COLOR-SETTING------------------------------------------------->*/
        /*ROW_0-------------------------->*/
        switch (results.value) {
          case RED_B: 
            COLORS_mode_setter(!COLOR_MODE[0], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); RGBW_mode_setter(0, 0, 0, 0); EFFECTS_mode_setter(0, 0, 0, 0);
            if(COLOR_MODE[0] == true){ 
              RGBW_bright_setter(COLORS[0][0], COLORS[0][1], COLORS[0][2], 0);
              stripFill(redBright, greenBright, blueBright);
            }
            else{ stripFill(0, 0, 0); }
          break;

          case GREEN_B: 
            COLORS_mode_setter(0, !COLOR_MODE[1], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); RGBW_mode_setter(0, 0, 0, 0); EFFECTS_mode_setter(0, 0, 0, 0);
            if(COLOR_MODE[1] == true){ 
              RGBW_bright_setter(COLORS[1][0], COLORS[1][1], COLORS[1][2], 0);
              stripFill(redBright, greenBright, blueBright);
            }
            else{ stripFill(0, 0, 0); }
          break;

          case BLUE_B: 
            COLORS_mode_setter(0, 0, !COLOR_MODE[2], 0, 0, 0, 0, 0, 0, 0, 0, 0); RGBW_mode_setter(0, 0, 0, 0); EFFECTS_mode_setter(0, 0, 0, 0);
            if(COLOR_MODE[2] == true){ 
              RGBW_bright_setter(COLORS[2][0], COLORS[2][1], COLORS[2][2], 0);
              stripFill(redBright, greenBright, blueBright);
            }
            else{ stripFill(0, 0, 0); }
          break;

          /*ROW_1-------------------------->*/
          case L_ORANGE_B: 
            COLORS_mode_setter(0, 0, 0, !COLOR_MODE[3], 0, 0, 0, 0, 0, 0, 0, 0); RGBW_mode_setter(0, 0, 0, 0); EFFECTS_mode_setter(0, 0, 0, 0);
            if(COLOR_MODE[3] == true){ 
              RGBW_bright_setter(COLORS[3][0], COLORS[3][1], COLORS[3][2], 0);
              stripFill(redBright, greenBright, blueBright);
            }
            else{ stripFill(0, 0, 0); }
          break;

          case L_TURQUISE_B: 
            COLORS_mode_setter(0, 0, 0, 0, !COLOR_MODE[4], 0, 0, 0, 0, 0, 0, 0); RGBW_mode_setter(0, 0, 0, 0); EFFECTS_mode_setter(0, 0, 0, 0);
            if(COLOR_MODE[4] == true){ 
              RGBW_bright_setter(COLORS[4][0], COLORS[4][1], COLORS[4][2], 0);
              stripFill(redBright, greenBright, blueBright);
            }
            else{ stripFill(0, 0, 0); }
          break;

          case D_VIOLET_B: 
            COLORS_mode_setter(0, 0, 0, 0, 0, !COLOR_MODE[5], 0, 0, 0, 0, 0, 0); RGBW_mode_setter(0, 0, 0, 0); EFFECTS_mode_setter(0, 0, 0, 0);
            if(COLOR_MODE[5] == true){ 
              RGBW_bright_setter(COLORS[5][0], COLORS[5][1], COLORS[5][2], 0);
              stripFill(redBright, greenBright, blueBright);
            }
            else{ stripFill(0, 0, 0); }
          break;

          /*ROW_2-------------------------->*/
            case ORANGE_B: 
            COLORS_mode_setter(0, 0, 0, 0, 0, 0, !COLOR_MODE[6], 0, 0, 0, 0, 0); RGBW_mode_setter(0, 0, 0, 0); EFFECTS_mode_setter(0, 0, 0, 0);
            if(COLOR_MODE[6] == true){ 
              RGBW_bright_setter(COLORS[6][0], COLORS[6][1], COLORS[6][2], 0);
              stripFill(redBright, greenBright, blueBright);
            }
            else{ stripFill(0, 0, 0); }
          break;

          case TURQUISE_B: 
            COLORS_mode_setter(0, 0, 0, 0, 0, 0, 0, !COLOR_MODE[7], 0, 0, 0, 0); RGBW_mode_setter(0, 0, 0, 0); EFFECTS_mode_setter(0, 0, 0, 0);
            if(COLOR_MODE[7] == true){ 
              RGBW_bright_setter(COLORS[7][0], COLORS[7][1], COLORS[7][2], 0);
              stripFill(redBright, greenBright, blueBright);
            }
            else{ stripFill(0, 0, 0); }
          break;

          case VIOLET_B: 
            COLORS_mode_setter(0, 0, 0, 0, 0, 0, 0, 0, !COLOR_MODE[8], 0, 0, 0); RGBW_mode_setter(0, 0, 0, 0); EFFECTS_mode_setter(0, 0, 0, 0);
            if(COLOR_MODE[8] == true){ 
              RGBW_bright_setter(COLORS[8][0], COLORS[8][1], COLORS[8][2], 0);
              stripFill(redBright, greenBright, blueBright);
            }
            else{ stripFill(0, 0, 0); }
          break;
          
          /*ROW_3-------------------------->*/
          case YELLLOW_B: 
            COLORS_mode_setter(0, 0, 0, 0, 0, 0, 0, 0, 0, !COLOR_MODE[9], 0, 0); RGBW_mode_setter(0, 0, 0, 0); EFFECTS_mode_setter(0, 0, 0, 0);
            if(COLOR_MODE[9] == true){ 
              RGBW_bright_setter(COLORS[9][0], COLORS[9][1], COLORS[9][2], 0);
              stripFill(redBright, greenBright, blueBright);
            }
            else{ stripFill(0, 0, 0); }
          break;

          case D_TURQUISE_B: 
            COLORS_mode_setter(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, !COLOR_MODE[10], 0); RGBW_mode_setter(0, 0, 0, 0); EFFECTS_mode_setter(0, 0, 0, 0);
            if(COLOR_MODE[10] == true){ 
              RGBW_bright_setter(COLORS[10][0], COLORS[10][1], COLORS[10][2], 0);
              stripFill(redBright, greenBright, blueBright);
            }
            else{ stripFill(0, 0, 0); }
          break;

          case L_VIOLET_B: 
            COLORS_mode_setter(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, !COLOR_MODE[11]); RGBW_mode_setter(0, 0, 0, 0); EFFECTS_mode_setter(0, 0, 0, 0);
            if(COLOR_MODE[11] == true){ 
              RGBW_bright_setter(COLORS[11][0], COLORS[11][1], COLORS[11][2], 0);
              stripFill(redBright, greenBright, blueBright);
            }
            else{ stripFill(0, 0, 0); }
          break;
        }

        /*RAINBOW_SETTING----------------------------------------------->*/
        switch(results.value){
          case RAINBOW_B: brightSettingMode = false;
            COMMON_MODES_RESET(); EFFECTS_mode_setter(1, 0, 0, 0);
            
            if(rainbowModeSwitcher >= 0 and rainbowModeSwitcher < 2){ rainbowModeSwitcher++; }
            else { rainbowModeSwitcher = 0; }

            switch(rainbowModeSwitcher){
              case 0: rainbowLoopMode = false; stripFill(0, 0, 0);  break;
              case 1: rainbowLoopMode = true; break;
              case 2: rainbowLoopMode = false; stripFill(redBright, greenBright, blueBright); break;
            }
          break;
        }

      }

      else{ 
        strip.fill(strip.Color(0, 0, 0), 0, STRIP_LED_NUM);
      }

    strip.show();
    reciver.resume();
  }
  
  if(millis() - rainbowLastTime >= rainbowTimeStep){ rainbowLastTime = millis();
    if(rainbowLoopMode == true){
      if(rainbowModesCounter == 0){
        if(redBright >= 0 and redBright < 255){
          redBright++;
          if(redBright == 255){ rainbowModesCounter = 1; }
        }
      }
      else if(rainbowModesCounter == 1){
        if(redBright <= 255 and redBright > 0){ redBright--; }
        if(greenBright >= 0 and greenBright < 255){ greenBright++; }
        if(redBright == 0 and greenBright == 255){ rainbowModesCounter = 2; }          
      }
      else if(rainbowModesCounter == 2){
        if(greenBright <= 255 and greenBright > 0){ greenBright--; }
        if(blueBright >= 0 and blueBright < 255){ blueBright++; }
        if(greenBright == 0 and blueBright == 255){ rainbowModesCounter = 3; }
      }
      else if(rainbowModesCounter == 3){
        if(blueBright <= 255 and blueBright > 0){ blueBright--; }
        if(redBright >= 0 and redBright < 255){ redBright++; }
        if(blueBright == 0 and redBright == 255){ rainbowModesCounter = 1; }
      }

      stripFill(redBright, greenBright, blueBright);
      strip.show();
    }
  }
  
}

/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
/*-----------------FUNCTIONS--------------------------------------------------------------------------------------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/

/*RGBW_FUNCTIONS-------------------------------------------------->*/
void RGBW_mode_setter(bool redMode,
                      bool greenMode,
                      bool blueMode, 
                      bool whiteMode ){
  RGBW_MODES[0] = redMode;
  RGBW_MODES[1] = greenMode;
  RGBW_MODES[2] = blueMode;
  RGBW_MODES[3] = whiteMode;
}

void RGBW_bright_setter(uint8_t red, 
                        uint8_t green, 
                        uint8_t blue, 
                        uint8_t white ){
  redBright = red;
  greenBright = green;
  blueBright = blue;
  whiteBright = white;
}

/*COLORS_FUNCTION------------------------------------------------->*/
void COLORS_mode_setter(bool col0, bool col1,  bool col2,
                        bool col3, bool col4,  bool col5,
                        bool col6, bool col7,  bool col8,
                        bool col9, bool col10, bool col11 ){

  COLOR_MODE[0] = col0;
  COLOR_MODE[1] = col1;
  COLOR_MODE[2] = col2;
  COLOR_MODE[3] = col3;
  COLOR_MODE[4] = col4;
  COLOR_MODE[5] = col5;
  COLOR_MODE[6] = col6;
  COLOR_MODE[7] = col7;
  COLOR_MODE[8] = col8;
  COLOR_MODE[9] = col9;
  COLOR_MODE[10] = col10;
  COLOR_MODE[11] = col11;

}

/*EFFECTS_FUNCTION------------------------------------------------>*/
void EFFECTS_mode_setter(bool eff0,
                         bool eff1,
                         bool eff2,
                         bool eff3 ){

  if(eff0 == false){ EFFECTS_MODES[0] = 0;  rainbowLoopMode = false; rainbowModeSwitcher = 0; }
  else{ EFFECTS_MODES[0] = eff0; }

  EFFECTS_MODES[1] = eff1;
  EFFECTS_MODES[2] = eff2;
  EFFECTS_MODES[3] = eff3;

}

/*COMMON_RESET---------------------------------------------------->*/
void COMMON_MODES_RESET(){
  for(uint8_t index = 0; index <= 3; index++){
    RGBW_MODES[index] = 0;
  }
  for(uint8_t index = 0; index <= 11; index++){
    COLOR_MODE[index] = 0;
  }
  for(uint8_t index = 0; index <= 3; index++){
    EFFECTS_MODES[index] = 0;
  }
}

/*OTHER_FUNCTIONS------------------------------------------------->*/
void stripFill(uint8_t red, uint8_t green, uint8_t blue){
  strip.fill(strip.Color(red, green, blue), 0, STRIP_LED_NUM);
}
10

Сигнал передается пачкой импульсов. Вы реагируете на первый импульс, когда пачка импульсов только начала приниматься, соответственно ничего не принято. Использовать прерывание в данном случае нет смысла, и даже вредно, т.к. может помешать приему сигнала. Посмотрите в чужих примерах, как работать с этой библиотекой.

11

Понял спасибо. Хотел бы спросить, есть ли какие-то плюс минус продвинутые сайты с проектами людей. Или стоит просто месатми лазить и смотреть?

12

гугль

1 лайк
13

всем спасибо разобрался)

14

уверен? :slight_smile:

15

Очень даже полезно.
Скажем так я реализовывал параллельную работу пульта и библиотеки Neopixel.
Тупо по прерыванию все бросаем, отключаем прерывание ,заканчиваем вывод текущего эффекта и читаем , что же там пришло с пульта.