stuff

Reviewed-on: #4

.devcontainer/docker-compose.yaml

@@ -1,7 +1,7 @@
 version: '3.8'
 services:
   app:
-    image: gitea.maiertobi.de/tobimai/devcontainer-pio:latest
+    image: gitea.tobiasmaier.me/tobimai/devcontainer-pio:latest
     user: tobi:tobi
     volumes:
       - ..:/workspace:cached

.gitea/workflows/on_push.yaml

@@ -1,24 +1,26 @@
-name: Test compiling project
+name: Compilie project and upload binaries
 
-on: [push]
+on:
+  push:
+    branches: ["main"]
 
 jobs:
   test:
     runs-on: ubuntu-latest
     container:
-      image: gitea.maiertobi.de/tobimai/devcontainer-pio:latest
+      image: gitea.tobiasmaier.me/tobimai/devcontainer-pio:2.1
 
     steps:
     - name: Checkout Code
       uses: actions/checkout@v2
+    - name: Run PlatformIO build for SPIFFS (same in both platforms, so only one build is necessary)
+      run: which pio && id && pio run --target buildfs -e ESP32_INA233
     - name: Run PlatformIO Tests
       run: pio test -e native
     - name: Run PlatformIO build for INA233
       run: pio run -e ESP32_INA233
     - name: Run PlatformIO build for INA226
       run: pio run -e ESP32_INA226
-    - name: Run PlatformIO build for SPIFFS (same in both platforms, so only one build is necessary)
-      run: pio run --target buildfs -e ESP32_INA233
     - name: Upload firmware binary for INA233
       run: |
         VERSION=$(sed -n 's/#define current_software_version Version{[[:space:]]*\([0-9]\+\),[[:space:]]*\([0-9]\+\),[[:space:]]*\([0-9]\+\)}/\1.\2.\3/p' src/global_data/defines.h)
@@ -27,7 +29,7 @@ jobs:
         curl -X PUT \
           -H "Content-Type: application/octet-stream" \
           --data-binary @.pio/build/ESP32_INA233/firmware.bin \
-          https://iot.tobiasmaier.me/firmware/waterlevel/INA233/${VERSION}
+          https://iot.tobiasmaier.me/firmware/waterlevel/INA233REV2/${VERSION}
 
     - name: Upload firmware binary for INA226
       run: |
@@ -37,7 +39,7 @@ jobs:
         curl -X PUT \
           -H "Content-Type: application/octet-stream" \
           --data-binary @.pio/build/ESP32_INA226/firmware.bin \
-          https://iot.tobiasmaier.me/firmware/waterlevel/INA226/${VERSION}
+          https://iot.tobiasmaier.me/firmware/waterlevel/INA226REV2/${VERSION}
 
     - name: Upload SPIFFS binary
       run: |
@@ -46,5 +48,5 @@ jobs:
 
         curl -X PUT \
           -H "Content-Type: application/octet-stream" \
-          --data-binary @.pio/build/ESP32_INA233/spiffs.bin \
-          https://iot.tobiasmaier.me/filesystem/waterlevel/generic/${VERSION}
+          --data-binary @.pio/build/ESP32_INA233/littlefs.bin \
+          https://iot.tobiasmaier.me/filesystem/waterlevel/generic/${VERSION}.0.0

.gitea/workflows/test_build.yaml

@@ -0,0 +1,24 @@
+name: Test project compilation
+
+on:
+  push:
+    branches-ignore: ["main"]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    container:
+      image: gitea.tobiasmaier.me/tobimai/devcontainer-pio:2.1
+
+    steps:
+    - name: Checkout Code
+      uses: actions/checkout@v2
+    - name: Run PlatformIO build for SPIFFS (same in both platforms, so only one build is necessary)
+      run: which pio && id && pio run --target buildfs -e ESP32_INA233
+    - name: Run PlatformIO Tests
+      run: pio test -e native
+    - name: Run PlatformIO build for INA233
+      run: pio run -e ESP32_INA233
+    - name: Run PlatformIO build for INA226
+      run: pio run -e ESP32_INA226

.vscode/extensions.json

@@ -1,7 +1,6 @@
 {
-    // See http://go.microsoft.com/fwlink/?LinkId=827846
-    // for the documentation about the extensions.json format
     "recommendations": [
+        "pioarduino.pioarduino-ide",
         "platformio.platformio-ide"
     ],
     "unwantedRecommendations": [

.vscode/settings.json

@@ -2,6 +2,73 @@
     "files.associations": {
         "iostream": "cpp",
         "random": "cpp",
-        "vector": "cpp"
+        "vector": "cpp",
+        "array": "cpp",
+        "deque": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "unordered_set": "cpp",
+        "string_view": "cpp",
+        "memory": "cpp",
+        "initializer_list": "cpp",
+        "regex": "cpp",
+        "istream": "cpp",
+        "ostream": "cpp",
+        "chrono": "cpp",
+        "list": "cpp",
+        "format": "cpp",
+        "mutex": "cpp",
+        "span": "cpp",
+        "text_encoding": "cpp",
+        "thread": "cpp",
+        "*.inc": "cpp",
+        "cstddef": "cpp",
+        "iomanip": "cpp",
+        "sstream": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "charconv": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "condition_variable": "cpp",
+        "cstdarg": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "map": "cpp",
+        "set": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory_resource": "cpp",
+        "netfwd": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "ratio": "cpp",
+        "source_location": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "iosfwd": "cpp",
+        "limits": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "semaphore": "cpp",
+        "stdexcept": "cpp",
+        "stop_token": "cpp",
+        "streambuf": "cpp",
+        "cinttypes": "cpp",
+        "typeinfo": "cpp",
+        "variant": "cpp"
     }
 }

data/logic.js

@@ -25,6 +25,7 @@ function fetchTelemetryData() {
         .then(data => {
             document.getElementById('uptime').textContent = data.uptime_seconds ? (roundToTwo(data.uptime_seconds) + ' s') : 'XXX';
             document.getElementById('heap').textContent = data.heap_percent ? (roundToTwo(data.heap_percent) + ' %%') : 'XXX';
+            document.getElementById('temperature').textContent = data.heap_percent ? (roundToTwo(data.temperature) + ' °C') : 'XXX';
         })
         .catch(error => {
             console.error("There was an error fetching data from the API", error);
@@ -48,7 +49,7 @@ function fetchWaterData(gauge) {
 }
 
 function fetchUpdateData(gauge) {
-    const apiUrl = '/ota_udpate_status';
+    const apiUrl = '/ota_update_status';
     // Fetching data from the API
     fetch(apiUrl)
         .then(response => response.json())

data/status.html

@@ -1,4 +1,5 @@
 <!DOCTYPE html>
+<meta charset="UTF-8">
 
 <head>
   <link rel="stylesheet" href="/chota.css">
@@ -19,9 +20,6 @@
           <a href="/export">Data export</a>
         </div>
       </div>
-      <div class="nav-right">
-        <a class="button outline">Button</a>
-      </div>
     </nav>
 
     <div class="row">
@@ -121,6 +119,10 @@
                 <td>Heap usage: </td>
                 <td id="heap">XXX</td>
               </tr>
+              <tr>
+                <td>CPU Temperature: </td>
+                <td id="temperature">XXX</td>
+              </tr>
             </tbody>
           </table>
         </div>

data/update_progress.html

@@ -5,20 +5,8 @@
 </head>
 
 <body>
-    <div class="container">
-        <div class="card bd-success">
-            <header class="is-center">
-                <h4>Update running</h4>
-            </header>
-            <div class="is-center" id="progress">
-                Running update...
-            </div>
-        </div>
-    </div>
-</body>
-
-<script>
-    const webSocket = new WebSocket('webSocket://' + window.location.host + '/webSocket');
+  <script>
+    const webSocket = new WebSocket('ws://' + window.location.host + '/webSocket');
 
     webSocket.onopen = function() {
       console.log('WebSocket connection opened.');
@@ -32,7 +20,7 @@
         document.getElementById('progress').textContent = "Upgrade Done, wait for reboot...";
 
         const checkStatus = setInterval(() => {
-          fetch('/ota_udpate_status')
+          fetch('/ota_update_status')
             .then(response => {
               if (response.ok) {
                 clearInterval(checkStatus);
@@ -55,4 +43,16 @@
     webSocket.onclose = function() {
       console.log('WebSocket connection closed.');
     };
-  </script>
+  </script>
+    <div class="container">
+        <div class="card bd-success">
+            <header class="is-center">
+                <h4>Update running</h4>
+            </header>
+            <div class="is-center" id="progress">
+                Running update...
+            </div>
+        </div>
+    </div>
+</body>
+

data/version

@@ -1 +1 @@
-8
+10

documentation/old.md

@@ -17,7 +17,7 @@ void listNetworkInterfaces() {
 }
 
 void setEthernetAsDefault() {
-  logger.log(0, DEBUG, "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
+  Logger.log(0, ELOG_LEVEL_DEBUG, "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
   listNetworkInterfaces();
   // Attempt to locate the Ethernet network interface.
   // (The name may vary—on some systems it might be "eth0")
@@ -31,8 +31,8 @@ void setEthernetAsDefault() {
   struct netif *eth_netif2 = netif_find("ETH_DEF");
   if (netif) {
     netif_set_default(eth_netif2);
-    logger.log(0, DEBUG, "Ethernet set as default network interface.");
+    Logger.log(0, ELOG_LEVEL_DEBUG, "Ethernet set as default network interface.");
   } else {
-    logger.log(0, DEBUG, "Could not find Ethernet netif.");
+    Logger.log(0, ELOG_LEVEL_DEBUG, "Could not find Ethernet netif.");
   }
 }

lib/INA233/INA233.h

@@ -10,25 +10,25 @@
 #define REGISTER_READ_IIN 0x89
 
 enum AveragingMode {
-  averages_1 = B000,
-  averages_4 =  B001,
-  averages_16 = B010,
-  averages_64 = B011,
-  averages_128 = B100,
-  averages_256 = B101,
-  averages_512 = B110,
-  averages_1024 = B111
+  averages_1 = 0b000,
+  averages_4 =  0b001,
+  averages_16 = 0b010,
+  averages_64 = 0b011,
+  averages_128 = 0b100,
+  averages_256 = 0b101,
+  averages_512 = 0b110,
+  averages_1024 = 0b111
 };
 
 enum ConversionTime {
-  conversion_time_140uS = B000,
-  conversion_time_204uS =  B001,
-  conversion_time_332us = B010,
-  conversion_time_588uS = B011,
-  conversion_time_1100uS = B100,
-  conversion_time_2116uS = B101,
-  conversion_time_4156uS = B110,
-  conversion_time_8244uS = B111
+  conversion_time_140uS = 0b000,
+  conversion_time_204uS =  0b001,
+  conversion_time_332us = 0b010,
+  conversion_time_588uS = 0b011,
+  conversion_time_1100uS = 0b100,
+  conversion_time_2116uS = 0b101,
+  conversion_time_4156uS = 0b110,
+  conversion_time_8244uS = 0b111
 };
 
 class INA233{

lib/fetchOTA/fetchOTA.cpp

@@ -5,6 +5,7 @@
 #include "Arduino.h"
 #include <ArduinoJson.h>
 #include <HTTPClient.h>
+#include <WiFiClient.h>
 #include <vector>
 #include <Elog.h>
 #include <HTTPUpdate.h>
@@ -22,14 +23,14 @@ Firmware OTA::getLatestVersionOnServer() {
     HTTPClient http;
     http.begin(_serverUrl);
     int httpCode = http.GET();
-    logger.log(0, DEBUG, "HTTP Code: %d", httpCode);
+    Logger.log(0, ELOG_LEVEL_DEBUG, "HTTP Code: %d", httpCode);
 
     if (httpCode != 200) {
         return createErrorResponse("HTTP GET request failed with code " + String(httpCode));
     }
 
     String payload = http.getString();
-    logger.log(0, DEBUG, "Payload: %s", payload.c_str());
+    Logger.log(0, ELOG_LEVEL_DEBUG, "Payload: %s", payload.c_str());
     DynamicJsonDocument doc(4096);
     DeserializationError error = deserializeJson(doc, payload);
 
@@ -54,7 +55,7 @@ Firmware OTA::getLatestVersionOnServer() {
                     deviceConfig
                 });
             } else {
-                logger.log(0, DEBUG, "Configuration %s does not match current device configuration %s", deviceConfig.c_str(), _current_device_configuration.c_str());
+                Logger.log(0, ELOG_LEVEL_DEBUG, "Configuration %s does not match current device configuration %s", deviceConfig.c_str(), _current_device_configuration.c_str());
             }
         }
     }
@@ -67,7 +68,7 @@ Firmware OTA::getLatestVersionOnServer() {
     Configuration latest = getLatestConfiguration(configs.data(), configs.size());
 
     if (!isVersionNewer(_currentVersion, latest.version)) {
-        logger.log(0, DEBUG, "No newer version found. Server version: %d.%d.%d", latest.version.major, latest.version.minor, latest.version.patch);
+        Logger.log(0, ELOG_LEVEL_DEBUG, "No newer version found. Server version: %d.%d.%d", latest.version.major, latest.version.minor, latest.version.patch);
     }
 
     return Firmware{
@@ -88,79 +89,83 @@ Firmware OTA::createErrorResponse(const String& errorMsg) {
 }
 
 void run_ota_update(String url, std::function<void()> callback_started,  std::function<void()> callback_finished, std::function<void(int, int)> callback_progress, std::function<void(int)> callback_error) {
-    logger.log(0, DEBUG, "Starting OTA upgrade");
+    Logger.log(0, ELOG_LEVEL_DEBUG, "Starting OTA upgrade");
+    Logger.log(0, ELOG_LEVEL_DEBUG, "URL: %s", url);
     HTTPUpdate httpUpdate;
     httpUpdate.onStart(callback_started);
     httpUpdate.onEnd(callback_finished);
     httpUpdate.onProgress(callback_progress);
     httpUpdate.onError(callback_error);
-    logger.log(0, DEBUG, "Defined callbacks, Starting update now");
+    Logger.log(0, ELOG_LEVEL_DEBUG, "Defined callbacks, Starting update now");
 
     t_httpUpdate_return ret;
 
     if (url.startsWith("https")) {
-        logger.log(0, DEBUG, "HTTPS URL");
-        WiFiClientSecure client;
-        client.setInsecure();
-        ret = httpUpdate.update(client, url);
+        Logger.log(0, ELOG_LEVEL_DEBUG, "HTTPS URL");
+        HTTPClient http_client;
+        http_client.begin(url);
+        ret = httpUpdate.update(http_client, url);
     } else if (url.startsWith("http")) {
-        logger.log(0, DEBUG, "HTTP URL");
-        WiFiClient client;
-        ret = httpUpdate.update(client, url);
+        Logger.log(0, ELOG_LEVEL_DEBUG, "HTTP URL");
+        HTTPClient http_client;
+        http_client.begin(url);
+        ret = httpUpdate.update(http_client, url);
     } else {
-        logger.log(0, ERROR, "URL is not valid: \n%s", url.c_str());
+        Logger.log(0, ELOG_LEVEL_ERROR, "URL is not valid: \n%s", url.c_str());
     }
 
     switch (ret) {
         case HTTP_UPDATE_FAILED:
-            logger.log(0, ERROR, "HTTP_UPDATE_FAILED Error (%d): %s\n", httpUpdate.getLastError(), httpUpdate.getLastErrorString().c_str());
+            Logger.log(0, ELOG_LEVEL_ERROR, "HTTP_UPDATE_FAILED Error (%d): %s\n", httpUpdate.getLastError(), httpUpdate.getLastErrorString().c_str());
             break;
   
         case HTTP_UPDATE_NO_UPDATES:
-            logger.log(0, ERROR, "HTTP_UPDATE_NO_UPDATES");
+            Logger.log(0, ELOG_LEVEL_ERROR, "HTTP_UPDATE_NO_UPDATES");
             break;
   
         case HTTP_UPDATE_OK:
-          logger.log(0, DEBUG, "Update done");
+          Logger.log(0, ELOG_LEVEL_DEBUG, "Update done");
           break;
       }
 }
 
 void run_ota_spiffs_update(String url, std::function<void()> callback_started,  std::function<void()> callback_finished, std::function<void(int, int)> callback_progress, std::function<void(int)> callback_error) {
-    logger.log(0, DEBUG, "Starting OTA SPIFFS upgrade");
+    Logger.log(0, ELOG_LEVEL_DEBUG, "Starting OTA SPIFFS upgrade");
     HTTPUpdate httpUpdate;
     httpUpdate.onStart(callback_started);
     httpUpdate.onEnd(callback_finished);
     httpUpdate.onProgress(callback_progress);
     httpUpdate.onError(callback_error);
-    logger.log(0, DEBUG, "Defined callbacks, Starting update now");
+    Logger.log(0, ELOG_LEVEL_DEBUG, "Defined callbacks, Starting update now");
 
     t_httpUpdate_return ret;
 
     if (url.startsWith("https")) {
-        logger.log(0, DEBUG, "HTTPS URL");
-        WiFiClientSecure client;
-        client.setInsecure();
-        ret = httpUpdate.updateSpiffs(client, url);
+        Logger.log(0, ELOG_LEVEL_DEBUG, "HTTPS URL");
+        HTTPClient http_client;
+        http_client.begin(url);
+        // client.setInsecure();
+        ret = httpUpdate.updateSpiffs(http_client, url);
     } else if (url.startsWith("http")) {
-        logger.log(0, DEBUG, "HTTP URL");
-        WiFiClient client;
-        ret = httpUpdate.updateSpiffs(client, url);
+        Logger.log(0, ELOG_LEVEL_DEBUG, "HTTP URL");
+        HTTPClient http_client;
+        http_client.begin(url);
+        ret = httpUpdate.updateSpiffs(http_client, url);
     } else {
-        logger.log(0, ERROR, "URL is not valid: \n%s", url.c_str());
+        Logger.log(0, ELOG_LEVEL_ERROR, "URL is not valid: \n%s", url.c_str());
     }
 
     switch (ret) {
         case HTTP_UPDATE_FAILED:
-            logger.log(0, ERROR, "HTTP_UPDATE_FAILED Error (%d): %s\n", httpUpdate.getLastError(), httpUpdate.getLastErrorString().c_str());
+            Logger.log(0, ELOG_LEVEL_ERROR, "HTTP_UPDATE_FAILED Error (%d): %s\n", httpUpdate.getLastError(), httpUpdate.getLastErrorString().c_str());
             break;
   
         case HTTP_UPDATE_NO_UPDATES:
-            logger.log(0, ERROR, "HTTP_UPDATE_NO_UPDATES");
+            Logger.log(0, ELOG_LEVEL_ERROR, "HTTP_UPDATE_NO_UPDATES");
             break;
   
         case HTTP_UPDATE_OK:
-          logger.log(0, DEBUG, "SPIFFS Update done");
+          Logger.log(0, ELOG_LEVEL_DEBUG, "SPIFFS Update done");
           break;
       }
 }

platformio.ini

@@ -11,39 +11,40 @@
 [platformio]
 default_envs = ESP32_INA233, ESP32_INA226
 
-[env:ESP32_INA233]
-platform = espressif32
+[env:esp32_base]
+platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.32/platform-espressif32.zip
 board = esp32dev
 framework = arduino
 monitor_speed = 115200
+monitor_filters = esp32_exception_decoder
+board_build.partitions = min_spiffs.csv
 lib_deps = 
-	ottowinter/ESPAsyncWebServer-esphome@^3.3.0
-	bblanchon/ArduinoJson@^6.21.3
-	fetchOTA
+    esp32async/AsyncTCP @ ~3.4.9
+    esp32async/ESPAsyncWebServer @ ~3.8.1
+    robtillaart/INA226@ ~0.6.4
+    bblanchon/ArduinoJson@^6.21.3
+    x385832/Elog@~2.0.10
+    fetchOTA
+build_flags = -fexceptions
+build_src_flags = -Wall -Wextra
+
+
+[env:ESP32_INA233]
+extends = env:esp32_base
+lib_deps = 
+	${env:esp32_base.lib_deps}
 	INA233
-	ESP32Ping
-	https://github.com/tobimai/elog.git#fix-syslog
-board_build.partitions = default.csv
 upload_protocol = espota
 upload_port = 192.168.5.205
-build_flags = -Wall -Wextra -DLOGGING_SPIFFS_DISABLE -DLOGGING_SD_DISABLE
 
 [env:ESP32_INA226]
-platform = espressif32
-board = esp32dev
-framework = arduino
-monitor_speed = 115200
+extends = env:esp32_base
 lib_deps = 
-	ottowinter/ESPAsyncWebServer-esphome@^3.3.0
-	robtillaart/INA226@^0.4.4
-	bblanchon/ArduinoJson@^6.21.3
-	jsc/ArduinoLog
-	ESP32Ping
-	https://github.com/tobimai/elog.git#fix-syslog
-board_build.partitions = default.csv
+	${env:esp32_base.lib_deps}
+	robtillaart/INA226@ ~0.6.4
 upload_protocol = espota
-upload_port = 192.168.4.18
-build_flags = -Wall -Wextra -DUSE_INA226 -DLOGGING_SPIFFS_DISABLE -DLOGGING_SD_DISABLE
+upload_port = 192.168.6.46
+build_flags = ${env:esp32_base.build_flags} -DUSE_INA226
 
 [env:native]
 platform = native
@@ -51,3 +52,4 @@ build_flags = -DUNIT_TEST -Ilib/fetchOTA/
 lib_deps = 
 	fetchOTA
 	arduino-libraries/ArduinoHttpClient@^0.6.1
+

src/external_interfacing/leds.cpp

@@ -7,93 +7,30 @@
 extern ActiveErrors active_errors;
 extern WaterData water_data;
 
-void display_percentage(float percentage)
-{
-    digitalWrite(LED_RED, 0);
-
-    if (percentage > 0) {
-        digitalWrite(LED_1, 1);
-    } else {
-        digitalWrite(LED_1, 0);
-    }
-    if (percentage > 20) {
-        digitalWrite(LED_2, 1);
-    } else {
-        digitalWrite(LED_2, 0);
-    }
-    if (percentage > 40) {
-        digitalWrite(LED_3, 1);
-    } else {
-        digitalWrite(LED_3, 0);
-    }
-    if (percentage > 60) {
-        digitalWrite(LED_4, 1);
-    } else {
-        digitalWrite(LED_4, 0);
-    }
-    if (percentage > 80) {
-        digitalWrite(LED_5, 1);
-    } else {
-        digitalWrite(LED_5, 0);
-    }
-
-    if (percentage > 10) {
-        delay(3000);
-    } else if (percentage > 0) {
-        for (int i = 0; i < 3; i++) {
-            digitalWrite(LED_1, 1);
-            delay(500);
-            digitalWrite(LED_1, 0);
-            delay(500);
-        }
-    } else if (percentage <= 0) {
-        for (int i = 0; i < 15; i++) {
-            digitalWrite(LED_1, 1);
-            delay(100);
-            digitalWrite(LED_1, 0);
-            delay(100);
-        }
-    }
-}
-
-void display_error_code(byte err_code)
-{
-    digitalWrite(LED_RED, 1);
-    digitalWrite(LED_1, bitRead(err_code, 0));
-    digitalWrite(LED_2, bitRead(err_code, 1));
-    digitalWrite(LED_3, bitRead(err_code, 2));
-    digitalWrite(LED_4, bitRead(err_code, 3));
-    digitalWrite(LED_5, bitRead(err_code, 4));
-}
-
 void display_task(void* parameter)
 {
+    LOG(ELOG_LEVEL_DEBUG, "Starting display tasks");
     while (true) {
         if (!is_error(active_errors)) {
             // We have no error, refresh status display and wait half a second
-            display_percentage(water_data.percentage);
+            ledcWrite(LED_GREEN, 255);
+            ledcWrite(LED_RED, 0);
         } else {
-            // We have an error, display error code for 3 seconds and then water level for 3 seconds
-            if (active_errors.voltage_low) {
-                display_error_code(1);
-                LOG(WARNING, "Sensor Error - Voltage low");
-                delay(3000);
-            } else if (active_errors.voltage_high) {
-                display_error_code(2);
-                LOG(WARNING, "Sensor Error - Voltage High");
-                delay(3000);
-            } else if (active_errors.current_low) {
-                display_error_code(3);
-                LOG(WARNING, "Sensor Error - Current low");
-                delay(3000);
-            } else if (active_errors.current_high) {
-                display_error_code(4);
-                LOG(WARNING, "Sensor Error - Current high");
-                delay(3000);
-            } else {
-                delay(3000);
-            }
-            display_percentage(water_data.percentage);
+            ledcWrite(LED_RED, LED_RED_HIGH);
+            ledcWrite(LED_GREEN, 0);
         }
+        delay(250);
     }
+}
+
+
+// Setup pin modes etc.
+void led_setup() {
+    pinMode(LED_RED, OUTPUT);
+    pinMode(LED_GREEN, OUTPUT);
+
+    ledcAttach(LED_RED, LED_PWM_FREQUENCY, LED_PWM_RESOLUTION);
+    ledcAttach(LED_GREEN, LED_PWM_FREQUENCY, LED_PWM_RESOLUTION);
+    ledcWrite(LED_RED, LED_RED_HIGH);
+    ledcWrite(LED_GREEN, 255);
 }

src/external_interfacing/leds.h

@@ -1,12 +1,14 @@
 #include <Arduino.h>
 
-#define LED_1 4
-#define LED_2 2
-#define LED_3 15
-#define LED_4 13
-#define LED_5 12
-#define LED_RED 14
+#define LED_RED 15
+#define LED_GREEN 2
+#define LED_PWM_FREQUENCY 5000
+#define LED_PWM_RESOLUTION 8
+#define LED_CHANNEL_RED 0
+#define LED_CHANNEL_GREEN 1
 
-void display_percentage(float percentage);
-void display_error_code(byte err_code);
-void display_task(void* parameter);
+#define LED_RED_HIGH 150
+
+// void display_error_code(byte err_code);
+void display_task(void* parameter);
+void led_setup();

src/global_data/defines.h

@@ -7,7 +7,7 @@
 #define water_level_min_key "water_level_min"
 #define water_level_max_key "water_level_max"
 #define water_volume_key "water_volume"
-#define current_software_version Version{1, 3, 0}
-#define REQUIRED_SPIFFS_VERSION Version{8, 0, 0}
+#define current_software_version Version{2, 4, 0}
+#define REQUIRED_SPIFFS_VERSION Version{10, 0, 0}
 
 #define RESISTOR_VALUE 4

src/global_data/global_data.h

@@ -29,6 +29,7 @@ struct NetworkData {
 struct DeviceTelemetry {
     float heap_used_percent;
     int uptime_seconds;
+    float temperature;
 };
 
 struct ActiveErrors {

src/main.cpp

@@ -24,9 +24,9 @@
 #include "networking/json_builder.h"
 #include "networking/responses.h"
 #include <fetchOTA.h>
-#include <ESP32Ping.h>
 #include "time.h"
 #include "tools/log.h"
+#include <LittleFS.h>
 
 #define MYLOG 0
 
@@ -37,8 +37,7 @@ extern DeviceTelemetry telemetry;
 extern NetworkData wifi_data;
 extern NetworkData ethernet_data;
 extern SensorData shunt_data;
-
-extern "C" int rom_phy_get_vdd33();
+extern ActiveErrors active_errors;
 
 Version current_spiffs_version;
 
@@ -47,86 +46,74 @@ AsyncWebSocket webSocket("/webSocket");
 #define FORMAT_LITTLEFS_IF_FAILED true
 
 void setup()
-{   
-    logger.registerSerial(MYLOG, DEBUG, "tst");
+{
+    Logger.registerSerial(MYLOG, ELOG_LEVEL_DEBUG, "Serial");
+
+    LOG(ELOG_LEVEL_DEBUG, "Init LEDs");
+    led_setup();
+
+    LOG(ELOG_LEVEL_DEBUG, "Init Starting prefs and Serial output");
     prefs.begin("waterlevel", false);
     Serial.begin(115200);
 
-    LOG(DEBUG, "Init LEDs");
-    pinMode(LED_1, OUTPUT);
-    pinMode(LED_2, OUTPUT);
-    pinMode(LED_3, OUTPUT);
-    pinMode(LED_4, OUTPUT);
-    pinMode(LED_5, OUTPUT);
-    pinMode(LED_RED, OUTPUT);
-    display_error_code(31);
     delay(500);
-    display_error_code(17);
+    LOG(ELOG_LEVEL_DEBUG, "Init Sensor");
     init_sensor();
 
-    LOG(DEBUG, "Beginning SPIFFS");
-    SPIFFS.begin(true);
+    LOG(ELOG_LEVEL_DEBUG, "Beginning LittleFS");
+    LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED);
 
     // Read the current SPIFFS version from the versions file on the spiffs
-    File file = SPIFFS.open("/version", FILE_READ);
+    LOG(ELOG_LEVEL_DEBUG, "Reading LittleFS version");
+    File file = LittleFS.open("/version", FILE_READ);
     if (!file) {
-      Serial.println("Failed to open version file for reading");
+        LOG( ELOG_LEVEL_ERROR, "Failed opening LittleFS version file");
     } else {
       String version = file.readStringUntil('\n');
-      LOG(DEBUG, "Version: %s", version);
       current_spiffs_version = parseVersion(version.c_str());
-      LOG(DEBUG, "Current SPIFFS Version: %d.%d.%d", current_spiffs_version.major, current_spiffs_version.minor, current_spiffs_version.patch);
+      LOG(ELOG_LEVEL_DEBUG, "Current LittleFS Version: %d.%d.%d", current_spiffs_version.major, current_spiffs_version.minor, current_spiffs_version.patch);
     }
-
-
-    LOG(DEBUG, "SPIFFS initialized");
-    display_error_code(19);
-
-    LOG(DEBUG, "Begin INA");
-
-    display_error_code(22);
+    LOG(ELOG_LEVEL_DEBUG, "LittleFS initialized");
 
     /////////////////////////////// ROUTES ///////////////////////////////
-    LOG(DEBUG, "Route Setup");
+    LOG(ELOG_LEVEL_DEBUG, "Route Setup");
 
     // Normal HTML stuff
-    server.on("/", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/status.html", "text/html", false, processor); });
+    server.on("/", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/status.html", "text/html", false, processor); });
 
-    server.on("/settings", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/settings.html", "text/html", false, processor); });
+    server.on("/settings", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/settings.html", "text/html", false, processor); });
 
-    server.on("/export", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/data_export.html", "text/html", false); });
+    server.on("/export", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/data_export.html", "text/html", false); });
 
-    server.on("/logic.js", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/logic.js", "application/javascript", false, processor); });
+    server.on("/logic.js", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/logic.js", "application/javascript", false, processor); });
 
-    server.on("/update", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/update_progress.html", "text/html", false, processor); });
+    server.on("/update", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/update_progress.html", "text/html", false, processor); });
 
     // API stuff - internal
     server.on("/update_wifi_credentials", HTTP_POST, [](AsyncWebServerRequest* request) {
-        int params = request->params();
-
         // For settings SSID
         if (request->hasParam(ssid_key, true) && request->hasParam(wifi_password_key, true)) {
-            LOG(DEBUG, "Updating SSID config");
-            AsyncWebParameter* ssid_param = request->getParam(ssid_key, true);
-            AsyncWebParameter* password_param = request->getParam(wifi_password_key, true);
+            LOG(ELOG_LEVEL_DEBUG, "Updating SSID config");
+            const AsyncWebParameter* ssid_param = request->getParam(ssid_key, true);
+            const AsyncWebParameter* password_param = request->getParam(wifi_password_key, true);
             prefs.putString(ssid_key, ssid_param->value().c_str());
             prefs.putString(wifi_password_key, password_param->value().c_str());
 
         } else {
             request->send(400, "text/plain", "Missing parameters"); // TODO add proper error messages
         }
-        request->send(SPIFFS, "/settings.html", "text/html", false, processor); // TODO add proper return templating
+        request->send(LittleFS, "/settings.html", "text/html", false, processor); // TODO add proper return templating
     });
 
     server.on("/update_sensor_settings", HTTP_POST, [](AsyncWebServerRequest* request) {
         int params = request->params();
 
         if (request->hasParam(level_sensor_range_key, true) && request->hasParam(water_level_min_key, true) && request->hasParam(water_level_max_key, true) && request->hasParam(water_volume_key, true)) {
-            LOG(DEBUG, "Updating Sensor config");
-            AsyncWebParameter* range_param = request->getParam(level_sensor_range_key, true);
-            AsyncWebParameter* level_min_param = request->getParam(water_level_min_key, true);
-            AsyncWebParameter* level_max_param = request->getParam(water_level_max_key, true);
-            AsyncWebParameter* liters_param = request->getParam(water_volume_key, true);
+            LOG(ELOG_LEVEL_DEBUG, "Updating Sensor config");
+            const AsyncWebParameter* range_param = request->getParam(level_sensor_range_key, true);
+            const AsyncWebParameter* level_min_param = request->getParam(water_level_min_key, true);
+            const AsyncWebParameter* level_max_param = request->getParam(water_level_max_key, true);
+            const AsyncWebParameter* liters_param = request->getParam(water_volume_key, true);
 
             String range_str = range_param->value();
             String level_min_str = level_min_param->value();
@@ -138,151 +125,76 @@ void setup()
             float level_max_float = level_max_str.toFloat();
             float liters_float = liters_str.toFloat();
 
-            const char* paramCStr = range_str.c_str();
-            char* endPtr;
-
-            // Convert the C string to a float using strtod
-            float value = strtod(paramCStr, &endPtr);
-
-            LOG(DEBUG, "range_float:%D:", range_float);
+            LOG(ELOG_LEVEL_DEBUG, "range_float:%D:", range_float);
 
             prefs.putFloat(level_sensor_range_key, range_float);
             prefs.putFloat(water_level_min_key, level_min_float);
             prefs.putFloat(water_level_max_key, level_max_float);
             prefs.putFloat(water_volume_key, liters_float);
 
-            LOG(DEBUG, "range_float_after:%D:", prefs.getFloat(level_sensor_range_key, -1.0));
+            LOG(ELOG_LEVEL_DEBUG, "range_float_after:%D:", prefs.getFloat(level_sensor_range_key, -1.0));
         } else {
-            LOG(DEBUG, "!!!! FAIL lo");
+            LOG(ELOG_LEVEL_DEBUG, "!!!! FAIL lo");
             for (int i = 0; i < params; i++) {
-                AsyncWebParameter* p = request->getParam(i);
+                const AsyncWebParameter* p = request->getParam(i);
                 if (p->isFile()) { // p->isPost() is also true
-                    LOG(DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
+                    LOG(ELOG_LEVEL_DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
                 } else if (p->isPost()) {
-                    LOG(DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
+                    LOG(ELOG_LEVEL_DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
                 } else {
-                    LOG(DEBUG, "GET[%s]: %s\n", p->name().c_str(), p->value().c_str());
+                    LOG(ELOG_LEVEL_DEBUG, "GET[%s]: %s\n", p->name().c_str(), p->value().c_str());
                 }
             }
             request->send(400, "text/plain", "Missing parameters"); // TODO add proper error messages
         }
-        request->send(SPIFFS, "/settings.html", "text/html", false); // TODO add proper return templating
+        request->send(LittleFS, "/settings.html", "text/html", false); // TODO add proper return templating
     });
     
     setup_api_endpoints();
-    display_error_code(23);
     webSocket.onEvent(onWsEvent);
     server.addHandler(&webSocket);
 
+    server.on("/chota.css", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/chota.css", "text/css", false); });
+    server.on("/gauge.js", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/gauge.js", "application/javascript", false); });
 
 
-    server.on("/chota.css", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/chota.css", "text/css", false); });
-    server.on("/gauge.js", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/gauge.js", "application/javascript", false); });
-
-    display_error_code(24);
-
-    LOG(DEBUG, "OTA Setup");
+    LOG(ELOG_LEVEL_DEBUG, "OTA Setup");
     ArduinoOTA
         .onStart([]() {
-      String type;
-      if (ArduinoOTA.getCommand() == U_FLASH)
-        type = "sketch";
-      else // U_SPIFFS
-        type = "filesystem";
+            String type;
+            if (ArduinoOTA.getCommand() == U_FLASH)
+                type = "sketch";
+            else // U_SPIFFS
+                type = "filesystem";
 
-      // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
-      LOG(DEBUG, "Start updating %s", type); })
-        .onEnd([]() { LOG(DEBUG, "\nEnd"); })
+            // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
+            LOG(ELOG_LEVEL_DEBUG, "Start updating %s", type); })
+        .onEnd([]() { LOG(ELOG_LEVEL_DEBUG, "\nEnd"); })
         .onProgress([](unsigned int progress, unsigned int total) { Serial.printf("Progress: %u%%\r", (progress / (total / 100))); })
         .onError([](ota_error_t error) {
       Serial.printf("Error[%u]: ", error);
-      if (error == OTA_AUTH_ERROR) LOG(DEBUG, "Auth Failed");
-      else if (error == OTA_BEGIN_ERROR) LOG(DEBUG, "Begin Failed");
-      else if (error == OTA_CONNECT_ERROR) LOG(DEBUG, "Connect Failed");
-      else if (error == OTA_RECEIVE_ERROR) LOG(DEBUG, "Receive Failed");
-      else if (error == OTA_END_ERROR) LOG(DEBUG, "End Failed"); });
+      if (error == OTA_AUTH_ERROR) LOG(ELOG_LEVEL_DEBUG, "Auth Failed");
+      else if (error == OTA_BEGIN_ERROR) LOG(ELOG_LEVEL_DEBUG, "Begin Failed");
+      else if (error == OTA_CONNECT_ERROR) LOG(ELOG_LEVEL_DEBUG, "Connect Failed");
+      else if (error == OTA_RECEIVE_ERROR) LOG(ELOG_LEVEL_DEBUG, "Receive Failed");
+      else if (error == OTA_END_ERROR) LOG(ELOG_LEVEL_DEBUG, "End Failed"); });
 
-    display_error_code(26);
-    digitalWrite(LED_RED, 0);
-
-    // Starting bootup sequence
 
+    LOG(ELOG_LEVEL_DEBUG, "Starting main tasks");
     xTaskCreate(ethernet_task, "EthernetTask", 4096, NULL, 1, NULL);
-
-    // Create Etnernet task and wait a second to see if there is connection
-    LOG(DEBUG, "Started Ethernet, waiting");
-    delay(2000);
-
-    if (ETH.linkUp()){
-        LOG(DEBUG, "Ethernet connected, starting update checker");
-        xTaskCreate(check_update_task, "CheckUpdateTask", 1024 * 8, NULL, 1, NULL);
-    } else {
-        LOG(DEBUG, "Ethernet not connected, starting update checker and WiFi Task");
-        xTaskCreate(wifi_task, "WiFiTask", 10000, NULL, 1, NULL);
-        xTaskCreate(check_update_task, "CheckUpdateTask", 1024 * 8, NULL, 1, NULL);
-        delay(2000);
-    }
-    
-    LOG(DEBUG, "Getting time now");
-    // Configure time to UTC
-    configTime(0, 0, "pool.ntp.org");
-    
-    // Wait until a valid time is obtained (time > 8 hours in seconds)
-    time_t now = time(NULL);
-    struct tm timeinfo;
-    int retry = 0;
-    while (now < 8 * 3600 && retry < 10) {
-        if(!getLocalTime(&timeinfo)){
-            Serial.println("Failed to obtain time");
-          }
-          Serial.println(&timeinfo, "%A, %B %d %Y %H:%M:%S");
-        retry++;
-    }
-
-    
-    getLocalTime(&timeinfo);
-
-      // Sanity check: Ensure the year is at least 2020.
-    int currentYear = timeinfo.tm_year + 1900;  // tm_year is years since 1900
-    if (currentYear < 2020) {
-        LOG(DEBUG, "Time not set properly: ");
-    } else {
-        LOG(DEBUG, "Time is valid: %s", asctime(&timeinfo));
-    }
-
-    // Setup syslog
-    logger.configureSyslog("192.168.6.11", 5514, "esp32");
-    logger.registerSyslog(MYLOG, DEBUG, FAC_USER, "waterlevel");
-    LOG(ERROR, "Here is an error message, error code: %d", 17);
-
-
-    
-
-    LOG(DEBUG, "Starting webserver");
-    server.begin();
-    ArduinoOTA.begin();
-    display_error_code(25);
-
-    xTaskCreate(display_task, "DisplayTask", 10000, NULL, 1, NULL);
+    xTaskCreate(wifi_task, "WiFiTask", 10000, NULL, 1, NULL);
     xTaskCreate(read_sensor_task, "ReadSensorTask", 1024 * 4, NULL, 1, NULL);
     xTaskCreate(collect_internal_telemetry_task, "InternalTelemetryTask", 2048, NULL, 1, NULL);
+    xTaskCreate(display_task, "DisplayTask", 10000, NULL, 1, NULL);
+    xTaskCreate(get_time_task, "GetTimeTask", 1024 * 4, NULL, 1, NULL);
 
-    // Wait until there is network connection
-    while (true) {
-        if (WiFi.status() == WL_CONNECTED || ETH.localIP()) {
-            int pingResult = Ping.ping("8.8.8.8"); // Use Google's public DNS server as a test IP
-            if (pingResult >= 0) {
-                LOG(DEBUG, "Network connection established");
-                break;
-            } else {
-                LOG(DEBUG, "Network not ready, retrying...");
-            }
-        } else {
-            LOG(DEBUG, "No WiFi or Ethernet connection, retrying...");
-        }
-        delay(1000); // Delay to prevent rapid retry
-    }
-    
+    delay(5000);
+    xTaskCreate(check_update_task, "CheckUpdateTask", 1024 * 8, NULL, 1, NULL);
+
+    LOG(ELOG_LEVEL_DEBUG, "Starting webserver");
+    server.begin();
+    LOG(ELOG_LEVEL_DEBUG, "Starting OTA handler");
+    ArduinoOTA.begin();
 }
 
 

src/networking/json_builder.cpp

@@ -27,6 +27,7 @@ StaticJsonDocument<128> build_telemetry_json(DeviceTelemetry data) {
     StaticJsonDocument<128> doc;
     doc["uptime_seconds"] = data.uptime_seconds;
     doc["heap_percent"] = data.heap_used_percent;
+    doc["temperature"] = data.temperature;
     return doc;
 }
 

src/networking/networking.cpp

@@ -1,11 +1,20 @@
 #include <Elog.h>
-#include <ETH.h>
 #include <WiFi.h>
 #include "../global_data/defines.h"
 #include <Preferences.h>
 #include "../global_data/global_data.h"
 #include <tools/log.h>
 
+#define ETH_PHY_TYPE ETH_PHY_LAN8720
+#define ETH_PHY_ADDR  0
+#define ETH_PHY_MDC   23
+#define ETH_PHY_MDIO  18
+#define ETH_PHY_POWER 14
+#define ETH_CLK_MODE  ETH_CLOCK_GPIO0_IN
+
+
+#include <ETH.h>
+
 int64_t mac_address = ESP.getEfuseMac();
 uint8_t failed_connection_attempts = 0;
 
@@ -13,6 +22,7 @@ extern NetworkData wifi_data;
 extern NetworkData ethernet_data;
 extern Preferences prefs;
 
+// Defines the type of connection for which the hostname should be created
 enum HostnameType {
     Wireless,
     Ethernet,
@@ -28,28 +38,28 @@ const char * get_hostname(HostnameType host_type) {
         return (hostname + "-wl").c_str();
     case Ethernet:
         return (hostname + "-eth").c_str();
-    case Generic:
+    default:
         return hostname.c_str();
     }
 }
 
 void wifi_task(void* parameter)
 {
-    LOG(DEBUG, "Starting WiFi Task");
+    LOG(ELOG_LEVEL_DEBUG, "Starting WiFi Task");
     WiFi.setHostname(get_hostname(Wireless));
     while (true) {
         if (prefs.getString(ssid_key, "") == "" || failed_connection_attempts > 5) {
             wifi_data.link = false;
             if (failed_connection_attempts > 5) {
-                LOG(DEBUG, "Failed to connecto to currently saved SSID, starting SoftAP");
+                LOG(ELOG_LEVEL_WARNING, "Failed to connect to currently saved SSID, starting SoftAP");
             } else {
-                LOG(DEBUG, "No SSID saved, starting SoftAP");
+                LOG(ELOG_LEVEL_WARNING, "No SSID saved, starting SoftAP");
             }
 
             String ap_ssid = get_hostname(Wireless);
-            WiFi.softAP(ap_ssid, "");
+            WiFi.softAP(ap_ssid.c_str(), "");
 
-            LOG(DEBUG, "[WIFI_TASK] Waiting for SSID now...");
+            LOG(ELOG_LEVEL_DEBUG, "Waiting for SSID now...");
 
             String old_ssid = prefs.getString(ssid_key, "xxx");
             while (prefs.getString(ssid_key, "") == "" || prefs.getString(ssid_key, "") == old_ssid) {
@@ -64,15 +74,16 @@ void wifi_task(void* parameter)
                 wifi_data.link = true;
                 wifi_data.network_name = WiFi.SSID();
                 wifi_data.ip_address = WiFi.localIP().toString();
-
-                LOG(DEBUG, "RSSI: %F, IP Address, %p, SSID: %s", float(WiFi.RSSI()), WiFi.localIP(), prefs.getString(ssid_key, "NOSSID"));
-                Serial.println(WiFi.channel());
-                delay(5000);
+                LOG(ELOG_LEVEL_DEBUG, "WIFI connected; RSSI: %F, IP Address, %s, SSID: %s", float(WiFi.RSSI()), WiFi.localIP().toString(), prefs.getString(ssid_key, "NOSSID"));
+                delay(1000 * 60);
             } else {
-                LOG(DEBUG, "Connecting to %s using password %s", prefs.getString(ssid_key, ""), prefs.getString(wifi_password_key, ""));
+                String ssid = prefs.getString(ssid_key, "");
+                String password = prefs.getString(wifi_password_key, "");
+                LOG(ELOG_LEVEL_DEBUG, "Connecting to %s...", ssid);
                 WiFi.mode(WIFI_STA);
-                WiFi.begin(prefs.getString(ssid_key, ""), prefs.getString(wifi_password_key, ""));
+                WiFi.begin(ssid, password);
                 failed_connection_attempts++;
+                LOG(ELOG_LEVEL_WARNING, "Failed to connect, retrying...");
                 delay(5000);
             }
         }
@@ -81,15 +92,20 @@ void wifi_task(void* parameter)
 
 void ethernet_task(void* parameter)
 {
-    LOG(DEBUG, "Connecting Ethernet");
-    ETH.begin(0, 17, 23, 18);
+    LOG(ELOG_LEVEL_DEBUG, "Starting Ethernet Task");
+    ETH.begin();
     ETH.setHostname(get_hostname(Ethernet));
     while (true) {
         ethernet_data.link = ETH.linkUp();
         ethernet_data.rssi = ETH.linkSpeed();
         ethernet_data.ip_address = ETH.localIP().toString();
-        Serial.println( ETH.localIP().toString());
-        LOG(DEBUG, "Ethernet RSSI: %F, IP Address, %s, LINK: %s", float(ethernet_data.rssi), ETH.localIP().toString().c_str(), String(ethernet_data.link));
+        LOG(ELOG_LEVEL_DEBUG, "Ethernet RSSI: %F, IP Address, %s, LINK: %s", float(ethernet_data.rssi), ETH.localIP().toString(), String(ethernet_data.link));
+        
+        if (ETH.linkUp() && !ETH.isDefault() && ETH.localIP().toString() != "0.0.0.0") {
+            LOG(ELOG_LEVEL_DEBUG, "Ethernet is up, setting to default");
+            ETH.setDefault();
+        }
+
         delay(60 * 1000);
     }
 }

src/networking/responses.cpp

@@ -51,7 +51,7 @@ void setup_api_endpoints(){
         request->send(200, "application/json", output);
     });
 
-    server.on("/ota_udpate_status", HTTP_GET, [](AsyncWebServerRequest* request) {
+    server.on("/ota_update_status", HTTP_GET, [](AsyncWebServerRequest* request) {
       String output;
       serializeJson(build_ota_json(ota_status), output);
       request->send(200, "application/json", output);
@@ -70,7 +70,7 @@ void setup_api_endpoints(){
         .ota_status = ota_status
       };
 
-      xTaskCreate(run_ota_update_task, "RunOTAUpdate", 1024 * 8, (void *)&args, 1, NULL);
-      request->send(SPIFFS, "/update_progress.html", "text/html", false, processor);
+      xTaskCreate(run_ota_update_task, "RunOTAUpdate", 1024 * 12, (void *)&args, 1, NULL);
+      request->send(LittleFS, "/update_progress.html", "text/html", false, processor);
     });
 }

src/networking/responses.h

@@ -1,3 +1,4 @@
 #include <ESPAsyncWebServer.h>
+#include <LittleFS.h>
 
 void setup_api_endpoints();

src/sensor/sensor.cpp

@@ -26,13 +26,15 @@ extern SensorData shunt_data;
 float zero_value = 0.03; // Measured shunt voltage with nothing connected, used to fix measuring offset
 
 void init_sensor(){
-    ina_sensor.begin(33, 32);
     #ifdef USE_INA226
+        Wire.begin(33, 32);
+        ina_sensor.begin();
         ina_sensor.setMaxCurrentShunt(0.02, 4, false);
         ina_sensor.setBusVoltageConversionTime(7);
         ina_sensor.setShuntVoltageConversionTime(7);
         ina_sensor.setAverage(4);
     #else
+        ina_sensor.begin(33, 32);
         ina_sensor.reset();
         ina_sensor.setShuntVoltageConversionTime(conversion_time_8244uS);
         ina_sensor.setBusVoltageConversionTime(conversion_time_8244uS);
@@ -43,17 +45,18 @@ void init_sensor(){
 
 void read_sensor_task(void* parameter)
 {
+    LOG(ELOG_LEVEL_DEBUG, "Starting read sensor tasks");
     while (true) {
         // Get Values from sensor
         #ifndef USE_INA226
         String chip_id = ina_sensor.get_device_model();
-        LOG(DEBUG, "Chip Model: %s", chip_id.c_str());
+        LOG(ELOG_LEVEL_DEBUG, "Chip Model: %s", chip_id.c_str());
         #endif
 
         float bus_voltage = ina_sensor.getBusVoltage();
         float shunt_voltage = ina_sensor.getShuntVoltage_mV() - zero_value;
 
-        LOG(DEBUG, "RAW Shunt voltage: %F mV", ina_sensor.getShuntVoltage_mV());
+        LOG(ELOG_LEVEL_DEBUG, "RAW Shunt voltage: %F mV", ina_sensor.getShuntVoltage_mV());
 
         float shunt_current = shunt_voltage / RESISTOR_VALUE;
         
@@ -73,8 +76,8 @@ void read_sensor_task(void* parameter)
         float min_water_level_mA = 4 + min_water_level_mA_over_zero;
         float max_water_level_mA = 4 + max_water_level_mA_over_zero;
 
-        LOG(DEBUG, "max_water_level_mA: %F", max_water_level_mA);
-        LOG(DEBUG, "min_water_level_mA_over_zero: %F", min_water_level_mA_over_zero);
+        LOG(ELOG_LEVEL_DEBUG, "max_water_level_mA: %F", max_water_level_mA);
+        LOG(ELOG_LEVEL_DEBUG, "min_water_level_mA_over_zero: %F", min_water_level_mA_over_zero);
 
         // Current over the 0 level of the water
         float shunt_current_over_zero = shunt_current - min_water_level_mA;
@@ -94,10 +97,10 @@ void read_sensor_task(void* parameter)
         active_errors.current_high = shunt_current > 20.2;
         active_errors.voltage_low = bus_voltage < 23;
         active_errors.voltage_high = bus_voltage > 25;
-        LOG(DEBUG, "Shunt current: %F", shunt_current);
-        LOG(DEBUG, "Shunt voltage: %F", shunt_voltage);
-        LOG(DEBUG, "Bus voltage: %F", bus_voltage);
-        LOG(DEBUG, "cm_over_zero: %F", cm_over_zero);
+        LOG(ELOG_LEVEL_DEBUG, "Shunt current: %F", shunt_current);
+        LOG(ELOG_LEVEL_DEBUG, "Shunt voltage: %F", shunt_voltage);
+        LOG(ELOG_LEVEL_DEBUG, "Bus voltage: %F", bus_voltage);
+        LOG(ELOG_LEVEL_DEBUG, "cm_over_zero: %F", cm_over_zero);
 
         shunt_data.bus_voltage =  bus_voltage;
         shunt_data.shunt_voltage = shunt_voltage;

src/telemetry/telemetry.cpp

@@ -1,17 +1,22 @@
 #include "telemetry.h"
 #include <Arduino.h>
 #include "../global_data/global_data.h"
+#include "tools/log.h"
+
+extern "C" uint8_t temprature_sens_read();
 
 extern DeviceTelemetry telemetry;
 
 void collect_internal_telemetry_task(void* parameter)
 {
+    LOG(ELOG_LEVEL_DEBUG, "Starting internal telemetry tasks");
     while (true) {
         float heap_usage = (float(ESP.getFreeHeap()) / float(ESP.getHeapSize())) * 100;
         uint64_t uptime_seconds = millis() / 1000;
 
         telemetry.heap_used_percent = heap_usage;
         telemetry.uptime_seconds = uptime_seconds;
+        telemetry.temperature = (temprature_sens_read()-32) / 1.8;
         delay(60000);
     }
 }

src/tools/log.h

@@ -1,9 +1,10 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
+#include <Elog.h>
 
 #define LOG(LEVEL, FMT, ...) \
     do { \
-        logger.log(0, LEVEL, "[Core: %i][Task: %s][%s] " FMT, \
+        Logger.log(0, LEVEL, "[Core: %i][Task: %s][Fn: %s] " FMT, \
                    xPortGetCoreID(), \
                    pcTaskGetName(xTaskGetCurrentTaskHandle()), \
                    __FUNCTION__, \

src/tools/tools.cpp

@@ -6,6 +6,14 @@
 #include <fetchOTA.h>
 #include <AsyncWebSocket.h>
 #include "log.h"
+#include "esp_sntp.h"
+#include <HTTPClient.h>
+
+#ifdef USE_INA226
+  #define BOARD_VARIANT "INA226REV2"
+#else
+  #define BOARD_VARIANT "INA233REV2"
+#endif
 
 extern Preferences prefs;
 extern OTAStatus ota_status;
@@ -36,12 +44,12 @@ String processor(const String& var)
 
 // OTA Callbacks
 void update_started() {
-  LOG(DEBUG, "OTA Update started");
+  LOG(ELOG_LEVEL_DEBUG, "OTA Update started");
   ota_status.update_progress = 0;
 }
 
 void update_finished() {
-  LOG(DEBUG, "OTA Update finished");
+  LOG(ELOG_LEVEL_DEBUG, "OTA Update finished");
   ota_status.update_progress = -1;
   webSocket.textAll(String(-1).c_str());
 }
@@ -50,80 +58,106 @@ void update_progress(int cur, int total) {
   ota_status.update_progress = 0;
   if (cur != 0 ) {
     ota_status.update_progress = int(float(cur)/float(total)*100);
-    LOG(DEBUG, "OTA Update progress: %d/%d, %i", cur, total, ota_status.update_progress);
+    LOG(ELOG_LEVEL_DEBUG, "OTA Update progress: %d/%d, %i", cur, total, ota_status.update_progress);
   }
   webSocket.textAll(String(ota_status.update_progress).c_str());
-  LOG(DEBUG, "OTA Update progress: %d/%d", cur, total);
+  LOG(ELOG_LEVEL_DEBUG, "OTA Update progress: %d/%d", cur, total);
 }
 
 void update_error(int err) {
-  LOG(ERROR, "OTA Update error: %d", err);
-  ota_status.update_progress = -2;
+  LOG(ELOG_LEVEL_ERROR, "OTA Update error: %d", err);
+  ota_status.update_progress = -1;
 }
 
 void check_update_task(void* parameter) {
+  LOG(ELOG_LEVEL_DEBUG, "Starting check Update Task");
   ota_status.current_version = current_software_version;
   ota_status.update_progress = -1;
-  #ifdef USE_INA226
-  OTA ota("https://iot.tobiasmaier.me/firmware/waterlevel", current_software_version, "INA226");
-  #else
-  OTA ota("https://iot.tobiasmaier.me/firmware/waterlevel", current_software_version, "INA233");
-  #endif
-  OTA spiffs_fs("https://iot.tobiasmaier.me/filesystem/waterlevel", REQUIRED_SPIFFS_VERSION, "generic");
-  
-
-  // Init SPIFFS update and check for update
-  // If there is a SPIFSS update it will be ran automatically, as SPIFFS is necessary for the firmware to run
-  Firmware latest_spiff_version = spiffs_fs.getLatestVersionOnServer();
-
-  LOG(DEBUG, "Required SPIFFS Version: %d.%d.%d; Current SPIFFS version: %d.%d.%d; Server SPIFFS Version: %d.%d.%d", REQUIRED_SPIFFS_VERSION.major, REQUIRED_SPIFFS_VERSION.minor, REQUIRED_SPIFFS_VERSION.patch, current_spiffs_version.major, current_spiffs_version.minor, current_spiffs_version.patch, latest_spiff_version.version.major, latest_spiff_version.version.minor, latest_spiff_version.version.patch);
-
-  if (latest_spiff_version.valid) {
-    if (isVersionNewer(current_spiffs_version, REQUIRED_SPIFFS_VERSION)) {
-      // If Required SPIFFS version is newer than current version, update
-      LOG(DEBUG, "New SPIFFS version, running update now");
-      run_ota_spiffs_update(latest_spiff_version.url, update_started, update_finished, update_progress, update_error);
-      // Reboot just to be safe
-      ESP.restart();
-    } else if (isVersionNewer(REQUIRED_SPIFFS_VERSION, latest_spiff_version.version)) {
-      // If Server has new SPIFFS version but it's not required
-      LOG(DEBUG, "New SPIFFS version available: %d.%d.%d, current version: %d.%d.%d but not necessary to update", latest_spiff_version.version.major, latest_spiff_version.version.minor, latest_spiff_version.version.patch, REQUIRED_SPIFFS_VERSION.major, REQUIRED_SPIFFS_VERSION.minor, REQUIRED_SPIFFS_VERSION.patch);
-    } else {
-      LOG(DEBUG, "No new SPIFFS version available");
-    }
-  }
 
+  OTA ota("https://iot.tobiasmaier.me/firmware/waterlevel", current_software_version, BOARD_VARIANT);
+  OTA littlefs_ota("https://iot.tobiasmaier.me/filesystem/waterlevel", REQUIRED_SPIFFS_VERSION, "generic");
 
   while (true) {
-    Firmware fw = ota.getLatestVersionOnServer();
-    if (fw.valid) {
-      LOG(DEBUG, "New firmware available: %d.%d.%d, current version: %d.%d.%d", fw.version.major, fw.version.minor, fw.version.patch, current_software_version.major, current_software_version.minor, current_software_version.patch);
-      ota_status.latest_version = fw.version;
-      ota_status.update_url = fw.url;
-      if (isVersionNewer(current_software_version, fw.version)) {
-        LOG(DEBUG, "Remote version is newer than current version");
-        ota_status.update_available = true;
-      } else {
-        ota_status.update_available = false;
-      }
+      // Check if internet connection exists before running update, the web client seems to fail otherwise
+    
+    if (check_for_internet_connection()) {
+      LOG(ELOG_LEVEL_DEBUG, "Ping sucessful, starting update checks");
+      check_and_update_littleFS(littlefs_ota);
+      check_and_update_firmware(ota);
     } else {
-      if (fw.version.major != 0 && fw.version.minor != 0 && fw.version.patch != 0) {
-        ota_status.latest_version = fw.version;
-        ota_status.update_available = false;
-      }
-      
-      LOG(DEBUG, "No new firmware available");
+      LOG(ELOG_LEVEL_WARNING, "Server did not respond to ping, waiting...");
     }
     delay(1000 * 60 * 1);
   }
 }
 
+void check_and_update_littleFS(OTA littlefs) {
+  Firmware latest_fs_version = littlefs.getLatestVersionOnServer();
 
+  LOG(ELOG_LEVEL_DEBUG, "Required SPIFFS Version: %d.%d.%d; Current SPIFFS version: %d.%d.%d; Server SPIFFS Version: %d.%d.%d", REQUIRED_SPIFFS_VERSION.major, REQUIRED_SPIFFS_VERSION.minor, REQUIRED_SPIFFS_VERSION.patch, current_spiffs_version.major, current_spiffs_version.minor, current_spiffs_version.patch, latest_fs_version.version.major, latest_fs_version.version.minor, latest_fs_version.version.patch);
+
+  if (latest_fs_version.valid) {
+
+    // If we need new version and the server has a new version
+    if (isVersionNewer(current_spiffs_version, REQUIRED_SPIFFS_VERSION) && isVersionNewer(current_spiffs_version, latest_fs_version.version)) {
+      LOG(ELOG_LEVEL_DEBUG, "New SPIFFS version, running update now");
+      run_ota_spiffs_update(latest_fs_version.url, update_started, update_finished, update_progress, update_error);
+      ESP.restart();
+
+    // If we do not need a new version but one is available on the server
+    } else if (isVersionNewer(REQUIRED_SPIFFS_VERSION, latest_fs_version.version)) {
+      LOG(ELOG_LEVEL_DEBUG, "New SPIFFS version available: %d.%d.%d, current version: %d.%d.%d but not necessary to update", latest_fs_version.version.major, latest_fs_version.version.minor, latest_fs_version.version.patch, REQUIRED_SPIFFS_VERSION.major, REQUIRED_SPIFFS_VERSION.minor, REQUIRED_SPIFFS_VERSION.patch);
+    
+    // If we need a new version but server has no new version
+    } else if (isVersionNewer(current_spiffs_version, REQUIRED_SPIFFS_VERSION)) {
+      LOG(ELOG_LEVEL_ERROR, "New LittleFS Version is needed, but not found on server");
+
+    // Catch case for the rest
+    } else {
+      LOG(ELOG_LEVEL_DEBUG, "No new SPIFFS version available");
+    }
+  }
+}
+
+void check_and_update_firmware(OTA ota){
+  Firmware fw = ota.getLatestVersionOnServer();
+  if (fw.valid) {
+    LOG(ELOG_LEVEL_DEBUG, "Firmware available on server: %d.%d.%d, current version: %d.%d.%d", fw.version.major, fw.version.minor, fw.version.patch, current_software_version.major, current_software_version.minor, current_software_version.patch);
+    ota_status.latest_version = fw.version;
+    ota_status.update_url = fw.url;
+    if (isVersionNewer(current_software_version, fw.version)) {
+      LOG(ELOG_LEVEL_DEBUG, "Remote version is newer than current version");
+      ota_status.update_available = true;
+    } else {
+      ota_status.update_available = false;
+    }
+  } else {
+    if (fw.version.major != 0 && fw.version.minor != 0 && fw.version.patch != 0) {
+      ota_status.latest_version = fw.version;
+      ota_status.update_available = false;
+    }
+    
+    LOG(ELOG_LEVEL_DEBUG, "No new firmware available");
+  }
+}
+
+bool check_for_internet_connection() {
+  HTTPClient http;
+  http.begin("https://iot.tobiasmaier.me");
+  int code = http.sendRequest("HEAD");
+  if (code > 0) {
+    return true;
+  } else {
+    return false;
+  }
+}
 
 void run_ota_update_task(void* parameter) {
   TaskArgs_t *args = (TaskArgs_t *) parameter;
-  LOG(DEBUG, "Running OTA upgrade now with URL: %s", args->ota_status.update_url.c_str());
-  run_ota_update(args->ota_status.update_url, update_started, update_finished, update_progress, update_error);
+  LOG(ELOG_LEVEL_DEBUG, "Running OTA upgrade now with URL: %s", args->ota_status.update_url.c_str());
+  String ota_url = args->ota_status.update_url;
+  Serial.println(ota_url);
+  run_ota_update(ota_url, update_started, update_finished, update_progress, update_error);
   vTaskDelete(NULL);
 }
 
@@ -138,3 +172,36 @@ void onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventTyp
   }
 }
 
+void get_time_task(void* parameter) {
+  LOG(ELOG_LEVEL_DEBUG, "Starting GetTimeTask");
+  LOG(ELOG_LEVEL_DEBUG, "Trying to get time from Internet");
+
+  sntp_set_time_sync_notification_cb(onTimeSync);
+  sntp_set_sync_mode(SNTP_SYNC_MODE_SMOOTH);
+  sntp_set_sync_interval(1000 * 60 * 60); //re-sync every hour
+  configTzTime("UTC0", "pool.ntp.org", "1.europe.pool.ntp.org", " time.Windows.com");
+  waitForTime();
+  vTaskDelete(NULL);
+}
+
+// Time stuff
+
+// Handler to handle successful time sync
+void onTimeSync(struct timeval* tv) {
+  struct tm timeinfo;
+  getLocalTime(&timeinfo);
+  LOG(ELOG_LEVEL_DEBUG, "Time synchronized. New Time: %s", asctime(&timeinfo));
+}
+
+// wait for succesful time sync
+bool waitForTime() {
+  time_t now;
+  do {
+    time(&now);
+    if (now > 8 * 3600) break;
+    delay(500);
+    LOG(ELOG_LEVEL_WARNING, "No valid time.");
+  } while (true);
+  LOG(ELOG_LEVEL_DEBUG, "Found valid time.");
+  return true;
+}

src/tools/tools.h

@@ -11,6 +11,13 @@ String processor(const String& var);
 void check_update_task(void* parameter);
 void run_ota_update_task(void* parameter);
 void onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type,void *arg, uint8_t *data, size_t len);
+void get_time_task(void* parameter);
+
+void onTimeSync(struct timeval* tv);
+bool waitForTime();
+void check_and_update_firmware(OTA fw);
+void check_and_update_littleFS(OTA littlefs);
+bool check_for_internet_connection();
 
 typedef struct {
     OTAStatus ota_status;

upload.sh

@@ -0,0 +1,3 @@
+pio run -t upload  -e ESP32_INA226 --upload-port 192.168.6.45
+pio run -t upload  -e ESP32_INA226 --upload-port 192.168.6.47
+pio run -t upload  -e ESP32_INA226 --upload-port 192.168.6.49