macrocell_office_iot/envisens/envisens_esp_fw/envisens_esp_fw.ino

/* Macrocell environmental sensor project EnviSens
 *  
 *  This firmware provides features to use the NodeMCU ESP12 unit as an environmental sensor broker.
 *  It currently collects all the sensor information via I2C from a connected ATMEGA.
 *  
 *  (C) 2019 Macrocell - Environmental sensing solutions
 *   proudly presented by Macrocell - FPGA Innovators
 */

#include <ESP8266WiFi.h>
#include <Wire.h>
#include <PubSubClient.h>
#include "DHT.h"
#include "configuration.h"

#define TOPIC_BASE "sensor/" sensor_id "/"
#define TOPIC_TEMP TOPIC_BASE "temperature"
#define TOPIC_HMID TOPIC_BASE "humidity"
#define TOPIC_HEAT TOPIC_BASE "heat_index"
#define TOPIC_AIRQ TOPIC_BASE "air_gas"

#define DIFF_TEMP 0.3 // sensor has only 0.5°C accuracy, triggering on less is ludicrous
#define DIFF_HMID 2.5 // humidity doesn't change that much anyways
#define DIFF_HEAT 0.2 // this one's actually quite active
#define DIFF_AIRQ 3 // this one hardly changes 

float hmid = 0; // humidity
float hmid_r = 0; // humidity
float temp = 0; // temperature
float temp_r = 0; // temperature
float heat = 0; // heat index
float heat_r = 0; // heat index
float airq = 0; // air quality / gas 
float airq_r = 0; // air quality / gas

char data[8];
char sensor_name[5];
float sensor_value;

WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  Serial.begin(SERIAL_BAUDRATE);
  pinMode(LED_BUILTIN, OUTPUT); 
  digitalWrite(LED_BUILTIN, LOW);
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
  Wire.begin();        // join i2c bus as master
}

void setup_wifi() {
  delay(10);
  // Connect to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(wifi_ssid);

  WiFi.begin(wifi_ssid, wifi_password);
  WiFi.mode(WIFI_STA);

  // blink LED fast until WiFi is connected
  while (WiFi.status() != WL_CONNECTED) {
    delay(200);
    digitalWrite(LED_BUILTIN, HIGH);
    Serial.print(".");
    delay(200);
    digitalWrite(LED_BUILTIN, LOW);
  }

  // WiFi connected
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void reconnect() {
  // Loop until reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Attempt to connect
    if (client.connect(mqtt_client, mqtt_user, mqtt_password)) {
      Serial.println("connected");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      digitalWrite(LED_BUILTIN, HIGH);
      // Wait 5 seconds before retrying
      delay(4000);
      digitalWrite(LED_BUILTIN, LOW);
      delay(1000);
    }
  }
}

bool checkVariation(float newValue, float prevValue, float maxDiff) {
  return !isnan(newValue) &&
         (newValue < prevValue - maxDiff || newValue > prevValue + maxDiff);
}

bool checkPlausibility(float newValue, float prevValue, float maxDiff) {
  return (newValue < prevValue + (maxDiff * 10) || newValue > prevValue - (maxDiff * 10));
}

long lastMsg = 0;
long lastSent = 0; 
bool published = false;
bool forcePublish = false;

bool publish (String desc, char *topic, float val, float &lastVal, float diff, bool force){
  bool retval = false;
  if (checkVariation(val, lastVal, diff) or force) {
    lastVal = val;
    Serial.println("New " + desc + ": " + String(val).c_str());
    if (checkPlausibility(val, lastVal, diff) or force) {
      Serial.println("Value published");
      client.publish(topic, String(val).c_str(), true);
      retval = true;
    } else {
      Serial.print("** ERROR: Value out of bounds, not published. Last value :");
      Serial.println(String(lastVal).c_str());
    }
  } else {
    Serial.println("Not enough variation for a publication");
  }
  return retval;
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  digitalWrite(LED_BUILTIN, HIGH);

  long now = millis();
  if (now - lastMsg > OPERATION_PERIOD / 2) {
    if (OPERATION_BLINK_EN) {digitalWrite(LED_BUILTIN, LOW);}
  }
  if (now - lastMsg > OPERATION_PERIOD) {
    lastMsg = now;
    if (OPERATION_BLINK_EN) {digitalWrite(LED_BUILTIN, HIGH);}

    Wire.requestFrom(8, 8);    // request 6 bytes from slave device #8
    int i = 0;
    while(Wire.available()) {   // slave may send less than requested
      char c =  Wire.read(); // receive a byte as character  
      data[i] = byte(c);
      i = i + 1;
    }
    
    union sensor_tag {byte sensor_b[4]; float sensor_float;} sensor_union;       //DRPS = Drum Revs per Second
    sensor_name[0] = char(data[0]);
    sensor_name[1] = char(data[1]);
    sensor_name[2] = char(data[2]);
    sensor_name[3] = char(data[3]);
    sensor_name[4] = '\0';
    
    sensor_union.sensor_b[0] = data[4];
    sensor_union.sensor_b[1] = data[5];
    sensor_union.sensor_b[2] = data[6];
    sensor_union.sensor_b[3] = data[7];    
    sensor_value = sensor_union.sensor_float;
    
    Serial.print("Received sensor reading: ");
    Serial.print(sensor_name);
    Serial.print(" - ");
    Serial.println(sensor_value);

    if (strcmp(sensor_name, "hmid") == 0){
      hmid = sensor_value;
    } else if (strcmp(sensor_name, "temp") == 0){
      temp = sensor_value;
    } else if (strcmp(sensor_name, "heat") == 0){
      heat = sensor_value;
    } else if (strcmp(sensor_name, "airq") == 0){
      airq = sensor_value;
    } else{
      Serial.println("ERR: Sensor could not be identified");
    }

    published = false;
    if (lastSent > FORCE_PERIOD) {
      Serial.println(F("Forcing a publish of all values"));
      forcePublish = true;
      lastSent = 0;
    }

    published += publish("temperature", TOPIC_TEMP, temp, temp_r, DIFF_TEMP, forcePublish);
    published += publish("humidity", TOPIC_HMID, hmid, hmid_r, DIFF_HMID, forcePublish);
    published += publish("heat index", TOPIC_HEAT, heat, heat_r, DIFF_HEAT, forcePublish);
    published += publish("air quality", TOPIC_AIRQ, airq, airq_r, DIFF_AIRQ, forcePublish);
    
    if (published == false) {
      lastSent = lastSent + 1;
    } else {
      lastSent = 0;
    }
    
    forcePublish = false;
  }
}