Version 2.3.0 with RFM69HW - Problem communication



  • Hi
    Todaye i update from 2.2.0 version to 2.3.0 on my Home Assistant 0.71.0
    After update to 2.3.0 i have a problem with communication on radio RFM69HW. Sometime lost communication and no reaction. When come back to 2.2.0 all is ok. Please help me....



  • This is my sketch

    // Enable debug prints to serial monitor
    #define MY_DEBUG
    
    // Enable and select radio type attached
    #define MY_RADIO_RFM69
    #define MY_IS_RFM69HW
    #define RFM69_868MH
    #define MY_RFM69_NEW_DRIVER
    
    #define MY_REPEATER_FEATURE
    
    //#define MY_RFM69_CSMA_LIMIT_DBM (-85)
    
    // uncomment if we want to manually assign an ID
    #define MY_NODE_ID 1
    
    #include <Bounce2.h>
    #include <MySensors.h>
    #include <SPI.h>
    
    #define BUTTON_UP_PIN 3  // Arduino Digital I/O pin number for up button
    #define BUTTON_DOWN_PIN 4  // Arduino Digital I/O pin number for down button
    //#define BUTTON_STOP_PIN 5  // Arduino Digital I/O pin number for stop button
    //#define RELAY_DIR_PIN 6  // Arduino Digital I/O pin number for direction relay
    //#define RELAY_POWER_PIN 7  // Arduino Digital I/O pin number for power relay
    #define RELAY_UP_PIN 5 
    #define RELAY_DOWN_PIN 6
    #define RELAY_ON 0
    #define RELAY_OFF 1
    //#define RELAY_DOWN 1
    //#define RELAY_UP 0
    #define DIRECTION_DOWN 0
    #define DIRECTION_UP 1
    #define SKETCH_NAME "Roleta w sypialni"
    #define SKETCH_VER "2.3"
    #define CHILD_ID_COVER 0   // sensor Id of the sensor child
    #define STATE_UP 100 // 100 is open - up
    #define STATE_DOWN 0 // 0 is closed - down
    //#define CHILD_ID_CALIBRATE 1   // sensor Id of the sensor child to calibrate
    #define CHILD_ID_SET 1   // sensor Id of the sensor child to init the roll time
    #define PRESENT_MESSAGE "Rolety dla Home Assistant"
    const int LEVELS = 100; //the number of levels
    float rollTime = 20.0; //the overall rolling time of the shutter
    const bool IS_ACK = false; //is to acknowlage
    static bool initial_state_sent = false;//for hass we need at list one state send at begining
    
    // debouncing parameters
    int value = 0;
    int oldValueUp = 0;
    int oldValueDown = 0;
    int oldValueStop = 0;
    //static unsigned long last_interrupt_time_up = 0;
    //static unsigned long last_interrupt_time_down = 0;
    //static unsigned long debounce_time = 200;
    
    Bounce debouncerUp = Bounce();
    Bounce debouncerDown = Bounce();
    Bounce debouncerStop = Bounce();
    
    // shutter position parameters
    float timeOneLevel = rollTime / LEVELS;
    int requestedShutterLevel = 0;
    int currentShutterLevel = 0;
    unsigned long lastLevelTime = 0;
    bool isMoving = false;
    int directionUpDown;
    bool calibrateDown;
    bool calibrateUp;
    unsigned long calibrationStartTime;
    float calibrationTime = 5.0;
    bool calibratedDown;
    bool calibratedUp;
    
    enum CoverState {
      STOP,
      UP, // Window covering. Up.
      DOWN, // Window covering. Down.
    };
    
    static int coverState = STOP;
    
    MyMessage msgUp(CHILD_ID_COVER, V_UP);
    MyMessage msgDown(CHILD_ID_COVER, V_DOWN);
    MyMessage msgStop(CHILD_ID_COVER, V_STOP);
    MyMessage msgPercentage(CHILD_ID_COVER, V_PERCENTAGE);
    //MyMessage msgCode(CHILD_ID_SET, V_IR_SEND);
    
    void sendState() {
      // Send current state and status to gateway.
    //  send(msgUp.set(coverState == UP));
    //  send(msgDown.set(coverState == DOWN));
    //  send(msgStop.set(coverState == STOP));
      send(msgPercentage.set(currentShutterLevel));
    }
    
    void shuttersUp(void) {
      #ifdef MY_DEBUG
      Serial.println("Shutters going up");
      #endif
      if (digitalRead(RELAY_DOWN_PIN) == RELAY_ON) {
        digitalWrite(RELAY_DOWN_PIN, RELAY_OFF);
        wait(50);
      }
      digitalWrite(RELAY_UP_PIN, RELAY_ON);
    
      directionUpDown = DIRECTION_UP;
      isMoving = true;
      coverState = UP;
      sendState();
    }
    
    void shuttersDown(void) {
      #ifdef MY_DEBUG
      Serial.println("Shutters going down");
      #endif
      if (digitalRead(RELAY_UP_PIN) == RELAY_ON) {
        digitalWrite(RELAY_UP_PIN, RELAY_OFF);
        wait(50);
      }
      digitalWrite(RELAY_DOWN_PIN, RELAY_ON);
    
      directionUpDown = DIRECTION_DOWN;
      isMoving = true;
      coverState = DOWN;
      sendState();
    }
    
    void shuttersHalt(void) {
    #ifdef MY_DEBUG
      Serial.println("Shutters halted");
    #endif
      digitalWrite(RELAY_UP_PIN, RELAY_OFF);
      digitalWrite(RELAY_DOWN_PIN, RELAY_OFF);
    
      isMoving = false;
      requestedShutterLevel = currentShutterLevel;
    #ifdef MY_DEBUG
      Serial.println("saving state to: ");
      Serial.println(String(currentShutterLevel));
    #endif
      saveState(CHILD_ID_COVER, currentShutterLevel);
      coverState = STOP;
      sendState();
    }
    
    void changeShuttersLevel(int level) {
      int dir = (level > currentShutterLevel) ? DIRECTION_UP : DIRECTION_DOWN;
      if (isMoving && dir != directionUpDown) {
        shuttersHalt();
      }
      requestedShutterLevel = level;
    }
    
    void initShutters() {
    #ifdef MY_DEBUG
      Serial.println("Init Cover");
    #endif
      shuttersUp();
      wait((rollTime + timeOneLevel * LEVELS) * 1000);
      currentShutterLevel = STATE_UP;
      requestedShutterLevel = currentShutterLevel;
    }
    
    void receive(const MyMessage &message) {
    #ifdef MY_DEBUG
      Serial.println("recieved incomming message");
      Serial.println("Recieved message for sensor: ");
      Serial.println(String(message.sensor));
      Serial.println("Recieved message with type: ");
      Serial.println(String(message.type));
    #endif
      if (message.sensor == CHILD_ID_COVER) {
        switch (message.type) {
          case V_UP:
            //Serial.println(", New status: V_UP");
            changeShuttersLevel(STATE_UP);
            //state = UP;
            //sendState();
            break;
    
          case V_DOWN:
            //Serial.println(", New status: V_DOWN");
            changeShuttersLevel(STATE_DOWN);
            //state = DOWN;
            //sendState();
            break;
    
          case V_STOP:
            //Serial.println(", New status: V_STOP");
            shuttersHalt();
            //state = IDLE;
            //sendState();
            break;
    
          case V_PERCENTAGE:
            //Serial.println(", New status: V_PERCENTAGE");
            //          if (!initial_state_sent) {
            //            #ifdef MY_DEBUG
            //            Serial.println("Receiving initial value from controller");
            //            #endif
            //            initial_state_sent = true;
            //          }
            int per = message.getInt();
            if (per > STATE_UP) {
              per = STATE_UP;
            }
            changeShuttersLevel(per);
            //InitShutters(message.getInt());//send value < 0 or > 100 to calibrate
            //sendState();
            break;
        }
      } 
    else if (message.sensor ==  CHILD_ID_SET) {
    
        if (message.type == V_VAR1) {
          #ifdef MY_DEBUG
          Serial.println(", New status: V_VAR1, with payload: ");
          #endif      
          String strRollTime = message.getString();
          rollTime = strRollTime.toFloat();
          #ifdef MY_DEBUG
          Serial.println("rolltime value: ");
          Serial.println(String(rollTime));
          #endif
          saveState(CHILD_ID_SET, rollTime);
        }
      }
    #ifdef MY_DEBUG
      Serial.println("exiting incoming message");
    #endif
      return;
    }
    
    void before() {
    
      // Setup the button
      pinMode(BUTTON_UP_PIN, INPUT_PULLUP);
      // Activate internal pull-up
    //  digitalWrite(BUTTON_UP_PIN, HIGH);
      //  attachInterrupt(digitalPinToInterrupt(BUTTON_UP_PIN), upButtonPress, FALLING);
    
      pinMode(BUTTON_DOWN_PIN, INPUT_PULLUP);
      // Activate internal pull-up
    //  digitalWrite(BUTTON_DOWN_PIN, HIGH);
      //  attachInterrupt(digitalPinToInterrupt(BUTTON_DOWN_PIN), downButtonPress, FALLING);
    
    //  pinMode(BUTTON_STOP_PIN, INPUT_PULLUP);
      // Activate internal pull-up
    //  digitalWrite(BUTTON_STOP_PIN, HIGH);
    
      // After setting up the button, setup debouncer
      debouncerUp.attach(BUTTON_UP_PIN);
      debouncerUp.interval(5);
      // After setting up the button, setup debouncer
      debouncerDown.attach(BUTTON_DOWN_PIN);
      debouncerDown.interval(5);
      // After setting up the button, setup debouncer
    //  debouncerStop.attach(BUTTON_STOP_PIN);
    //  debouncerStop.interval(5);
    
      // Make sure relays are off when starting up
      digitalWrite(RELAY_UP_PIN, RELAY_OFF);
      // Then set relay pins in output mode
      pinMode(RELAY_UP_PIN, OUTPUT);
    
      // Make sure relays are off when starting up
      digitalWrite(RELAY_DOWN_PIN, RELAY_OFF);
      // Then set relay pins in output mode
      pinMode(RELAY_DOWN_PIN, OUTPUT);
    }
    
    void presentation() {
      // Send the sketch version information to the gateway and Controller
      sendSketchInfo(SKETCH_NAME, SKETCH_VER);
      // Register all sensors to gw (they will be created as child devices)
      present(CHILD_ID_COVER, S_COVER, PRESENT_MESSAGE, IS_ACK);
      // present(CHILD_ID_SET, S_CUSTOM);
    }
    
    void setup(void) {
      //set up roll time if the saved value is not 255
      #ifdef MY_DEBUG
      Serial.println("getting rolltime from eeprom: ");
      #endif
      float tmpRollTime = loadState(CHILD_ID_SET);
      if (tmpRollTime != 0xff) {
        rollTime = tmpRollTime;
      }
      #ifdef MY_DEBUG
      Serial.println(String(rollTime));
      #endif
      
      int state = loadState(CHILD_ID_COVER);
      
      #ifdef MY_DEBUG
      Serial.println("getting state from eeprom: ");
      Serial.println(String(state));
      #endif
      
    //  if (state == 0xff) {
    //    initShutters();
    //  } else {
        currentShutterLevel = state;
        requestedShutterLevel = state;
    //  }
    }
    
    void loop(void) {
      if (!initial_state_sent) {
    #ifdef MY_DEBUG
        Serial.println("Sending initial value");
    #endif
        sendState();
        
       // send(msgCode.set('20.0'));
        //    #ifdef MY_DEBUG
        //    Serial.println("Requesting initial value from controller");
        //    #endif
        //    request(CHILD_ID_COVER, V_PERCENTAGE);
        //    wait(2000, C_SET, V_PERCENTAGE);
        initial_state_sent = true;
      }
    
      debouncerUp.update();
      value = debouncerUp.read();
      if (value == 0 && value != oldValueUp) {
        if(isMoving){
          shuttersHalt();
        }  
        else{
        calibrateUp = false;
        calibratedUp = false;
        changeShuttersLevel(STATE_UP);
        }
        //state = UP;
        //sendState();
      }
      oldValueUp = value;
    
      debouncerDown.update();
      value = debouncerDown.read();
      if (value == 0 && value != oldValueDown) {
        if(isMoving){
          shuttersHalt();
        }  
        else{
        calibrateDown = false;
        calibratedDown = false;
        changeShuttersLevel(STATE_DOWN);
        }    
        //state = DOWN;
        //sendState();
      }
      oldValueDown = value;
    
    /*  debouncerStop.update();
      value = debouncerStop.read();
      if (value == 0 && value != oldValueStop) {
        shuttersHalt();
        //state = IDLE;
        //sendState();
      }
      oldValueStop = value;
    */
      if(currentShutterLevel != 100)
      {
        calibrateUp = false;
        calibratedUp = false;
      }
      if(currentShutterLevel != 0)
      {
        calibrateDown = false;
        calibratedDown = false;
      }
      
      if (isMoving) 
      {
        unsigned long _now = millis();
        if (_now - lastLevelTime >= timeOneLevel * 1000) {
          if (directionUpDown == DIRECTION_UP) {
            currentShutterLevel += 1;
          } else {
            currentShutterLevel -= 1;
          }
          currentShutterLevel = constrain(currentShutterLevel, 0, 100);
          #ifdef MY_DEBUG
          Serial.println(String(requestedShutterLevel));
          Serial.println(String(currentShutterLevel));
          #endif
          lastLevelTime = millis();
          send(msgPercentage.set(currentShutterLevel));
        }
        if (currentShutterLevel == requestedShutterLevel) 
        {
          if(currentShutterLevel == 0 && !calibratedDown)
          {
            if(calibrateDown == false)
            {
              calibrateDown = true;
              calibratedDown = false;
              calibrationStartTime = _now;
            }
            else 
            {
              if(calibratedDown == false)
              {
                if (_now - calibrationStartTime >= calibrationTime * 1000)
                {
                 calibratedDown = true;
                }
              }
            }
          }
          else if (currentShutterLevel == 100 && !calibratedUp)
          {
            if(calibrateUp == false)
            {
              calibrateUp = true;
              calibratedUp = false;
              calibrationStartTime = _now;
            }
            else 
            {
              if(calibratedUp == false)
              {
                if (_now - calibrationStartTime >= calibrationTime * 1000)
                {
                 calibratedUp = true;
                }
              }
            }
          }
          else
          {
            shuttersHalt();
          }
        }
      } 
      else 
      {
        if (requestedShutterLevel != currentShutterLevel) 
        {
          if (requestedShutterLevel > currentShutterLevel) {
            shuttersUp();
          }
          else {
            shuttersDown();
          }
          lastLevelTime = millis();
        }
      }
    }
    

 

409
Online

7.8k
Users

8.7k
Topics

92.9k
Posts