Merge pull request 'rev2' (#3) from rev2 into main

Reviewed-on: #3

.vscode/extensions.json

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

data/version

@@ -1 +1 @@
-10
+9

lib/fetchOTA/fetchOTA.cpp

@@ -6,7 +6,6 @@
 #include <ArduinoJson.h>
 #include <HTTPClient.h>
 #include <WiFiClient.h>
-#include <WiFiClientSecure.h>
 #include <vector>
 #include <Elog.h>
 #include <HTTPUpdate.h>
@@ -98,11 +97,11 @@ void run_ota_update(String url, std::function<void()> callback_started,  std::fu
     httpUpdate.onError(callback_error);
     Logger.log(0, ELOG_LEVEL_DEBUG, "Defined callbacks, Starting update now");
 
-    t_httpUpdate_return ret = HTTP_UPDATE_FAILED;
+    t_httpUpdate_return ret;
 
     if (url.startsWith("https")) {
         Logger.log(0, ELOG_LEVEL_DEBUG, "HTTPS URL");
-        WiFiClientSecure client;
+        WiFiClient client;
         // client.setInsecure();
         ret = httpUpdate.update(client, url);
     } else if (url.startsWith("http")) {
@@ -111,20 +110,15 @@ void run_ota_update(String url, std::function<void()> callback_started,  std::fu
         ret = httpUpdate.update(client, url);
     } else {
         Logger.log(0, ELOG_LEVEL_ERROR, "URL is not valid: \n%s", url.c_str());
-        if (callback_error) callback_error(-1);
-        return;
     }
 
     switch (ret) {
         case HTTP_UPDATE_FAILED:
             Logger.log(0, ELOG_LEVEL_ERROR, "HTTP_UPDATE_FAILED Error (%d): %s\n", httpUpdate.getLastError(), httpUpdate.getLastErrorString().c_str());
-            // Don't restart ESP on HTTP errors, just return
-            if (callback_error) callback_error(httpUpdate.getLastError());
             break;
   
         case HTTP_UPDATE_NO_UPDATES:
             Logger.log(0, ELOG_LEVEL_ERROR, "HTTP_UPDATE_NO_UPDATES");
-            if (callback_error) callback_error(-2);
             break;
   
         case HTTP_UPDATE_OK:
@@ -142,12 +136,12 @@ void run_ota_spiffs_update(String url, std::function<void()> callback_started,
     httpUpdate.onError(callback_error);
     Logger.log(0, ELOG_LEVEL_DEBUG, "Defined callbacks, Starting update now");
 
-    t_httpUpdate_return ret = HTTP_UPDATE_FAILED;
+    t_httpUpdate_return ret;
 
     if (url.startsWith("https")) {
         Logger.log(0, ELOG_LEVEL_DEBUG, "HTTPS URL");
-        WiFiClientSecure client;
+        WiFiClient client;
-        client.setInsecure();
+        // client.setInsecure();
         ret = httpUpdate.updateSpiffs(client, url);
     } else if (url.startsWith("http")) {
         Logger.log(0, ELOG_LEVEL_DEBUG, "HTTP URL");
@@ -155,20 +149,15 @@ void run_ota_spiffs_update(String url, std::function<void()> callback_started,
         ret = httpUpdate.updateSpiffs(client, url);
     } else {
         Logger.log(0, ELOG_LEVEL_ERROR, "URL is not valid: \n%s", url.c_str());
-        if (callback_error) callback_error(-1);
-        return;
     }
 
     switch (ret) {
         case HTTP_UPDATE_FAILED:
             Logger.log(0, ELOG_LEVEL_ERROR, "HTTP_UPDATE_FAILED Error (%d): %s\n", httpUpdate.getLastError(), httpUpdate.getLastErrorString().c_str());
-            // Don't restart ESP on HTTP errors, just return
-            if (callback_error) callback_error(httpUpdate.getLastError());
             break;
   
         case HTTP_UPDATE_NO_UPDATES:
             Logger.log(0, ELOG_LEVEL_ERROR, "HTTP_UPDATE_NO_UPDATES");
-            if (callback_error) callback_error(-2);
             break;
   
         case HTTP_UPDATE_OK:

platformio.ini

@@ -34,8 +34,8 @@ extends = env:esp32_base
 lib_deps = 
 	${env:esp32_base.lib_deps}
 	INA233
-; upload_protocol = espota
+upload_protocol = espota
-; upload_port = 192.168.18.18
+upload_port = 192.168.5.205
 
 [env:ESP32_INA226]
 extends = env:esp32_base
@@ -43,7 +43,7 @@ lib_deps =
 	${env:esp32_base.lib_deps}
 	robtillaart/INA226@ ~0.6.4
 upload_protocol = espota
-upload_port = 192.168.18.21
+upload_port = 192.168.6.47
 build_flags = ${env:esp32_base.build_flags} -DUSE_INA226
 
 [env:native]

src/external_interfacing/leds.cpp

@@ -4,20 +4,22 @@
 #include "../tools/tools.h"
 #include <tools/log.h>
 
-// TODO: Rewrite so that this task does not do anything smart, just receives data over queue and displays it
+extern ActiveErrors active_errors;
-// So it just receives: OK, Error, error code X, warning, warning X (blink)
+extern WaterData water_data;
 
 void display_task(void* parameter)
 {
-    LOG(ELOG_LEVEL_DEBUG, "Starting LED tasks");
+    LOG(ELOG_LEVEL_DEBUG, "Starting display tasks");
-    led_setup();
     while (true) {
-        ledcWrite(LED_RED, 0);
+        if (!is_error(active_errors)) {
-        ledcWrite(LED_GREEN, 255);
+            // We have no error, refresh status display and wait half a second
-        delay(500);
+            ledcWrite(LED_GREEN, 255);
-        ledcWrite(LED_RED, LED_RED_HIGH);
+            ledcWrite(LED_RED, 0);
-        ledcWrite(LED_GREEN, 0);
+        } else {
-        delay(500);
+            ledcWrite(LED_RED, LED_RED_HIGH);
+            ledcWrite(LED_GREEN, 0);
+        }
+        delay(250);
     }
 }
 

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{2, 5, 0}
+#define current_software_version Version{2, 1, 0}
-#define REQUIRED_SPIFFS_VERSION Version{10, 0, 0}
+#define REQUIRED_SPIFFS_VERSION Version{9, 0, 0}
 
 #define RESISTOR_VALUE 4

src/global_data/global_data.cpp

@@ -1,3 +1,12 @@
 #include "global_data.h"
 
-OTAStatus ota_status;
+NetworkData wifi_data;
+NetworkData ethernet_data;
+DeviceTelemetry telemetry;
+
+SensorData shunt_data;
+WaterData water_data;
+
+OTAStatus ota_status;
+
+ActiveErrors active_errors = { false, false, false, false, false, false };

src/global_data/global_data.h

@@ -3,112 +3,48 @@
 
 #pragma once
 
-/**
- * @brief Structure to hold sensor data.
- * 
- * Contains voltage and current measurements from the sensor.
- */
 struct SensorData {
-    float bus_voltage;     /**< Bus voltage in volts */
+    float bus_voltage;
-    float shunt_voltage;   /**< Shunt voltage in millivolts */
+    float shunt_voltage;
-    float shunt_current;   /**< Shunt current in milliamps */
+    float shunt_current;
 };
 
-/**
- * @brief Structure to hold water data.
- * 
- * Contains water level, volume, and percentage measurements.
- */
 struct WaterData{
-  float level;        /**< Water level in cm */
+  // Water level in cm
-  float liters;       /**< Water volume in liters */
+  float level; 
-  float percentage;   /**< Water level as a percentage */
+  // Water volume in liters
+  float liters;
+  // Percentage
+  float percentage;
 };
 
-/**
+
- * @brief Structure to hold network data.
- * 
- * Contains network-related information such as IP address and signal strength.
- */
 struct NetworkData {
-    char ip_address[16];   /**< IP address of the device (max 15 chars + null terminator) */
+    String ip_address;
-    bool link;             /**< Whether the network link is active */
+    bool link;
-    float rssi;            /**< Received signal strength indicator */
+    float rssi;
-    char network_name[33]; /**< Name of the network (max 32 chars + null terminator) */
+    String network_name;
 };
 
-/**
- * @brief Structure to hold device telemetry data.
- * 
- * Contains information about the device's internal state.
- */
 struct DeviceTelemetry {
-    float heap_used_percent;  /**< Percentage of heap memory used */
+    float heap_used_percent;
-    int uptime_seconds;       /**< Uptime of the device in seconds */
+    int uptime_seconds;
-    float temperature;        /**< Temperature of the device in Celsius */
+    float temperature;
 };
 
-/**
- * @brief Structure to hold active error flags.
- * 
- * Contains boolean flags indicating various error conditions.
- */
 struct ActiveErrors {
-    bool voltage_low;    /**< Indicates if the voltage is too low */
+    bool voltage_low;
-    bool voltage_high;   /**< Indicates if the voltage is too high */
+    bool voltage_high;
-    bool current_low;    /**< Indicates if the current is too low */
+    bool current_low;
-    bool current_high;   /**< Indicates if the current is too high */
+    bool current_high;
-    bool level_low;      /**< Indicates if the water level is too low */
+    bool level_low;
-    bool level_high;     /**< Indicates if the water level is too high */
+    bool level_high;
 };
 
-/**
- * @brief Structure to hold OTA (Over-The-Air) update status.
- * 
- * Contains information about the OTA update process.
- */
 struct OTAStatus {
-    bool update_available;   /**< Indicates if an update is available */
+    bool update_available;
-    Version current_version; /**< Current version of the firmware */
+    Version current_version;
-    Version latest_version; /**< Latest available version of the firmware */
+    Version latest_version;
-    int update_progress;     /**< Progress of the update as a percentage */
+    int update_progress;
-    String update_url;       /**< URL to download the update */
+    String update_url;
-};
+};
-
-/**
- * @brief Structure to hold the current state of the system.
- * 
- * Contains all data structs to represent the current state of the system.
- */
-typedef struct {
-    WaterData waterData;         /**< Latest water data */
-    SensorData sensorData;       /**< Latest sensor data */
-    NetworkData wifiData;        /**< Latest WiFi network data */
-    NetworkData ethernetData;    /**< Latest Ethernet network data */
-    DeviceTelemetry telemetryData; /**< Latest telemetry data */
-    OTAStatus otaStatus;         /**< Latest OTA status */
-    ActiveErrors activeErrors;   /**< Latest active errors */
-} CurrentState;
-
-// Enum to represent different types of data that can be sent between tasks
-typedef enum {
-    DATA_TYPE_SENSOR,
-    DATA_TYPE_WATER,
-    DATA_TYPE_WIFI,
-    DATA_TYPE_ETHERNET,
-    DATA_TYPE_TELEMETRY
-} DataType;
-
-// Union to hold different types of data
-typedef union {
-    SensorData sensorData;
-    WaterData waterData;
-    NetworkData networkData;
-    DeviceTelemetry telemetryData;
-} DataUnion;
-
-// Structure to hold data type and the actual data
-typedef struct {
-    DataType type;
-    DataUnion data;
-} DataMessage;

src/main.cpp

@@ -1,6 +1,7 @@
 #include "SPIFFS.h"
 #include <Arduino.h>
 #include <AsyncTCP.h>
+#include <ESPAsyncWebServer.h>
 #include <ETH.h>
 #include <WiFi.h>
 #include <HTTPUpdate.h>
@@ -12,10 +13,8 @@
 #include <ArduinoOTA.h>
 
 #include "global_data/defines.h"
-#include "global_data/global_data.h"
 
 #include "networking/networking.h"
-#include "networking/webserver.h"
 
 #include "external_interfacing/leds.h"
 #include "sensor/sensor.h"
@@ -23,44 +22,36 @@
 #include "tools/tools.h"
 #include <Preferences.h>
 #include "networking/json_builder.h"
+#include "networking/responses.h"
 #include <fetchOTA.h>
 #include "time.h"
 #include "tools/log.h"
-#include "tools/ota_handler.h"
 #include <LittleFS.h>
 
-#include "esp_heap_caps.h"
-
 #define MYLOG 0
 
 Preferences prefs;
 
-extern AsyncWebSocket webSocket;
+extern WaterData water_data;
+extern DeviceTelemetry telemetry;
+extern NetworkData wifi_data;
+extern NetworkData ethernet_data;
+extern SensorData shunt_data;
+extern ActiveErrors active_errors;
 
 Version current_spiffs_version;
 
-// Variable to store the current state of the system
+AsyncWebServer server(80);
-CurrentState current_state = {
+AsyncWebSocket webSocket("/webSocket");
-    {-999.0f, -999.0f, -999.0f},
-    {-999.0f, -999.0f, -999.0f},
-    {"0.0.0.0", false, -999.0f, "UNKNOWN"},  // wifiData
-    {"0.0.0.0", false, -999.0f, "UNKNOWN"},  // ethernetData
-    {-999.0f, -999, -999.0f},
-    {false, {0, 0, 0}, {0, 0, 0}, -999, "UNKNOWN"},
-    {false, false, false, false, false, false}
-};
-
 #define FORMAT_LITTLEFS_IF_FAILED true
 
-// Queue for sending data from producers to the processor in main
-QueueHandle_t dataQueue = xQueueCreate(5, sizeof(DataMessage));
-
-// Queue for sending data from processor to different tasks
-QueueHandle_t stateForWebserverQueue = xQueueCreate(2, sizeof(CurrentState));
-
 void setup()
 {
     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);
@@ -68,7 +59,7 @@ void setup()
     delay(500);
     LOG(ELOG_LEVEL_DEBUG, "Init Sensor");
     init_sensor();
-    
+
     LOG(ELOG_LEVEL_DEBUG, "Beginning LittleFS");
     LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED);
 
@@ -83,75 +74,132 @@ void setup()
       LOG(ELOG_LEVEL_DEBUG, "Current LittleFS Version: %d.%d.%d", current_spiffs_version.major, current_spiffs_version.minor, current_spiffs_version.patch);
     }
     LOG(ELOG_LEVEL_DEBUG, "LittleFS initialized");
-    LOG(ELOG_LEVEL_DEBUG, "Starting main tasks");
-    
-    
-    if (dataQueue == NULL) {
-        LOG(ELOG_LEVEL_ERROR, "Failed to create data queue");
-    } else {
-        xTaskCreate(ethernet_task, "EthernetTask", 1024 * 4, dataQueue, 1, NULL);
-        xTaskCreate(wifi_task, "WiFiTask", 1024 * 4, dataQueue, 1, NULL);
-        xTaskCreate(read_sensor_task, "ReadSensorTask", 1024 * 4, dataQueue, 1, NULL);
-        xTaskCreate(collect_internal_telemetry_task, "InternalTelemetryTask", 1024 * 2, dataQueue, 1, NULL);
-        xTaskCreate(display_task, "DisplayTask", 1024 * 2, NULL, 1, NULL);
-        xTaskCreate(get_time_task, "GetTimeTask", 1024 * 2, NULL, 1, NULL);
 
-        delay(5000);
+    /////////////////////////////// ROUTES ///////////////////////////////
-        xTaskCreate(check_update_task, "CheckUpdateTask", 1024 * 6, NULL, 1, NULL);
+    LOG(ELOG_LEVEL_DEBUG, "Route Setup");
-        xTaskCreate(webserver_task, "WebServerTask", 1024 * 4, stateForWebserverQueue, 1, NULL);
+
-        xTaskCreate(ota_handler_task, "OTAHandlerTask", 1024 * 4, NULL, 3, NULL);
+    // Normal HTML stuff
-    }
+    server.on("/", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/status.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(LittleFS, "/data_export.html", "text/html", false); });
+
+    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(LittleFS, "/update_progress.html", "text/html", false, processor); });
+
+    // API stuff - internal
+    server.on("/update_wifi_credentials", HTTP_POST, [](AsyncWebServerRequest* request) {
+        // For settings SSID
+        if (request->hasParam(ssid_key, true) && request->hasParam(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(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(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();
+            String level_max_str = level_max_param->value();
+            String liters_str = liters_param->value();
+
+            float range_float = range_str.toFloat();
+            float level_min_float = level_min_str.toFloat();
+            float level_max_float = level_max_str.toFloat();
+            float liters_float = liters_str.toFloat();
+
+            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(ELOG_LEVEL_DEBUG, "range_float_after:%D:", prefs.getFloat(level_sensor_range_key, -1.0));
+        } else {
+            LOG(ELOG_LEVEL_DEBUG, "!!!! FAIL lo");
+            for (int i = 0; i < params; i++) {
+                const AsyncWebParameter* p = request->getParam(i);
+                if (p->isFile()) { // p->isPost() is also true
+                    LOG(ELOG_LEVEL_DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
+                } else if (p->isPost()) {
+                    LOG(ELOG_LEVEL_DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
+                } else {
+                    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(LittleFS, "/settings.html", "text/html", false); // TODO add proper return templating
+    });
+    
+    setup_api_endpoints();
+    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); });
+
+
+    LOG(ELOG_LEVEL_DEBUG, "OTA Setup");
+    ArduinoOTA
+        .onStart([]() {
+            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(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(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"); });
+
+
+    LOG(ELOG_LEVEL_DEBUG, "Starting main tasks");
+    xTaskCreate(ethernet_task, "EthernetTask", 4096, 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);
+
+    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();
 }
 
+
 void loop()
 {
-    size_t free_heap = heap_caps_get_free_size(MALLOC_CAP_8BIT);
+    ArduinoOTA.handle();
-    Serial.println(free_heap);
-
-    // Check if there is new data in the queue
-    DataMessage dataMessage;
-    if (xQueueReceive(dataQueue, &dataMessage, portMAX_DELAY) == pdTRUE) {
-        // Decode the data based on its type and update the current state
-        switch (dataMessage.type) {
-            case DATA_TYPE_WATER:
-                current_state.waterData = dataMessage.data.waterData;
-                LOG(ELOG_LEVEL_DEBUG, "Received water data: level=%F, liters=%F, percentage=%F",
-                    current_state.waterData.level, current_state.waterData.liters, current_state.waterData.percentage);
-                break;
-            case DATA_TYPE_SENSOR:
-                current_state.sensorData = dataMessage.data.sensorData;
-                LOG(ELOG_LEVEL_DEBUG, "Received sensor data: bus_voltage=%F, shunt_voltage=%F, shunt_current=%F",
-                    current_state.sensorData.bus_voltage, current_state.sensorData.shunt_voltage, current_state.sensorData.shunt_current);
-                break;
-            case DATA_TYPE_WIFI:
-                current_state.wifiData = dataMessage.data.networkData;
-                LOG(ELOG_LEVEL_DEBUG, "Received WiFi data: ip=%s, link=%d, rssi=%F, name=%s",
-                    current_state.wifiData.ip_address, current_state.wifiData.link,
-                    current_state.wifiData.rssi, current_state.wifiData.network_name);
-                break;
-            case DATA_TYPE_ETHERNET:
-                current_state.ethernetData = dataMessage.data.networkData;
-                LOG(ELOG_LEVEL_DEBUG, "Received Ethernet data: ip=%s, link=%d, rssi=%F, name=%s",
-                    current_state.ethernetData.ip_address, current_state.ethernetData.link,
-                    current_state.ethernetData.rssi, current_state.ethernetData.network_name);
-                break;
-            case DATA_TYPE_TELEMETRY:
-                current_state.telemetryData = dataMessage.data.telemetryData;
-                LOG(ELOG_LEVEL_DEBUG, "Received telemetry data: heap=%F, uptime=%d, temperature=%F",
-                    current_state.telemetryData.heap_used_percent, current_state.telemetryData.uptime_seconds,
-                    current_state.telemetryData.temperature);
-                break;
-            default:
-                LOG(ELOG_LEVEL_ERROR, "Unknown data type received");
-                break;
-        }
-        // Send the updated current_state to the webserver queue
-        if (xQueueSendToBack(stateForWebserverQueue, &current_state, 250 / portTICK_PERIOD_MS) != pdTRUE) {
-            LOG(ELOG_LEVEL_ERROR, "Failed to send current_state to webserver queue");
-        }
-    } else {
-        LOG(ELOG_LEVEL_WARNING, "No message received within max wait");
-    }
-    
     delay(1000);
 }

src/networking/json_builder.cpp

@@ -1,34 +1,38 @@
 #include "json_builder.h"
 #include <Elog.h>
 
-// Refactored: no return by value, serialize directly to output String
+extern WaterData water_data;
-// Reduced document sizes based on actual JSON output requirements
+extern DeviceTelemetry telemetry;
-void build_shunt_data_json(SensorData data, String& output) {
+extern NetworkData wifi_data;
-    StaticJsonDocument<96> doc;  // Reduced from 128: 3 floats ~70-80 bytes
+extern NetworkData ethernet_data;
+extern SensorData shunt_data;
+
+StaticJsonDocument<128> build_shunt_data_json(SensorData data) {
+    StaticJsonDocument<128> doc;
     doc["bus_voltage"] = data.bus_voltage;
     doc["shunt_voltage"] = data.shunt_voltage;
     doc["current"] = data.shunt_current;
-    serializeJson(doc, output);
+    return doc;
 }
 
-void build_water_data_json(WaterData data, String& output) {
+StaticJsonDocument<128> build_water_data_json(WaterData data) {
-    StaticJsonDocument<96> doc;  // Reduced from 128: 3 floats ~70-80 bytes
+    StaticJsonDocument<128> doc;
     doc["percentage"] = data.percentage;
     doc["water_height"] = data.level;
     doc["liters"] = data.liters;
-    serializeJson(doc, output);
+    return doc;
 }
 
-void build_telemetry_json(DeviceTelemetry data, String& output) {
+StaticJsonDocument<128> build_telemetry_json(DeviceTelemetry data) {
-    StaticJsonDocument<96> doc;  // Reduced from 128: 1 int + 2 floats ~70-80 bytes
+    StaticJsonDocument<128> doc;
     doc["uptime_seconds"] = data.uptime_seconds;
     doc["heap_percent"] = data.heap_used_percent;
     doc["temperature"] = data.temperature;
-    serializeJson(doc, output);
+    return doc;
 }
 
-void build_network_json(NetworkData wired, NetworkData wireless, String& output) {
+StaticJsonDocument<256> build_network_json(NetworkData wired, NetworkData wireless) {
-    StaticJsonDocument<256> doc;  // Keep 256: nested objects + strings ~200 bytes
+    StaticJsonDocument<256> doc;
     doc["wifi"]["ip"] = wireless.ip_address;
     doc["wifi"]["rssi"] = wireless.rssi;
     doc["wifi"]["link"] = wireless.link;
@@ -38,15 +42,15 @@ void build_network_json(NetworkData wired, NetworkData wireless, String& output)
     doc["ethernet"]["rssi"] = wired.rssi;
     doc["ethernet"]["link"] = wired.link;
 
-    serializeJson(doc, output);
+    return doc;
 }
 
-void build_ota_json(OTAStatus status, String& output) {
+StaticJsonDocument<128> build_ota_json(OTAStatus status) {
-    StaticJsonDocument<192> doc;  // Reduced from 256: bool + 2 version strings + int ~150-170 bytes
+    StaticJsonDocument<256> doc;
     doc["update_available"] = status.update_available;
     doc["current_version"] = String(status.current_version.major) + "." + String(status.current_version.minor) + "." + String(status.current_version.patch);
     doc["new_version"] = String(status.latest_version.major) + "." + String(status.latest_version.minor) + "." + String(status.latest_version.patch);
     doc["progress"] = status.update_progress;
 
-    serializeJson(doc, output);
+    return doc;
-}
+}

src/networking/json_builder.h

@@ -1,9 +1,8 @@
 #include <ArduinoJson.h>
 #include "../global_data/global_data.h"
 
-// Refactored to pass by reference - no expensive copies on stack
+StaticJsonDocument<128> build_shunt_data_json(SensorData data);
-void build_shunt_data_json(SensorData data, String& output);
+StaticJsonDocument<128> build_water_data_json(WaterData data);
-void build_water_data_json(WaterData data, String& output);
+StaticJsonDocument<128> build_telemetry_json(DeviceTelemetry data);
-void build_telemetry_json(DeviceTelemetry data, String& output);
+StaticJsonDocument<256> build_network_json(NetworkData wired, NetworkData wireless);
-void build_network_json(NetworkData wired, NetworkData wireless, String& output);
+StaticJsonDocument<128> build_ota_json(OTAStatus status);
-void build_ota_json(OTAStatus status, String& output);

src/networking/networking.cpp

@@ -4,7 +4,6 @@
 #include <Preferences.h>
 #include "../global_data/global_data.h"
 #include <tools/log.h>
-#include "freertos/queue.h"
 
 #define ETH_PHY_TYPE ETH_PHY_LAN8720
 #define ETH_PHY_ADDR  0
@@ -19,9 +18,8 @@
 int64_t mac_address = ESP.getEfuseMac();
 uint8_t failed_connection_attempts = 0;
 
-NetworkData wifi_data;
+extern NetworkData wifi_data;
-NetworkData ethernet_data;
+extern NetworkData ethernet_data;
-
 extern Preferences prefs;
 
 // Defines the type of connection for which the hostname should be created
@@ -47,14 +45,6 @@ const char * get_hostname(HostnameType host_type) {
 
 void wifi_task(void* parameter)
 {
-    // Extract the queue handle from the task parameters
-    QueueHandle_t dataQueue = (QueueHandle_t)parameter;
-    if (dataQueue == NULL) {
-        LOG(ELOG_LEVEL_ERROR, "Data queue is NULL");
-        vTaskDelete(NULL);
-        return;
-    }
-    
     LOG(ELOG_LEVEL_DEBUG, "Starting WiFi Task");
     WiFi.setHostname(get_hostname(Wireless));
     while (true) {
@@ -82,21 +72,8 @@ void wifi_task(void* parameter)
                 failed_connection_attempts = 0;
                 wifi_data.rssi = WiFi.RSSI();
                 wifi_data.link = true;
-                strncpy(wifi_data.network_name, WiFi.SSID().c_str(), sizeof(wifi_data.network_name) - 1);
+                wifi_data.network_name = WiFi.SSID();
-                wifi_data.network_name[sizeof(wifi_data.network_name) - 1] = '\0';
+                wifi_data.ip_address = WiFi.localIP().toString();
-                strncpy(wifi_data.ip_address, WiFi.localIP().toString().c_str(), sizeof(wifi_data.ip_address) - 1);
-                wifi_data.ip_address[sizeof(wifi_data.ip_address) - 1] = '\0';
-                
-                // Create a DataMessage for WiFi data
-                DataMessage dataMessage;
-                dataMessage.type = DATA_TYPE_WIFI;
-                dataMessage.data.networkData = wifi_data;
-                
-                // Send the WiFi data to the queue
-                if (xQueueSend(dataQueue, &dataMessage, 0) != pdTRUE) {
-                    LOG(ELOG_LEVEL_ERROR, "Failed to send WiFi data to queue");
-                }
-                
                 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 {
@@ -115,33 +92,13 @@ void wifi_task(void* parameter)
 
 void ethernet_task(void* parameter)
 {
-    // Extract the queue handle from the task parameters
-    QueueHandle_t dataQueue = (QueueHandle_t)parameter;
-    if (dataQueue == NULL) {
-        LOG(ELOG_LEVEL_ERROR, "Data queue is NULL");
-        vTaskDelete(NULL);
-        return;
-    }
-    
     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();
-        strncpy(ethernet_data.ip_address, ETH.localIP().toString().c_str(), sizeof(ethernet_data.ip_address) - 1);
+        ethernet_data.ip_address = ETH.localIP().toString();
-        ethernet_data.ip_address[sizeof(ethernet_data.ip_address) - 1] = '\0';
-        
-        // Create a DataMessage for Ethernet data
-        DataMessage dataMessage;
-        dataMessage.type = DATA_TYPE_ETHERNET;
-        dataMessage.data.networkData = ethernet_data;
-        
-        // Send the Ethernet data to the queue
-        if (xQueueSend(dataQueue, &dataMessage, 0) != pdTRUE) {
-            LOG(ELOG_LEVEL_ERROR, "Failed to send Ethernet data to queue");
-        }
-        
         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") {

src/networking/responses.cpp

@@ -0,0 +1,76 @@
+#include "responses.h"
+
+#include <Arduino.h>
+#include <ESPAsyncWebServer.h>
+#include "AsyncJson.h"
+#include <ArduinoJson.h>
+#include <Elog.h>
+#include "json_builder.h"
+#include "../tools/tools.h"
+#include <SPIFFS.h>
+
+extern WaterData water_data;
+extern DeviceTelemetry telemetry;
+extern NetworkData wifi_data;
+extern NetworkData ethernet_data;
+extern SensorData shunt_data;
+extern OTAStatus ota_status;
+
+extern AsyncWebServer server;
+
+void setup_api_endpoints(){
+    server.on("/sensor_data", HTTP_GET, [](AsyncWebServerRequest* request) {
+      String output;
+      serializeJson(build_shunt_data_json(shunt_data), output);
+      request->send(200, "application/json", output); });
+
+    server.on("/water_data", HTTP_GET, [](AsyncWebServerRequest* request) {
+      String output;
+      serializeJson(build_water_data_json(water_data), output);
+      request->send(200, "application/json", output); });
+
+    server.on("/raw_percent", HTTP_GET, [](AsyncWebServerRequest* request) {
+      String output;
+      output = water_data.percentage;
+      request->send(200, "text/raw", output); });
+
+    server.on("/raw_level", HTTP_GET, [](AsyncWebServerRequest* request) {
+      String output;
+      output = water_data.level;
+      request->send(200, "text/raw", output); });
+  
+
+    server.on("/telemetry", HTTP_GET, [](AsyncWebServerRequest* request) {
+      String output;
+      serializeJson(build_telemetry_json(telemetry), output);
+      request->send(200, "application/json", output); });
+
+    server.on("/network_info", HTTP_GET, [](AsyncWebServerRequest* request) {
+        String output;
+        serializeJson(build_network_json(ethernet_data, wifi_data), output);
+        request->send(200, "application/json", output);
+    });
+
+    server.on("/ota_udpate_status", HTTP_GET, [](AsyncWebServerRequest* request) {
+      String output;
+      serializeJson(build_ota_json(ota_status), output);
+      request->send(200, "application/json", output);
+    });
+
+    server.on("/run_ota_update", HTTP_GET, [](AsyncWebServerRequest* request) {
+      if (ota_status.update_progress > -1) {
+        request->send(200, "text/plain", "OTA Update already in progress");
+        return;
+      } else if (!ota_status.update_available) {
+        request->send(200, "text/plain", "No update available");
+        return;
+      }
+
+      static TaskArgs_t args = {
+        .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);
+    });
+}

src/networking/responses.h

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

src/networking/webserver.cpp

@@ -1,371 +0,0 @@
-#include "webserver.h"
-
-#include <Arduino.h>
-#include <ESPAsyncWebServer.h>
-#include <LittleFS.h>
-#include <Elog.h>
-#include <AsyncTCP.h>
-#include <Preferences.h>
-#include "tools/log.h"
-#include "AsyncJson.h"
-#include <ArduinoJson.h>
-#include <SPIFFS.h>
-#include <freertos/FreeRTOS.h>
-#include <freertos/semphr.h>
-#include <freertos/queue.h>
-
-#include "../global_data/global_data.h"
-#include "../tools/tools.h"
-#include "../tools/readers_writer_lock.h"
-#include "../global_data/defines.h"
-#include "json_builder.h"
-
-extern Preferences prefs;
-
-AsyncWebSocket webSocket("/webSocket");
-AsyncWebServer server(80);
-
-
-WaterData local_water_data;
-SensorData local_sensor_data;
-NetworkData local_wifi_data;
-NetworkData local_ethernet_data;
-DeviceTelemetry local_telemetry;
-OTAStatus local_ota_status;
-
-
-ReadersWriterLock waterDataLock;
-ReadersWriterLock sensorDataLock;
-ReadersWriterLock networkDataLock;
-ReadersWriterLock telemetryDataLock;
-ReadersWriterLock otaStatusLock;
-
-
-// ======================
-// Webserver Setup
-// ======================
-
-/**
- * @brief Sets up all routes for the webserver.
- * 
- * Configures routes for serving HTML pages, handling form submissions,
- * REST API endpoints, WebSocket connections, and static assets.
- * 
- * @note Calls setup_api_endpoints() to configure API-specific routes.
- */
-void setup_routes() {
-    server.on("/", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/status.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(LittleFS, "/data_export.html", "text/html", false); });
-
-    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(LittleFS, "/update_progress.html", "text/html", false, processor); });
-
-    // API stuff - internal
-    server.on("/update_wifi_credentials", HTTP_POST, [](AsyncWebServerRequest* request) {
-        handle_update_wifi_credentials(request);
-    });
-
-    server.on("/update_sensor_settings", HTTP_POST, [](AsyncWebServerRequest* request) {
-        handle_update_sensor_settings(request);
-    });
-    
-    setup_api_endpoints();
-    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); });
-}
-
-/**
- * @brief Configures REST API endpoints for data retrieval.
- * 
- * Sets up endpoints to fetch sensor data, water data, telemetry,
- * network information, and OTA update status in JSON format.
- * 
- * @note These endpoints are used by the frontend to dynamically
- *       display device status and configuration.
- */
-void setup_api_endpoints(){
-    server.on("/sensor_data", HTTP_GET, [](AsyncWebServerRequest* request) {
-      rwLockAcquireRead(&sensorDataLock);
-      String output;
-      build_shunt_data_json(local_sensor_data, output);
-      rwLockReleaseRead(&sensorDataLock);
-      request->send(200, "application/json", output); });
-
-    server.on("/water_data", HTTP_GET, [](AsyncWebServerRequest* request) {
-      rwLockAcquireRead(&waterDataLock);
-      String output;
-      build_water_data_json(local_water_data, output);
-      rwLockReleaseRead(&waterDataLock);
-      request->send(200, "application/json", output);
-    });
-
-    server.on("/raw_percent", HTTP_GET, [](AsyncWebServerRequest* request) {
-      rwLockAcquireRead(&waterDataLock);
-      String output = String(local_water_data.percentage);
-      rwLockReleaseRead(&waterDataLock);
-      request->send(200, "text/raw", output);
-    });
-
-    server.on("/raw_level", HTTP_GET, [](AsyncWebServerRequest* request) {
-      rwLockAcquireRead(&waterDataLock);
-      String output = String(local_water_data.level);
-      rwLockReleaseRead(&waterDataLock);
-      request->send(200, "text/raw", output);
-    });
-  
-    server.on("/telemetry", HTTP_GET, [](AsyncWebServerRequest* request) {
-      rwLockAcquireRead(&telemetryDataLock);
-      String output;
-      build_telemetry_json(local_telemetry, output);
-      rwLockReleaseRead(&telemetryDataLock);
-      request->send(200, "application/json", output); });
-
-    server.on("/network_info", HTTP_GET, [](AsyncWebServerRequest* request) {
-        rwLockAcquireRead(&networkDataLock);
-        String output;
-        build_network_json(local_ethernet_data, local_wifi_data, output);
-        rwLockReleaseRead(&networkDataLock);
-        request->send(200, "application/json", output);
-    });
-
-    server.on("/ota_update_status", HTTP_GET, [](AsyncWebServerRequest* request) {
-      rwLockAcquireRead(&otaStatusLock);
-      String output;
-      build_ota_json(local_ota_status, output);
-      rwLockReleaseRead(&otaStatusLock);
-      request->send(200, "application/json", output); });
-
-    server.on("/run_ota_update", HTTP_GET, [](AsyncWebServerRequest* request) {
-      if (local_ota_status.update_progress > -1) {
-        request->send(200, "text/plain", "OTA Update already in progress");
-        return;
-      } else if (!local_ota_status.update_available) {
-        request->send(200, "text/plain", "No update available");
-        return;
-      }
-
-      static TaskArgs_t args = {
-        .ota_status = local_ota_status
-      };
-
-      xTaskCreate(run_ota_update_task, "RunOTAUpdate", 1024 * 8, (void *)&args, 1, NULL);
-      request->send(LittleFS, "/update_progress.html", "text/html", false, processor);
-    });
-}
-
-// ======================
-// Helper Functions
-// ======================
-
-/**
- * @brief Handles the update of WiFi credentials.
- * 
- * Validates and updates the SSID and password in preferences.
- * 
- * @param request The web server request object.
- */
-void handle_update_wifi_credentials(AsyncWebServerRequest* request) {
-    if (request->hasParam(ssid_key, true) && request->hasParam(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");
-        return;
-    }
-    request->send(LittleFS, "/settings.html", "text/html", false, processor);
-}
-
-/**
- * @brief Handles the update of sensor settings.
- * 
- * Validates and updates sensor configuration parameters in preferences.
- * 
- * @param request The web server request object.
- */
-void handle_update_sensor_settings(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(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();
-        String level_max_str = level_max_param->value();
-        String liters_str = liters_param->value();
-
-        float range_float = range_str.toFloat();
-        float level_min_float = level_min_str.toFloat();
-        float level_max_float = level_max_str.toFloat();
-        float liters_float = liters_str.toFloat();
-
-        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(ELOG_LEVEL_DEBUG, "range_float_after:%D:", prefs.getFloat(level_sensor_range_key, -1.0));
-    } else {
-        LOG(ELOG_LEVEL_DEBUG, "!!!! FAIL lo");
-        for (int i = 0; i < params; i++) {
-            const AsyncWebParameter* p = request->getParam(i);
-            if (p->isFile()) {
-                LOG(ELOG_LEVEL_DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
-            } else if (p->isPost()) {
-                LOG(ELOG_LEVEL_DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
-            } else {
-                LOG(ELOG_LEVEL_DEBUG, "GET[%s]: %s\n", p->name().c_str(), p->value().c_str());
-            }
-        }
-        request->send(400, "text/plain", "Missing parameters");
-        return;
-    }
-    request->send(LittleFS, "/settings.html", "text/html", false);
-}
-
-/**
- * @brief Main task for the webserver.
- * 
- * Initializes all routes, starts the webserver, and sets up local water data.
- * Receives the current state from the main task via a queue and updates local_water_data.
- * Runs indefinitely to keep the server active.
- * 
- * @param pvParameters Task parameters (expected to be a QueueHandle_t for the state queue).
- */
-void webserver_task(void *pvParameters) {
-    // Extract the queue handle from the task parameters
-    QueueHandle_t stateQueue = (QueueHandle_t)pvParameters;
-    if (stateQueue == NULL) {
-        LOG(ELOG_LEVEL_ERROR, "State queue is NULL");
-        vTaskDelete(NULL);
-        return;
-    }
-    
-    LOG(ELOG_LEVEL_DEBUG, "Setting up routes");
-    setup_routes();
-    
-    // Initialize the readers-writer locks
-    if (!rwLockInit(&waterDataLock)) {
-        LOG(ELOG_LEVEL_ERROR, "Failed to initialize water data readers-writer lock");
-        vTaskDelete(NULL);
-        return;
-    }
-    
-    if (!rwLockInit(&sensorDataLock)) {
-        LOG(ELOG_LEVEL_ERROR, "Failed to initialize sensor data readers-writer lock");
-        vTaskDelete(NULL);
-        return;
-    }
-    
-    if (!rwLockInit(&networkDataLock)) {
-        LOG(ELOG_LEVEL_ERROR, "Failed to initialize network data readers-writer lock");
-        vTaskDelete(NULL);
-        return;
-    }
-    
-    if (!rwLockInit(&telemetryDataLock)) {
-        LOG(ELOG_LEVEL_ERROR, "Failed to initialize telemetry data readers-writer lock");
-        vTaskDelete(NULL);
-        return;
-    }
-    
-    if (!rwLockInit(&otaStatusLock)) {
-        LOG(ELOG_LEVEL_ERROR, "Failed to initialize OTA status readers-writer lock");
-        vTaskDelete(NULL);
-        return;
-    }
-    
-    // Initialize local water data with static values
-    rwLockAcquireWrite(&waterDataLock);
-    local_water_data.level = -1.0;
-    local_water_data.liters = -1.0;
-    local_water_data.percentage = -1.0;
-    rwLockReleaseWrite(&waterDataLock);
-    
-    // Initialize local sensor data with static values
-    rwLockAcquireWrite(&sensorDataLock);
-    local_sensor_data.bus_voltage = -1.0;
-    local_sensor_data.shunt_voltage = -1.0;
-    local_sensor_data.shunt_current = -1.0;
-    rwLockReleaseWrite(&sensorDataLock);
-    
-    // Initialize local network data with static values
-    rwLockAcquireWrite(&networkDataLock);
-    strcpy(local_wifi_data.ip_address, "0.0.0.0");
-    local_wifi_data.link = false;
-    local_wifi_data.rssi = -1.0;
-    strcpy(local_wifi_data.network_name, "UNKNOWN");
-    
-    strcpy(local_ethernet_data.ip_address, "0.0.0.0");
-    local_ethernet_data.link = false;
-    local_ethernet_data.rssi = -1.0;
-    strcpy(local_ethernet_data.network_name, "UNKNOWN");
-    rwLockReleaseWrite(&networkDataLock);
-    
-    // Initialize local telemetry data with static values
-    rwLockAcquireWrite(&telemetryDataLock);
-    local_telemetry.heap_used_percent = -1.0;
-    local_telemetry.uptime_seconds = -1;
-    local_telemetry.temperature = -1.0;
-    rwLockReleaseWrite(&telemetryDataLock);
-    
-    // Initialize local OTA status with static values
-    rwLockAcquireWrite(&otaStatusLock);
-    local_ota_status.update_available = false;
-    local_ota_status.current_version = {0, 0, 0};
-    local_ota_status.latest_version = {0, 0, 0};
-    local_ota_status.update_progress = -1;
-    local_ota_status.update_url = "UNKNOWN";
-    rwLockReleaseWrite(&otaStatusLock);
-    
-    LOG(ELOG_LEVEL_DEBUG, "Starting webserver");
-    server.begin();
-    
-    while (1) {
-        // Check if there is new state data in the queue
-        CurrentState currentState;
-        if (xQueueReceive(stateQueue, &currentState, portMAX_DELAY) == pdTRUE) {
-            // Update local_water_data with the new data from the queue
-            rwLockAcquireWrite(&waterDataLock);
-            local_water_data = currentState.waterData;
-            rwLockReleaseWrite(&waterDataLock);
-            
-            // Update local_sensor_data with the new data from the queue
-            rwLockAcquireWrite(&sensorDataLock);
-            local_sensor_data = currentState.sensorData;
-            rwLockReleaseWrite(&sensorDataLock);
-            
-            // Update local network data with the new data from the queue
-            rwLockAcquireWrite(&networkDataLock);
-            local_wifi_data = currentState.wifiData;
-            local_ethernet_data = currentState.ethernetData;
-            rwLockReleaseWrite(&networkDataLock);
-            
-            // Update local telemetry data with the new data from the queue
-            rwLockAcquireWrite(&telemetryDataLock);
-            local_telemetry = currentState.telemetryData;
-            rwLockReleaseWrite(&telemetryDataLock);
-            
-            // Update local OTA status with the new data from the queue
-            rwLockAcquireWrite(&otaStatusLock);
-            local_ota_status = currentState.otaStatus;
-            rwLockReleaseWrite(&otaStatusLock);
-        }
-    }
-}

src/networking/webserver.h

@@ -1,16 +0,0 @@
-#ifndef ASYNC_WEBSERVER_H
-#define ASYNC_WEBSERVER_H
-
-#include <ESPAsyncWebServer.h>
-#include <LittleFS.h>
-
-extern AsyncWebServer server;
-
-void setup_api_endpoints();
-void setup_routes();
-void webserver_task(void *pvParameters);
-void handle_update_wifi_credentials(AsyncWebServerRequest* request);
-void handle_update_sensor_settings(AsyncWebServerRequest* request);
-
-#endif // ASYNC_WEBSERVER_H
-

src/sensor/sensor.cpp

@@ -18,8 +18,9 @@ INA233 ina_sensor(0x40);
 #include "freertos/task.h"
 
 extern Preferences prefs;
-
+extern WaterData water_data;
-WaterData water_data;
+extern ActiveErrors active_errors;
+extern SensorData shunt_data;
 
 // Calibration variables
 float zero_value = 0.03; // Measured shunt voltage with nothing connected, used to fix measuring offset
@@ -32,8 +33,6 @@ void init_sensor(){
         ina_sensor.setBusVoltageConversionTime(7);
         ina_sensor.setShuntVoltageConversionTime(7);
         ina_sensor.setAverage(4);
-        // 111 - Shunt + Bus continous
-        ina_sensor.setMode(7);
     #else
         ina_sensor.begin(33, 32);
         ina_sensor.reset();
@@ -46,14 +45,6 @@ void init_sensor(){
 
 void read_sensor_task(void* parameter)
 {
-    // Extract the queue handle from the task parameters
-    QueueHandle_t dataQueue = (QueueHandle_t)parameter;
-    if (dataQueue == NULL) {
-        LOG(ELOG_LEVEL_ERROR, "Data queue is NULL");
-        vTaskDelete(NULL);
-        return;
-    }
-    
     LOG(ELOG_LEVEL_DEBUG, "Starting read sensor tasks");
     while (true) {
         // Get Values from sensor
@@ -61,28 +52,13 @@ void read_sensor_task(void* parameter)
         String chip_id = ina_sensor.get_device_model();
         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(ELOG_LEVEL_DEBUG, "RAW Shunt voltage: %F mV", ina_sensor.getShuntVoltage_mV());
 
         float shunt_current = shunt_voltage / RESISTOR_VALUE;
-
-
-        // Build SensorData object
-        SensorData sensor_data;
-        sensor_data.bus_voltage = bus_voltage;
-        sensor_data.shunt_current = shunt_current;
-        sensor_data.shunt_voltage = shunt_voltage;
-
-        // Send the sensor data to the data queue
-        DataMessage dataMessageSensor;
-        dataMessageSensor.type = DATA_TYPE_SENSOR;
-        dataMessageSensor.data.sensorData = sensor_data;
-        if (xQueueSend(dataQueue, &dataMessageSensor, 0) != pdTRUE) {
-            LOG(ELOG_LEVEL_ERROR, "Failed to send water data to queue");
-        }
-        
         
         // Get values from storage
         float sensor_range = prefs.getFloat(level_sensor_range_key, 200);
@@ -117,31 +93,23 @@ void read_sensor_task(void* parameter)
         float liters_raw = max_liters * percentage_raw;
         int liters = round(liters_raw);
 
+        active_errors.current_low = shunt_current < 3.8;
+        active_errors.current_high = shunt_current > 20.2;
+        active_errors.voltage_low = bus_voltage < 23;
+        active_errors.voltage_high = bus_voltage > 25;
         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;
+        shunt_data.shunt_current = shunt_current;
+
         water_data.level = cm_over_zero;
         water_data.liters = liters;
         water_data.percentage = percentage_rounded;
 
-        // Send the water data to the data queue
-        DataMessage dataMessageWater;
-        dataMessageWater.type = DATA_TYPE_WATER;
-        dataMessageWater.data.waterData = water_data;
-        
-        // Log the data being sent
-        LOG(ELOG_LEVEL_DEBUG, "Sending water data to queue: level=%F, liters=%F, percentage=%F",
-            water_data.level, water_data.liters, water_data.percentage);
-        
-        if (xQueueSend(dataQueue, &dataMessageWater, 0) != pdTRUE) {
-            LOG(ELOG_LEVEL_ERROR, "Failed to send water data to queue");
-            // Log the queue status
-            UBaseType_t messagesWaiting = uxQueueMessagesWaiting(dataQueue);
-            LOG(ELOG_LEVEL_ERROR, "Queue messages waiting: %d", messagesWaiting);
-        }
-
         delay(20000);
     }
 }

src/telemetry/telemetry.cpp

@@ -2,38 +2,21 @@
 #include <Arduino.h>
 #include "../global_data/global_data.h"
 #include "tools/log.h"
-#include <freertos/queue.h>
 
 extern "C" uint8_t temprature_sens_read();
 
+extern DeviceTelemetry telemetry;
+
 void collect_internal_telemetry_task(void* parameter)
 {
-    // Extract the queue handle from the task parameters
-    QueueHandle_t dataQueue = (QueueHandle_t)parameter;
-    if (dataQueue == NULL) {
-        LOG(ELOG_LEVEL_ERROR, "Data queue is NULL");
-        vTaskDelete(NULL);
-        return;
-    }
-    
     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;
-        float temperature = (temprature_sens_read()-32) / 1.8;
 
-        // Create a DataMessage for telemetry data
+        telemetry.heap_used_percent = heap_usage;
-        DataMessage dataMessage;
+        telemetry.uptime_seconds = uptime_seconds;
-        dataMessage.type = DATA_TYPE_TELEMETRY;
+        telemetry.temperature = (temprature_sens_read()-32) / 1.8;
-        dataMessage.data.telemetryData.heap_used_percent = heap_usage;
+        delay(60000);
-        dataMessage.data.telemetryData.uptime_seconds = uptime_seconds;
-        dataMessage.data.telemetryData.temperature = temperature;
-
-        // Send the telemetry data to the queue
-        if (xQueueSend(dataQueue, &dataMessage, 0) != pdTRUE) {
-            LOG(ELOG_LEVEL_ERROR, "Failed to send telemetry data to queue");
-        }
-
-        delay(10 * 1000);
     }
 }

src/tools/ota_handler.cpp

@@ -1,59 +0,0 @@
-#include <ArduinoOTA.h>
-#include <Elog.h>
-#include "tools/log.h"
-
-/**
- * @brief Task to handle ArduinoOTA updates.
- * 
- * This task initializes the ArduinoOTA library and handles OTA updates.
- * It runs indefinitely to process OTA update requests.
- * 
- * @param pvParameters Task parameters (unused).
- */
-void ota_handler_task(void *pvParameters) {
-    (void)pvParameters; // Suppress unused parameter warning
-    
-    LOG(ELOG_LEVEL_DEBUG, "Setting up OTA handler");
-    
-    // Configure OTA settings
-    ArduinoOTA
-        .onStart([]() {
-            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(ELOG_LEVEL_DEBUG, "Start updating %s", type.c_str());
-        })
-        .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(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");
-            }
-        });
-    // Start the OTA handler
-    ArduinoOTA.begin();
-    
-    // Run indefinitely to handle OTA updates
-    while (1) {
-        ArduinoOTA.handle();
-        vTaskDelay(250 / portTICK_PERIOD_MS); // Even more frequent handling
-    }
-}

src/tools/ota_handler.h

@@ -1,14 +0,0 @@
-#ifndef OTA_HANDLER_H
-#define OTA_HANDLER_H
-
-/**
- * @brief Task to handle ArduinoOTA updates.
- * 
- * This task initializes the ArduinoOTA library and handles OTA updates.
- * It runs indefinitely to process OTA update requests.
- * 
- * @param pvParameters Task parameters (unused).
- */
-void ota_handler_task(void *pvParameters);
-
-#endif // OTA_HANDLER_H

src/tools/readers_writer_lock.cpp

@@ -1,70 +0,0 @@
-#include "readers_writer_lock.h"
-#include <freertos/task.h>
-
-bool rwLockInit(ReadersWriterLock* rwLock) {
-    if (rwLock == NULL) {
-        return false;
-    }
-    
-    rwLock->mutex = xSemaphoreCreateMutex();
-    if (rwLock->mutex == NULL) {
-        return false;
-    }
-    
-    rwLock->readersCount = 0;
-    rwLock->writerActive = false;
-    
-    return true;
-}
-
-void rwLockAcquireRead(ReadersWriterLock* rwLock) {
-    if (rwLock == NULL) {
-        return;
-    }
-    
-    xSemaphoreTake(rwLock->mutex, portMAX_DELAY);
-    // Wait until no writer is active
-    while (rwLock->writerActive) {
-        xSemaphoreGive(rwLock->mutex);
-        vTaskDelay(10 / portTICK_PERIOD_MS); // Small delay to avoid busy-waiting
-        xSemaphoreTake(rwLock->mutex, portMAX_DELAY);
-    }
-    rwLock->readersCount++;
-    xSemaphoreGive(rwLock->mutex);
-}
-
-void rwLockReleaseRead(ReadersWriterLock* rwLock) {
-    if (rwLock == NULL) {
-        return;
-    }
-    
-    xSemaphoreTake(rwLock->mutex, portMAX_DELAY);
-    rwLock->readersCount--;
-    xSemaphoreGive(rwLock->mutex);
-}
-
-void rwLockAcquireWrite(ReadersWriterLock* rwLock) {
-    if (rwLock == NULL) {
-        return;
-    }
-    
-    xSemaphoreTake(rwLock->mutex, portMAX_DELAY);
-    // Set the writer active flag to block new readers
-    rwLock->writerActive = true;
-    // Wait until no readers are active
-    while (rwLock->readersCount > 0) {
-        xSemaphoreGive(rwLock->mutex);
-        vTaskDelay(10 / portTICK_PERIOD_MS); // Small delay to avoid busy-waiting
-        xSemaphoreTake(rwLock->mutex, portMAX_DELAY);
-    }
-    // Writer now has exclusive access
-}
-
-void rwLockReleaseWrite(ReadersWriterLock* rwLock) {
-    if (rwLock == NULL) {
-        return;
-    }
-    
-    rwLock->writerActive = false;
-    xSemaphoreGive(rwLock->mutex);
-}

src/tools/readers_writer_lock.h

@@ -1,65 +0,0 @@
-#ifndef READERS_WRITER_LOCK_H
-#define READERS_WRITER_LOCK_H
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/semphr.h>
-
-/**
- * @brief Readers-Writer Lock structure.
- * 
- * This structure holds the state for a readers-writer lock,
- * allowing multiple readers or a single writer to access a shared resource.
- */
-typedef struct {
-    SemaphoreHandle_t mutex;   /**< Mutex to protect the lock state. */
-    int readersCount;         /**< Number of active readers. */
-    bool writerActive;        /**< Flag to indicate if a writer is active. */
-} ReadersWriterLock;
-
-/**
- * @brief Initialize a readers-writer lock.
- * 
- * Initializes the mutex and sets the initial state of the lock.
- * 
- * @param rwLock Pointer to the ReadersWriterLock structure to initialize.
- * @return true if initialization succeeded, false otherwise.
- */
-bool rwLockInit(ReadersWriterLock* rwLock);
-
-/**
- * @brief Acquire a read lock.
- * 
- * Blocks if a writer is active, otherwise allows multiple readers to access the data simultaneously.
- * 
- * @param rwLock Pointer to the ReadersWriterLock structure.
- */
-void rwLockAcquireRead(ReadersWriterLock* rwLock);
-
-/**
- * @brief Release a read lock.
- * 
- * Decrements the readers count.
- * 
- * @param rwLock Pointer to the ReadersWriterLock structure.
- */
-void rwLockReleaseRead(ReadersWriterLock* rwLock);
-
-/**
- * @brief Acquire a write lock.
- * 
- * Blocks until all readers have finished and sets the writer active flag.
- * 
- * @param rwLock Pointer to the ReadersWriterLock structure.
- */
-void rwLockAcquireWrite(ReadersWriterLock* rwLock);
-
-/**
- * @brief Release a write lock.
- * 
- * Clears the writer active flag and allows readers and writers.
- * 
- * @param rwLock Pointer to the ReadersWriterLock structure.
- */
-void rwLockReleaseWrite(ReadersWriterLock* rwLock);
-
-#endif // READERS_WRITER_LOCK_H

src/tools/tools.cpp

@@ -21,6 +21,10 @@ extern AsyncWebSocket webSocket;
 
 extern Version current_spiffs_version;
 
+bool is_error(ActiveErrors active_errors) {
+    return active_errors.current_high || active_errors.current_low || active_errors.level_high || active_errors.level_low || active_errors.voltage_high || active_errors.voltage_low;
+}
+
 String processor(const String& var)
 {
   if (var == level_sensor_range_key) {
@@ -45,11 +49,9 @@ void update_started() {
 }
 
 void update_finished() {
-  LOG(ELOG_LEVEL_DEBUG, "OTA Update finished, rebooting after 2 seconds");
+  LOG(ELOG_LEVEL_DEBUG, "OTA Update finished");
   ota_status.update_progress = -1;
   webSocket.textAll(String(-1).c_str());
-  delay(2000);
-  ESP.restart();
 }
 
 void update_progress(int cur, int total) {
@@ -100,6 +102,7 @@ void check_and_update_littleFS(OTA littlefs) {
     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)) {

src/tools/tools.h

@@ -6,6 +6,7 @@
 
 void printSuffix(Print* _logOutput, int logLevel);
 void print_prefix(Print* _logOutput, int logLevel);
+bool is_error(ActiveErrors active_errors);
 String processor(const String& var);
 void check_update_task(void* parameter);
 void run_ota_update_task(void* parameter);