support CCS811, serial relais.

README.md

 
 Small firmware supporting different environmental sensors, as well as different microcontroller platforms.
 
-Supports SHT21, BME280, analog moisture sensors.
+Supports SHT21, BME280, CCS811, analog moisture sensors, serial or gpio relais.
 
 Runs on ESP32, ESP8266, Arduino Uno Wifi Developer Edition.

include/config.h

 #define __ESP_ENV_CONFIG__
 
 // Sketch version
-const char* esp_env_version = "0.4.0";
+#define ESP_ENV_VERSION "0.5.0"
 
 // location of sensor, used in DB and hostname
-//const char* sensor_location = "livingroom";
-//const char* sensor_location = "bedroom";
-//const char* sensor_location = "bathroom";
-//const char* sensor_location = "kitchen";
-//const char* sensor_location = "hallway";
-//const char* sensor_location = "tent";
-//const char* sensor_location = "storage";
-//const char* sensor_location = "greenhouse";
-const char* sensor_location = "testing";
-
-#define SENSOR_HOSTNAME_PREFIX "ESP-"
+//#define SENSOR_LOCATION_LIVINGROOM
+//#define SENSOR_LOCATION_BEDROOM
+//#define SENSOR_LOCATION_BATHROOM
+//#define SENSOR_LOCATION_GREENHOUSE
+#define SENSOR_LOCATION_TESTING
 
 // WiFi AP settings
-const char* ssid = "WIFI_SSID_HERE";
-const char* password = "WIFI_PASSWORD_HERE";
+#define WIFI_SSID "WIFI_SSID_HERE"
+#define WIFI_PASS "WIFI_PASSWORD_HERE"
+
+// MQTT settings
+#define MQTT_HOST "MQTT_IP_HERE"
+#define MQTT_PORT 1883
+#define MQTT_USER "USERNAME" // undef to disable auth
+#define MQTT_PASS "PASSWORD" // undef to disable auth
 
 // InfluxDB settings
 #define INFLUXDB_HOST "INFLUX_IP_HERE"
 #define INFLUXDB_PORT 8086
 #define INFLUXDB_DATABASE "roomsensorsdiy"
 
-// feature selection
-#define ENABLE_INFLUXDB_LOGGING
-
 // all given in milliseconds
 #define SERVER_HANDLE_INTERVAL 10
 #define DB_WRITE_INTERVAL (30 * 1000)
 #define LED_INIT_BLINK_INTERVAL 500
 #define LED_CONNECT_BLINK_INTERVAL 250
 #define LED_ERROR_BLINK_INTERVAL 100
+#define MQTT_RECONNECT_INTERVAL (5 * 1000)
 
-#endif // __ESP_ENV_CONFIG__
+#if defined(SENSOR_LOCATION_LIVINGROOM)
+#define SENSOR_LOCATION "livingroom"
+#elif defined(SENSOR_LOCATION_BEDROOM)
+#define SENSOR_LOCATION "bedroom"
+#elif defined(SENSOR_LOCATION_BATHROOM)
+#define SENSOR_LOCATION "bathroom"
+#elif defined(SENSOR_LOCATION_GREENHOUSE)
+#define SENSOR_LOCATION "greenhouse"
+#elif defined(SENSOR_LOCATION_TESTING)
+#define SENSOR_LOCATION "testing"
+#else
+#define SENSOR_LOCATION "unknown"
+#endif
 
+#if defined(RELAIS_SERIAL) || defined(RELAIS_GPIO)
+#define FEATURE_RELAIS
+#endif
+
+#if defined(MOISTURE_ADC_ESP32) || defined(MOISTURE_ADC_ARDUINO)
+#define FEATURE_MOISTURE
+#endif
+
+#endif // __ESP_ENV_CONFIG__

include/moisture.h

 #ifndef __ESP_ADC_MOISTURE_SENSOR__
 #define __ESP_ADC_MOISTURE_SENSOR__
 
+void moisture_init(void);
 int moisture_count(void);
 int moisture_read(int sensor);
 int moisture_max(void);
-void moisture_init(void);
 
 #endif // __ESP_ADC_MOISTURE_SENSOR__
-

include/relais.h

 #ifndef __ESP_RELAIS_ACTOR__
 #define __ESP_RELAIS_ACTOR__
 
-int relais_count(void);
-int relais_enable(int relais, unsigned long time);
 void relais_init(void);
-void relais_run(void);
+int relais_count(void);
+void relais_set(int relais, int state);
+int relais_get(int relais);
+String relais_name(int relais);
 
 #endif // __ESP_RELAIS_ACTOR__
-

platformio.ini

 ; Please visit documentation for the other options and examples
 ; https://docs.platformio.org/page/projectconf.html
 
-[env:esp01_1m]
+[env:esp8266env]
 platform = espressif8266
 board = esp01_1m
 framework = arduino
+build_flags =
+  -DSENSOR_HOSTNAME_PREFIX=\"env-\"
+  -DENABLE_CCS811
+  -DENABLE_INFLUXDB_LOGGING
+  -DENABLE_MQTT
 lib_deps =
     Wire
     ESP8266 Influxdb
     Adafruit Unified Sensor
     Adafruit BME280 Library
+    https://github.com/adafruit/Adafruit_CCS811
+    https://github.com/knolleary/pubsubclient.git#2d228f2f862a95846c65a8518c79f48dfc8f188c
 
-[env:esp32dev]
-platform = espressif32
+[env:esp8266relais]
+platform = espressif8266
+board = esp01_1m
+framework = arduino
+build_flags =
+  -DSENSOR_HOSTNAME_PREFIX=\"relais-\"
+  -DRELAIS_SERIAL
+  -DENABLE_INFLUXDB_LOGGING
+  -DENABLE_MQTT
+lib_deps =
+    Wire
+    ESP8266 Influxdb
+    Adafruit Unified Sensor
+    Adafruit BME280 Library
+    https://github.com/knolleary/pubsubclient.git#2d228f2f862a95846c65a8518c79f48dfc8f188c
+
+[env:esp32env]
+platform = platformio/espressif32@3.5.0
+board = esp32dev
+framework = arduino
+upload_protocol = esptool
+upload_port = /dev/ttyUSB1
+monitor_port = /dev/ttyUSB1
+monitor_speed = 115200
+build_flags =
+  -DSENSOR_HOSTNAME_PREFIX=\"env-\"
+  -DENABLE_CCS811
+  -DENABLE_INFLUXDB_LOGGING
+  -DENABLE_MQTT
+lib_deps =
+    Wire
+    Adafruit Unified Sensor
+    Adafruit BME280 Library
+    https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino.git#66ed5d031caab6953cc79b407a4b49d33b1126dc
+    https://github.com/adafruit/Adafruit_CCS811
+    https://github.com/knolleary/pubsubclient.git#2d228f2f862a95846c65a8518c79f48dfc8f188c
+
+[env:esp32moisture]
+platform = platformio/espressif32@3.5.0
 board = esp32dev
 framework = arduino
 upload_protocol = esptool
+upload_port = /dev/ttyUSB1
+monitor_port = /dev/ttyUSB1
+monitor_speed = 115200
+build_flags =
+  -DSENSOR_HOSTNAME_PREFIX=\"env-\"
+  -DMOISTURE_ADC_ESP32
+  -DENABLE_CCS811
+  -DENABLE_INFLUXDB_LOGGING
+  -DENABLE_MQTT
 lib_deps =
     Wire
     Adafruit Unified Sensor
     Adafruit BME280 Library
     https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino.git#66ed5d031caab6953cc79b407a4b49d33b1126dc
+    https://github.com/adafruit/Adafruit_CCS811
+    https://github.com/knolleary/pubsubclient.git#2d228f2f862a95846c65a8518c79f48dfc8f188c
 
-[env:arduinowifideved]
+[env:arduinomoisture]
 platform = atmelavr
 board = uno
 framework = arduino
 upload_port = /dev/ttyACM0
 monitor_port = /dev/ttyACM0
 monitor_speed = 115200
+build_flags =
+  -DSENSOR_HOSTNAME_PREFIX=\"env-\"
+  -DMOISTURE_ADC_ARDUINO
+  -DENABLE_INFLUXDB_LOGGING
 lib_deps =
     Wire
     Adafruit Unified Sensor

src/main.cpp

 #include <Adafruit_BME280.h>
 #include <SHT2x.h>
 
+#ifdef ENABLE_CCS811
+#include <Adafruit_CCS811.h>
+#endif // ENABLE_CCS811
+
 #if defined(ARDUINO_ARCH_ESP8266)
 
 #include <ESP8266WiFi.h>
 
 #include "config.h"
 #include "moisture.h"
+#include "relais.h"
 
 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
 
 UPDATE_WEB_SERVER server(80);
 SimpleUpdater updater;
 
+#ifdef ENABLE_MQTT
+#include <PubSubClient.h>
+WiFiClient mqttClient;
+PubSubClient mqtt(mqttClient);
+unsigned long last_mqtt_reconnect_time = 0;
+#endif // ENABLE_MQTT
+
 #elif defined(ARDUINO_ARCH_AVR)
 
 #define ESP_PLATFORM_NAME "Uno WiFi"
 #define SHT_I2C_ADDRESS HTDU21D_ADDRESS
 #define BME_I2C_ADDRESS_1 0x76
 #define BME_I2C_ADDRESS_2 0x77
+#define CCS811_ADDRESS_1 0x5A
+#define CCS811_ADDRESS_2 0x5B
 
 #if defined(ARDUINO_ARCH_ESP8266)
 
 
 #endif
 
-//#define ENABLE_RELAIS_TEST
-
 Adafruit_BME280 bme1, bme2;
 
 bool found_bme1 = false;
 bool found_bme2 = false;
 bool found_sht = false;
 
+#ifdef ENABLE_CCS811
+Adafruit_CCS811 ccs1, ccs2;
+bool found_ccs1 = false;
+bool found_ccs2 = false;
+bool ccs1_data_valid = false;
+bool ccs2_data_valid = false;
+int ccs1_error_code = 0;
+int ccs2_error_code = 0;
+#endif // ENABLE_CCS811
+
 unsigned long last_server_handle_time = 0;
 unsigned long last_db_write_time = 0;
 unsigned long last_led_blink_time = 0;
 
-#ifdef ENABLE_RELAIS_TEST
-
-#include "relais.h"
-
-static void relaisTest() {
-    for (int i = 0; i < 10; i++) {
-        relais_enable(i, 400 + (i * 1000));
-        delay(100);
-    }
-}
-
-void handleRelaisTest() {
-    String message = F("<html><head>");
-    message += F("<title>" ESP_PLATFORM_NAME " Environment Sensor</title>");
-    message += F("</head><body>");
-    message += F("<p>Relais Test started!</p>");
-    message += F("<p><a href=\"/\">Return to Home</a></p>");
-    message += F("</body></html>");
-    
-    server.send(200, "text/html", message);
-    
-    relaisTest();
-}
-
-#endif // ENABLE_RELAIS_TEST
+void writeDatabase();
 
 static float bme1_temp(void) {
     while (1) {
     return 0.0;
 }
 
+#ifdef ENABLE_CCS811
+
+static float ccs1_eco2(void) {
+    return ccs1.geteCO2();
+}
+
+static float ccs1_tvoc(void) {
+    return ccs1.getTVOC();
+}
+
+static float ccs2_eco2(void) {
+    return ccs2.geteCO2();
+}
+
+static float ccs2_tvoc(void) {
+    return ccs2.getTVOC();
+}
+
+#endif // ENABLE_CCS811
+
+#if defined(ARDUINO_ARCH_AVR)
+#define ARDUINO_SEND_PARTIAL_PAGE() do { \
+        size_t len = message.length(), off = 0; \
+        while (off < len) { \
+            if ((len - off) >= 50) { \
+                client.write(message.c_str() + off, 50); \
+                off += 50; \
+            } else { \
+                client.write(message.c_str() + off, len - off); \
+                off = len; \
+            } \
+        } \
+        message = ""; \
+    } while (false);
+#else
+#define ARDUINO_SEND_PARTIAL_PAGE() while (false) { }
+#endif
+
 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
-void handleRoot() {
+void handlePage(int mode = -1, int id = 0) {
 #else
-void handleRoot(WiFiClient &client) {
+void handlePage(WiFiClient &client, int mode = -1, int id = 0) {
 #endif
     String message;
 
     message += F("<h1>" ESP_PLATFORM_NAME " Environment Sensor</h1>");
     message += F("\n<p>\n");
     message += F("Version: ");
-    message += esp_env_version;
+    message += ESP_ENV_VERSION;
     message += F("\n<br>\n");
     message += F("Location: ");
-    message += sensor_location;
+    message += SENSOR_LOCATION;
 
 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
     message += F("\n<br>\n");
 
     message += F("\n</p>\n");
 
-#if defined(ARDUINO_ARCH_AVR)
-    do {
-        size_t len = message.length(), off = 0;
-        while (off < len) {
-            if ((len - off) >= 50) {
-                client.write(message.c_str() + off, 50);
-                off += 50;
-            } else {
-                client.write(message.c_str() + off, len - off);
-                off = len;
-            }
-        }
-        message = "";
-    } while (false);
-#endif
+    ARDUINO_SEND_PARTIAL_PAGE();
 
 #if defined(ARDUINO_ARCH_ESP8266)
     
     }
     message += F("\n</p>\n");
 
+    ARDUINO_SEND_PARTIAL_PAGE();
+
     message += F("\n<p>\n");
     if (found_sht) {
         message += F("SHT21:");
     }
     message += F("\n</p>\n");
 
-#if defined(ARDUINO_ARCH_AVR)
-    do {
-        size_t len = message.length(), off = 0;
-        while (off < len) {
-            if ((len - off) >= 50) {
-                client.write(message.c_str() + off, 50);
-                off += 50;
-            } else {
-                client.write(message.c_str() + off, len - off);
-                off = len;
-            }
+#ifdef ENABLE_CCS811
+
+    message += F("\n<p>\n");
+    if (found_ccs1) {
+        message += F("CCS811 Low:");
+        message += F("\n<br>\n");
+        message += F("eCO2: ");
+        message += String(ccs1_eco2());
+        message += F("ppm");
+        message += F("\n<br>\n");
+        message += F("TVOC: ");
+        message += String(ccs1_tvoc());
+        message += F("ppb");
+
+        if (!ccs1_data_valid) {
+            message += F("\n<br>\n");
+            message += F("Data invalid (");
+            message += String(ccs1_error_code);
+            message += F(")!");
         }
-        message = "";
-    } while (false);
-#endif
+    } else {
+        message += F("CCS811 (Low) not connected!");
+    }
+    message += F("\n</p>\n");
+
+    message += F("\n<p>\n");
+    if (found_ccs2) {
+        message += F("CCS811 High:");
+        message += F("\n<br>\n");
+        message += F("eCO2: ");
+        message += String(ccs2_eco2());
+        message += F("ppm");
+        message += F("\n<br>\n");
+        message += F("TVOC: ");
+        message += String(ccs2_tvoc());
+        message += F("ppb");
+
+        if (!ccs2_data_valid) {
+            message += F("\n<br>\n");
+            message += F("Data invalid (");
+            message += String(ccs2_error_code);
+            message += F(")!");
+        }
+    } else {
+        message += F("CCS811 (High) not connected!");
+    }
+    message += F("\n</p>\n");
 
+#endif // ENABLE_CCS811
+
+    ARDUINO_SEND_PARTIAL_PAGE();
+
+#ifdef FEATURE_MOISTURE
     for (int i = 0; i < moisture_count(); i++) {
         int moisture = moisture_read(i);
         if (moisture < moisture_max()) {
         message += F("\n</p>\n");
     }
 
+    ARDUINO_SEND_PARTIAL_PAGE();
+#endif // FEATURE_MOISTURE
+
+#ifdef FEATURE_RELAIS
+    message += F("\n<p>\n");
+    for (int i = 0; i < relais_count(); i++) {
+        message += String(F("<a href=\"/on?id=")) + String(i) + String(F("\">Relais ")) + String(i) + String(F(" On (")) + relais_name(i) + String(F(")</a><br>\n"));
+        message += String(F("<a href=\"/off?id=")) + String(i) + String(F("\">Relais ")) + String(i) + String(F(" Off (")) + relais_name(i) + String(F(")</a><br>\n"));
+    }
+    message += String(F("<a href=\"/on?id=")) + String(relais_count()) + String(F("\">All Relais On</a><br>\n"));
+    message += String(F("<a href=\"/off?id=")) + String(relais_count()) + String(F("\">All Relais Off</a><br>\n"));
+    message += F("</p>\n");
+
+    if (mode >= 0) {
+        message += F("<p>");
+        message += F("Turned Relais ");
+        message += (id < relais_count()) ? String(id) : String(F("1-4"));
+        message += (mode ? String(F(" On")) : String(F(" Off")));
+        message += F("</p>\n");
+    }
+
+    message += F("\n<p>\n");
+    for (int i = 0; i < relais_count(); i++) {
+        message += String(F("Relais ")) + String(i) + String(F(" (")) + relais_name(i) + String(F(") = ")) + (relais_get(i) ? String(F("On")) : String(F("Off"))) + String(F("<br>\n"));
+    }
+    message += F("</p>\n");
+
+    ARDUINO_SEND_PARTIAL_PAGE();
+#endif // FEATURE_RELAIS
+
 #if ! defined(ARDUINO_ARCH_AVR)
     message += F("<p>");
     message += F("Try <a href=\"/update\">/update</a> for OTA firmware updates!");
     message += F("InfluxDB logging not enabled!");
 #endif
     message += F("</p>");
-    
-#ifdef ENABLE_RELAIS_TEST
-    message += F("<p><a href=\"/relaistest\">Relais Test</a></p>");
-#endif // ENABLE_RELAIS_TEST
 
     message += F("</body></html>");
 
 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
     server.send(200, "text/html", message);
 #else
-    do {
-        size_t len = message.length(), off = 0;
-        while (off < len) {
-            if ((len - off) >= 50) {
-                client.write(message.c_str() + off, 50);
-                off += 50;
-            } else {
-                client.write(message.c_str() + off, len - off);
-                off = len;
-            }
+    ARDUINO_SEND_PARTIAL_PAGE();
+#endif
+}
+
+#ifdef FEATURE_RELAIS
+
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+void handleOn() {
+#else
+void handleOn(WiFiClient &client) {
+#endif
+    String id_string = server.arg("id");
+    int id = id_string.toInt();
+
+    if ((id >= 0) && (id < relais_count())) {
+        relais_set(id, 1);
+    } else {
+        for (int i = 0; i < relais_count(); i++) {
+            relais_set(i, 1);
         }
-    } while (false);
+    }
+
+#ifdef ENABLE_INFLUXDB_LOGGING
+    writeDatabase();
+#endif // ENABLE_INFLUXDB_LOGGING
+
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+    handlePage(1, id);
+#else
+    handlePage(client, 1, id);
 #endif
 }
 
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+void handleOff() {
+#else
+void handleOff(WiFiClient &client) {
+#endif
+    String id_string = server.arg("id");
+    int id = id_string.toInt();
+
+    if ((id >= 0) && (id < relais_count())) {
+        relais_set(id, 0);
+    } else {
+        for (int i = 0; i < relais_count(); i++) {
+            relais_set(i, 0);
+        }
+    }
+
+#ifdef ENABLE_INFLUXDB_LOGGING
+    writeDatabase();
+#endif // ENABLE_INFLUXDB_LOGGING
+
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+    handlePage(0, id);
+#else
+    handlePage(client, 0, id);
+#endif
+}
+
+#endif // FEATURE_RELAIS
+
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+void handleRoot() {
+    handlePage();
+#else
+void handleRoot(WiFiClient &client) {
+    handlePage(client);
+#endif
+}
+
+#ifdef ENABLE_MQTT
+void writeMQTT() {
+    if (!mqtt.connected()) {
+        return;
+    }
+
+    if (found_bme1) {
+        mqtt.publish(SENSOR_LOCATION "/temperature", String(bme1_temp()).c_str());
+        mqtt.publish(SENSOR_LOCATION "/humidity", String(bme1_humid()).c_str());
+        mqtt.publish(SENSOR_LOCATION "/pressure", String(bme1_pressure()).c_str());
+    } else if (found_bme2) {
+        mqtt.publish(SENSOR_LOCATION "/temperature", String(bme2_temp()).c_str());
+        mqtt.publish(SENSOR_LOCATION "/humidity", String(bme2_humid()).c_str());
+        mqtt.publish(SENSOR_LOCATION "/pressure", String(bme2_pressure()).c_str());
+    } else if (found_sht) {
+        mqtt.publish(SENSOR_LOCATION "/temperature", String(sht_temp()).c_str());
+        mqtt.publish(SENSOR_LOCATION "/humidity", String(sht_humid()).c_str());
+    }
+
+#ifdef ENABLE_CCS811
+    if (found_ccs1) {
+        mqtt.publish(SENSOR_LOCATION "/eco2", String(ccs1_eco2()).c_str());
+        mqtt.publish(SENSOR_LOCATION "/tvoc", String(ccs1_tvoc()).c_str());
+    } else if (found_ccs2) {
+        mqtt.publish(SENSOR_LOCATION "/eco2", String(ccs2_eco2()).c_str());
+        mqtt.publish(SENSOR_LOCATION "/tvoc", String(ccs2_tvoc()).c_str());
+    }
+#endif // ENABLE_CCS811
+}
+
+void mqttCallback(char* topic, byte* payload, unsigned int length) {
+#ifdef FEATURE_RELAIS
+    int state = 0;
+    int id = -1;
+
+    String ts(topic), ps((char *)payload);
+
+    String our_topic(SENSOR_LOCATION);
+    our_topic += "/";
+
+    if (!ts.startsWith(our_topic)) {
+        Serial.print(F("Unknown MQTT room "));
+        Serial.println(ts);
+        return;
+    }
+
+    String ids = ts.substring(our_topic.length());
+    for (int i = 0; i < relais_count(); i++) {
+        if (ids == relais_name(i)) {
+            id = i;
+            break;
+        }
+    }
+
+    if (id < 0) {
+        Serial.print(F("Unknown MQTT topic "));
+        Serial.println(ts);
+        return;
+    }
+
+    if (ps.indexOf("on") != -1) {
+        state = 1;
+    } else if (ps.indexOf("off") != -1) {
+        state = 0;
+    } else {
+        return;
+    }
+
+    if ((id >= 0) && (id < relais_count())) {
+        relais_set(id, state);
+
+#ifdef ENABLE_INFLUXDB_LOGGING
+        writeDatabase();
+#endif // ENABLE_INFLUXDB_LOGGING
+    }
+#endif // FEATURE_RELAIS
+}
+
+void mqttReconnect() {
+    // Create a random client ID
+    String clientId = F("ESP-" SENSOR_LOCATION "-");
+    clientId += String(random(0xffff), HEX);
+
+    // Attempt to connect
+#if defined(MQTT_USER) && defined(MQTT_PASS)
+    if (mqtt.connect(clientId.c_str(), MQTT_USER, MQTT_PASS)) {
+#else
+    if (mqtt.connect(clientId.c_str())) {
+#endif
+        // Once connected, publish an announcement...
+        mqtt.publish(SENSOR_LOCATION, "sensor online");
+
+        // ... and resubscribe
+#ifdef FEATURE_RELAIS
+        mqtt.subscribe(SENSOR_LOCATION);
+        for (int i = 0; i < relais_count(); i++) {
+            String topic(SENSOR_LOCATION);
+            topic += String("/") + relais_name(i);
+            mqtt.subscribe(topic.c_str());
+        }
+#endif // FEATURE_RELAIS
+    }
+}
+#endif // ENABLE_MQTT
+
 void setup() {
     pinMode(BUILTIN_LED_PIN, OUTPUT);
     
-#ifdef ENABLE_RELAIS_TEST
-    relais_init();
-#endif // ENABLE_RELAIS_TEST
+    Serial.begin(115200);
 
     // Blink LED for init
     for (int i = 0; i < 2; i++) {
         digitalWrite(BUILTIN_LED_PIN, HIGH); // LED off
         delay(LED_INIT_BLINK_INTERVAL);
     }
+
+    Serial.print(F("Relais"));
+    relais_init();
     
+    Serial.print(F("Moisture"));
     moisture_init();
 
     // Init I2C and try to connect to sensors
 #if defined(ARDUINO_ARCH_ESP8266)
 
+    Serial.print(F("Wire2"));
     Wire2.begin(I2C_SDA_PIN, I2C_SCL_PIN);
+
+    Serial.print(F("BME"));
     found_bme1 = (!bme1.begin(BME_I2C_ADDRESS_1, &Wire2)) ? false : true;
     found_bme2 = (!bme2.begin(BME_I2C_ADDRESS_2, &Wire2)) ? false : true;
 
+#ifdef ENABLE_CCS811
+    Serial.print(F("CCS"));
+    found_ccs1 = ccs1.begin(CCS811_ADDRESS_1, &Wire2);
+    found_ccs2 = ccs2.begin(CCS811_ADDRESS_2, &Wire2);
+#endif // ENABLE_CCS811
+
 #elif defined(ARDUINO_ARCH_ESP32)
 
+    Serial.print(F("Wire"));
     Wire.begin();
+
+    Serial.print(F("BME"));
     found_bme1 = (!bme1.begin(BME_I2C_ADDRESS_1, &Wire)) ? false : true;
     found_bme2 = (!bme2.begin(BME_I2C_ADDRESS_2, &Wire)) ? false : true;
 
+#ifdef ENABLE_CCS811
+    Serial.print(F("CCS"));
+    found_ccs1 = ccs1.begin(CCS811_ADDRESS_1, &Wire);
+    found_ccs2 = ccs2.begin(CCS811_ADDRESS_2, &Wire);
+#endif // ENABLE_CCS811
+
 #elif defined(ARDUINO_ARCH_AVR)
 
+    Serial.print(F("BME"));
     found_bme1 = (!bme1.begin(BME_I2C_ADDRESS_1, &Wire)) ? false : true;
     found_bme2 = (!bme2.begin(BME_I2C_ADDRESS_2, &Wire)) ? false : true;
 
+#ifdef ENABLE_CCS811
+    Serial.print(F("CCS"));
+    found_ccs1 = ccs1.begin(CCS811_ADDRESS_1, &Wire);
+    found_ccs2 = ccs2.begin(CCS811_ADDRESS_2, &Wire);
+#endif // ENABLE_CCS811
+
 #endif
 
+    Serial.print(F("SHT"));
     found_sht = sht.GetAlive();
 
     // Build hostname string
     String hostname = SENSOR_HOSTNAME_PREFIX;
-    hostname += sensor_location;
+    hostname += SENSOR_LOCATION;
 
 #if defined(ARDUINO_ARCH_ESP8266)
 
     // Connect to WiFi AP
+    Serial.print(F("Connecting WiFi"));
     WiFi.hostname(hostname);
     WiFi.mode(WIFI_STA);
-    WiFi.begin(ssid, password);
+    WiFi.begin(WIFI_SSID, WIFI_PASS);
     while (WiFi.status() != WL_CONNECTED) {
         delay(LED_CONNECT_BLINK_INTERVAL);
         digitalWrite(BUILTIN_LED_PIN, !digitalRead(BUILTIN_LED_PIN));
+        Serial.print(F("."));
     }
+    Serial.println(F("\nWiFi connected!"));
     
 #elif defined(ARDUINO_ARCH_ESP32)
 
     }, WiFiEvent_t::SYSTEM_EVENT_STA_DISCONNECTED);
 
     // Connect to WiFi AP
+    Serial.print(F("Connecting WiFi"));
     WiFi.mode(WIFI_STA);
-    WiFi.begin(ssid, password);
+    WiFi.begin(WIFI_SSID, WIFI_PASS);
     while (WiFi.status() != WL_CONNECTED) {
         delay(LED_CONNECT_BLINK_INTERVAL);
         digitalWrite(BUILTIN_LED_PIN, !digitalRead(BUILTIN_LED_PIN));
+        Serial.print(F("."));
     }
+    Serial.println(F("\nWiFi connected!"));
     
     // Set hostname workaround
     WiFi.setHostname(hostname.c_str());
 
 #elif defined(ARDUINO_ARCH_AVR)
 
-    Serial.begin(115200);
     Serial1.begin(115200);
 
     WiFi.init(&Serial1);
 
     Serial.print(F("Connecting WiFi"));
-    WiFi.begin(ssid, password);
+    WiFi.begin(WIFI_SSID, WIFI_PASS);
     while (WiFi.status() != WL_CONNECTED) {
         delay(LED_CONNECT_BLINK_INTERVAL);
         digitalWrite(BUILTIN_LED_PIN, !digitalRead(BUILTIN_LED_PIN));
 
 #endif
 
+    Serial.println(F("Seeding"));
+    randomSeed(micros());
+
+#ifdef ENABLE_MQTT
+    Serial.println(F("MQTT"));
+    mqtt.setServer(MQTT_HOST, MQTT_PORT);
+    mqtt.setCallback(mqttCallback);
+#endif // ENABLE_MQTT
+
 #ifdef ENABLE_INFLUXDB_LOGGING
-    // Setup InfluxDB Client
+    Serial.println(F("Influx"));
     influx.setDb(INFLUXDB_DATABASE);
 #endif // ENABLE_INFLUXDB_LOGGING
 
 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
     // Setup HTTP Server
+    Serial.println(F("HTTP"));
     MDNS.begin(hostname.c_str());
     updater.setup(&server);
     server.on("/", handleRoot);
 
-#ifdef ENABLE_RELAIS_TEST
-    server.on("/relaistest", handleRelaisTest);
-#endif
+#ifdef FEATURE_RELAIS
+    server.on("/on", handleOn);
+    server.on("/off", handleOff);
+#endif // FEATURE_RELAIS
 
     MDNS.addService("http", "tcp", 80);
 #endif
                     client.println(F("Content-Type: text/html"));
                     client.println(F("Connection: close"));
                     client.println();
+
+                    // TODO parse path and handle different pages
                     handleRoot(client);
+
                     break;
                 }
 
         InfluxData measurement("environment");
 #endif
 
-        measurement.addTag("location", sensor_location);
+        measurement.addTag("location", SENSOR_LOCATION);
         measurement.addTag("placement", "1");
         measurement.addTag("sensor", "bme280");
 
         InfluxData measurement("environment");
 #endif
 
-        measurement.addTag("location", sensor_location);
+        measurement.addTag("location", SENSOR_LOCATION);
         measurement.addTag("placement", "2");
         measurement.addTag("sensor", "bme280");
 
         InfluxData measurement("environment");
 #endif
 
-        measurement.addTag("location", sensor_location);
+        measurement.addTag("location", SENSOR_LOCATION);
         measurement.addTag("sensor", "sht21");
 
 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
         writeMeasurement(measurement);
         Serial.println(F("Done!"));
     }
-    
+
+#ifdef ENABLE_CCS811
+
+    if (found_ccs1) {
+#if defined(ARDUINO_ARCH_AVR)
+        measurement.clear();
+        measurement.setName("environment");
+#else
+        InfluxData measurement("environment");
+#endif
+
+        measurement.addTag("location", SENSOR_LOCATION);
+        measurement.addTag("placement", "1");
+        measurement.addTag("sensor", "ccs811");
+
+        String err(ccs1_error_code);
+        measurement.addTag("error", err);
+
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+        measurement.addTag("device", WiFi.macAddress());
+#endif
+
+        measurement.addValue("eco2", ccs1_eco2());
+        measurement.addValue("tvoc", ccs1_tvoc());
+
+        Serial.println(F("Writing ccs1"));
+        writeMeasurement(measurement);
+        Serial.println(F("Done!"));
+    }
+
+    if (found_ccs2) {
+#if defined(ARDUINO_ARCH_AVR)
+        measurement.clear();
+        measurement.setName("environment");
+#else
+        InfluxData measurement("environment");
+#endif
+
+        measurement.addTag("location", SENSOR_LOCATION);
+        measurement.addTag("placement", "2");
+        measurement.addTag("sensor", "ccs811");
+
+        String err(ccs2_error_code);
+        measurement.addTag("error", err);
+
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+        measurement.addTag("device", WiFi.macAddress());
+#endif
+
+        measurement.addValue("eco2", ccs2_eco2());
+        measurement.addValue("tvoc", ccs2_tvoc());
+
+        Serial.println(F("Writing ccs2"));
+        writeMeasurement(measurement);
+        Serial.println(F("Done!"));
+    }
+
+#endif // ENABLE_CCS811
+
+#ifdef FEATURE_MOISTURE
     for (int i = 0; i < moisture_count(); i++) {
         int moisture = moisture_read(i);
         if (moisture < moisture_max()) {
             InfluxData measurement("moisture");
 #endif
 
-            measurement.addTag("location", sensor_location);
+            measurement.addTag("location", SENSOR_LOCATION);
             String sensor(i + 1, DEC);
             measurement.addTag("sensor", sensor);
 
             Serial.println(F("Done!"));
         }
     }
+#endif // FEATURE_MOISTURE
+
+#ifdef FEATURE_RELAIS
+    for (int i = 0; i < relais_count(); i++) {
+        InfluxData measurement("relais");
+        measurement.addTag("location", SENSOR_LOCATION);
+        measurement.addTag("id", String(i));
+        measurement.addTag("name", relais_name(i));
+
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+        measurement.addTag("device", WiFi.macAddress());
+#endif
+
+        measurement.addValue("state", relais_get(i));
+        writeMeasurement(measurement);
+    }
+#endif // FEATURE_RELAIS
 
     Serial.println(F("All Done!"));
 }
 #endif // ENABLE_INFLUXDB_LOGGING
 
+#ifdef ENABLE_CCS811
+void ccs_update() {
+    if (found_ccs1) {
+        if (ccs1.available()) {
+            ccs1_error_code = ccs1.readData();
+            ccs1_data_valid = (ccs1_error_code == 0);
+
+            if (found_bme1) {
+                ccs1.setEnvironmentalData(bme1_humid(), bme1_temp());
+            } else if (found_bme2) {
+                ccs1.setEnvironmentalData(bme2_humid(), bme2_temp());
+            } else if (found_sht) {
+                ccs1.setEnvironmentalData(sht_humid(), sht_temp());
+            }
+        }
+    }
+
+    if (found_ccs2) {
+        if (ccs2.available()) {
+            ccs2_error_code = ccs2.readData();
+            ccs2_data_valid = (ccs2_error_code == 0);
+
+            if (found_bme1) {
+                ccs2.setEnvironmentalData(bme1_humid(), bme1_temp());
+            } else if (found_bme2) {
+                ccs2.setEnvironmentalData(bme2_humid(), bme2_temp());
+            } else if (found_sht) {
+                ccs2.setEnvironmentalData(sht_humid(), sht_temp());
+            }
+        }
+    }
+}
+#endif // ENABLE_CCS811
+
 void loop() {
     unsigned long time = millis();
     
-#ifdef ENABLE_RELAIS_TEST
-    relais_run();
-#endif // ENABLE_RELAIS_TEST
+#ifdef ENABLE_CCS811
+    if (found_ccs1 || found_ccs2) {
+        ccs_update();
+    }
+#endif // ENABLE_CCS811
 
     if ((time - last_server_handle_time) >= SERVER_HANDLE_INTERVAL) {
         last_server_handle_time = time;
         handleServers();
     }
 
-#ifdef ENABLE_INFLUXDB_LOGGING
     if ((time - last_db_write_time) >= DB_WRITE_INTERVAL) {
         last_db_write_time = time;
+
+#ifdef ENABLE_INFLUXDB_LOGGING
         writeDatabase();
+#endif // ENABLE_INFLUXDB_LOGGING
+
+#ifdef ENABLE_MQTT
+        writeMQTT();
+#endif // ENABLE_MQTT
     }
     
+#ifdef ENABLE_INFLUXDB_LOGGING
 #ifdef INFLUX_MAX_ERRORS_RESET
     if (error_count >= INFLUX_MAX_ERRORS_RESET) {
 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
 #endif // INFLUX_MAX_ERRORS_RESET
 #endif // ENABLE_INFLUXDB_LOGGING
 
+#ifdef ENABLE_MQTT
+    if (!mqtt.connected() && ((millis() - last_mqtt_reconnect_time) >= MQTT_RECONNECT_INTERVAL)) {
+        last_mqtt_reconnect_time = millis();
+        mqttReconnect();
+    }
+
+    mqtt.loop();
+#endif // ENABLE_MQTT
+
     // blink heartbeat LED
     if ((time - last_led_blink_time) >= LED_BLINK_INTERVAL) {
         last_led_blink_time = time;
     }
     
 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
-    // reset ESP every 6h to be safe
-    if (time >= (6 * 60 * 60 * 1000)) {
+    // reset ESP every 3d to be safe
+    if (time >= (3UL * 24UL * 60UL * 60UL * 1000UL)) {
         ESP.restart();
     }
 #endif
 }
-

src/moisture.cpp

 #include <Arduino.h>
 #include "moisture.h"
 
-#if defined(ARDUINO_ARCH_ESP8266)
-
-int moisture_count(void) {
-    return 0;
-}
-
-int moisture_read(int sensor) {
-    return 0;
-}
-
-int moisture_max(void) {
-    return 0;
-}
-
-void moisture_init(void) { }
-
-#elif defined(ARDUINO_ARCH_ESP32)
+#if defined(MOISTURE_ADC_ESP32)
 
 #include <driver/adc.h>
 
     return sample_sum / ADC_OVERSAMPLE;
 }
 
+void moisture_init(void) {
+    adc1_config_width(ADC_BITS);
+    for (int i = 0; i < SENSOR_COUNT; i++) {
+        adc1_config_channel_atten(sensor_pin[i], ADC_ATTENUATION);
+    }
+}
+
 int moisture_count(void) {
     return SENSOR_COUNT;
 }
     return (1 << ADC_BITWIDTH) - 1;
 }
 
-void moisture_init(void) {
-    adc1_config_width(ADC_BITS);
-    for (int i = 0; i < SENSOR_COUNT; i++) {
-        adc1_config_channel_atten(sensor_pin[i], ADC_ATTENUATION);
-    }
-}
-
-#elif defined(ARDUINO_ARCH_AVR)
+#elif defined(MOISTURE_ADC_ARDUINO)
 
 // Hardware I2C pins A4 and A5 not usable on Arduino Uno Wifi Dev. Ed.
 #define SENSOR_COUNT 6
 
 #define OVERSAMPLE_COUNT 3
 
+void moisture_init(void) {
+
+}
+
 int moisture_count(void) {
     return SENSOR_COUNT;
 }
     return 4095;
 }
 
-void moisture_init(void) {
+#else
+
+void moisture_init(void) { }
 
+int moisture_count(void) {
+    return 0;
 }
 
-#endif
+int moisture_read(int sensor) {
+    return 0;
+}
 
+int moisture_max(void) {
+    return 0;
+}
+
+#endif

src/relais.cpp

 
 #include <Arduino.h>
 #include "relais.h"
+#include "config.h"
 
-#if defined(ARDUINO_ARCH_ESP8266)
+#if defined(RELAIS_SERIAL)
+
+#define SERIAL_RELAIS_COUNT 4
+
+/*
+Turn OFF the first relay  : A0 01 00 A1
+Turn ON the first relay   : A0 01 01 A2
+Turn OFF the second relay : A0 02 00 A2
+Turn ON the second relay  : A0 02 01 A3
+Turn OFF the third relay  : A0 03 00 A3
+Turn ON the third relay   : A0 03 01 A4
+Turn OFF the fourth relay : A0 04 00 A4
+Turn ON the fourth relay  : A0 04 01 A5
+*/
+
+static int states[SERIAL_RELAIS_COUNT];
+
+static String names[SERIAL_RELAIS_COUNT] = {
+#if defined(SENSOR_LOCATION_BATHROOM)
+    String("light_small"),
+    String("light_big"),
+    String("relais_2"),
+    String("fan")
+#else
+    String("relais_0"),
+    String("relais_1"),
+    String("relais_2"),
+    String("relais_3")
+#endif
+};
+
+static int initial_values[SERIAL_RELAIS_COUNT] = {
+#if defined(SENSOR_LOCATION_BATHROOM)
+    1, 0, 0, 1
+#else
+    0, 0, 0, 0
+#endif
+};
+
+void relais_init(void) {
+    Serial.begin(115200);
+
+    for (int i = 0; i < SERIAL_RELAIS_COUNT; i++) {
+        relais_set(i, initial_values[i]);
+    }
+}
 
 int relais_count(void) {
-    return 0;
+    return SERIAL_RELAIS_COUNT;
 }
 
-int relais_enable(int relais, unsigned long time) {
-    return 0;
+void relais_set(int relais, int state) {
+    if ((relais < 0) || (relais >= SERIAL_RELAIS_COUNT)) {
+        return;
+    }
+
+    states[relais] = state;
+
+    int cmd[4];
+    cmd[0] = 0xA0; // command
+
+    cmd[1] = relais + 1; // relais id, 1-4
+    cmd[2] = state ? 1 : 0; // relais state
+
+    cmd[3] = 0; // checksum
+    for (int i = 0; i < 3; i++) {
+        cmd[3] += cmd[i];
+    }
+
+    for (int i = 0; i < 4; i++) {
+        Serial.write(cmd[i]);
+    }
+
+    delay(100);
 }
 
-void relais_init(void) { }
-void relais_run(void) { }
+int relais_get(int relais) {
+    if ((relais < 0) || (relais >= SERIAL_RELAIS_COUNT)) {
+        return 0;
+    }
 
-#elif defined(ARDUINO_ARCH_ESP32)
+    return states[relais];
+}
 
-#define RELAIS_COUNT 10
+String relais_name(int relais) {
+    if ((relais < 0) || (relais >= SERIAL_RELAIS_COUNT)) {
+        return String(F("Unknown"));
+    }
 
-struct relais_state {
-    unsigned long turn_off;
-};
+    return names[relais];
+}
+
+#elif defined(RELAIS_GPIO)
+
+#define GPIO_RELAIS_COUNT 10
 
-static struct relais_state state[RELAIS_COUNT];
-static int gpios[RELAIS_COUNT] = {
+static int gpios[GPIO_RELAIS_COUNT] = {
     0, 15, 2, 4,
     16, 17, 5, 18,
     19, 23
 };
 
-static void relais_set(int relais, int state) {
-    digitalWrite(gpios[relais], state ? LOW : HIGH);
+static int states[GPIO_RELAIS_COUNT];
+
+static String names[GPIO_RELAIS_COUNT] = {
+    String(F("relais_0")),
+    String(F("relais_1")),
+    String(F("relais_2")),
+    String(F("relais_3")),
+    String(F("relais_4")),
+    String(F("relais_5")),
+    String(F("relais_6")),
+    String(F("relais_7")),
+    String(F("relais_8")),
+    String(F("relais_9"))
+};
+
+void relais_init(void) {
+    for (int i = 0; i < GPIO_RELAIS_COUNT; i++) {
+        pinMode(gpios[i], OUTPUT);
+        relais_set(i, 0);
+    }
 }
 
 int relais_count(void) {
-    return RELAIS_COUNT;
+    return GPIO_RELAIS_COUNT;
 }
 
-int relais_enable(int relais, unsigned long time) {
-    if ((relais < 0) || (relais >= RELAIS_COUNT)) {
-        return -1;
+void relais_set(int relais, int state) {
+    if ((relais < 0) || (relais >= GPIO_RELAIS_COUNT)) {
+        return;
     }
-    
-    relais_set(relais, 1);
-    state[relais].turn_off = millis() + time;
-    return 0;
+
+    states[relais] = state;
+    digitalWrite(gpios[relais], state ? LOW : HIGH);
 }
 
-void relais_init(void) {
-    for (int i = 0; i < RELAIS_COUNT; i++) {
-        pinMode(gpios[i], OUTPUT);
-        relais_set(i, 0);
-        
-        state[i].turn_off = 0;
+int relais_get(int relais) {
+    if ((relais < 0) || (relais >= GPIO_RELAIS_COUNT)) {
+        return 0;
     }
+
+    return states[relais];
 }
 
-void relais_run(void) {
-    for (int i = 0; i < RELAIS_COUNT; i++) {
-        if (state[i].turn_off > 0) {
-            if (millis() >= state[i].turn_off) {
-                relais_set(i, 0);
-            }
-        }
+String relais_name(int relais) {
+    if ((relais < 0) || (relais >= GPIO_RELAIS_COUNT)) {
+        return String(F("Unknown"));
     }
+
+    return names[relais];
 }
 
-#endif
+#else
 
+void relais_init(void) { }
+int relais_count(void) { return 0; }
+void relais_set(int relais, int state) { }
+int relais_get(int relais) { return 0; }
+
+#endif