Navigation

    • Register
    • Login
    • Search
    • OpenHardware.io
    • Categories
    • Recent
    • Tags
    • Popular
    1. Home
    2. JCH
    • Profile
    • Following
    • Followers
    • Topics
    • Posts
    • Best
    • Groups

    JCH

    @JCH

    3
    Reputation
    19
    Posts
    281
    Profile views
    0
    Followers
    0
    Following
    Joined Last Online

    JCH Follow

    Best posts made by JCH

    • Trying to build a ethernet gateway but cant set an ip address

      I have been running a serial gateway for quite a few years now but i have just built a ethernet gateway and am trying to get it up and running.....
      Here is the output from the monitor.
      MCO:BGN:INIT GW,CP=RNNGA---,FQ=16,REL=255,VER=2.3.2
      4 TSM:INIT
      5 TSF:WUR:MS=0
      12 TSM:INIT:TSP OK
      13 TSM:INIT:GW MODE
      15 TSM:READY:ID=0,PAR=0,DIS=0
      18 MCO:REG:NOT NEEDED
      601 GWT:TIN:IP=5.0.0.0
      1603 MCO:BGN:STP
      1604 MCO:BGN:INIT OK,TSP=1
      1607 TSM:READY:NWD REQ
      1612 ?TSF:MSG:SEND,0-0-255-255,s=255,c=3,t=20,pt=0,l=0,sg=0,ft=0,st=OK:
      1903 TSF:MSG:READ,9-9-0,s=255,c=3,t=21,pt=1,l=1,sg=0:0
      1911 TSF:MSG:READ,0-9-255,s=255,c=3,t=20,pt=0,l=0,sg=0:
      1916 TSF:MSG:BC
      1949 TSF:MSG:READ,14-9-0,s=3,c=1,t=16,pt=2,l=2,sg=0:0
      1956 TSF:MSG:READ,11-9-0,s=255,c=3,t=21,pt=1,l=1,sg=0:9
      2395 TSF:MSG:READ,14-9-0,s=255,c=3,t=21,pt=1,l=1,sg=0:9
      2509 TSF:MSG:READ,10-9-0,s=255,c=3,t=21,pt=1,l=1,sg=0:9
      2518 TSF:MSG:READ,10-9-0,s=255,c=3,t=21,pt=1,l=1,sg=0:9

      I cant seem to set an ip address, it keeps giving a random one each time i restart it. Any ideas?

      posted in Troubleshooting
      JCH
      JCH
    • RE: Sketch problems.... I think

      Turns out i had a bad battery...... Must of shorted internally and was causing my arduino to go crazy 👻.
      Node is up and running and reporting perfectly. Power consumption is approx 220uA.
      Reporting temp, humidity, light level , barometer, forecast and battery level.
      Here is the code if anyone wants..................

      /**
      OUTDOOR WEATHER STATION SKETCH
      TEMP AND PRESSURE VIA BMP180
      HUMIDITY VIA DHT22
      LIGHT SENSOR VIA LM393
      SOIL MOISTURE VIA SOIL MOISTURE SENSOR
      
      CREATED BY J.H 4.3.2020
      
      REV 2
       *
       */
      
      // Enable debug prints to serial monitor
      #define MY_DEBUG 
      
      // Enable and select radio type attached
      #define MY_RADIO_NRF24
      
      // Define Node ID
      #define MY_NODE_ID 5
      
      // Includes
      #include <SPI.h>
      #include <MySensors.h>  
      #include <Wire.h>
      #include <Adafruit_BMP085.h>
      #include <DHT.h>
      
      // Pin Defines
      #define DHT_DATA_PIN 2
      #define LIGHT_SENSOR_ANALOG_PIN 1
      #define LUX_ON 5
      
      // Defines
      #define POWER_ON 1  //  value to write to turn on sensor
      #define POWER_OFF 0 //  value to write to turn off sensor
      
      #define BARO_CHILD 0
      #define TEMP_CHILD 1
      #define VOLTAGE_CHILD_ID 3
      #define CHILD_ID_HUM 4
      #define CHILD_ID_LIGHT 5
      
      
      static const uint64_t UPDATE_INTERVAL = 30000;
      static const uint8_t FORCE_UPDATE_N_READS = 10;
      
      int BATTERY_SENSE_PIN = A0;  // select the input pin for the battery sense point
      
      int oldBatteryPcnt = 0;
      
      const float ALTITUDE = 59; // <-- adapt this value to your own location's altitude.
      
      // Sleep time between reads (in seconds). Do not change this value as the forecast algorithm needs a sample every minute.
      const unsigned long SLEEP_TIME = 60000; 
      
      const char *weather[] = { "stable", "sunny", "cloudy", "unstable", "thunderstorm", "unknown" };
      enum FORECAST
      {
        STABLE = 0,     // "Stable Weather Pattern"
        SUNNY = 1,      // "Slowly rising Good Weather", "Clear/Sunny "
        CLOUDY = 2,     // "Slowly falling L-Pressure ", "Cloudy/Rain "
        UNSTABLE = 3,   // "Quickly rising H-Press",     "Not Stable"
        THUNDERSTORM = 4, // "Quickly falling L-Press",    "Thunderstorm"
        UNKNOWN = 5     // "Unknown (More Time needed)
      };
      
      Adafruit_BMP085 bmp = Adafruit_BMP085();      // Digital Pressure Sensor 
      
      float lastPressure = -1;
      float lastTemp = -1;
      int lastForecast = -1;
      
      //float lastTemp;
      float lastHum;
      uint8_t nNoUpdatesTemp;
      uint8_t nNoUpdatesHum;
      //bool metric = true;
      
      const int LAST_SAMPLES_COUNT = 5;
      float lastPressureSamples[LAST_SAMPLES_COUNT];
      
      // this CONVERSION_FACTOR is used to convert from Pa to kPa in forecast algorithm
      // get kPa/h be dividing hPa by 10 
      #define CONVERSION_FACTOR (1.0/10.0)
      
      int minuteCount = 0;
      bool firstRound = true;
      // average value is used in forecast algorithm.
      float pressureAvg;
      // average after 2 hours is used as reference value for the next iteration.
      float pressureAvg2;
      
      float dP_dt;
      bool metric;
      MyMessage tempMsg(TEMP_CHILD, V_TEMP);
      MyMessage pressureMsg(BARO_CHILD, V_PRESSURE);
      MyMessage forecastMsg(BARO_CHILD, V_FORECAST);
      MyMessage voltageMsg(VOLTAGE_CHILD_ID, V_VOLTAGE);
      MyMessage msgHum(CHILD_ID_HUM, V_HUM);
      DHT dht;
      MyMessage msg(CHILD_ID_LIGHT, V_LIGHT_LEVEL);
      int lastLightLevel;
      
      
      
      
      
      
      
      
      void setup() 
      {
      //Serial.println("Setting Pin Mode to Output");
      //pinMode(LUX_ON, OUTPUT);
          
      Serial.println("Setup Sensor");
        
        dht.setup(DHT_DATA_PIN); // set data pin of DHT sensor
        if (UPDATE_INTERVAL <= dht.getMinimumSamplingPeriod()) {
          Serial.println("Warning: UPDATE_INTERVAL is smaller than supported by the sensor!");
        }
        // Sleep for the time of the minimum sampling period to give the sensor time to power up
        // (otherwise, timeout errors might occure for the first reading)
        sleep(dht.getMinimumSamplingPeriod());
        {
          // use the 1.1 V internal reference
      #if defined(__AVR_ATmega2560__)
          analogReference(INTERNAL1V1);
      #else
          analogReference(INTERNAL);
      #endif
      }
        
        if (!bmp.begin()) 
        {
          Serial.println("Could not find a valid BMP085 sensor, check wiring!");
          while (1) {}
        }
        metric = getConfig().isMetric;
      }
      
      void presentation()  {
        // Send the sketch version information to the gateway and Controller
        sendSketchInfo("Pressure Sensor", "1.1");
      Serial.println("Present sensors to gateway");
        // Register sensors to gw (they will be created as child devices)
        present(BARO_CHILD, S_BARO, "Pressure" );
        present(TEMP_CHILD, S_TEMP, "Temperature" );
        present(VOLTAGE_CHILD_ID, S_MULTIMETER, "Battery" );
        present(CHILD_ID_HUM, S_HUM, "Humidity" );
        present(CHILD_ID_LIGHT, S_LIGHT_LEVEL, "Lux" );  
      
       // metric = getConfig().isMetric; 
      
      
      }
      
      
      void loop() 
      
      {
        ////////////////////////////////////////
        ////////// Lux Sensor Code /////////////
        ////////////////////////////////////////
        
          digitalWrite(LUX_ON, POWER_ON); // Power the Lux sensor of Digital Pin to save power
          Serial.print("Sensor Power on pin "); Serial.print(LUX_ON); Serial.print(" is..."); Serial.println((POWER_ON));
          wait(1000); // Wait a second for sensor to power up before reading
          
          int16_t lightLevel = (1023-analogRead(LIGHT_SENSOR_ANALOG_PIN))/10.23;
              Serial.println("Light Lux Level:");
          Serial.println(lightLevel);
          if (lightLevel != lastLightLevel) {
              send(msg.set(lightLevel));
              lastLightLevel = lightLevel;
      
         digitalWrite(LUX_ON, POWER_OFF); // turn it off
         Serial.print("Sensor Power on pin "); Serial.print(LUX_ON); Serial.print(" is..."); Serial.println((POWER_OFF));
          }
          wait(1000);
      
        ////////////////////////////////////////
        ////////// DHT22 Sensor Code ///////////
        ////////////////////////////////////////
        
        // Force reading sensor, so it works also after sleep()
        dht.readSensor(true);
        
      
        // Get humidity from DHT library
        float humidity = dht.getHumidity();
        if (isnan(humidity)) {
          Serial.println("Failed reading humidity from DHT");
        } else if (humidity != lastHum || nNoUpdatesHum == FORCE_UPDATE_N_READS) {
          // Only send humidity if it changed since the last measurement or if we didn't send an update for n times
          lastHum = humidity;
          // Reset no updates counter
          nNoUpdatesHum = 0;
          send(msgHum.set(humidity, 1));
          
         #ifdef MY_DEBUG
          Serial.print("Humidity: ");
          Serial.println(humidity);
         #endif
        } else {
          // Increase no update counter if the humidity stayed the same
          nNoUpdatesHum++;
        }
      
        // Sleep for a while to save energy
        //sleep(UPDATE_INTERVAL); 
       {
        /////////////////////////////////////////////
        ////////// Battery Reporting Code ///////////
        /////////////////////////////////////////////
        
          // get the battery Voltage
          int sensorValue = analogRead(BATTERY_SENSE_PIN);
      #ifdef MY_DEBUG
          Serial.println(sensorValue);
      #endif
      
          // 1M, 470K divider across battery and using internal ADC ref of 1.1V
          // Sense point is bypassed with 0.1 uF cap to reduce noise at that point
          // ((1e6+470e3)/470e3)*1.1 = Vmax = 3.44 Volts
          // 3.44/1023 = Volts per bit = 0.003363075
      
          int batteryPcnt = sensorValue / 10;
      
      #ifdef MY_DEBUG
          float batteryV  = sensorValue * 0.003363075;
          float voltage = sensorValue * 0.003363075;
          Serial.print("Battery Voltage: ");
          Serial.print(batteryV);
          Serial.println(" V");
      
          Serial.print("Battery percent: ");
          Serial.print(batteryPcnt);
          Serial.println(" %");
      #endif
      
          if (oldBatteryPcnt != batteryPcnt) {
              // Power up radio after sleep
              sendBatteryLevel(batteryPcnt);
              oldBatteryPcnt = batteryPcnt;
              send(voltageMsg.set(voltage,2));
          }
      //    sleep(SLEEP_TIME);
      }
        //////////////////////////////////////////////////
        ////////// BMP180 Pressure Sensor Code ///////////
        //////////////////////////////////////////////////
        
        float pressure = bmp.readSealevelPressure(ALTITUDE) / 100.0;
        float temperature = bmp.readTemperature();
      
        if (!metric) 
        {
          // Convert to fahrenheit
          temperature = temperature * 9.0 / 5.0 + 32.0;
        }
      
        int forecast = sample(pressure);
      
        Serial.print("Temperature = ");
        Serial.print(temperature);
        Serial.println(metric ? " *C" : " *F");
        Serial.print("Pressure = ");
        Serial.print(pressure);
        Serial.println(" hPa");
        Serial.print("Forecast = ");
        Serial.println(weather[forecast]);
      
      
        if (temperature != lastTemp) 
        {
          send(tempMsg.set(temperature, 1));
          lastTemp = temperature;
        }
      
        if (pressure != lastPressure) 
        {
          send(pressureMsg.set(pressure, 0));
          lastPressure = pressure;
        }
      
        if (forecast != lastForecast)
        {
          send(forecastMsg.set(weather[forecast]));
          lastForecast = forecast;
        }
      
        sleep(SLEEP_TIME);
      }
      
      float getLastPressureSamplesAverage()
      {
        float lastPressureSamplesAverage = 0;
        for (int i = 0; i < LAST_SAMPLES_COUNT; i++)
        {
          lastPressureSamplesAverage += lastPressureSamples[i];
        }
        lastPressureSamplesAverage /= LAST_SAMPLES_COUNT;
      
        return lastPressureSamplesAverage;
      }
      
      
      
        //////////////////////////////////////////
        ////////// Forecast Algorithm ///////////
        /////////////////////////////////////////
        
      int sample(float pressure)
      {
        // Calculate the average of the last n minutes.
        int index = minuteCount % LAST_SAMPLES_COUNT;
        lastPressureSamples[index] = pressure;
      
        minuteCount++;
        if (minuteCount > 185)
        {
          minuteCount = 6;
        }
      
        if (minuteCount == 5)
        {
          pressureAvg = getLastPressureSamplesAverage();
        }
        else if (minuteCount == 35)
        {
          float lastPressureAvg = getLastPressureSamplesAverage();
          float change = (lastPressureAvg - pressureAvg) * CONVERSION_FACTOR;
          if (firstRound) // first time initial 3 hour
          {
            dP_dt = change * 2; // note this is for t = 0.5hour
          }
          else
          {
            dP_dt = change / 1.5; // divide by 1.5 as this is the difference in time from 0 value.
          }
        }
        else if (minuteCount == 65)
        {
          float lastPressureAvg = getLastPressureSamplesAverage();
          float change = (lastPressureAvg - pressureAvg) * CONVERSION_FACTOR;
          if (firstRound) //first time initial 3 hour
          {
            dP_dt = change; //note this is for t = 1 hour
          }
          else
          {
            dP_dt = change / 2; //divide by 2 as this is the difference in time from 0 value
          }
        }
        else if (minuteCount == 95)
        {
          float lastPressureAvg = getLastPressureSamplesAverage();
          float change = (lastPressureAvg - pressureAvg) * CONVERSION_FACTOR;
          if (firstRound) // first time initial 3 hour
          {
            dP_dt = change / 1.5; // note this is for t = 1.5 hour
          }
          else
          {
            dP_dt = change / 2.5; // divide by 2.5 as this is the difference in time from 0 value
          }
        }
        else if (minuteCount == 125)
        {
          float lastPressureAvg = getLastPressureSamplesAverage();
          pressureAvg2 = lastPressureAvg; // store for later use.
          float change = (lastPressureAvg - pressureAvg) * CONVERSION_FACTOR;
          if (firstRound) // first time initial 3 hour
          {
            dP_dt = change / 2; // note this is for t = 2 hour
          }
          else
          {
            dP_dt = change / 3; // divide by 3 as this is the difference in time from 0 value
          }
        }
        else if (minuteCount == 155)
        {
          float lastPressureAvg = getLastPressureSamplesAverage();
          float change = (lastPressureAvg - pressureAvg) * CONVERSION_FACTOR;
          if (firstRound) // first time initial 3 hour
          {
            dP_dt = change / 2.5; // note this is for t = 2.5 hour
          }
          else
          {
            dP_dt = change / 3.5; // divide by 3.5 as this is the difference in time from 0 value
          }
        }
        else if (minuteCount == 185)
        {
          float lastPressureAvg = getLastPressureSamplesAverage();
          float change = (lastPressureAvg - pressureAvg) * CONVERSION_FACTOR;
          if (firstRound) // first time initial 3 hour
          {
            dP_dt = change / 3; // note this is for t = 3 hour
          }
          else
          {
            dP_dt = change / 4; // divide by 4 as this is the difference in time from 0 value
          }
          pressureAvg = pressureAvg2; // Equating the pressure at 0 to the pressure at 2 hour after 3 hours have past.
          firstRound = false; // flag to let you know that this is on the past 3 hour mark. Initialized to 0 outside main loop.
        }
      
        int forecast = UNKNOWN;
        if (minuteCount < 35 && firstRound) //if time is less than 35 min on the first 3 hour interval.
        {
          forecast = UNKNOWN;
        }
        else if (dP_dt < (-0.25))
        {
          forecast = THUNDERSTORM;
        }
        else if (dP_dt > 0.25)
        {
          forecast = UNSTABLE;
        }
        else if ((dP_dt > (-0.25)) && (dP_dt < (-0.05)))
        {
          forecast = CLOUDY;
        }
        else if ((dP_dt > 0.05) && (dP_dt < 0.25))
        {
          forecast = SUNNY;
        }
        else if ((dP_dt >(-0.05)) && (dP_dt < 0.05))
        {
          forecast = STABLE;
        }
        else
        {
          forecast = UNKNOWN;
        }
      
        // uncomment when debugging
        Serial.print(F("Forecast at minute "));
        Serial.print(minuteCount);
        Serial.print(F(" dP/dt = "));
        Serial.print(dP_dt);
        Serial.print(F("kPa/h --> "));
        Serial.println(weather[forecast]);
      
        return forecast;
      }
      
      posted in Troubleshooting
      JCH
      JCH
    • RE: Help with pool solar controller code

      @skywatch Good advice.. I will do that today.
      Thanks

      posted in Troubleshooting
      JCH
      JCH

    Latest posts made by JCH

    • RE: Sketch problems.... I think

      So after running this weather station for a few weeks i decided to switch out the lux sensor for a soil moisture sensor without modifying the code....
      The readings are working but they are very up and down.... they are not a steady decline..... how are people measuring the analog values of soil moisture ?

      posted in Troubleshooting
      JCH
      JCH
    • RE: Help with pool solar controller code

      Edit.... Does mysensors use pin 9 for anything? as soon as i try to use it as an input the radio seems to not be communicating with the controller?
      I loaded a bounce sketch to test the button and pin and it works fine untill i reload my sketch.

      posted in Troubleshooting
      JCH
      JCH
    • RE: Help with pool solar controller code

      Ok i need help again please... I cannot get to the bottom of my last little problem......

      void setup()  
      { 
        pinMode(BUTTON_PIN, INPUT);
        // Activate internal pull-up
        digitalWrite(BUTTON_PIN, HIGH);
        pinMode(BUTTON_PIN_2, INPUT);
        // Activate internal pull-up
        digitalWrite(BUTTON_PIN_2, HIGH);
       // pinMode(BUTTON_PIN_3, INPUT);
        // Activate internal pull-up
       // digitalWrite(BUTTON_PIN_3, HIGH);
       
        debouncer.attach(BUTTON_PIN);
        debouncer.interval(5);
        debouncer2.attach(BUTTON_PIN_2);
        debouncer2.interval(5); 
        debouncer3.attach(BUTTON_PIN_3);
        debouncer3.interval(5);
        oldValue = debouncer.read();
        oldValue2 = debouncer2.read();
        oldValue3 = debouncer3.read();  
      

      As soon as i tired to add a 3rd button and debouncer the whole code crashes.... as soon a a comment out the above lines it goes good again.... thoughts?

      Here is the whole code (havent tidyed it up yet 😉

      /**
      JH REV 1.0 - 12-04-2020
       */
      
      
      // Enable debug prints to serial monitor
      #define MY_DEBUG 
      
      // Enable and select radio type attached
      #define MY_RADIO_RF24
      #define MY_RF24_PA_LEVEL RF24_PA_HIGH
      #define MY_NODE_ID 22  //////////FOR TESTING
      #define MY_REPEATER_FEATURE
      
      #include <MySensors.h>  
      #include <DallasTemperature.h>
      #include <OneWire.h>
      #include <LiquidCrystal_I2C.h>
      #include <Bounce2.h>
      #include <SPI.h>
      
      LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
      
      #define COMPARE_TEMP 0 // Send temperature only if changed? 1 = Yes 0 = No
      
      #define ONE_WIRE_BUS 3 // Pin where dallase sensor is connected 
      #define MAX_ATTACHED_DS18B20 16
      #define RELAY_PIN 4    
      #define RELAY_PIN_2 5  
      #define RELAY_PIN_3 6  
      #define RELAY_ON 0
      #define RELAY_OFF 1
      #define BUTTON_PIN 7
      #define BUTTON_PIN_2 8
      #define BUTTON_PIN_3 9
      #define CHILD_ID 4 // Id of the sensor child for 1st relay
      #define CHILD_ID_2 5 // Id of the sensor child for 2nd relay
      #define CHILD_ID_3 6 // Id of the sensor child for 2nd relay
      
      bool state;
      Bounce debouncer = Bounce(); 
      int oldValue=0;
      int oldValue1=0;
      bool state1;
      Bounce debouncer2 = Bounce();
      int oldValue2=0;
      bool state2;
      Bounce debouncer3 = Bounce();
      int oldValue3=0;
      bool state3;
      
      bool initialValueSent = false;
      
      
      unsigned long SLEEP_TIME = 60000; // Sleep time between reads (in milliseconds)
      unsigned long CHECK_TIME = millis();
      
      OneWire oneWire(ONE_WIRE_BUS); // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
      DallasTemperature sensors(&oneWire); // Pass the oneWire reference to Dallas Temperature. 
      float lastTemperature[MAX_ATTACHED_DS18B20];
      int numSensors=0;
      float roofTemp;
      float poolTemp;
      String poolPumpstate;
      String solarPumpstate;
      
      bool receivedConfig = false;
      bool metric = true;
      
      
      
      
       
      // Initialize temperature message
      MyMessage msg(1,V_TEMP);
      
      MyMessage msg2(CHILD_ID, V_LIGHT);
      MyMessage msg3(CHILD_ID_2, V_LIGHT);
      MyMessage msg4(CHILD_ID_3, V_LIGHT);
      
      void before()
      {
        // Startup up the OneWire library
        sensors.begin();
      }
      
      void setup()  
      { 
        pinMode(BUTTON_PIN, INPUT);
        // Activate internal pull-up
        digitalWrite(BUTTON_PIN, HIGH);
        pinMode(BUTTON_PIN_2, INPUT);
        // Activate internal pull-up
        digitalWrite(BUTTON_PIN_2, HIGH);
       // pinMode(BUTTON_PIN_3, INPUT);
        // Activate internal pull-up
       // digitalWrite(BUTTON_PIN_3, HIGH);
       
        debouncer.attach(BUTTON_PIN);
        debouncer.interval(5);
        debouncer2.attach(BUTTON_PIN_2);
        debouncer2.interval(5); 
        debouncer3.attach(BUTTON_PIN_3);
        debouncer3.interval(5);
        oldValue = debouncer.read();
        oldValue2 = debouncer2.read();
        oldValue3 = debouncer3.read();  
        
        
        // requestTemperatures() will not block current thread
        sensors.setWaitForConversion(false);
      
          lcd.begin(16, 2);                   // LCD 2 lines * 16 char.
          lcd.setBacklight(HIGH);
          lcd.setCursor(0, 0);
          lcd.setCursor(0, 0);
          lcd.clear();
          lcd.print("   Contoller  "); 
          lcd.setCursor(0, 1);  
          lcd.print("   Starting  ");
          wait(2000);
      
           pinMode(RELAY_PIN, OUTPUT);
           pinMode(RELAY_PIN_2, OUTPUT);        
           digitalWrite(RELAY_PIN, RELAY_OFF);  
           digitalWrite(RELAY_PIN_2, RELAY_OFF);       
       /*    lcd.setCursor(0, 0);
           lcd.clear();
           lcd.print("Begin Pump Test"); 
           wait(2000);  
           digitalWrite(RELAY_PIN, RELAY_ON);
           wait(5000);  
           digitalWrite(RELAY_PIN, RELAY_OFF);     
           lcd.setCursor(0, 0);
           lcd.clear();
           lcd.print("Pool Pump Test");
           lcd.setCursor(0, 1);
           lcd.print("OK");     
           wait(2000);
           lcd.setCursor(0, 0);
           lcd.clear();
           lcd.print("Begin Pump Test"); 
           digitalWrite(RELAY_PIN_2, RELAY_ON);
           wait(5000);  
           digitalWrite(RELAY_PIN_2, RELAY_OFF);     
           lcd.setCursor(0, 0);
           lcd.clear();
           lcd.print("Solar Pump Test"); 
           lcd.setCursor(0, 1);
           lcd.print("OK");  */      
           wait(2000);
      
          
      wait(10000);
      
      }
      
      void presentation()
      {
        // Send the sketch version information to the gateway and Controller
        sendSketchInfo("Pool Controller", "1.1");
      
        // Fetch the number of attached temperature sensors  
        numSensors = sensors.getDeviceCount();
      
        // Present all sensors to controller
        for (int i=0; i<numSensors && i<MAX_ATTACHED_DS18B20; i++) {   
           present(i, S_TEMP);
           present(CHILD_ID, S_BINARY);
           present(CHILD_ID_2, S_BINARY); 
      
       }
      }
      
      
      
      
      void loop()     
      { 
        
      
          if (!initialValueSent) {
          Serial.println("Sending initial value");
          send(msg2.set(state?RELAY_OFF:RELAY_ON));
          send(msg3.set(state?RELAY_OFF:RELAY_ON));
          Serial.println("Requesting initial value from controller");
          request(CHILD_ID, V_STATUS);
          request(CHILD_ID_2, V_STATUS);
          wait(2000, C_SET, V_STATUS);
          }
      
      
        debouncer.update();
        debouncer2.update();
        // Get the update value
        int value1 = debouncer.read();
        int value2 = debouncer2.read();
      
        if (debouncer.fell()) {
            state1 = !state1;
            send(msg2.set(state1?true:false), false); // Send new state and request ack back
            digitalWrite(RELAY_PIN, state1?RELAY_ON:RELAY_OFF);       // TURN ON / OFF RELAYS
            oldValue1 = value1;
        }
        if (debouncer2.fell()) {
            state2 = !state2;
            send(msg3.set(state2?true:false), false); // Send new state and request ack back
            digitalWrite(RELAY_PIN_2, state2?RELAY_ON:RELAY_OFF);       // TURN ON / OFF RELAYS      
            oldValue2 = value2;
        }
        
        
          unsigned long NOW_TIME = millis();
        if(NOW_TIME - CHECK_TIME >= SLEEP_TIME) {
           updateLCDtemps();
          CHECK_TIME = NOW_TIME;
           Serial.println("Updating LCD");
        }
        
        updateTemperature(30);
      
      
        if (solarPumpstate == "Running" ){
          updateLCDstatus;
        }
       
      
      
      
        
      }
      
      
      
      
      
      
      
      ///////////////////////////////////////////////////////////////////////////////////////////////       
      //////////////////////////////  RECIEVE TEMPS   ////////////////////////////////////////////
      ///////////////////////////////////////////////////////////////////////////////////////////////
      
      void receive(const MyMessage &message) {
      
      
       
       if (message.type==V_TEMP) {
         if (message.sensor == 1) {
      
         
          // Write some debug info
          Serial.print("Incoming change from roof sensor:");
          Serial.print(message.sensor);
          Serial.print("\n");
          Serial.print(", New status: ");
          Serial.println(message.getFloat());
      
        roofTemp = (message.getFloat());
         }}
      ///////////////////////////////////////////////////////////////////////////////////////////////       
      //////////////////////////////  RECIEVE RELAYS  ////////////////////////////////////////////
      ///////////////////////////////////////////////////////////////////////////////////////////////
       
      
              else if (message.getType()==V_STATUS) {
              if (message.sensor == 4){
              state1 = message.getBool();
              digitalWrite(RELAY_PIN, state1?RELAY_ON:RELAY_OFF);
              Serial.print("Incoming change for sensor:");
              Serial.print(message.getSensor());
              Serial.print(", New status: ");
              Serial.println(message.getBool());
            //  send(msg2.set(state?RELAY_ON:RELAY_OFF)); 
              if ((message.getBool())== 1){
              poolPumpstate = ("Running");}
              else{
              poolPumpstate = ("Standby");
              }}
              if (message.sensor == 5){
              state2 = message.getBool();
              Serial.print(state);       
              digitalWrite(RELAY_PIN_2, state2?RELAY_ON:RELAY_OFF);
              Serial.print("Incoming change for sensor:");
              Serial.print(message.getSensor());
              Serial.print(", New status: ");
              Serial.println(message.getBool());
             // send(msg3.set(state?RELAY_OFF:RELAY_ON)); 
               if ((message.getBool())== 1){
              solarPumpstate = ("Running");}
              else{
              solarPumpstate = ("Standby");
              }}
              if (message.type == V_STATUS) {
              if (!initialValueSent) {
              Serial.println("Receiving initial value from controller");
              initialValueSent = true;
          }}
         }
      }   
      
      void updateLCDtemps()
      {      
        
          lcd.clear();
          lcd.setCursor(0, 1);
          lcd.print("Pool  :");
          lcd.print(" ");
          lcd.print(poolTemp);
          lcd.print((char)223);              
          lcd.print("C");       
          lcd.setCursor(0, 0);
          lcd.print("Solar :");
          lcd.print(" ");
          lcd.print(roofTemp);    
          lcd.print((char)223);       
          lcd.print("C");   
      
      }
      
      void updateLCDstatus()
      {      
        
      
          lcd.clear();       
          lcd.setCursor(0, 1);
          lcd.print("Pool  :");
          lcd.print(" ");
          lcd.print(poolPumpstate);       
          lcd.setCursor(0, 0);
          lcd.print("Solar :");
          lcd.print(" ");      
          lcd.print(solarPumpstate); 
        
      
      }
        
             
                  
                 
      void updateTemperature(int frequency)
      {       
        static unsigned long lastUpdateTime;
        if (millis() - lastUpdateTime >= frequency * 1000UL)
        {
          Serial.println("Updating Dallas Temp");
          sensors.requestTemperatures(); 
          for (int i=0; i<numSensors && i< MAX_ATTACHED_DS18B20; i++) 
          {
            float temperature = static_cast<float>(static_cast<int>((getControllerConfig().isMetric?sensors.getTempCByIndex(i):sensors.getTempFByIndex(i)) * 10.)) / 10.;
            if (lastTemperature[i] != temperature && temperature != -127.00) 
            {
              send(msg.setSensor(i).set(temperature,1));
              lastTemperature[i]=temperature;
              poolTemp = temperature;
               Serial.println("Pool Temp = ");
               Serial.println(poolTemp);
               updateLCDtemps();
            }
          }
          lastUpdateTime += frequency * 1000UL;
      
        }
      }
      
      posted in Troubleshooting
      JCH
      JCH
    • RE: Help with pool solar controller code

      @skywatch Good advice.. I will do that today.
      Thanks

      posted in Troubleshooting
      JCH
      JCH
    • RE: Help with pool solar controller code

      @skywatch Will the interrupt work with wait or only sleep?
      I ended up going down a rabbit hole trying to implement a non breaking timer as below... it all seems to be working now except the button doesnt switch states everytime.... sometimes have to press it 2 or 3 times?

      /**
      JH REV 1.0 - 12-04-2020
       */
      
      
      // Enable debug prints to serial monitor
      #define MY_DEBUG 
      
      // Enable and select radio type attached
      #define MY_RADIO_RF24
      #define MY_RF24_PA_LEVEL RF24_PA_HIGH
      #define MY_NODE_ID 2  //////////FOR TESTING
      #define MY_REPEATER_FEATURE
      
      #include <MySensors.h>  
      #include <DallasTemperature.h>
      #include <OneWire.h>
      #include <LiquidCrystal_I2C.h>
      #include <Bounce2.h>
      #include <SPI.h>
      
      LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
      
      #define COMPARE_TEMP 0 // Send temperature only if changed? 1 = Yes 0 = No
      
      #define ONE_WIRE_BUS 3 // Pin where dallase sensor is connected 
      #define MAX_ATTACHED_DS18B20 16
      #define RELAY_PIN 4    
      #define RELAY_PIN_2 5  
      #define RELAY_ON 0
      #define RELAY_OFF 1
      #define BUTTON_PIN 7
      #define BUTTON_PIN_2 8
      #define CHILD_ID 4 // Id of the sensor child for 1st relay
      #define CHILD_ID_2 5 // Id of the sensor child for 2nd relay
      
      bool state;
      Bounce debouncer = Bounce(); 
      int oldValue=0;
      bool state1;
      Bounce debouncer2 = Bounce();
      int oldValue2;
      bool state2;
      
      bool initialValueSent = false;
      
      
      unsigned long SLEEP_TIME = 30000; // Sleep time between reads (in milliseconds)
      unsigned long CHECK_TIME = millis();
      
      OneWire oneWire(ONE_WIRE_BUS); // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
      DallasTemperature sensors(&oneWire); // Pass the oneWire reference to Dallas Temperature. 
      float lastTemperature[MAX_ATTACHED_DS18B20];
      int numSensors=0;
      float roofTemp;
      float poolTemp;
      String poolPumpstate;
      String solarPumpstate;
      
      bool receivedConfig = false;
      bool metric = true;
      
      
      
      
       
      // Initialize temperature message
      MyMessage msg(1,V_TEMP);
      
      MyMessage msg2(CHILD_ID, V_LIGHT);
      MyMessage msg3(CHILD_ID_2, V_LIGHT);
      
      void before()
      {
        // Startup up the OneWire library
        sensors.begin();
      }
      
      void setup()  
      { 
        pinMode(BUTTON_PIN, INPUT);
        // Activate internal pull-up
        digitalWrite(BUTTON_PIN, HIGH);
        pinMode(BUTTON_PIN_2, INPUT);
        // Activate internal pull-up
        digitalWrite(BUTTON_PIN_2, HIGH);
      
        debouncer.attach(BUTTON_PIN);
        debouncer.interval(5);
        debouncer2.attach(BUTTON_PIN_2);
        debouncer2.interval(5);  
        oldValue = debouncer.read();
        oldValue2 = debouncer2.read();
        
        // requestTemperatures() will not block current thread
        sensors.setWaitForConversion(false);
      
          lcd.begin(16, 2);                   // LCD 2 lines * 16 char.
          lcd.setBacklight(HIGH);
          lcd.setCursor(0, 0);
          lcd.setCursor(0, 0);
          lcd.clear();
          lcd.print("   Contoller  "); 
          lcd.setCursor(0, 1);  
          lcd.print("   Starting  ");
          wait(2000);
      
           pinMode(RELAY_PIN, OUTPUT);
           pinMode(RELAY_PIN_2, OUTPUT);        
           digitalWrite(RELAY_PIN, RELAY_OFF);  
           digitalWrite(RELAY_PIN_2, RELAY_OFF);       
       /*    lcd.setCursor(0, 0);
           lcd.clear();
           lcd.print("Begin Pump Test"); 
           wait(2000);  
           digitalWrite(RELAY_PIN, RELAY_ON);
           wait(5000);  
           digitalWrite(RELAY_PIN, RELAY_OFF);     
           lcd.setCursor(0, 0);
           lcd.clear();
           lcd.print("Pool Pump Test");
           lcd.setCursor(0, 1);
           lcd.print("OK");     
           wait(2000);
           lcd.setCursor(0, 0);
           lcd.clear();
           lcd.print("Begin Pump Test"); 
           digitalWrite(RELAY_PIN_2, RELAY_ON);
           wait(5000);  
           digitalWrite(RELAY_PIN_2, RELAY_OFF);     
           lcd.setCursor(0, 0);
           lcd.clear();
           lcd.print("Solar Pump Test"); 
           lcd.setCursor(0, 1);
           lcd.print("OK");  */      
           wait(2000);
      
          
      wait(10000);
      
      }
      
      void presentation()
      {
        // Send the sketch version information to the gateway and Controller
        sendSketchInfo("Pool Controller", "1.1");
      
        // Fetch the number of attached temperature sensors  
        numSensors = sensors.getDeviceCount();
      
        // Present all sensors to controller
        for (int i=0; i<numSensors && i<MAX_ATTACHED_DS18B20; i++) {   
           present(i, S_TEMP);
           present(CHILD_ID, S_BINARY);
           present(CHILD_ID_2, S_BINARY); 
      
       }
      }
      
      
      
      
      void loop()     
      { 
        
      
          if (!initialValueSent) {
          Serial.println("Sending initial value");
          send(msg2.set(state?RELAY_OFF:RELAY_ON));
          send(msg3.set(state?RELAY_OFF:RELAY_ON));
          Serial.println("Requesting initial value from controller");
          request(CHILD_ID, V_STATUS);
          request(CHILD_ID_2, V_STATUS);
          wait(2000, C_SET, V_STATUS);
          }
      
      {
        debouncer.update();
        // Get the update value
        int value = debouncer.read();
        state = !state;
        if (value != oldValue && value==0) {
            send(msg2.set(state?true:false), true); // Send new state and request ack back
        digitalWrite(RELAY_PIN, state?RELAY_ON:RELAY_OFF);    
        }
        oldValue = value;
        
      /*  {
        debouncer2.update();
        // Get the update value
        int value = debouncer2.read();
        state2 = !state2;
        if (value != oldValue2 && value==0) {
            send(msg3.set(state2?true:false), false); // Send new state and request ack back
        digitalWrite(RELAY_PIN_2, state2?RELAY_ON:RELAY_OFF);    
        }
        oldValue = value;
        }*/
        }
        
          unsigned long NOW_TIME = millis();
        if(NOW_TIME - CHECK_TIME >= SLEEP_TIME) {
           updateLCDtemps();
          CHECK_TIME = NOW_TIME;
           Serial.println("Updating LCD");
        }
        
        updateTemperature(30);
      
        if (solarPumpstate == "Running" ){
          updateLCDstatus;
        }
       
      
      
      
        
      }
      
      
      
      
      
      
      
      ///////////////////////////////////////////////////////////////////////////////////////////////       
      //////////////////////////////  RECIEVE TEMPS   ////////////////////////////////////////////
      ///////////////////////////////////////////////////////////////////////////////////////////////
      
      void receive(const MyMessage &message) {
      
      
       
       if (message.type==V_TEMP) {
         if (message.sensor == 1) {
      
         
          // Write some debug info
          Serial.print("Incoming change from roof sensor:");
          Serial.print(message.sensor);
          Serial.print("\n");
          Serial.print(", New status: ");
          Serial.println(message.getFloat());
      
        roofTemp = (message.getFloat());
         }}
      ///////////////////////////////////////////////////////////////////////////////////////////////       
      //////////////////////////////  RECIEVE RELAYS  ////////////////////////////////////////////
      ///////////////////////////////////////////////////////////////////////////////////////////////
       
      
              else if (message.getType()==V_STATUS) {
              if (message.sensor == 4){
              state = message.getBool();
              Serial.print(state);
              digitalWrite(RELAY_PIN, state?RELAY_ON:RELAY_OFF);
              Serial.print("Incoming change for sensor:");
              Serial.print(message.getSensor());
              Serial.print(", New status: ");
              Serial.println(message.getBool());
          //    send(msg2.set(state?RELAY_ON:RELAY_OFF)); 
              if ((message.getBool())== 1){
              poolPumpstate = ("Running");}
              else{
              poolPumpstate = ("Standby");
              }}
              if (message.sensor == 5){
              state = (bool)message.getInt();
              Serial.print(state);       
              digitalWrite(RELAY_PIN_2, state?RELAY_ON:RELAY_OFF);
              Serial.print("Incoming change for sensor:");
              Serial.print(message.getSensor());
              Serial.print(", New status: ");
              Serial.println(message.getBool());
              send(msg3.set(state?RELAY_OFF:RELAY_ON)); 
               if ((message.getBool())== 1){
              solarPumpstate = ("Running");}
              else{
              solarPumpstate = ("Standby");
              }}
              if (message.type == V_STATUS) {
              if (!initialValueSent) {
              Serial.println("Receiving initial value from controller");
              initialValueSent = true;
          }}
         }
      }   
      
      void updateLCDtemps()
      {      
        
          lcd.clear();
          lcd.setCursor(0, 1);
          lcd.print("Pool  :");
          lcd.print(" ");
          lcd.print(poolTemp);
          lcd.print((char)223);              
          lcd.print("C");       
          lcd.setCursor(0, 0);
          lcd.print("Solar :");
          lcd.print(" ");
          lcd.print(roofTemp);    
          lcd.print((char)223);       
          lcd.print("C");   
      
      }
      
      void updateLCDstatus()
      {      
        
      
          lcd.clear();       
          lcd.setCursor(0, 1);
          lcd.print("Pool  :");
          lcd.print(" ");
          lcd.print(poolPumpstate);       
          lcd.setCursor(0, 0);
          lcd.print("Solar :");
          lcd.print(" ");      
          lcd.print(solarPumpstate); 
        
      
      }
        
             
                  
                 
      void updateTemperature(int frequency)
      {
        static unsigned long lastUpdateTime;
        if (millis() - lastUpdateTime >= frequency * 1000UL)
        {
          sensors.requestTemperatures(); 
          for (int i=0; i<numSensors && i< MAX_ATTACHED_DS18B20; i++) 
          {
            float temperature = static_cast<float>(static_cast<int>((getControllerConfig().isMetric?sensors.getTempCByIndex(i):sensors.getTempFByIndex(i)) * 10.)) / 10.;
            if (lastTemperature[i] != temperature && temperature != -127.00) 
            {
              send(msg.setSensor(i).set(temperature,1));
              lastTemperature[i]=temperature;
              poolTemp = temperature;
            }
          }
          lastUpdateTime += frequency * 1000UL;
      
        }
      }
      
      posted in Troubleshooting
      JCH
      JCH
    • RE: Help with pool solar controller code

      EDIT: I think the push button wont work if there is a wait for sleep.... Is there anyway around this?

      posted in Troubleshooting
      JCH
      JCH
    • RE: Help with pool solar controller code

      @skywatch
      The 30 seconds is while im only testing it.... once it is working as expected i will change the time

      posted in Troubleshooting
      JCH
      JCH
    • RE: Help with pool solar controller code

      Ok i am stuck again.....
      I cant seem to get the push buttons to activate the relays.....
      What am i doing wrong?

      /**
      JH REV 1.0 - 12-04-2020
       */
      
      
      // Enable debug prints to serial monitor
      #define MY_DEBUG 
      
      // Enable and select radio type attached
      #define MY_RADIO_RF24
      #define MY_RF24_PA_LEVEL RF24_PA_HIGH
      #define MY_NODE_ID 50  //////////FOR TESTING
      
      
      #include <MySensors.h>  
      #include <DallasTemperature.h>
      #include <OneWire.h>
      #include <LiquidCrystal_I2C.h>
      #include <Bounce2.h>
      
      LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
      
      #define COMPARE_TEMP 0 // Send temperature only if changed? 1 = Yes 0 = No
      
      #define ONE_WIRE_BUS 3 // Pin where dallase sensor is connected 
      #define MAX_ATTACHED_DS18B20 16
      #define RELAY_PIN 4    
      #define RELAY_PIN_2 5  
      #define RELAY_ON 0
      #define RELAY_OFF 1
      #define BUTTON_PIN_1 7
      #define BUTTON_PIN_2 8
      #define CHILD_ID 4 // Id of the sensor child for 1st relay
      #define CHILD_ID_2 5 // Id of the sensor child for 2nd relay
      
      Bounce debouncer = Bounce();
      Bounce debouncer2 = Bounce();
      
      int oldValue=-1;
      int oldValue2=-1;
      bool state ;
      bool state2 ;
      bool initialValueSent = false;
      
      unsigned long SLEEP_TIME = 3000; // Sleep time between reads (in milliseconds)
      OneWire oneWire(ONE_WIRE_BUS); // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
      DallasTemperature sensors(&oneWire); // Pass the oneWire reference to Dallas Temperature. 
      float lastTemperature[MAX_ATTACHED_DS18B20];
      int numSensors=0;
      float roofTemp;
      float poolTemp;
      String poolPumpstate;
      String solarPumpstate;
      
      bool receivedConfig = false;
      bool metric = true;
      
      
      
      
       
      // Initialize temperature message
      MyMessage msg(1,V_TEMP);
      
      MyMessage msg2(CHILD_ID, V_LIGHT);
      MyMessage msg3(CHILD_ID_2, V_LIGHT);
      
      void before()
      {
        // Startup up the OneWire library
        sensors.begin();
      }
      
      void setup()  
      { 
      
        pinMode(BUTTON_PIN_1,INPUT);
        // Activate internal pull-up
        digitalWrite(BUTTON_PIN_1,HIGH);
        pinMode(BUTTON_PIN_2,INPUT);
        // Activate internal pull-up
        digitalWrite(BUTTON_PIN_2,HIGH);
      
        debouncer.attach(BUTTON_PIN_1);
        debouncer.interval(5);
        debouncer2.attach(BUTTON_PIN_2);
        debouncer2.interval(5);  
        oldValue = debouncer.read();
        oldValue2 = debouncer2.read();
        
        // requestTemperatures() will not block current thread
        sensors.setWaitForConversion(false);
      
          lcd.begin(16, 2);                   // LCD 2 lines * 16 char.
          lcd.setBacklight(HIGH);
          lcd.setCursor(0, 0);
          lcd.setCursor(0, 0);
          lcd.clear();
          lcd.print("   Contoller  "); 
          lcd.setCursor(0, 1);  
          lcd.print("   Starting  ");
          wait(2000);
      
           pinMode(RELAY_PIN, OUTPUT);
           pinMode(RELAY_PIN_2, OUTPUT);        
           digitalWrite(RELAY_PIN, RELAY_OFF);  
           digitalWrite(RELAY_PIN_2, RELAY_OFF);       
           lcd.setCursor(0, 0);
           lcd.clear();
           lcd.print("Begin Pump Test"); 
           wait(2000);  
           digitalWrite(RELAY_PIN, RELAY_ON);
           wait(5000);  
           digitalWrite(RELAY_PIN, RELAY_OFF);     
           lcd.setCursor(0, 0);
           lcd.clear();
           lcd.print("Pool Pump Test");
           lcd.setCursor(0, 1);
           lcd.print("OK");     
           wait(2000);
           lcd.setCursor(0, 0);
           lcd.clear();
           lcd.print("Begin Pump Test"); 
           digitalWrite(RELAY_PIN_2, RELAY_ON);
           wait(5000);  
           digitalWrite(RELAY_PIN_2, RELAY_OFF);     
           lcd.setCursor(0, 0);
           lcd.clear();
           lcd.print("Solar Pump Test"); 
           lcd.setCursor(0, 1);
           lcd.print("OK");        
           wait(2000);
      
          
      wait(10000);
      
      }
      
      void presentation()
      {
        // Send the sketch version information to the gateway and Controller
        sendSketchInfo("Pool Controller", "1.1");
      
        // Fetch the number of attached temperature sensors  
        numSensors = sensors.getDeviceCount();
      
        // Present all sensors to controller
        for (int i=0; i<numSensors && i<MAX_ATTACHED_DS18B20; i++) {   
           present(i, S_TEMP);
           present(CHILD_ID, S_BINARY);
           present(CHILD_ID_2, S_BINARY); 
      
       }
      }
      
      
      
      
      void loop()     
      { 
      
      
      ///////////////////////////////////////////////////////////////////////////////////////       
      ///////////////////  REQUEST AND SEND INITIAL VALUES FOR RELAYS  //////////////////////
      ///////////////////////////////////////////////////////////////////////////////////////
      
        if (!initialValueSent) {
          Serial.println("Sending initial value");
          send(msg2.set(state?RELAY_OFF:RELAY_ON));
          send(msg3.set(state?RELAY_OFF:RELAY_ON));
          Serial.println("Requesting initial value from controller");
          request(CHILD_ID, V_STATUS);
          request(CHILD_ID_2, V_STATUS);
          wait(2000, C_SET, V_STATUS);
      
        
        
        }
           
      ///////////////////////////////////////////////////////////////////////////////////////       
      //////////////////////////////  MAIN LOOP  ////////////////////////////////////////////
      ///////////////////////////////////////////////////////////////////////////////////////
      {
        
        debouncer.update();
        debouncer2.update();
        // Get the update value
        int value = debouncer.read();
        int value2 = debouncer2.read();
      
        if (value != oldValue) {
          state =  !state;                                                  // Toggle the state
          send(msg.set(state), false);                          // send new state to controller, no ack requested
          digitalWrite(RELAY_PIN, state);                // switch the relay to the new state
          oldValue = value;
        }
        
      
        if (value2 != oldValue2) {
          state2 =  !state2;                                         // Toggle the state
          send(msg2.set(state2), false);                 // send new state to controller, no ack requested
          digitalWrite(RELAY_PIN_2, state2);     // switch the relay to the new state
          oldValue2 = value2;
        }
            // Fetch temperatures from Dallas sensors
        sensors.requestTemperatures();
        
        // query conversion time and sleep until conversion completed
        int16_t conversionTime = sensors.millisToWaitForConversion(sensors.getResolution());
        // sleep() call can be replaced by wait() call if node need to process incoming messages (or if node is repeater)
        wait(conversionTime);
      
        // Read temperatures and send them to controller 
        for (int i=0; i<numSensors && i<MAX_ATTACHED_DS18B20; i++) {
      
          // Fetch and round temperature to one decimal
          float temperature = static_cast<float>(static_cast<int>((getControllerConfig().isMetric?sensors.getTempCByIndex(i):sensors.getTempFByIndex(i)) * 10.)) / 10.;
      
          // Only send data if temperature has changed and no error
          #if COMPARE_TEMP == 1
          if (lastTemperature[i] != temperature && temperature != -127.00 && temperature != 85.00) {
          #else
          if (temperature != -127.00 && temperature != 85.00) {
          #endif
      
            // Send in the new temperature
            send(msg.setSensor(i).set(temperature,1));
            // Save new temperatures for next compare
            lastTemperature[i]=temperature;
            poolTemp = temperature;
                    }
                 }
      
             wait(1000);
        }
             updateLCD();
        }
             
           
      
      
      
      
      
      ///////////////////////////////////////////////////////////////////////////////////////////////       
      //////////////////////////////  RECIEVE TEMPS   ////////////////////////////////////////////
      ///////////////////////////////////////////////////////////////////////////////////////////////
      
      void receive(const MyMessage &message) {
      
      
       
       if (message.type==V_TEMP) {
         if (message.sensor == 1) {
      
         
          // Write some debug info
          Serial.print("Incoming change from roof sensor:");
          Serial.print(message.sensor);
          Serial.print("\n");
          Serial.print(", New status: ");
          Serial.println(message.getFloat());
      
        roofTemp = (message.getFloat());
         }}
      ///////////////////////////////////////////////////////////////////////////////////////////////       
      //////////////////////////////  RECIEVE RELAYS  ////////////////////////////////////////////
      ///////////////////////////////////////////////////////////////////////////////////////////////
          
      
              else if (message.getType()==V_STATUS) {
              if (message.sensor == 4){
              state = (bool)message.getInt();
              Serial.print(state);
              digitalWrite(RELAY_PIN, state?RELAY_ON:RELAY_OFF);
              Serial.print("Incoming change for sensor:");
              Serial.print(message.getSensor());
              Serial.print(", New status: ");
              Serial.println(message.getBool());
              send(msg2.set(state?RELAY_OFF:RELAY_ON)); 
              if ((message.getBool())== 1){
              poolPumpstate = ("Running");}
              else{
              poolPumpstate = ("Standby");
              }}
              if (message.sensor == 5){
              state = (bool)message.getInt();
              Serial.print(state);       
              digitalWrite(RELAY_PIN_2, state?RELAY_ON:RELAY_OFF);
              Serial.print("Incoming change for sensor:");
              Serial.print(message.getSensor());
              Serial.print(", New status: ");
              Serial.println(message.getBool());
              send(msg3.set(state?RELAY_OFF:RELAY_ON)); 
               if ((message.getBool())== 1){
              solarPumpstate = ("Running");}
              else{
              solarPumpstate = ("Standby");
              }}
              if (message.type == V_STATUS) {
              if (!initialValueSent) {
              Serial.println("Receiving initial value from controller");
              initialValueSent = true;
          }}
         }}
             
      
      void updateLCD()
      {      
        
          lcd.clear();
          lcd.setCursor(0, 1);
          lcd.print("Pool  :");
          lcd.print(" ");
          lcd.print(poolTemp);
          lcd.print((char)223);              
          lcd.print("C");       
          lcd.setCursor(0, 0);
          lcd.print("Solar :");
          lcd.print(" ");
          lcd.print(roofTemp);    
          lcd.print((char)223);       
          lcd.print("C");       
          wait(10000);
          lcd.clear();
          lcd.print("  Pump Status");
          wait(2000);
          lcd.clear();       
          lcd.setCursor(0, 1);
          lcd.print("Pool  :");
          lcd.print(" ");
          lcd.print(poolPumpstate);       
          lcd.setCursor(0, 0);
          lcd.print("Solar :");
          lcd.print(" ");      
          lcd.print(solarPumpstate); 
          wait(10000);       
          lcd.clear();
          lcd.print("  Temperatures");
          wait(2000);     
             
       }           
                 
              
      
          
      
      
      posted in Troubleshooting
      JCH
      JCH
    • RE: Help with pool solar controller code

      Thanks @BearWithBeard

      Ok how does this look.......

      /**
       * The MySensors Arduino library handles the wireless radio link and protocol
       * between your home built sensors/actuators and HA controller of choice.
       * The sensors forms a self healing radio network with optional repeaters. Each
       * repeater and gateway builds a routing tables in EEPROM which keeps track of the
       * network topology allowing messages to be routed to nodes.
       *
       * Created by Henrik Ekblad <henrik.ekblad@mysensors.org>
       * Copyright (C) 2013-2015 Sensnology AB
       * Full contributor list: https://github.com/mysensors/Arduino/graphs/contributors
       *
       * Documentation: http://www.mysensors.org
       * Support Forum: http://forum.mysensors.org
       *
       * This program is free software; you can redistribute it and/or
       * modify it under the terms of the GNU General Public License
       * version 2 as published by the Free Software Foundation.
       *
       *******************************
       *
       * DESCRIPTION
       *
       * Example sketch showing how to send in DS1820B OneWire temperature readings back to the controller
       * http://www.mysensors.org/build/temp
       */
      
      
      // Enable debug prints to serial monitor
      #define MY_DEBUG 
      
      // Enable and select radio type attached
      #define MY_RADIO_RF24
      #define MY_RF24_PA_LEVEL RF24_PA_HIGH
      #define MY_NODE_ID 2
      //#define MY_RADIO_RFM69
      
      
      #include <MySensors.h>  
      #include <DallasTemperature.h>
      #include <OneWire.h>
      #include <LiquidCrystal_I2C.h>
      
      LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
      
      #define COMPARE_TEMP 0 // Send temperature only if changed? 1 = Yes 0 = No
      
      #define ONE_WIRE_BUS 3 // Pin where dallase sensor is connected 
      #define MAX_ATTACHED_DS18B20 16
      unsigned long SLEEP_TIME = 3000; // Sleep time between reads (in milliseconds)
      OneWire oneWire(ONE_WIRE_BUS); // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
      DallasTemperature sensors(&oneWire); // Pass the oneWire reference to Dallas Temperature. 
      float lastTemperature[MAX_ATTACHED_DS18B20];
      int numSensors=0;
      int roofTemp;
      bool receivedConfig = false;
      bool metric = true;
      
       
      // Initialize temperature message
      MyMessage msg(1,V_TEMP);
      
      void before()
      {
        // Startup up the OneWire library
        sensors.begin();
      }
      
      void setup()  
      { 
        // requestTemperatures() will not block current thread
        sensors.setWaitForConversion(false);
      
          lcd.begin(16, 2);                   // LCD 2 lines * 16 char.
          lcd.setBacklight(HIGH);
          lcd.setCursor(0, 0);
          lcd.setCursor(0, 0);
          lcd.print("Waiting for temperature updates");
          wait(10000);
      }
      
      void presentation() {
        // Send the sketch version information to the gateway and Controller
        sendSketchInfo("Temperature Sensor", "1.1");
      
        // Fetch the number of attached temperature sensors  
        numSensors = sensors.getDeviceCount();
      
        // Present all sensors to controller
        for (int i=0; i<numSensors && i<MAX_ATTACHED_DS18B20; i++) {   
           present(i, S_TEMP);
        }
      }
      
      void loop()     
      { 
        
      ///////////////////////////////////////////////////////////////////////////////////////       
      //////////////////////////////  MAIN LOOP  ////////////////////////////////////////////
      ///////////////////////////////////////////////////////////////////////////////////////
      
       // Fetch temperatures from Dallas sensors
        sensors.requestTemperatures();
        
        // query conversion time and sleep until conversion completed
        int16_t conversionTime = sensors.millisToWaitForConversion(sensors.getResolution());
        // sleep() call can be replaced by wait() call if node need to process incoming messages (or if node is repeater)
        wait(conversionTime);
      
        // Read temperatures and send them to controller 
        for (int i=0; i<numSensors && i<MAX_ATTACHED_DS18B20; i++) {
      
          // Fetch and round temperature to one decimal
          float temperature = static_cast<float>(static_cast<int>((getControllerConfig().isMetric?sensors.getTempCByIndex(i):sensors.getTempFByIndex(i)) * 10.)) / 10.;
      
          // Only send data if temperature has changed and no error
          #if COMPARE_TEMP == 1
          if (lastTemperature[i] != temperature && temperature != -127.00 && temperature != 85.00) {
          #else
          if (temperature != -127.00 && temperature != 85.00) {
          #endif
      
            // Send in the new temperature
            send(msg.setSensor(i).set(temperature,1));
            // Save new temperatures for next compare
            lastTemperature[i]=temperature;
            
             lcd.clear();
             lcd.setCursor(0, 1);
             lcd.print("Pool Temp:");
             lcd.print(" ");
             lcd.print(temperature);
      
      
             lcd.setCursor(0, 0);
             lcd.print("Roof Temp:");
             lcd.print(" ");
             lcd.print(roofTemp);
      
                         }
                 }
        }
        
      ///////////////////////////////////////////////////////////////////////////////////////////////       
      //////////////////////////////  RECIEVE ROOF TEMP  ////////////////////////////////////////////
      ///////////////////////////////////////////////////////////////////////////////////////////////
      
      void receive(const MyMessage &message) {
      
      
       
       if (message.type==V_TEMP) {
         if (message.sensor <= 1) {
      
         
          // Write some debug info
          Serial.print("Incoming change from roof sensor:");
          Serial.print(message.sensor);
          Serial.print("\n");
          Serial.print(", New status: ");
          Serial.println(message.getFloat());
      
       roofTemp = (message.getFloat());
          }
        }
      } 
       
      
      

      One more question i need help with......
      On the roof sensor , do i send the nodes different msg. or the same?

      posted in Troubleshooting
      JCH
      JCH
    • Help with pool solar controller code

      I am trying to create a pool solar controller and have run into a couple of issues which i cannot figure out as im not a very good coder 😀

      I am going to have a ds18b20 waterproof temp sensor in the pool pump shed which is taped to the pool pipe to reflect the pool temp.
      This node is also going to have a lcd screen which displays the pool temp and well as the roof solar temp.
      I am going to have a 2nd node on the roof measuring the roof water temp and that node is going to send its data back to the controller and also direct to the node (not sure if this is the best way or not) so that it can be displayed on the lcd screen.
      The roof node is powered by solar and reports every 30 seconds and then goes back to sleep.

      Here is the code for the roof sensor

      /**
       * The MySensors Arduino library handles the wireless radio link and protocol
       * between your home built sensors/actuators and HA controller of choice.
       * The sensors forms a self healing radio network with optional repeaters. Each
       * repeater and gateway builds a routing tables in EEPROM which keeps track of the
       * network topology allowing messages to be routed to nodes.
       *
       * Created by Henrik Ekblad <henrik.ekblad@mysensors.org>
       * Copyright (C) 2013-2015 Sensnology AB
       * Full contributor list: https://github.com/mysensors/Arduino/graphs/contributors
       *
       * Documentation: http://www.mysensors.org
       * Support Forum: http://forum.mysensors.org
       *
       * This program is free software; you can redistribute it and/or
       * modify it under the terms of the GNU General Public License
       * version 2 as published by the Free Software Foundation.
       *
       *******************************
       *
       * DESCRIPTION
       *
       * Example sketch showing how to send in DS1820B OneWire temperature readings back to the controller
       * http://www.mysensors.org/build/temp
       */
      
      
      // Enable debug prints to serial monitor
      #define MY_DEBUG 
      
      // Enable and select radio type attached
      #define MY_RADIO_RF24
      #define MY_RF24_PA_LEVEL RF24_PA_LOW
      #define MY_NODE_ID 1
      
      #include <MySensors.h>  
      #include <DallasTemperature.h>
      #include <OneWire.h>
      
      #define COMPARE_TEMP 0 // Send temperature only if changed? 1 = Yes 0 = No
      
      int BATTERY_SENSE_PIN = A0;  // select the input pin for the battery sense point
      int oldBatteryPcnt = 0;
      
      #define ONE_WIRE_BUS 3 // Pin where dallase sensor is connected 
      #define MAX_ATTACHED_DS18B20 16
      unsigned long SLEEP_TIME = 30000; // Sleep time between reads (in milliseconds)
      OneWire oneWire(ONE_WIRE_BUS); // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
      DallasTemperature sensors(&oneWire); // Pass the oneWire reference to Dallas Temperature. 
      float lastTemperature[MAX_ATTACHED_DS18B20];
      int numSensors=0;
      bool receivedConfig = false;
      bool metric = true;
      // Initialize temperature message
      MyMessage msg(0,V_TEMP);
      
      void before()
      {
        // Startup up the OneWire library
        sensors.begin();
      }
      
      void setup()  
      
      {
         
       // use the 1.1 V internal reference for battery mointor
      #if defined(__AVR_ATmega2560__)
        analogReference(INTERNAL1V1);
      #else
        analogReference(INTERNAL);
      #endif
      
        // requestTemperatures() will not block current thread
        sensors.setWaitForConversion(false);
      }
      
      void presentation() {
        // Send the sketch version information to the gateway and Controller
        sendSketchInfo("Roof Temperature Sensor", "1.0");
      
        // Fetch the number of attached temperature sensors  
        numSensors = sensors.getDeviceCount();
      
        // Present all sensors to controller
        for (int i=0; i<numSensors && i<MAX_ATTACHED_DS18B20; i++) {   
           present(i, S_TEMP);
        }
      }
      
      void loop()     
      {
        
      //////////////////////////////////////////////
      ///////////  BATTERY CODE  ///////////////////  
      /////////////////////////////////////////////
      
        // get the battery Voltage
        int sensorValue = analogRead(BATTERY_SENSE_PIN);
      #ifdef MY_DEBUG
        Serial.println(sensorValue);
      #endif
      
        // 1M, 470K divider across battery and using internal ADC ref of 1.1V
        // Sense point is bypassed with 0.1 uF cap to reduce noise at that point
        // ((1e6+470e3)/470e3)*1.1 = Vmax = 3.44 Volts
        // 3.44/1023 = Volts per bit = 0.003363075
      
        int batteryPcnt = sensorValue / 10;
      
      #ifdef MY_DEBUG
        float batteryV  = sensorValue * 0.003363075;
        Serial.print("Battery Voltage: ");
        Serial.print(batteryV);
        Serial.println(" V");
      
        Serial.print("Battery percent: ");
        Serial.print(batteryPcnt);
        Serial.println(" %");
      #endif
      
        if (oldBatteryPcnt != batteryPcnt) {
          // Power up radio after sleep
          sendBatteryLevel(batteryPcnt);
          oldBatteryPcnt = batteryPcnt;
        }
             
      //////////////////////////////////////////////
      ///////////  DALLAS CODE  ///////////////////  
      /////////////////////////////////////////////
      
        // Fetch temperatures from Dallas sensors
        sensors.requestTemperatures();
      
        // query conversion time and sleep until conversion completed
        int16_t conversionTime = sensors.millisToWaitForConversion(sensors.getResolution());
        // sleep() call can be replaced by wait() call if node need to process incoming messages (or if node is repeater)
        sleep(conversionTime);
      
        // Read temperatures and send them to controller 
        for (int i=0; i<numSensors && i<MAX_ATTACHED_DS18B20; i++) {
      
          // Fetch and round temperature to one decimal
          float temperature = static_cast<float>(static_cast<int>((getControllerConfig().isMetric?sensors.getTempCByIndex(i):sensors.getTempFByIndex(i)) * 10.)) / 10.;
      
          // Only send data if temperature has changed and no error
          #if COMPARE_TEMP == 1
          if (lastTemperature[i] != temperature && temperature != -127.00 && temperature != 85.00) {
          #else
          if (temperature != -127.00 && temperature != 85.00) {
          #endif
      
            // Send in the new temperature
            send(msg.setSensor(i).set(temperature,1));
            send(msg.setDestination(2).setSensor(1).set(temperature, 1)); // send the temp to Node 2(Pool temp)
            // Save new temperatures for next compare
            lastTemperature[i]=temperature;
          }
      
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////    
        }
        sleep(SLEEP_TIME);
      }
      

      And here is the code for the pool controller so far.....

      /**
       * The MySensors Arduino library handles the wireless radio link and protocol
       * between your home built sensors/actuators and HA controller of choice.
       * The sensors forms a self healing radio network with optional repeaters. Each
       * repeater and gateway builds a routing tables in EEPROM which keeps track of the
       * network topology allowing messages to be routed to nodes.
       *
       * Created by Henrik Ekblad <henrik.ekblad@mysensors.org>
       * Copyright (C) 2013-2015 Sensnology AB
       * Full contributor list: https://github.com/mysensors/Arduino/graphs/contributors
       *
       * Documentation: http://www.mysensors.org
       * Support Forum: http://forum.mysensors.org
       *
       * This program is free software; you can redistribute it and/or
       * modify it under the terms of the GNU General Public License
       * version 2 as published by the Free Software Foundation.
       *
       *******************************
       *
       * DESCRIPTION
       *
       * Example sketch showing how to send in DS1820B OneWire temperature readings back to the controller
       * http://www.mysensors.org/build/temp
       */
      
      
      // Enable debug prints to serial monitor
      #define MY_DEBUG 
      
      // Enable and select radio type attached
      #define MY_RADIO_RF24
      #define MY_RF24_PA_LEVEL RF24_PA_HIGH
      #define MY_NODE_ID 2
      //#define MY_RADIO_RFM69
      
      #include <MySensors.h>  
      #include <DallasTemperature.h>
      #include <OneWire.h>
      #include <LiquidCrystal_I2C.h>
      
      LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
      
      #define COMPARE_TEMP 0 // Send temperature only if changed? 1 = Yes 0 = No
      
      #define ONE_WIRE_BUS 3 // Pin where dallase sensor is connected 
      #define MAX_ATTACHED_DS18B20 16
      unsigned long SLEEP_TIME = 3000; // Sleep time between reads (in milliseconds)
      OneWire oneWire(ONE_WIRE_BUS); // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
      DallasTemperature sensors(&oneWire); // Pass the oneWire reference to Dallas Temperature. 
      float lastTemperature[MAX_ATTACHED_DS18B20];
      int numSensors=0;
      bool receivedConfig = false;
      bool metric = true;
      // Initialize temperature message
      MyMessage msg(1,V_TEMP);
      
      void before()
      {
        // Startup up the OneWire library
        sensors.begin();
      }
      
      void setup()  
      { 
        // requestTemperatures() will not block current thread
        sensors.setWaitForConversion(false);
      
          lcd.begin(16, 2);                   // LCD 2 lines * 16 char.
          lcd.setBacklight(HIGH);
          lcd.setCursor(0, 0);
          lcd.setCursor(0, 0);
          lcd.print("Waiting for temperature updates");
          wait(10000);
      }
      
      void presentation() {
        // Send the sketch version information to the gateway and Controller
        sendSketchInfo("Temperature Sensor", "1.1");
      
        // Fetch the number of attached temperature sensors  
        numSensors = sensors.getDeviceCount();
      
        // Present all sensors to controller
        for (int i=0; i<numSensors && i<MAX_ATTACHED_DS18B20; i++) {   
           present(i, S_TEMP);
        }
      }
      
      void loop()     
      { 
            
      //request(1, V_TEMP);  // NO NEED TO REQUEST AS IT IS BEING SENT
      
       }
      
      
      void receive(const MyMessage &message) {
      
          
       if (message.type==V_TEMP) {
         if (message.sensor <= 1) {
      
         
          // Write some debug info
          Serial.print("Incoming change from roof sensor:");
          Serial.print(message.sensor);
          Serial.print("\n");
          Serial.print(", New status: ");
          Serial.println(message.getFloat());
          lcd.clear();
          lcd.setCursor(0, 0);
          lcd.print("Roof Temp:");
          lcd.print(" ");
          lcd.print(message.getFloat());
         }
      
         
        // Fetch temperatures from Dallas sensors
        sensors.requestTemperatures();
      
        // query conversion time and sleep until conversion completed
        int16_t conversionTime = sensors.millisToWaitForConversion(sensors.getResolution());
        // sleep() call can be replaced by wait() call if node need to process incoming messages (or if node is repeater)
        sleep(conversionTime);
      
        // Read temperatures and send them to controller 
        for (int i=0; i<numSensors && i<MAX_ATTACHED_DS18B20; i++) {
      
          // Fetch and round temperature to one decimal
          float temperature = static_cast<float>(static_cast<int>((getControllerConfig().isMetric?sensors.getTempCByIndex(i):sensors.getTempFByIndex(i)) * 10.)) / 10.;
      
          // Only send data if temperature has changed and no error
          #if COMPARE_TEMP == 1
          if (lastTemperature[i] != temperature && temperature != -127.00 && temperature != 85.00) {
          #else
          if (temperature != -127.00 && temperature != 85.00) {
          #endif
      
            // Send in the new temperature
            send(msg.setSensor(i).set(temperature,1));
            // Save new temperatures for next compare
            lastTemperature[i]=temperature;
      
             lcd.setCursor(0, 1);
             lcd.print("Pool Temp:");
             lcd.print(" ");
             lcd.print(temperature);
      
          }
       }
      
        }
      //  wait(SLEEP_TIME);
        }
        
      

      Now the problem i am having is as the pool node doesn't sleep it basically just waits to receive a message from the pool controller and once it does it reports both sensors and then goes back to start again.... so if the roof node goes down for whatever reason then the whole thing stops working.
      What is the best way around this?

      Also i wasnt getting alot of the messages and figured ouit from the logs that it was bcasue it was being repeated by the gateway... so to get around that i changed

      if (message.sensor == 1)
      

      to

      if (message.sensor <= 1)
      

      to include the gateway ( 0 )

      again i am not sure if thats the best way forward?
      I really am only a weekend hobbyist so not too sure that i am going about this the right way

      posted in Troubleshooting
      JCH
      JCH