mysensors.ru

Код: Выделить всё

#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#define MY_RADIO_NRF5_ESB
#define MY_SMART_SLEEP_WAIT_DURATION_MS 1000
#define MY_PASSIVE_NODE
#define MY_NODE_ID 100

#define TEMP_CHILD_ID 0
#define HUM_CHILD_ID 1
#define BARO_CHILD_ID 2
#define FORECAST_CHILD_ID 3
#define ALTITUDE_CHILD_ID 4
#define BAROCONF_CHILD_ID 100
#define LEDCONF_CHILD_ID 101
#define FORECASTCONF_CHILD_ID 102
#define ALTITUDECONF_CHILD_ID 103
#define SLEEP_TIME_SENS_ID 104
#define BATTARY_SEND_SENS_ID 105
#define POWER_CHILD_ID 110

#define BAT_COOF 0.0092957746478873
#define BAT_MIN 225
#define BAT_MAX 295


float tempThreshold = 0.5;
float humThreshold = 5;
float presThreshold = 1;
float pres_mmThreshold = 1;
float altiThreshold = 5;

byte baromem;
byte ledmem;
byte altitudemem;
byte forecastmem;
uint16_t temp;
float vcc;
int battery;
int old_battery;
boolean first_send_battery = 1;
boolean first_param_send = 1;
uint32_t sleepTime;
byte sleep_mode;
uint32_t w_battetyTime = 0;
uint32_t send_batteryTime;
bool metric = true;                // Variable that stores if the sensor will output the temperature in Fahrenheit of Celsius. The gateway sends this preference to the node, so you dont need to change it here.
bool receivedConfig = false;
bool flag_led = 0;
bool stat = 0;

#define SEALEVELPRESSURE_HPA (1013.25)

Adafruit_BME280 bme; // I2C

float temperature;
float pressure;
float pressure_mm;
float altitude;
float humidity;
float lastTemperature = -1;
float lastHumidity = -1;
float lastPressure = -1;
float lastPressure_mm = -1;
float lastAltitude = -1;
bool status;

#define CONVERSION_FACTOR (1.0/10.0)         // used by forecast algorithm to convert from Pa to kPa, by dividing hPa by 10.
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)
};
int lastForecast = -1;                // Stores the previous forecast, so it can be compared with a new forecast.
const int LAST_SAMPLES_COUNT = 5;
float lastPressureSamples[LAST_SAMPLES_COUNT];
int minuteCount = 0;                // Helps the forecst algorithm keep time.
bool firstRound = true;                // Helps the forecast algorithm recognise if the sensor has just been powered up.
float pressureAvg;                // Average value is used in forecast algorithm.
float pressureAvg2;                // Average after 2 hours is used as reference value for the next iteration.
float dP_dt;                    // Pressure delta over time


#include <MySensors.h>

MyMessage temperatureMsg(TEMP_CHILD_ID, V_TEMP);
MyMessage humidityMsg(HUM_CHILD_ID, V_HUM);
MyMessage pressureMsg(BARO_CHILD_ID, V_PRESSURE);
MyMessage forecastMsg(FORECAST_CHILD_ID, V_FORECAST);
MyMessage altitudeMsg(ALTITUDE_CHILD_ID, V_DISTANCE);
MyMessage baromemMsg(BAROCONF_CHILD_ID, V_VAR1);
MyMessage ledmemMsg(LEDCONF_CHILD_ID, V_VAR1);
MyMessage forecastmemMsg(FORECASTCONF_CHILD_ID, V_VAR1);
MyMessage altitudememMsg(ALTITUDECONF_CHILD_ID, V_VAR1);
MyMessage msg_sleep_time(SLEEP_TIME_SENS_ID, V_VAR1);
MyMessage msg_battary_send(BATTARY_SEND_SENS_ID, V_VAR1);
MyMessage powerMsg(POWER_CHILD_ID, V_VAR1);


void preHwInit() {
  pinMode(21, INPUT);
  pinMode(29, INPUT);
  pinMode(25, OUTPUT);
  digitalWrite(25, HIGH);
  pinMode(26, OUTPUT);
  digitalWrite(26, HIGH);
  pinMode(27, OUTPUT);
  digitalWrite(27, HIGH);
  red_short_blink();
  delay(500);
  white_blinkhw();
  delay(500);
  //white_blinkhw();
}


void before()
{
  NRF_POWER->DCDCEN = 1;
  analogReadResolution(10);
  analogReference(AR_INTERNAL);
  NRF_UART0->ENABLE = 0;
  disableNfc();
  turnOffAdc();


  baromem = loadState(100);
  if (baromem > 1) {
    baromem = 0;
    saveState(100, baromem);
  }

  ledmem = loadState(101);
  if (ledmem > 1) {
    ledmem = 0;
    saveState(101, ledmem);
  }

  forecastmem = loadState(102);
  if (forecastmem > 1) {
    forecastmem = 0;
    saveState(102, forecastmem);
  }

  altitudemem = loadState(103);
  //altitudemem = 1;
  if (altitudemem > 1) {
    altitudemem = 1;
    saveState(103, altitudemem);
  }

  sleepTime = loadState(104);
  if (sleepTime > 240 || sleepTime == 0) {
    sleepTime = 1;
    saveState(104, sleepTime);
  }

  send_batteryTime = loadState(105);
  if (send_batteryTime > 168 || send_batteryTime == 0) {
    send_batteryTime = 1;
    saveState(105, send_batteryTime);
  }



 // digitalWrite(27, LOW);
}


void presentation()  {
  sendSketchInfo("EFEKTA BME280 Sensor", "1.1");
  present(TEMP_CHILD_ID, S_TEMP, "TEMPERATURE [C or F]");
  wait(100);
  present(HUM_CHILD_ID, S_HUM, "HUMIDITY [%]");
  wait(100);
  present(BARO_CHILD_ID, S_BARO, "PRESSURE [hPa or mmHg]");
  wait(100);
  present(FORECAST_CHILD_ID, S_BARO, "FORECAST");
  wait(100);
  present(ALTITUDE_CHILD_ID, S_DISTANCE, "ALTITUDE [m]");
  wait(100);
  present(BAROCONF_CHILD_ID, S_CUSTOM, "PRESSURE 0:ON|1:OFF");
  wait(100);
  present(LEDCONF_CHILD_ID, S_CUSTOM, "LEDS 0:ON|1:OFF");
  wait(100);
  present(FORECASTCONF_CHILD_ID, S_CUSTOM, "FORECAST 0:ON|1:OFF");
  wait(100);
  present(ALTITUDECONF_CHILD_ID, S_CUSTOM, "ALTITUDE 0:ON|1:OFF");
  wait(100);
  present(SLEEP_TIME_SENS_ID, S_CUSTOM, "DELAY TIME|MIN");
  wait(100);
  present(BATTARY_SEND_SENS_ID, S_CUSTOM, "BATTERY SEND TIME|H");
}

void setup() {

  //digitalWrite(27, HIGH);

  if (isTransportReady() == true)
  {
    green_long_blink();
  } else {
    red_long_blink();
  }

  if (! bme.begin(&Wire)) {
    while (1);
  }
  bme.setSampling(Adafruit_BME280::MODE_FORCED,
                  Adafruit_BME280::SAMPLING_X1, // temperature
                  Adafruit_BME280::SAMPLING_X1, // pressure
                  Adafruit_BME280::SAMPLING_X1, // humidity
                  Adafruit_BME280::FILTER_OFF   );
                  sleep(1000);

  sleep_mode = 2;
}


void loop() {
  /*
  if (stat == 1) {
    send(altitudememMsg.set(altitudemem));
    red_long_blink();
    stat = 0;
  }
  */

  bme.takeForcedMeasurement(); // has no effect in normal mode
  wait(100);
  sendData();

  if (first_param_send == 1) {
    first_send_param ();
    first_param_send = 0;
  }

  if (w_battetyTime >= send_batteryTime * 60 * 60 * 1000) {
    readBatLev();
    sleep_mode = 2;
    w_battetyTime = 0;
  }

  //mySleepPrepare();
  //i2c_off();

  if (sleep_mode == 0) {
    sleep(sleepTime * 60 * 1000, false);
    //wait(500);
  }
  if (sleep_mode == 1) {
    sleep(sleepTime * 60 * 1000, true);
    sleep_mode = 0;
    //wait(1000);
  }
  if (sleep_mode == 2) {
    sleep(sleepTime * 60 * 1000, true);
    sleep_mode = 1;
    //wait(1000);
  }
  w_battetyTime = w_battetyTime + (sleepTime * 60 * 1000);
}


void receive(const MyMessage & message)
{
  if (message.sensor == BAROCONF_CHILD_ID) {
    if (message.type == V_VAR1) {
      if (message.getByte() <= 1) {
        baromem = message.getByte();
        saveState(100, baromem);
        if (send(baromemMsg.set(baromem))) {
          if (baromem == 0) {
            TRANSPORT_DEBUG(PSTR("MyS: SENDING PRESSURE: ON\n"));
          }
          if (baromem == 1) {
            TRANSPORT_DEBUG(PSTR("MyS: SENDING PRESSURE: OFF\n"));
          }
          if (ledmem == 0) {
            green_long_blink();
          }
        }
      }
    }
  }

  if (message.sensor == LEDCONF_CHILD_ID) {
    if (message.type == V_VAR1) {
      if (message.getByte() <= 1) {
        ledmem = message.getByte();
        saveState(101, ledmem);
        if (send(ledmemMsg.set(ledmem))) {
          if (ledmem == 0) {
            TRANSPORT_DEBUG(PSTR("MyS: LEDS: ON\n"));
          }
          if (ledmem == 1) {
            TRANSPORT_DEBUG(PSTR("MyS: LEDS: OFF\n"));
          }
          if (ledmem == 0) {
            green_long_blink();
          }
        }
      }
    }
  }

  if (message.sensor == FORECASTCONF_CHILD_ID) {
    if (message.type == V_VAR1) {
      if (message.getByte() <= 1) {
        forecastmem = message.getByte();
        saveState(102, forecastmem);
        if (send(forecastmemMsg.set(forecastmem))) {
          if (forecastmem == 0) {
            TRANSPORT_DEBUG(PSTR("MyS: SENDING FORECAST: ON\n"));
          }
          if (forecastmem == 1) {
            TRANSPORT_DEBUG(PSTR("MyS: SENDING FORECAST: OFF\n"));
          }
          if (ledmem == 0) {
            red_long_blink();
          }
        }
      }
    }
  }

  if (message.sensor == ALTITUDECONF_CHILD_ID) {
   // stat = 1;
    if (message.type == V_VAR1) {
      if (message.getByte() <= 1) {
        altitudemem = message.getByte();
        saveState(103, altitudemem);
        sleep(1000);
        send(altitudememMsg.set(altitudemem));
        if (ledmem == 0) {
          blue_long_blink();
        }
        if (altitudemem == 0) {
          TRANSPORT_DEBUG(PSTR("MyS: SENDING ALTITUDE: ON\n"));
        }
        if (altitudemem == 1) {
          TRANSPORT_DEBUG(PSTR("MyS: SENDING ALTITUDE: OFF\n"));
        }
      }
    }
  }


  if (message.sensor == SLEEP_TIME_SENS_ID) {
    if (message.type == V_VAR1) {
      if (message.getULong() <= 240 && message.getULong() != 0) {
        sleepTime = message.getULong();
        saveState(104, sleepTime);
        if (send(msg_sleep_time.set(sleepTime))) {
          TRANSPORT_DEBUG(PSTR("MyS: THE NEW INTERVAL SEND VALUES IS SET: %d MIN.\n"), sleepTime);
          if (ledmem == 0) {
            green_long_blink();
          }
        }
      }
    }
  }

  if (message.sensor == BATTARY_SEND_SENS_ID) {
    if (message.type == V_VAR1) {
      if (message.getULong() <= 168 && message.getULong() != 0) {
        send_batteryTime = message.getULong();
        saveState(105, send_batteryTime);
        if (send(msg_battary_send.set(send_batteryTime))) {
          TRANSPORT_DEBUG(PSTR("MyS: THE NEW INTERVAL BATTERY SEND IS SET: %d HOUR\n"), send_batteryTime);
          if (ledmem == 0) {
            green_long_blink();
          }
        }
      }
    }
  }
}




void sendData() {
  temperature = bme.readTemperature();
  if (baromem == 0 || forecastmem == 0) {
    pressure = bme.readPressure() / 100.0F;
  }
  if (altitudemem == 0) {
    altitude = bme.readAltitude(SEALEVELPRESSURE_HPA);
  }
  humidity = bme.readHumidity();

  if (!metric) {
    temperature = temperature * 9.0 / 5.0 + 32.0;
  } else {
    if (baromem == 0) {
      pressure_mm = pressure * 0.75006375541921;
    }
  }
  int forecast;
  if (forecastmem == 0) {
    forecast = sample(pressure);                        // Run the forecast function with a new pressure update.
  }

  //send(temperatureMsg.set(temperature, 0));
  //wait(200);
  if (abs(temperature - lastTemperature) >= tempThreshold) {
    if (send(temperatureMsg.set(temperature, 2))) {
      flag_led = 1;
    }
    lastTemperature = temperature;
    //sleep(5000);
  }

  if (abs(humidity - lastHumidity) >= humThreshold) {
    if (send(humidityMsg.set(humidity, 2))) {
      flag_led = 1;
    }
    lastHumidity = humidity;
    //sleep(5000);
  }

  if (baromem == 0) {
    if (!metric) {
      if (abs(pressure - lastPressure) >= presThreshold) {
        if (send(pressureMsg.set(pressure, 1))) {
          flag_led = 1;
        }
        lastPressure = pressure;
        //sleep(500);
      }

    } else {
      if (abs(pressure_mm - lastPressure_mm) >= pres_mmThreshold) {
        if (send(pressureMsg.set(pressure_mm, 1))) {
          flag_led = 1;
        }
        lastPressure_mm = pressure_mm;
        //sleep(500);
      }

    }
  }

  if (forecastmem == 0) {
    if (forecast != lastForecast) {
      if (send(forecastMsg.set(weather[forecast]))) {
        flag_led = 1;
      }
      lastForecast = forecast;
      //sleep(500);
    }
  }


  if (altitudemem == 0) {
    if (abs(altitude - lastAltitude) >= altiThreshold) {
      if (send(altitudeMsg.set(altitude, 2))) {
        flag_led = 1;
      }
      lastAltitude = altitude;
      //sleep(500);
    }

  }
  if (flag_led == 1) {
    if (ledmem == 0) {
      blue_long_blink();
    }
    flag_led = 0;
  } else {
    if (ledmem == 0) {
      green_long_blink();
    }
  }
}

void disableNfc() {
  NRF_NFCT->TASKS_DISABLE = 1;
  NRF_NVMC->CONFIG = 1;
  NRF_UICR->NFCPINS = 0;
  NRF_NVMC->CONFIG = 0;
}

void turnOffRadio() {
  NRF_RADIO->TASKS_DISABLE = 1;
  while (!(NRF_RADIO->EVENTS_DISABLED)) {}
}

void turnOffAdc() {
  if (NRF_SAADC->ENABLE) {
    NRF_SAADC->TASKS_STOP = 1;
    while (NRF_SAADC->EVENTS_STOPPED) {}
    NRF_SAADC->ENABLE = 0;
    while (NRF_SAADC->ENABLE) {}
  }
}

void turnOffHighFrequencyClock() {
  NRF_CLOCK->TASKS_HFCLKSTOP = 1;
  while ((NRF_CLOCK->HFCLKSTAT) & 0x0100) {}
}

void mySleepPrepare() {
  turnOffHighFrequencyClock();
  //turnOffRadio();
  NRF_UART0->ENABLE = 0;
}

void i2c_off()
{
  NRF_TWI1->ENABLE = TWI_ENABLE_ENABLE_Disabled << TWI_ENABLE_ENABLE_Pos;
  *(volatile uint32_t *)0x40004FFC = 0;
  *(volatile uint32_t *)0x40004FFC;
  *(volatile uint32_t *)0x40004FFC = 1;
}




void readBatLev() {
  NRF5_ESB_startListening();
  wait(200);
  temp = analogRead(29);
  vcc = temp * 0.0092957746478873 * 100;
  battery = map((int)vcc, BAT_MIN, BAT_MAX, 0, 100);
  if (battery < 0) {
    battery = 0;
  }
  if (battery > 100) {
    battery = 100;
  }
  if (first_send_battery == 1) {
    first_send_battery = 0;
    sendBatteryLevel(battery);
    //TRANSPORT_DEBUG(PSTR("MyS: SEND BATTERY LEVEL\n"));
    //TRANSPORT_DEBUG(PSTR("MyS: BATTERY LEVEL ADC: %d\n"), temp);
    old_battery = battery;
  } else {
    if (old_battery != battery) {
      if (battery < old_battery) {
        old_battery = battery;
        sendBatteryLevel(battery);
        //TRANSPORT_DEBUG(PSTR("MyS: SEND BATTERY LEVEL\n"));
        //TRANSPORT_DEBUG(PSTR("MyS: BATTERY LEVEL ADC: %d\n"), temp);
      } else {
        battery = old_battery;
      }
    }
  }
}

void red_short_blink() {
  digitalWrite(25, LOW);
  sleep(50);
  digitalWrite(25, HIGH);
}

void green_short_blink() {
  digitalWrite(26, LOW);
  sleep(50);
  digitalWrite(26, HIGH);
}

void blue_short_blink() {
  digitalWrite(27, LOW);
  sleep(50);
  digitalWrite(27, HIGH);
}
void red_long_blink() {
  digitalWrite(25, LOW);
  sleep(200);
  digitalWrite(25, HIGH);
}

void green_long_blink() {
  digitalWrite(26, LOW);
  sleep(200);
  digitalWrite(26, HIGH);
}

void blue_long_blink() {
  digitalWrite(27, LOW);
  sleep(200);
  digitalWrite(27, HIGH);
}

void white_blinkhw() {
  digitalWrite(27, LOW);
  digitalWrite(26, LOW);
  digitalWrite(25, LOW);
  delay(300);
  digitalWrite(27, HIGH);
  digitalWrite(26, HIGH);
  digitalWrite(25, HIGH);
}

void first_send_param () {
  send(msg_sleep_time.set(sleepTime));
  wait(100);
  send(ledmemMsg.set(ledmem));
  wait(100);
  send(msg_battary_send.set(send_batteryTime));
  wait(100);
  send(baromemMsg.set(baromem));
  wait(100);
  send(forecastmemMsg.set(forecastmem));
  wait(100);
  send(altitudememMsg.set(altitudemem));
  readBatLev();
}






// These functions are only included if the forecast function is enables. The are used to generate a weater prediction by checking if the barometric pressure is rising or falling over 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 found here
// http://www.freescale.com/files/sensors/doc/app_note/AN3914.pdf
// Pressure in hPa -->  forecast done by calculating kPa/h
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("BME280 - 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;
}