Arduino.ru

Всем доброго дня.

Возникла нужда добавить новые переменные в библиотеку RCSwitch.

Сама библиотека была урезана до минимального необходимого рабочего функционала

   с библиотекой используется такой радиопульт с алиэкспрэс на 433мгц.

   И модуль приёмника 433мгц.

   Хочу подключить данный пульт к гирлянде на WS2812 но мне необходимо вывести переменную которая будет сигнализировать о том что данный приняты и можно выводить данные на гирлянду. А когда поступают данные с пульта остонавливать вывод на гирлянду обработать команды с пульта и только потом вернутся к выводу на гирлянду.

//скетч
//RF_remote
#include "RCSwitch_mini.h"
RCSwitch_mini mySwitch = RCSwitch_mini();
//--------------------------------------------------------------------
void setup() 
{
  Serial.begin(9600);
  mySwitch.enableReceive(0);  // прерывание по приёму данных по RF INT0(pin2).
}
//--------------------------------------------------------------------
void loop() 
{
  if (mySwitch.available()) 
  {
    int value1 = mySwitch.getReceivedValue();
    if (value1) 
    {
      
      Serial.println(mySwitch.getReceivedValue());
      
      if (mySwitch.flag)
      {
         Serial.println("010");
      }
    }
  }
    mySwitch.resetAvailable();
}

//RCSwitch_mini.cpp
/*
  RCSwitch_mini
*/
#include "RCSwitch_mini.h"
boolean rf_flag1;
unsigned long RCSwitch_mini::nReceivedValue = NULL;
unsigned int RCSwitch_mini::nReceivedBitlength = 0;
unsigned int RCSwitch_mini::nReceivedDelay = 0;
unsigned int RCSwitch_mini::nReceivedProtocol = 0;
int RCSwitch_mini::nReceiveTolerance = 60;
unsigned int RCSwitch_mini::timings[RCSWITCH_MAX_CHANGES];
//-------------------------------------------------------------------------
RCSwitch_mini::RCSwitch_mini() 
{
  this->nReceiverInterrupt = -1;
  this->setReceiveTolerance(60);
  RCSwitch_mini::nReceivedValue = NULL;
}
//-------------------------------------------------------------------------
// Set Receiving Tolerance
void RCSwitch_mini::setReceiveTolerance(int nPercent) 
{
  RCSwitch_mini::nReceiveTolerance = nPercent;
}
//-------------------------------------------------------------------------
//Enable receiving data
void RCSwitch_mini::enableReceive(int interrupt) 
{
  nReceiverInterrupt = interrupt;
  if (this->nReceiverInterrupt != -1) 
  {
    RCSwitch_mini::nReceivedValue = NULL;
    RCSwitch_mini::nReceivedBitlength = NULL;
    attachInterrupt(this->nReceiverInterrupt, handleInterrupt, CHANGE);
  }
}
//-------------------------------------------------------------------------
bool RCSwitch_mini::available() 
{
  return RCSwitch_mini::nReceivedValue != NULL;
}
//-------------------------------------------------------------------------
void RCSwitch_mini::resetAvailable() 
{
  RCSwitch_mini::nReceivedValue = NULL;
}
//-------------------------------------------------------------------------
unsigned long RCSwitch_mini::getReceivedValue() 
{
    return RCSwitch_mini::nReceivedValue;
}
//-------------------------------------------------------------------------
bool RCSwitch_mini::receiveProtocol(unsigned int changeCount)
{
      unsigned long code = 0;
      unsigned long delay = RCSwitch_mini::timings[0] / 31;
      unsigned long delayTolerance = delay * RCSwitch_mini::nReceiveTolerance * 0.01;    

      for (int i = 1; i<changeCount; i = i + 2) 
      {
          if (RCSwitch_mini::timings[i] > delay-delayTolerance && RCSwitch_mini::timings[i] < delay+delayTolerance && RCSwitch_mini::timings[i+1] > delay*3-delayTolerance && RCSwitch_mini::timings[i+1] < delay*3+delayTolerance) 
          {
            code = code << 1;
          } 
          else if (RCSwitch_mini::timings[i] > delay*3-delayTolerance && RCSwitch_mini::timings[i] < delay*3+delayTolerance && RCSwitch_mini::timings[i+1] > delay-delayTolerance && RCSwitch_mini::timings[i+1] < delay+delayTolerance) 
          {
            code += 1;
            code = code << 1;
          } 
          else 
          {
            // Failed
            i = changeCount;
            code = 0;
          }
      }      
      code = code >> 1;
      
    if (changeCount > 6) 
    {    // ignore < 4bit values as there are no devices sending 4bit values => noise
      RCSwitch_mini::nReceivedValue = code;
      RCSwitch_mini::nReceivedBitlength = changeCount / 2;
      RCSwitch_mini::nReceivedDelay = delay;
      RCSwitch_mini::nReceivedProtocol = 1;
    }

    if (code == 0)
    {
        flag = false;
        return false;
    }
    else if (code != 0)
    {
        flag = true;
        return true;
    }
}
//-------------------------------------------------------------------------
void RCSwitch_mini::handleInterrupt() //Прерывание по приходу данных по RF
{
  static unsigned int duration;
  static unsigned int changeCount;
  static unsigned long lastTime;
  static unsigned int repeatCount;
  long time = micros();
  duration = time - lastTime;
 
  if (duration > 5000 && duration > RCSwitch_mini::timings[0] - 200 && duration < RCSwitch_mini::timings[0] + 200) 
  {
    repeatCount++;
    changeCount--;
    if (repeatCount == 2) 
    {
      if (receiveProtocol(changeCount) == false){ }
      repeatCount = 0;
    }
    changeCount = 0;
  } 
  else if (duration > 5000) 
  {
    changeCount = 0;
  }
 
  if (changeCount >= RCSWITCH_MAX_CHANGES) 
  {
    changeCount = 0;
    repeatCount = 0;
  }
  RCSwitch_mini::timings[changeCount++] = duration;
  lastTime = time;  
}
//-------------------------------------------------------------------------

//RCSwitch_mini.h
/*
  RCSwitch_mini
*/
#ifndef _RCSwitch_mini_h
#define _RCSwitch_mini_h

#if defined(ARDUINO) && ARDUINO >= 100
    #include "Arduino.h"
#else
    #include "WProgram.h"
#endif

// Number of maximum High/Low changes per packet.
// We can handle up to (unsigned long) => 32 bit * 2 H/L changes per bit + 2 for sync
#define RCSWITCH_MAX_CHANGES 67

class RCSwitch_mini 
{
  public:
    RCSwitch_mini();  
    void enableReceive(int interrupt);
    void enableReceive();
    void disableReceive();
    bool available();
    void resetAvailable();
    unsigned long getReceivedValue();
    void setReceiveTolerance(int nPercent);
    volatile boolean flag;
    
  private:    
    static void handleInterrupt();
    static bool receiveProtocol(unsigned int changeCount);
    int nReceiverInterrupt;
    int nPulseLength;
    int nRepeatTransmit;
    char nProtocol;
    static int nReceiveTolerance;
    static unsigned long nReceivedValue;
    static unsigned int nReceivedBitlength;
    static unsigned int nReceivedDelay;
    static unsigned int nReceivedProtocol;
    // timings[0] contains sync timing, followed by a number of bits
    static unsigned int timings[RCSWITCH_MAX_CHANGES];  
};
#endif

Вот кусочек кода откуда я хочу получить в скетч состояние переменной Flag

    if (code == 0)
    {
        flag = false;
        return false;
    }
    else if (code != 0)
    {
        flag = true;
        return true;
    }