Moved moisture sensor and updater into own files. Added relais support (only testing for now).

include/SimpleUpdater.h

@@ -0,0 +1,52 @@
+/*
+ * SimpleUpdater.h
+ *
+ * ESP8266 / ESP32 Environmental Sensor
+ *
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+ * you can do whatever you want with this stuff. If we meet some day, and you
+ * think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+ * ----------------------------------------------------------------------------
+ */
+
+#ifndef __ESP_SIMPLE_UPDATER__
+#define __ESP_SIMPLE_UPDATER__
+
+#if defined(ARDUINO_ARCH_ESP8266)
+#include <ESP8266WebServer.h>
+#include <ESP8266HTTPUpdateServer.h>
+#define UPDATE_WEB_SERVER ESP8266WebServer
+#elif defined(ARDUINO_ARCH_ESP32)
+#include <WebServer.h>
+#define UPDATE_WEB_SERVER WebServer
+#else
+#error Platform not supported!
+#endif
+
+class SimpleUpdater {
+public:
+    SimpleUpdater(String _uri = String("/update"));
+    void setup(UPDATE_WEB_SERVER *_server);
+    
+private:
+
+#if defined(ARDUINO_ARCH_ESP8266)
+    
+    ESP8266HTTPUpdateServer updateServer;
+
+#elif defined(ARDUINO_ARCH_ESP32)
+    
+    void get(void);
+    void postResult(void);
+    void postUpload(void);
+    
+#endif
+    
+    String uri;
+    UPDATE_WEB_SERVER *server;
+};
+
+#endif // __ESP_SIMPLE_UPDATER__
+

src/config.h → include/config.h

@@ -1,8 +1,21 @@
+/*
+ * config.h
+ *
+ * ESP8266 / ESP32 Environmental Sensor
+ *
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+ * you can do whatever you want with this stuff. If we meet some day, and you
+ * think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+ * ----------------------------------------------------------------------------
+ */
+
 #ifndef __ESP_ENV_CONFIG__
 #define __ESP_ENV_CONFIG__
 
 // Sketch version
-const char* esp_env_version = "0.2.0";
+const char* esp_env_version = "0.4.0";
 
 // location of sensor, used in DB and hostname
 //const char* sensor_location = "livingroom";
@@ -11,7 +24,9 @@ const char* esp_env_version = "0.2.0";
 //const char* sensor_location = "kitchen";
 //const char* sensor_location = "hallway";
 //const char* sensor_location = "tent";
-const char* sensor_location = "storage";
+//const char* sensor_location = "storage";
+//const char* sensor_location = "greenhouse";
+const char* sensor_location = "testing";
 
 #define SENSOR_HOSTNAME_PREFIX "ESP-"
 
@@ -24,6 +39,9 @@ const char* password = "WIFI_PASSWORD_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)
@@ -32,11 +50,5 @@ const char* password = "WIFI_PASSWORD_HERE";
 #define LED_CONNECT_BLINK_INTERVAL 250
 #define LED_ERROR_BLINK_INTERVAL 100
 
-// feature selection
-#define ENABLE_DATABASE_WRITES
-#define ENABLE_LED_HEARTBEAT_BLINK
-#define DONT_RUN_WITHOUT_SENSORS
-#define HTTP_SHOW_ESP_STATS
-
 #endif // __ESP_ENV_CONFIG__
 

include/moisture.h

@@ -0,0 +1,23 @@
+/*
+ * moisture.h
+ *
+ * ESP8266 / ESP32 Environmental Sensor
+ *
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+ * you can do whatever you want with this stuff. If we meet some day, and you
+ * think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+ * ----------------------------------------------------------------------------
+ */
+
+#ifndef __ESP_ADC_MOISTURE_SENSOR__
+#define __ESP_ADC_MOISTURE_SENSOR__
+
+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

@@ -0,0 +1,23 @@
+/*
+ * relais.h
+ *
+ * ESP8266 / ESP32 Environmental Sensor
+ *
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+ * you can do whatever you want with this stuff. If we meet some day, and you
+ * think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+ * ----------------------------------------------------------------------------
+ */
+
+#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);
+
+#endif // __ESP_RELAIS_ACTOR__
+

platformio.ini

@@ -18,3 +18,14 @@ lib_deps =
     Adafruit Unified Sensor
     Adafruit BME280 Library
 
+[env:esp32dev]
+platform = espressif32
+board = esp32dev
+framework = arduino
+upload_protocol = esptool
+lib_deps =
+    Wire
+    Adafruit Unified Sensor
+    Adafruit BME280 Library
+    https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino.git#66ed5d031caab6953cc79b407a4b49d33b1126dc
+

src/SimpleUpdater.cpp

@@ -0,0 +1,133 @@
+/*
+ * SimpleUpdater.cpp
+ *
+ * ESP8266 / ESP32 Environmental Sensor
+ *
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+ * you can do whatever you want with this stuff. If we meet some day, and you
+ * think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+ * ----------------------------------------------------------------------------
+ */
+
+#if defined(ARDUINO_ARCH_ESP8266)
+#include <ESP8266HTTPUpdateServer.h>
+#elif defined(ARDUINO_ARCH_ESP32)
+#include <Update.h>
+#endif
+
+#include "SimpleUpdater.h"
+
+#if defined(ARDUINO_ARCH_ESP32)
+
+void SimpleUpdater::get(void) {
+    String uploadPage = F(
+        "<html><head>"
+        "<script src='https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js'></script>"
+        "<title>SimpleUpdater ESP32</title>"
+        "</head><body>"
+        "<h1>SimpleUpdater</h1>"
+        "<form method='POST' action='#' enctype='multipart/form-data' id='upload_form'>"
+        "<input type='file' name='update'>"
+        "<input type='submit' value='Update'>"
+        "</form>"
+        "<div id='prg'>progress: 0%</div>"
+        "<a href=\"/\">Back to Main Page</a>"
+        "<script>"
+        "$('form').submit(function(e){"
+        "e.preventDefault();"
+        "var form = $('#upload_form')[0];"
+        "var data = new FormData(form);"
+        " $.ajax({"
+        "url: '/update',"
+        "type: 'POST',"
+        "data: data,"
+        "contentType: false,"
+        "processData:false,"
+        "xhr: function() {"
+        "var xhr = new window.XMLHttpRequest();"
+        "xhr.upload.addEventListener('progress', function(evt) {"
+        "if (evt.lengthComputable) {"
+        "var per = evt.loaded / evt.total;"
+        "$('#prg').html('progress: ' + Math.round(per*100) + '%');"
+        "}"
+        "}, false);"
+        "return xhr;"
+        "},"
+        "success:function(d, s) {"
+        "console.log('success!')" 
+        "},"
+        "error: function (a, b, c) {"
+        "}"
+        "});"
+        "});"
+        "</script>"
+        "</body></html>"
+    );
+    
+    server->send(200, "text/html", uploadPage);
+}
+
+void SimpleUpdater::postResult(void) {
+    server->sendHeader("Connection", "close");
+    server->send(200, "text/plain", (Update.hasError()) ? "FAIL" : "OK");
+    ESP.restart();
+}
+
+void SimpleUpdater::postUpload(void) {
+    HTTPUpload& upload = server->upload();
+    if (upload.status == UPLOAD_FILE_START) {
+        Serial.printf("Update: %s\n", upload.filename.c_str());
+        // start with max available size
+        if (!Update.begin(UPDATE_SIZE_UNKNOWN)) {
+            Update.printError(Serial);
+        }
+    } else if (upload.status == UPLOAD_FILE_WRITE) {
+        // flashing firmware to ESP
+        if (Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
+            Update.printError(Serial);
+        }
+    } else if (upload.status == UPLOAD_FILE_END) {
+        // true to set the size to the current progress
+        if (Update.end(true)) {
+            Serial.printf("Update Success: %u\nRebooting...\n", upload.totalSize);
+        } else {
+            Update.printError(Serial);
+        }
+    }
+}
+
+#endif
+
+void SimpleUpdater::setup(UPDATE_WEB_SERVER *_server) {
+    if (_server == NULL) {
+        return;
+    }
+    
+    server = _server;
+    
+#if defined(ARDUINO_ARCH_ESP8266)
+    
+    updateServer.setup(server);
+    
+#elif defined(ARDUINO_ARCH_ESP32)
+    
+    server->on(uri.c_str(), HTTP_POST, [this]() {
+        postResult();
+    }, [this]() {
+        postUpload();
+    });
+    
+    server->on(uri.c_str(), HTTP_GET, [this]() {
+        get();
+    });
+    
+#endif
+}
+
+SimpleUpdater::SimpleUpdater(String _uri) {
+    uri = _uri;
+    server = NULL;
+}
+

src/main.cpp

@@ -1,110 +1,261 @@
+/*
+ * main.cpp
+ *
+ * ESP8266 / ESP32 Environmental Sensor
+ *
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+ * you can do whatever you want with this stuff. If we meet some day, and you
+ * think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+ * ----------------------------------------------------------------------------
+ */
+
 #include <Arduino.h>
 #include <Wire.h>
+#include <Adafruit_BME280.h>
+#include <SHT2x.h>
+
+#if defined(ARDUINO_ARCH_ESP8266)
+
 #include <ESP8266WiFi.h>
 #include <ESP8266WebServer.h>
 #include <ESP8266mDNS.h>
-#include <ESP8266HTTPUpdateServer.h>
-#include <Adafruit_BME280.h>
-#include <SHT2x.h>
+
+#define ESP_PLATFORM_NAME "ESP8266"
+
+#elif defined(ARDUINO_ARCH_ESP32)
+
+#include <WiFi.h>
+#include <WebServer.h>
+#include <ESPmDNS.h>
+
+#define ESP_PLATFORM_NAME "ESP32"
+
+#endif
+
 #include "config.h"
+#include "moisture.h"
+#include "relais.h"
+#include "SimpleUpdater.h"
+
+#define BUILTIN_LED_PIN 1
+
+UPDATE_WEB_SERVER server(80);
+SimpleUpdater updater;
 
-#ifdef ENABLE_DATABASE_WRITES
+#ifdef ENABLE_INFLUXDB_LOGGING
 #include <InfluxDb.h>
+
 Influxdb influx(INFLUXDB_HOST, INFLUXDB_PORT);
-#endif // ENABLE_DATABASE_WRITES
 
-#define BUILTIN_LED_PIN 1
+#define INFLUX_MAX_ERRORS_RESET 10
+int error_count = 0;
+#endif // ENABLE_INFLUXDB_LOGGING
+
+#define SHT_I2C_ADDRESS HTDU21D_ADDRESS
+#define BME_I2C_ADDRESS_1 0x76
+#define BME_I2C_ADDRESS_2 0x77
 
-ESP8266WebServer server(80);
-ESP8266HTTPUpdateServer updater;
+#if defined(ARDUINO_ARCH_ESP8266)
+
+#define I2C_SDA_PIN 2
+#define I2C_SCL_PIN 0
 
 TwoWire Wire2;
-SHT2x sht(HTDU21D_ADDRESS, &Wire2);
-Adafruit_BME280 bme;
+SHT2x sht(SHT_I2C_ADDRESS, &Wire2);
+
+#elif defined(ARDUINO_ARCH_ESP32)
 
-bool found_bme = false;
+SHT2x sht(SHT_I2C_ADDRESS, &Wire);
+
+#endif
+
+Adafruit_BME280 bme1, bme2;
+
+bool found_bme1 = false;
+bool found_bme2 = false;
 bool found_sht = false;
 
 unsigned long last_server_handle_time = 0;
 unsigned long last_db_write_time = 0;
 unsigned long last_led_blink_time = 0;
 
+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>\n");
+    message += F("<title>" ESP_PLATFORM_NAME " Environment Sensor</title>\n");
+    message += F("</head><body>\n");
+    message += F("<p>Relais Test started!</p>\n");
+    message += F("<p><a href=\"/\">Return to Home</a></p>\n");
+    message += F("</body></html>\n");
+    
+    server.send(200, "text/html", message);
+    
+    relaisTest();
+}
+
 void handleRoot() {
-    String message = F("ESP8266 Environment Sensor");
-    message += F("\n\n");
+    String message = F("<html><head>\n");
+    message += F("<title>" ESP_PLATFORM_NAME " Environment Sensor</title>\n");
+    message += F("</head><body>\n");
+    message += F("<h1>" ESP_PLATFORM_NAME " Environment Sensor</h1>\n");
+    message += F("\n<p>\n");
     message += F("Version: ");
     message += esp_env_version;
-    message += F("\n");
+    message += F("\n<br>\n");
     message += F("Location: ");
     message += sensor_location;
-    message += F("\n");
+    message += F("\n<br>\n");
     message += F("MAC: ");
     message += WiFi.macAddress();
+    message += F("\n</p>\n");
 
-#ifdef HTTP_SHOW_ESP_STATS
-    message += F("\n");
+#if defined(ARDUINO_ARCH_ESP8266)
+    
+    message += F("\n<p>\n");
     message += F("Reset reason: ");
     message += ESP.getResetReason();
-    message += F("\n");
+    message += F("\n<br>\n");
     message += F("Free heap: ");
     message += String(ESP.getFreeHeap());
     message += F(" (");
     message += String(ESP.getHeapFragmentation());
     message += F("% fragmentation)");
-    message += F("\n");
+    message += F("\n<br>\n");
     message += F("Free sketch space: ");
     message += String(ESP.getFreeSketchSpace());
-    message += F("\n");
+    message += F("\n<br>\n");
     message += F("Flash chip real size: ");
     message += String(ESP.getFlashChipRealSize());
 
     if (ESP.getFlashChipSize() != ESP.getFlashChipRealSize()) {
-        message += F("\n");
+        message += F("\n<br>\n");
         message += F("WARNING: sdk chip size (");
         message += (ESP.getFlashChipSize());
         message += F(") does not match!");
     }
-#endif // HTTP_SHOW_ESP_STATS
+    
+    message += F("\n</p>\n");
+    
+#elif defined(ARDUINO_ARCH_ESP32)
+
+    message += F("\n<p>\n");
+    message += F("Free heap: ");
+    message += String(ESP.getFreeHeap() / 1024.0);
+    message += F("k\n<br>\n");
+    message += F("Free sketch space: ");
+    message += String(ESP.getFreeSketchSpace() / 1024.0);
+    message += F("k\n<br>\n");
+    message += F("Flash chip size: ");
+    message += String(ESP.getFlashChipSize() / 1024.0);
+    message += F("k\n</p>\n");
+    
+#endif
+
+    message += F("\n<p>\n");
+    if (found_bme1) {
+        message += F("BME280 Low:");
+        message += F("\n<br>\n");
+        message += F("Temperature: ");
+        message += String(bme1.readTemperature());
+        message += F("\n<br>\n");
+        message += F("Humidity: ");
+        message += String(bme1.readHumidity());
+        message += F("\n<br>\n");
+        message += F("Pressure: ");
+        message += String(bme1.readPressure());
+    } else {
+        message += F("BME280 (low) not connected!");
+    }
+    message += F("\n</p>\n");
 
-    if (found_bme) {
-        message += F("\n\n");
-        message += F("BME280:");
-        message += F("\n");
+    message += F("\n<p>\n");
+    if (found_bme2) {
+        message += F("BME280 High:");
+        message += F("\n<br>\n");
         message += F("Temperature: ");
-        message += String(bme.readTemperature());
-        message += F("\n");
+        message += String(bme2.readTemperature());
+        message += F("\n<br>\n");
         message += F("Humidity: ");
-        message += String(bme.readHumidity());
-        message += F("\n");
+        message += String(bme2.readHumidity());
+        message += F("\n<br>\n");
         message += F("Pressure: ");
-        message += String(bme.readPressure());
+        message += String(bme2.readPressure());
+    } else {
+        message += F("BME280 (high) not connected!");
     }
+    message += F("\n</p>\n");
 
+    message += F("\n<p>\n");
     if (found_sht) {
-        message += F("\n\n");
         message += F("SHT21:");
-        message += F("\n");
+        message += F("\n<br>\n");
         message += F("Temperature: ");
         message += String(sht.GetTemperature());
-        message += F("\n");
+        message += F("\n<br>\n");
         message += F("Humidity: ");
         message += String(sht.GetHumidity());
+    } else {
+        message += F("SHT21 not connected!");
     }
-
-    if ((!found_bme) && (!found_sht)) {
-        message += F("\n\n");
-        message += F("No Sensor available!");
+    message += F("\n</p>\n");
+
+    for (int i = 0; i < moisture_count(); i++) {
+        int moisture = moisture_read(i);
+        if (moisture < moisture_max()) {
+            message += F("\n<p>\n");
+            message += F("Sensor ");
+            message += String(i + 1);
+            message += F(":\n<br>\n");
+            message += F("Moisture: ");
+            message += String(moisture);
+            message += F(" / ");
+            message += String(moisture_max());
+            message += F("\n</p>\n");
+        }
+    }
+    
+    if (moisture_count() <= 0) {
+        message += F("\n<p>\n");
+        message += F("No moisture sensors configured!");
+        message += F("\n</p>\n");
     }
 
-    message += F("\n\n");
-    message += F("Try /update for OTA firmware updates!");
+    message += F("<p>\n");
+    message += F("Try <a href=\"/update\">/update</a> for OTA firmware updates!\n");
+    message += F("</p>\n");
+    
+    message += F("<p>\n");
+#ifdef ENABLE_INFLUXDB_LOGGING
+    message += F("InfluxDB: ");
+    message += INFLUXDB_DATABASE;
+    message += F(" @ ");
+    message += INFLUXDB_HOST;
+    message += F(":");
+    message += String(INFLUXDB_PORT);
     message += F("\n");
-
-    server.send(200, "text/plain", message);
+#else
+    message += F("InfluxDB logging not enabled!\n");
+#endif
+    message += F("</p>\n");
+    
+    message += F("<p><a href=\"/relaistest\">Relais Test</a></p>\n");
+    message += F("</body></html>\n");
+
+    server.send(200, "text/html", message);
 }
 
 void setup() {
     pinMode(BUILTIN_LED_PIN, OUTPUT);
+    
+    relais_init();
 
     // Blink LED for init
     for (int i = 0; i < 2; i++) {
@@ -113,26 +264,56 @@ void setup() {
         digitalWrite(BUILTIN_LED_PIN, HIGH); // LED off
         delay(LED_INIT_BLINK_INTERVAL);
     }
+    
+    moisture_init();
 
     // Init I2C and try to connect to sensors
-    Wire2.begin(2, 0);
-    found_bme = (!bme.begin(0x76, &Wire2)) ? false : true;
-    found_sht = sht.GetAlive();
+#if defined(ARDUINO_ARCH_ESP8266)
 
-#ifdef DONT_RUN_WITHOUT_SENSORS
-    if ((!found_bme) && (!found_sht)) {
-        // no sensor available
-        while (1) {
-            digitalWrite(BUILTIN_LED_PIN, !digitalRead(BUILTIN_LED_PIN));
-            delay(LED_ERROR_BLINK_INTERVAL);
-        }
-    }
-#endif // DONT_RUN_WITHOUT_SENSORS
+    Wire2.begin(I2C_SDA_PIN, I2C_SCL_PIN);
+    found_bme1 = (!bme1.begin(BME_I2C_ADDRESS_1, &Wire2)) ? false : true;
+    found_bme2 = (!bme2.begin(BME_I2C_ADDRESS_2, &Wire2)) ? false : true;
+
+#elif defined(ARDUINO_ARCH_ESP32)
+
+    Wire.begin();
+    found_bme1 = (!bme1.begin(BME_I2C_ADDRESS_1, &Wire)) ? false : true;
+    found_bme2 = (!bme2.begin(BME_I2C_ADDRESS_2, &Wire)) ? false : true;
+
+#endif
 
-    // Set hostname
+    found_sht = sht.GetAlive();
+
+    // Build hostname string
     String hostname = SENSOR_HOSTNAME_PREFIX;
     hostname += sensor_location;
+
+#if defined(ARDUINO_ARCH_ESP8266)
+
+    // Connect to WiFi AP
     WiFi.hostname(hostname);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(ssid, password);
+    while (WiFi.status() != WL_CONNECTED) {
+        delay(LED_CONNECT_BLINK_INTERVAL);
+        digitalWrite(BUILTIN_LED_PIN, !digitalRead(BUILTIN_LED_PIN));
+    }
+    
+#elif defined(ARDUINO_ARCH_ESP32)
+
+    // Set hostname workaround
+    WiFi.config(INADDR_NONE, INADDR_NONE, INADDR_NONE);
+    WiFi.setHostname(hostname.c_str());
+    
+    // Workaround for WiFi connecting only every 2nd reset
+    // https://github.com/espressif/arduino-esp32/issues/2501#issuecomment-513602522
+    WiFi.onEvent([](WiFiEvent_t event, WiFiEventInfo_t info) {
+        if (info.disconnected.reason == 202) {
+            esp_sleep_enable_timer_wakeup(10);
+            esp_deep_sleep_start();
+            delay(100);
+        }
+    }, WiFiEvent_t::SYSTEM_EVENT_STA_DISCONNECTED);
 
     // Connect to WiFi AP
     WiFi.mode(WIFI_STA);
@@ -141,46 +322,75 @@ void setup() {
         delay(LED_CONNECT_BLINK_INTERVAL);
         digitalWrite(BUILTIN_LED_PIN, !digitalRead(BUILTIN_LED_PIN));
     }
+    
+    // Set hostname workaround
+    WiFi.setHostname(hostname.c_str());
+
+#endif
 
-#ifdef ENABLE_DATABASE_WRITES
+#ifdef ENABLE_INFLUXDB_LOGGING
     // Setup InfluxDB Client
     influx.setDb(INFLUXDB_DATABASE);
-#endif // ENABLE_DATABASE_WRITES
+#endif // ENABLE_INFLUXDB_LOGGING
 
     // Setup HTTP Server
-    MDNS.begin(hostname);
+    MDNS.begin(hostname.c_str());
     updater.setup(&server);
     server.on("/", handleRoot);
+    server.on("/relaistest", handleRelaisTest);
     server.begin();
     MDNS.addService("http", "tcp", 80);
 }
 
 void handleServers() {
     server.handleClient();
+    
+#if defined(ARDUINO_ARCH_ESP8266)
     MDNS.update();
+#endif
+}
+
+static boolean writeMeasurement(InfluxData &measurement) {
+    boolean success = influx.write(measurement);
+    if (!success) {
+        error_count++;
+        for (int i = 0; i < 10; i++) {
+            digitalWrite(BUILTIN_LED_PIN, LOW); // LED on
+            delay(LED_ERROR_BLINK_INTERVAL);
+            digitalWrite(BUILTIN_LED_PIN, HIGH); // LED off
+            delay(LED_ERROR_BLINK_INTERVAL);
+        }
+    }
+    return success;
 }
 
-#ifdef ENABLE_DATABASE_WRITES
+#ifdef ENABLE_INFLUXDB_LOGGING
 void writeDatabase() {
-    if (found_bme) {
+    if (found_bme1) {
         InfluxData measurement("environment");
         measurement.addTag("location", sensor_location);
+        measurement.addTag("placement", "1");
         measurement.addTag("device", WiFi.macAddress());
         measurement.addTag("sensor", "bme280");
 
-        measurement.addValue("temperature", bme.readTemperature());
-        measurement.addValue("pressure", bme.readPressure());
-        measurement.addValue("humidity", bme.readHumidity());
-
-        boolean success = influx.write(measurement);
-        if (!success) {
-            for (int i = 0; i < 10; i++) {
-                digitalWrite(BUILTIN_LED_PIN, LOW); // LED on
-                delay(LED_ERROR_BLINK_INTERVAL);
-                digitalWrite(BUILTIN_LED_PIN, HIGH); // LED off
-                delay(LED_ERROR_BLINK_INTERVAL);
-            }
-        }
+        measurement.addValue("temperature", bme1.readTemperature());
+        measurement.addValue("pressure", bme1.readPressure());
+        measurement.addValue("humidity", bme1.readHumidity());
+
+        writeMeasurement(measurement);
+    }
+    if (found_bme2) {
+        InfluxData measurement("environment");
+        measurement.addTag("location", sensor_location);
+        measurement.addTag("placement", "2");
+        measurement.addTag("device", WiFi.macAddress());
+        measurement.addTag("sensor", "bme280");
+
+        measurement.addValue("temperature", bme2.readTemperature());
+        measurement.addValue("pressure", bme2.readPressure());
+        measurement.addValue("humidity", bme2.readHumidity());
+
+        writeMeasurement(measurement);
     }
 
     if (found_sht) {
@@ -192,39 +402,52 @@ void writeDatabase() {
         measurement.addValue("temperature", sht.GetTemperature());
         measurement.addValue("humidity", sht.GetHumidity());
 
-        boolean success = influx.write(measurement);
-        if (!success) {
-            for (int i = 0; i < 10; i++) {
-                digitalWrite(BUILTIN_LED_PIN, LOW); // LED on
-                delay(LED_ERROR_BLINK_INTERVAL);
-                digitalWrite(BUILTIN_LED_PIN, HIGH); // LED off
-                delay(LED_ERROR_BLINK_INTERVAL);
-            }
+        writeMeasurement(measurement);
+    }
+    
+    for (int i = 0; i < moisture_count(); i++) {
+        int moisture = moisture_read(i);
+        if (moisture < moisture_max()) {
+            InfluxData measurement("moisture");
+            measurement.addTag("location", sensor_location);
+            measurement.addTag("device", WiFi.macAddress());
+            measurement.addTag("sensor", String(i + 1));
+
+            measurement.addValue("value", moisture);
+            measurement.addValue("maximum", moisture_max());
+
+            writeMeasurement(measurement);
         }
     }
 }
-#endif // ENABLE_DATABASE_WRITES
+#endif // ENABLE_INFLUXDB_LOGGING
 
 void loop() {
     unsigned long time = millis();
+    
+    relais_run();
 
     if ((time - last_server_handle_time) >= SERVER_HANDLE_INTERVAL) {
         last_server_handle_time = time;
         handleServers();
     }
 
-#ifdef ENABLE_DATABASE_WRITES
+#ifdef ENABLE_INFLUXDB_LOGGING
     if ((time - last_db_write_time) >= DB_WRITE_INTERVAL) {
         last_db_write_time = time;
         writeDatabase();
     }
-#endif // ENABLE_DATABASE_WRITES
+    
+#ifdef INFLUX_MAX_ERRORS_RESET
+    if (error_count >= INFLUX_MAX_ERRORS_RESET) {
+        ESP.restart();
+    }
+#endif // INFLUX_MAX_ERRORS_RESET
+#endif // ENABLE_INFLUXDB_LOGGING
 
-#ifdef ENABLE_LED_HEARTBEAT_BLINK
     if ((time - last_led_blink_time) >= LED_BLINK_INTERVAL) {
         last_led_blink_time = time;
         digitalWrite(BUILTIN_LED_PIN, !digitalRead(BUILTIN_LED_PIN));
     }
-#endif // ENABLE_LED_HEARTBEAT_BLINK
 }
 

src/moisture.cpp

@@ -0,0 +1,83 @@
+/*
+ * moisture.cpp
+ *
+ * ESP8266 / ESP32 Environmental Sensor
+ *
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+ * you can do whatever you want with this stuff. If we meet some day, and you
+ * think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+ * ----------------------------------------------------------------------------
+ */
+
+#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)
+
+#include <driver/adc.h>
+
+#define ADC_OVERSAMPLE 20
+#define ADC_BITWIDTH 12
+#define ADC_BITS ADC_WIDTH_BIT_12
+#define ADC_ATTENUATION ADC_ATTEN_DB_11
+
+#define SENSOR_COUNT 6
+adc1_channel_t sensor_pin[SENSOR_COUNT] = {
+    ADC1_CHANNEL_0, ADC1_CHANNEL_3,
+    ADC1_CHANNEL_6, ADC1_CHANNEL_7,
+    ADC1_CHANNEL_4, ADC1_CHANNEL_5
+};
+
+static int adc_read_oversampled(adc1_channel_t pin) {
+    uint32_t sample_sum = 0;
+    
+    for (int i = 0; i < ADC_OVERSAMPLE; i++) {
+        sample_sum += adc1_get_raw(pin);
+    }
+    
+    return sample_sum / ADC_OVERSAMPLE;
+}
+
+int moisture_count(void) {
+    return SENSOR_COUNT;
+}
+
+int moisture_read(int sensor) {
+    if ((sensor < 0) || (sensor > SENSOR_COUNT)) {
+        return -1;
+    }
+    
+    return adc_read_oversampled(sensor_pin[sensor]);
+}
+
+int moisture_max(void) {
+    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);
+    }
+}
+
+#endif
+

src/relais.cpp

@@ -0,0 +1,83 @@
+/*
+ * relais.cpp
+ *
+ * ESP8266 / ESP32 Environmental Sensor
+ *
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+ * you can do whatever you want with this stuff. If we meet some day, and you
+ * think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+ * ----------------------------------------------------------------------------
+ */
+
+#include <Arduino.h>
+#include "relais.h"
+
+#if defined(ARDUINO_ARCH_ESP8266)
+
+int relais_count(void) {
+    return 0;
+}
+
+int relais_enable(int relais, unsigned long time) {
+    return 0;
+}
+
+void relais_init(void) { }
+void relais_run(void) { }
+
+#elif defined(ARDUINO_ARCH_ESP32)
+
+#define RELAIS_COUNT 10
+
+struct relais_state {
+    unsigned long turn_off;
+};
+
+static struct relais_state state[RELAIS_COUNT];
+static int gpios[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);
+}
+
+int relais_count(void) {
+    return RELAIS_COUNT;
+}
+
+int relais_enable(int relais, unsigned long time) {
+    if ((relais < 0) || (relais >= RELAIS_COUNT)) {
+        return -1;
+    }
+    
+    relais_set(relais, 1);
+    state[relais].turn_off = millis() + time;
+    return 0;
+}
+
+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;
+    }
+}
+
+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);
+            }
+        }
+    }
+}
+
+#endif
+