in between commit

platformio.ini

@@ -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.10.158
 build_flags = ${env:esp32_base.build_flags} -DUSE_INA226
 
 [env:native]

src/global_data/defines.h

@@ -3,6 +3,7 @@
 
 #define ssid_key "ssid"
 #define wifi_password_key "wifi_password"
+#define hostname_key "hostname"
 #define level_sensor_range_key "sensor_range"
 #define water_level_min_key "water_level_min"
 #define water_level_max_key "water_level_max"

src/global_data/global_data.h

@@ -88,6 +88,7 @@ typedef struct {
     DeviceTelemetry telemetryData; /**< Latest telemetry data */
     OTAStatus otaStatus;         /**< Latest OTA status */
     ActiveErrors activeErrors;   /**< Latest active errors */
+    Version spiffs_version;       /**< Current SPIFFS version */
 } CurrentState;
 
 // Enum to represent different types of data that can be sent between tasks
@@ -97,9 +98,25 @@ typedef enum {
     DATA_TYPE_WIFI,
     DATA_TYPE_ETHERNET,
     DATA_TYPE_TELEMETRY,
-    DATA_TYPE_OTA
+    DATA_TYPE_OTA,
+    DATA_TYPE_PREFERENCES
 } DataType;
 
+/**
+ * @brief Structure to hold sensor-related preferences.
+ * 
+ * Contains calibration and configuration values for the sensor and network.
+ */
+typedef struct {
+    float level_sensor_range;  /**< Maximum range of the level sensor in cm */
+    float water_level_min;     /**< Minimum water level in cm */
+    float water_level_max;     /**< Maximum water level in cm */
+    float water_volume;        /**< Total volume of the tank in liters */
+    char ssid[33];             /**< WiFi SSID (max 32 chars + null terminator) */
+    char wifi_password[65];    /**< WiFi password (max 64 chars + null terminator) */
+    char hostname[33];         /**< Device hostname (max 32 chars + null terminator) */
+} PreferencesData;
+
 // Union to hold different types of data
 typedef union {
     SensorData sensorData;
@@ -107,6 +124,7 @@ typedef union {
     NetworkData networkData;
     DeviceTelemetry telemetryData;
     OTAStatus otaStatus;
+    PreferencesData preferencesData;
 } DataUnion;
 
 // Structure to hold data type and the actual data

src/main.cpp

@@ -39,13 +39,14 @@ Version current_spiffs_version;
 
 // Variable to store the current state of the system
 CurrentState current_state = {
-    {-999.0f, -999.0f, -999.0f},
+    {-999.0f, -999.0f, -999.0f},         // waterData
-    {-999.0f, -999.0f, -999.0f},
+    {-999.0f, -999.0f, -999.0f},         // sensorData
     {"0.0.0.0", false, -999.0f, "UNKNOWN"},  // wifiData
     {"0.0.0.0", false, -999.0f, "UNKNOWN"},  // ethernetData
-    {-999.0f, -999, -999.0f},
+    {-999.0f, -999, -999.0f},            // telemetryData
-    {false, {0, 0, 0}, {0, 0, 0}, -999, "UNKNOWN"},
+    {false, {0, 0, 0}, {0, 0, 0}, -999, "UNKNOWN"},  // otaStatus
-    {false, false, false, false, false, false}
+    {false, false, false, false, false, false}, // activeErrors
+    {0, 0, 0}                            // spiffs_version
 };
 
 #define FORMAT_LITTLEFS_IF_FAILED true
@@ -56,6 +57,15 @@ QueueHandle_t dataQueue = xQueueCreate(5, sizeof(DataMessage));
 // Queue for sending data from processor to different tasks
 QueueHandle_t stateForWebserverQueue = xQueueCreate(2, sizeof(CurrentState));
 
+// Queue for sending preferences from main to webserver
+QueueHandle_t prefsForWebserverQueue = xQueueCreate(2, sizeof(DataMessage));
+
+// Queue for sending preferences from main to sensor task
+QueueHandle_t prefsForSensorQueue = xQueueCreate(2, sizeof(DataMessage));
+
+// Queue for sending preferences from main to networking tasks
+QueueHandle_t prefsForNetworkingQueue = xQueueCreate(2, sizeof(DataMessage));
+
 void setup()
 {
     Logger.registerSerial(MYLOG, ELOG_LEVEL_DEBUG, "Serial");
@@ -63,6 +73,49 @@ void setup()
     prefs.begin("waterlevel", false);
     Serial.begin(115200);
 
+    // Read initial preferences and send to webserver, sensor, and networking
+    if (prefsForWebserverQueue != NULL || prefsForSensorQueue != NULL || prefsForNetworkingQueue != NULL) {
+        DataMessage prefsMessage;
+        prefsMessage.type = DATA_TYPE_PREFERENCES;
+        prefsMessage.data.preferencesData.level_sensor_range = prefs.getFloat(level_sensor_range_key, 200);
+        prefsMessage.data.preferencesData.water_level_min = prefs.getFloat(water_level_min_key, 0);
+        prefsMessage.data.preferencesData.water_level_max = prefs.getFloat(water_level_max_key, 200);
+        prefsMessage.data.preferencesData.water_volume = prefs.getFloat(water_volume_key, 10000.0f);
+        strncpy(prefsMessage.data.preferencesData.ssid, prefs.getString(ssid_key, "").c_str(), sizeof(prefsMessage.data.preferencesData.ssid) - 1);
+        prefsMessage.data.preferencesData.ssid[sizeof(prefsMessage.data.preferencesData.ssid) - 1] = '\0';
+        strncpy(prefsMessage.data.preferencesData.wifi_password, prefs.getString(wifi_password_key, "").c_str(), sizeof(prefsMessage.data.preferencesData.wifi_password) - 1);
+        prefsMessage.data.preferencesData.wifi_password[sizeof(prefsMessage.data.preferencesData.wifi_password) - 1] = '\0';
+        strncpy(prefsMessage.data.preferencesData.hostname, prefs.getString(hostname_key, "").c_str(), sizeof(prefsMessage.data.preferencesData.hostname) - 1);
+        prefsMessage.data.preferencesData.hostname[sizeof(prefsMessage.data.preferencesData.hostname) - 1] = '\0';
+        
+        // Send to webserver
+        if (prefsForWebserverQueue != NULL) {
+            if (xQueueSend(prefsForWebserverQueue, &prefsMessage, 100 / portTICK_PERIOD_MS) != pdTRUE) {
+                LOG(ELOG_LEVEL_ERROR, "Failed to send initial preferences to webserver queue");
+            } else {
+                LOG(ELOG_LEVEL_DEBUG, "Sent initial preferences to webserver");
+            }
+        }
+        
+        // Send to sensor task
+        if (prefsForSensorQueue != NULL) {
+            if (xQueueSend(prefsForSensorQueue, &prefsMessage, 100 / portTICK_PERIOD_MS) != pdTRUE) {
+                LOG(ELOG_LEVEL_ERROR, "Failed to send initial preferences to sensor queue");
+            } else {
+                LOG(ELOG_LEVEL_DEBUG, "Sent initial preferences to sensor");
+            }
+        }
+        
+        // Send to networking tasks
+        if (prefsForNetworkingQueue != NULL) {
+            if (xQueueSend(prefsForNetworkingQueue, &prefsMessage, 100 / portTICK_PERIOD_MS) != pdTRUE) {
+                LOG(ELOG_LEVEL_ERROR, "Failed to send initial preferences to networking queue");
+            } else {
+                LOG(ELOG_LEVEL_DEBUG, "Sent initial preferences to networking");
+            }
+        }
+    }
+
     LOG(ELOG_LEVEL_DEBUG, "Beginning LittleFS");
     LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED);
 
@@ -74,6 +127,7 @@ void setup()
     } else {
       String version = file.readStringUntil('\n');
       current_spiffs_version = parseVersion(version.c_str());
+      current_state.spiffs_version = current_spiffs_version;
       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");
@@ -83,14 +137,35 @@ void setup()
     if (dataQueue == NULL) {
         LOG(ELOG_LEVEL_ERROR, "Failed to create data queue");
     } else {
-        xTaskCreate(ethernet_task, "EthernetTask", 1024 * 4, dataQueue, 1, NULL);
+        // Create networking queues struct (shared by wifi and ethernet tasks)
-        xTaskCreate(wifi_task, "WiFiTask", 1024 * 4, dataQueue, 1, NULL);
+        NetworkingQueues networkingQueues = {
-        xTaskCreate(read_sensor_task, "ReadSensorTask", 1024 * 4, dataQueue, 1, NULL);
+            .dataQueue = dataQueue,
+            .prefsQueue = prefsForNetworkingQueue
+        };
+        xTaskCreate(ethernet_task, "EthernetTask", 1024 * 4, &networkingQueues, 1, NULL);
+        xTaskCreate(wifi_task, "WiFiTask", 1024 * 4, &networkingQueues, 1, NULL);
+        // Create sensor queues struct
+        SensorQueues sensorQueues = {
+            .dataQueue = dataQueue,
+            .prefsQueue = prefsForSensorQueue
+        };
+        xTaskCreate(read_sensor_task, "ReadSensorTask", 1024 * 4, &sensorQueues, 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);
-        xTaskCreate(check_update_task, "CheckUpdateTask", 1024 * 6, dataQueue, 1, NULL);
+        // Create check update task args with spiffs_version
-        xTaskCreate(webserver_task, "WebServerTask", 1024 * 4, stateForWebserverQueue, 1, NULL);
+        CheckUpdateTaskArgs checkUpdateArgs = {
+            .dataQueue = dataQueue,
+            .spiffs_version = current_spiffs_version
+        };
+        xTaskCreate(check_update_task, "CheckUpdateTask", 1024 * 6, &checkUpdateArgs, 1, NULL);
+        // Create webserver queues struct
+        WebserverQueues webserverQueues = {
+            .stateQueue = stateForWebserverQueue,
+            .dataQueue = dataQueue,
+            .prefsQueue = prefsForWebserverQueue
+        };
+        xTaskCreate(webserver_task, "WebServerTask", 1024 * 4, &webserverQueues, 1, NULL);
         xTaskCreate(ota_handler_task, "OTAHandlerTask", 1024 * 4, NULL, 3, NULL);
     }
 }
@@ -140,14 +215,50 @@ void loop()
                     current_state.otaStatus.current_version.major, current_state.otaStatus.current_version.minor, current_state.otaStatus.current_version.patch,
                     current_state.otaStatus.latest_version.major, current_state.otaStatus.latest_version.minor, current_state.otaStatus.latest_version.patch);
                 break;
+            case DATA_TYPE_PREFERENCES:
+                // Store preferences in flash and forward to webserver
+                LOG(ELOG_LEVEL_DEBUG, "Received preference update request");
+                
+                // Write to preferences storage
+                prefs.putFloat(level_sensor_range_key, dataMessage.data.preferencesData.level_sensor_range);
+                prefs.putFloat(water_level_min_key, dataMessage.data.preferencesData.water_level_min);
+                prefs.putFloat(water_level_max_key, dataMessage.data.preferencesData.water_level_max);
+                prefs.putFloat(water_volume_key, dataMessage.data.preferencesData.water_volume);
+                prefs.putString(ssid_key, dataMessage.data.preferencesData.ssid);
+                prefs.putString(wifi_password_key, dataMessage.data.preferencesData.wifi_password);
+                
+                // Forward to webserver so it can update its local copy
+                if (prefsForWebserverQueue != NULL) {
+                    if (xQueueSend(prefsForWebserverQueue, &dataMessage, 100 / portTICK_PERIOD_MS) != pdTRUE) {
+                        LOG(ELOG_LEVEL_ERROR, "Failed to forward preferences to webserver queue");
+                    }
+                }
+                
+                // Forward to sensor task so it can update its local copy
+                if (prefsForSensorQueue != NULL) {
+                    if (xQueueSend(prefsForSensorQueue, &dataMessage, 100 / portTICK_PERIOD_MS) != pdTRUE) {
+                        LOG(ELOG_LEVEL_ERROR, "Failed to forward preferences to sensor queue");
+                    }
+                }
+                
+                // Forward to networking tasks so they can update their local copy
+                if (prefsForNetworkingQueue != NULL) {
+                    if (xQueueSend(prefsForNetworkingQueue, &dataMessage, 100 / portTICK_PERIOD_MS) != pdTRUE) {
+                        LOG(ELOG_LEVEL_ERROR, "Failed to forward preferences to networking queue");
+                    }
+                }
+                LOG(ELOG_LEVEL_DEBUG, "Stored preferences and forwarded to all tasks");
+                break;
             default:
                 LOG(ELOG_LEVEL_ERROR, "Unknown data type received");
                 break;
         }
-        // Send the updated current_state to the webserver queue
+        // Send the updated current_state to the webserver queue (for non-preference messages)
+        if (dataMessage.type != DATA_TYPE_PREFERENCES) {
             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");
     }

src/networking/networking.cpp

@@ -1,10 +1,10 @@
 #include <Elog.h>
 #include <WiFi.h>
 #include "../global_data/defines.h"
-#include <Preferences.h>
 #include "../global_data/global_data.h"
 #include <tools/log.h>
 #include "freertos/queue.h"
+#include "networking.h"
 
 #define ETH_PHY_TYPE ETH_PHY_LAN8720
 #define ETH_PHY_ADDR  0
@@ -22,7 +22,13 @@ uint8_t failed_connection_attempts = 0;
 NetworkData wifi_data;
 NetworkData ethernet_data;
 
-extern Preferences prefs;
+// Local preference storage
+static char local_hostname[33] = "";
+static char local_ssid[33] = "";
+static char local_wifi_password[65] = "";
+
+// Queue handle for receiving preference updates
+static QueueHandle_t g_prefsQueue = NULL;
 
 // Defines the type of connection for which the hostname should be created
 enum HostnameType {
@@ -32,33 +38,60 @@ enum HostnameType {
 };
 
 const char * get_hostname(HostnameType host_type) {
-    String default_hostname = "Waterlevel-" + String(mac_address, HEX);
+    String hostname_str = String(local_hostname);
-    String hostname = prefs.getString("hostname", default_hostname);
+    if (hostname_str.length() == 0) {
+        hostname_str = "Waterlevel-" + String(mac_address, HEX);
+    }
+    
+    static char hostname_buffer[64];
     switch (host_type)
     {
     case Wireless:
-        return (hostname + "-wl").c_str();
+        snprintf(hostname_buffer, sizeof(hostname_buffer), "%s-wl", hostname_str.c_str());
+        break;
     case Ethernet:
-        return (hostname + "-eth").c_str();
+        snprintf(hostname_buffer, sizeof(hostname_buffer), "%s-eth", hostname_str.c_str());
+        break;
     default:
-        return hostname.c_str();
+        snprintf(hostname_buffer, sizeof(hostname_buffer), "%s", hostname_str.c_str());
+        break;
     }
+    return hostname_buffer;
 }
 
 void wifi_task(void* parameter)
 {
-    // Extract the queue handle from the task parameters
+    // Extract the queue handles from the task parameters
-    QueueHandle_t dataQueue = (QueueHandle_t)parameter;
+    NetworkingQueues* queues = (NetworkingQueues*)parameter;
-    if (dataQueue == NULL) {
+    if (queues == NULL || queues->dataQueue == NULL) {
-        LOG(ELOG_LEVEL_ERROR, "Data queue is NULL");
+        LOG(ELOG_LEVEL_ERROR, "Queue parameters are NULL");
         vTaskDelete(NULL);
         return;
     }
     
+    // Store queue handles
+    QueueHandle_t dataQueue = queues->dataQueue;
+    g_prefsQueue = queues->prefsQueue;
+    
     LOG(ELOG_LEVEL_DEBUG, "Starting WiFi Task");
     WiFi.setHostname(get_hostname(Wireless));
     while (true) {
-        if (prefs.getString(ssid_key, "") == "" || failed_connection_attempts > 5) {
+        // Check for preference updates first
+        DataMessage prefsMessage;
+        if (g_prefsQueue != NULL && xQueueReceive(g_prefsQueue, &prefsMessage, 0) == pdTRUE) {
+            if (prefsMessage.type == DATA_TYPE_PREFERENCES) {
+                // Update local preference values
+                strncpy(local_ssid, prefsMessage.data.preferencesData.ssid, sizeof(local_ssid) - 1);
+                local_ssid[sizeof(local_ssid) - 1] = '\0';
+                strncpy(local_wifi_password, prefsMessage.data.preferencesData.wifi_password, sizeof(local_wifi_password) - 1);
+                local_wifi_password[sizeof(local_wifi_password) - 1] = '\0';
+                strncpy(local_hostname, prefsMessage.data.preferencesData.hostname, sizeof(local_hostname) - 1);
+                local_hostname[sizeof(local_hostname) - 1] = '\0';
+                LOG(ELOG_LEVEL_DEBUG, "Updated networking preferences: ssid=%s, hostname=%s", local_ssid, local_hostname);
+            }
+        }
+        
+        if (local_ssid[0] == '\0' || failed_connection_attempts > 5) {
             wifi_data.link = false;
             if (failed_connection_attempts > 5) {
                 LOG(ELOG_LEVEL_WARNING, "Failed to connect to currently saved SSID, starting SoftAP");
@@ -71,14 +104,14 @@ void wifi_task(void* parameter)
 
             LOG(ELOG_LEVEL_DEBUG, "Waiting for SSID now...");
 
-            String old_ssid = prefs.getString(ssid_key, "xxx");
+            String old_ssid = String(local_ssid);
-            while (prefs.getString(ssid_key, "") == "" || prefs.getString(ssid_key, "") == old_ssid) {
+            while (local_ssid[0] == '\0' || String(local_ssid) == old_ssid) {
                 delay(5000);
             }
 
             failed_connection_attempts = 0;
         } else {
-            if (WiFi.isConnected() && WiFi.SSID() == prefs.getString(ssid_key, "")) {
+            if (WiFi.isConnected() && WiFi.SSID() == String(local_ssid)) {
                 failed_connection_attempts = 0;
                 wifi_data.rssi = WiFi.RSSI();
                 wifi_data.link = true;
@@ -97,14 +130,12 @@ void wifi_task(void* parameter)
                     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"));
+                LOG(ELOG_LEVEL_DEBUG, "WIFI connected; RSSI: %F, IP Address, %s, SSID: %s", float(WiFi.RSSI()), WiFi.localIP().toString(), local_ssid);
                 delay(1000 * 60);
             } else {
-                String ssid = prefs.getString(ssid_key, "");
+                LOG(ELOG_LEVEL_DEBUG, "Connecting to %s...", local_ssid);
-                String password = prefs.getString(wifi_password_key, "");
-                LOG(ELOG_LEVEL_DEBUG, "Connecting to %s...", ssid);
                 WiFi.mode(WIFI_STA);
-                WiFi.begin(ssid, password);
+                WiFi.begin(local_ssid, local_wifi_password);
                 failed_connection_attempts++;
                 LOG(ELOG_LEVEL_WARNING, "Failed to connect, retrying...");
                 delay(5000);
@@ -115,18 +146,35 @@ void wifi_task(void* parameter)
 
 void ethernet_task(void* parameter)
 {
-    // Extract the queue handle from the task parameters
+    // Extract the queue handles from the task parameters
-    QueueHandle_t dataQueue = (QueueHandle_t)parameter;
+    NetworkingQueues* queues = (NetworkingQueues*)parameter;
-    if (dataQueue == NULL) {
+    if (queues == NULL || queues->dataQueue == NULL) {
-        LOG(ELOG_LEVEL_ERROR, "Data queue is NULL");
+        LOG(ELOG_LEVEL_ERROR, "Queue parameters are NULL");
         vTaskDelete(NULL);
         return;
     }
     
+    // Store queue handles
+    QueueHandle_t dataQueue = queues->dataQueue;
+    g_prefsQueue = queues->prefsQueue;
+    
     LOG(ELOG_LEVEL_DEBUG, "Starting Ethernet Task");
     ETH.begin();
     ETH.setHostname(get_hostname(Ethernet));
     while (true) {
+        // Check for preference updates first
+        DataMessage prefsMessage;
+        if (g_prefsQueue != NULL && xQueueReceive(g_prefsQueue, &prefsMessage, 0) == pdTRUE) {
+            if (prefsMessage.type == DATA_TYPE_PREFERENCES) {
+                // Update local preference values
+                strncpy(local_hostname, prefsMessage.data.preferencesData.hostname, sizeof(local_hostname) - 1);
+                local_hostname[sizeof(local_hostname) - 1] = '\0';
+                // Update hostname on Ethernet interface
+                ETH.setHostname(get_hostname(Ethernet));
+                LOG(ELOG_LEVEL_DEBUG, "Updated networking preferences: hostname=%s", local_hostname);
+            }
+        }
+        
         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);
@@ -146,6 +194,7 @@ void ethernet_task(void* parameter)
         
         if (ETH.linkUp() && !ETH.isDefault() && ETH.localIP().toString() != "0.0.0.0") {
             LOG(ELOG_LEVEL_DEBUG, "Ethernet is up, setting to default");
+            ETH.setHostname(get_hostname(Ethernet));
             ETH.setDefault();
         }
 

src/networking/networking.h

@@ -1,2 +1,10 @@
-void wifi_task(void*);
+#include <freertos/queue.h>
-void ethernet_task(void*);
+
+// Structure to hold queue handles for networking tasks
+typedef struct {
+    QueueHandle_t dataQueue;
+    QueueHandle_t prefsQueue;
+} NetworkingQueues;
+
+void wifi_task(void* parameter);
+void ethernet_task(void* parameter);

src/networking/webserver.cpp

@@ -5,7 +5,6 @@
 #include <LittleFS.h>
 #include <Elog.h>
 #include <AsyncTCP.h>
-#include <Preferences.h>
 #include "tools/log.h"
 #include "AsyncJson.h"
 #include <ArduinoJson.h>
@@ -21,10 +20,12 @@
 #include "../global_data/defines.h"
 #include "json_builder.h"
 
-extern Preferences prefs;
-
 AsyncWebServer server(80);
 
+// Queue handles (initialized in webserver_task)
+static QueueHandle_t g_dataQueue = NULL;
+static QueueHandle_t g_prefsQueue = NULL;
+
 
 WaterData local_water_data;
 SensorData local_sensor_data;
@@ -33,6 +34,16 @@ NetworkData local_ethernet_data;
 DeviceTelemetry local_telemetry;
 OTAStatus local_ota_status;
 
+// Local preference storage for template processing
+float local_level_sensor_range = -1.0f;
+float local_water_level_min = 0.0f;
+float local_water_level_max = 200.0f;
+float local_water_volume = 10000.0f;
+char local_ssid[33] = "";
+char local_wifi_password[65] = "";
+
+// Local SPIFFS version storage
+static Version local_spiffs_version = {0, 0, 0};
 
 ReadersWriterLock waterDataLock;
 ReadersWriterLock sensorDataLock;
@@ -41,6 +52,38 @@ ReadersWriterLock telemetryDataLock;
 ReadersWriterLock otaStatusLock;
 
 
+
+// ======================
+// Template Processor
+// ======================
+
+/**
+ * @brief Template processor for substituting variables in HTML/JavaScript templates.
+ * 
+ * Replaces template placeholders with values from preferences.
+ * Used by AsyncWebServer when serving template files.
+ * 
+ * @param var The template variable name to replace
+ * @return String The value to substitute, or empty string if not found
+ */
+String processor(const String& var)
+{
+  if (var == level_sensor_range_key) {
+    return String(local_level_sensor_range);
+  } else if (var == water_level_min_key) {
+    return String(local_water_level_min);
+  } else if (var == water_level_max_key) {
+    return String(local_water_level_max);
+  } else if (var == water_volume_key) {
+    return String(local_water_volume);
+  } else if (var == ssid_key) {
+    return String(local_ssid);
+  }
+    
+  return String("");
+}
+
+
 // ======================
 // Webserver Setup
 // ======================
@@ -150,7 +193,8 @@ void setup_api_endpoints(){
       }
 
       static TaskArgs_t args = {
-        .ota_status = local_ota_status
+        .ota_status = local_ota_status,
+        .spiffs_version = local_spiffs_version
       };
 
       xTaskCreate(run_ota_update_task, "RunOTAUpdate", 1024 * 8, (void *)&args, 1, NULL);
@@ -165,7 +209,8 @@ void setup_api_endpoints(){
 /**
  * @brief Handles the update of WiFi credentials.
  * 
- * Validates and updates the SSID and password in preferences.
+ * Validates and sends SSID and password update request to main task.
+ * Main task will write to preferences and distribute to tasks.
  * 
  * @param request The web server request object.
  */
@@ -174,8 +219,22 @@ void handle_update_wifi_credentials(AsyncWebServerRequest* request) {
         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());
+        // Send preference update to main task
+        DataMessage prefsMessage;
+        prefsMessage.type = DATA_TYPE_PREFERENCES;
+        prefsMessage.data.preferencesData.level_sensor_range = local_level_sensor_range; // Keep existing values
+        prefsMessage.data.preferencesData.water_level_min = local_water_level_min;
+        prefsMessage.data.preferencesData.water_level_max = local_water_level_max;
+        prefsMessage.data.preferencesData.water_volume = local_water_volume;
+        strncpy(prefsMessage.data.preferencesData.ssid, ssid_param->value().c_str(), sizeof(prefsMessage.data.preferencesData.ssid) - 1);
+        prefsMessage.data.preferencesData.ssid[sizeof(prefsMessage.data.preferencesData.ssid) - 1] = '\0';
+        strncpy(prefsMessage.data.preferencesData.wifi_password, password_param->value().c_str(), sizeof(prefsMessage.data.preferencesData.wifi_password) - 1);
+        prefsMessage.data.preferencesData.wifi_password[sizeof(prefsMessage.data.preferencesData.wifi_password) - 1] = '\0';
+        
+        if (g_dataQueue != NULL && xQueueSend(g_dataQueue, &prefsMessage, 100 / portTICK_PERIOD_MS) != pdTRUE) {
+            LOG(ELOG_LEVEL_ERROR, "Failed to send WiFi credentials update to main");
+        }
     } else {
         request->send(400, "text/plain", "Missing parameters");
         return;
@@ -213,12 +272,23 @@ void handle_update_sensor_settings(AsyncWebServerRequest* request) {
 
         LOG(ELOG_LEVEL_DEBUG, "range_float:%D:", range_float);
 
-        prefs.putFloat(level_sensor_range_key, range_float);
+        // Send preference update to main task
-        prefs.putFloat(water_level_min_key, level_min_float);
+        DataMessage prefsMessage;
-        prefs.putFloat(water_level_max_key, level_max_float);
+        prefsMessage.type = DATA_TYPE_PREFERENCES;
-        prefs.putFloat(water_volume_key, liters_float);
+        prefsMessage.data.preferencesData.level_sensor_range = range_float;
+        prefsMessage.data.preferencesData.water_level_min = level_min_float;
+        prefsMessage.data.preferencesData.water_level_max = level_max_float;
+        prefsMessage.data.preferencesData.water_volume = liters_float;
+        strncpy(prefsMessage.data.preferencesData.ssid, local_ssid, sizeof(prefsMessage.data.preferencesData.ssid) - 1);
+        prefsMessage.data.preferencesData.ssid[sizeof(prefsMessage.data.preferencesData.ssid) - 1] = '\0';
+        strncpy(prefsMessage.data.preferencesData.wifi_password, local_wifi_password, sizeof(prefsMessage.data.preferencesData.wifi_password) - 1);
+        prefsMessage.data.preferencesData.wifi_password[sizeof(prefsMessage.data.preferencesData.wifi_password) - 1] = '\0';
         
-        LOG(ELOG_LEVEL_DEBUG, "range_float_after:%D:", prefs.getFloat(level_sensor_range_key, -1.0));
+        if (g_dataQueue != NULL && xQueueSend(g_dataQueue, &prefsMessage, 100 / portTICK_PERIOD_MS) != pdTRUE) {
+            LOG(ELOG_LEVEL_ERROR, "Failed to send sensor settings update to main");
+        }
+
+        LOG(ELOG_LEVEL_DEBUG, "Sent sensor settings update to main");
     } else {
         LOG(ELOG_LEVEL_DEBUG, "!!!! FAIL lo");
         for (int i = 0; i < params; i++) {
@@ -244,17 +314,22 @@ void handle_update_sensor_settings(AsyncWebServerRequest* request) {
  * 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).
+ * @param pvParameters Task parameters (expected to be a WebserverQueues* containing stateQueue, dataQueue, and prefsQueue).
  */
 void webserver_task(void *pvParameters) {
-    // Extract the queue handle from the task parameters
+    // Extract the queue handles from the task parameters
-    QueueHandle_t stateQueue = (QueueHandle_t)pvParameters;
+    WebserverQueues* queues = (WebserverQueues*)pvParameters;
-    if (stateQueue == NULL) {
+    if (queues == NULL || queues->stateQueue == NULL) {
-        LOG(ELOG_LEVEL_ERROR, "State queue is NULL");
+        LOG(ELOG_LEVEL_ERROR, "Queue parameters are NULL");
         vTaskDelete(NULL);
         return;
     }
     
+    // Store queue handles in file-scoped variables
+    g_dataQueue = queues->dataQueue;
+    g_prefsQueue = queues->prefsQueue;
+    QueueHandle_t stateQueue = queues->stateQueue;
+    
     LOG(ELOG_LEVEL_DEBUG, "Setting up routes");
     setup_routes();
     
@@ -337,6 +412,25 @@ void webserver_task(void *pvParameters) {
     server.begin();
     
     while (1) {
+        // Check if there is new preference data in the queue
+        DataMessage prefsMessage;
+        if (g_prefsQueue != NULL && xQueueReceive(g_prefsQueue, &prefsMessage, 0) == pdTRUE) {
+            if (prefsMessage.type == DATA_TYPE_PREFERENCES) {
+                // Update local preference values
+                local_level_sensor_range = prefsMessage.data.preferencesData.level_sensor_range;
+                local_water_level_min = prefsMessage.data.preferencesData.water_level_min;
+                local_water_level_max = prefsMessage.data.preferencesData.water_level_max;
+                local_water_volume = prefsMessage.data.preferencesData.water_volume;
+                strncpy(local_ssid, prefsMessage.data.preferencesData.ssid, sizeof(local_ssid) - 1);
+                local_ssid[sizeof(local_ssid) - 1] = '\0';
+                strncpy(local_wifi_password, prefsMessage.data.preferencesData.wifi_password, sizeof(local_wifi_password) - 1);
+                local_wifi_password[sizeof(local_wifi_password) - 1] = '\0';
+                LOG(ELOG_LEVEL_DEBUG, "Updated preferences: range=%F, min=%F, max=%F, volume=%F, ssid=%s",
+                    local_level_sensor_range, local_water_level_min, local_water_level_max,
+                    local_water_volume, local_ssid);
+            }
+        }
+        
         // Check if there is new state data in the queue
         CurrentState currentState;
         if (xQueueReceive(stateQueue, &currentState, portMAX_DELAY) == pdTRUE) {
@@ -365,6 +459,9 @@ void webserver_task(void *pvParameters) {
             rwLockAcquireWrite(&otaStatusLock);
             local_ota_status = currentState.otaStatus;
             rwLockReleaseWrite(&otaStatusLock);
+            
+            // Update local SPIFFS version
+            local_spiffs_version = currentState.spiffs_version;
         }
     }
 }

src/networking/webserver.h

@@ -3,14 +3,23 @@
 
 #include <ESPAsyncWebServer.h>
 #include <LittleFS.h>
+#include <freertos/queue.h>
 
 extern AsyncWebServer server;
 
+// Structure to hold queue handles for the webserver task
+typedef struct {
+    QueueHandle_t stateQueue;
+    QueueHandle_t dataQueue;
+    QueueHandle_t prefsQueue;
+} WebserverQueues;
+
 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);
+String processor(const String& var);
 
 #endif // ASYNC_WEBSERVER_H
 

src/sensor/sensor.cpp

@@ -1,8 +1,8 @@
 #include "../global_data/defines.h"
-#include <Preferences.h>
 #include <Elog.h>
 #include "Wire.h"
 #include "../global_data/global_data.h"
+#include "sensor.h"
 
 
 #ifdef USE_INA226
@@ -17,13 +17,20 @@ INA233 ina_sensor(0x40);
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 
-extern Preferences prefs;
-
 WaterData water_data;
 
 // Calibration variables
 float zero_value = 0.03; // Measured shunt voltage with nothing connected, used to fix measuring offset
 
+// Local preference storage
+static float local_sensor_range = 200.0f;
+static float local_water_level_min = 0.0f;
+static float local_water_level_max = 200.0f;
+static float local_water_volume = 10000.0f;
+
+// Queue handle for receiving preference updates
+static QueueHandle_t g_prefsQueue = NULL;
+
 void init_sensor(){
     #ifdef USE_INA226
         Wire.begin(33, 32);
@@ -46,17 +53,35 @@ void init_sensor(){
 
 void read_sensor_task(void* parameter)
 {
-    // Extract the queue handle from the task parameters
+    // Extract the queue handles from the task parameters
-    QueueHandle_t dataQueue = (QueueHandle_t)parameter;
+    SensorQueues* queues = (SensorQueues*)parameter;
-    if (dataQueue == NULL) {
+    if (queues == NULL || queues->dataQueue == NULL) {
-        LOG(ELOG_LEVEL_ERROR, "Data queue is NULL");
+        LOG(ELOG_LEVEL_ERROR, "Queue parameters are NULL");
         vTaskDelete(NULL);
         return;
     }
     
+    // Store queue handles
+    QueueHandle_t dataQueue = queues->dataQueue;
+    g_prefsQueue = queues->prefsQueue;
+    
     LOG(ELOG_LEVEL_DEBUG, "Starting read sensor tasks");
     init_sensor();
     while (true) {
+        // Check for preference updates first
+        DataMessage prefsMessage;
+        if (g_prefsQueue != NULL && xQueueReceive(g_prefsQueue, &prefsMessage, 0) == pdTRUE) {
+            if (prefsMessage.type == DATA_TYPE_PREFERENCES) {
+                // Update local preference values
+                local_sensor_range = prefsMessage.data.preferencesData.level_sensor_range;
+                local_water_level_min = prefsMessage.data.preferencesData.water_level_min;
+                local_water_level_max = prefsMessage.data.preferencesData.water_level_max;
+                local_water_volume = prefsMessage.data.preferencesData.water_volume;
+                LOG(ELOG_LEVEL_DEBUG, "Updated sensor preferences: range=%F, min=%F, max=%F, volume=%F",
+                    local_sensor_range, local_water_level_min, local_water_level_max, local_water_volume);
+            }
+        }
+        
         // Get Values from sensor
         #ifndef USE_INA226
         String chip_id = ina_sensor.get_device_model();
@@ -85,11 +110,11 @@ void read_sensor_task(void* parameter)
         }
         
         
-        // Get values from storage
+        // Use locally stored preference values
-        float sensor_range = prefs.getFloat(level_sensor_range_key, 200);
+        float sensor_range = local_sensor_range;
-        float max_water_level = prefs.getFloat(water_level_max_key, sensor_range);
+        float max_water_level = local_water_level_max;
-        float min_water_level = prefs.getFloat(water_level_min_key, 0);
+        float min_water_level = local_water_level_min;
-        float max_liters = prefs.getFloat(water_volume_key, 10000.);
+        float max_liters = local_water_volume;
         
         float mA_per_cm = (20. - 4.) / (sensor_range);
 

src/sensor/sensor.h

@@ -1,2 +1,10 @@
-void read_sensor_task(void*);
+#include <freertos/queue.h>
+
+// Structure to hold queue handles for the sensor task
+typedef struct {
+    QueueHandle_t dataQueue;
+    QueueHandle_t prefsQueue;
+} SensorQueues;
+
+void read_sensor_task(void* parameter);
 void init_sensor();

src/tools/ota.cpp

@@ -2,7 +2,6 @@
 #include "ota.h"
 #include <Elog.h>
 #include "../global_data/defines.h"
-#include <Preferences.h>
 #include <fetchOTA.h>
 #include <utils.h>
 #include <ArduinoOTA.h>
@@ -14,9 +13,6 @@
   #define BOARD_VARIANT "INA233REV2"
 #endif
 
-extern Preferences prefs;
-extern Version current_spiffs_version;
-
 // OTA Callbacks
 void update_started() {
   LOG(ELOG_LEVEL_DEBUG, "OTA Update started");
@@ -37,8 +33,16 @@ void update_error(int err) {
 }
 
 void check_update_task(void* parameter) {
-  // Extract the queue handle from the task parameters
+  // Extract the queue handle and spiffs_version from the task parameters
-  QueueHandle_t dataQueue = (QueueHandle_t)parameter;
+  CheckUpdateTaskArgs* args = (CheckUpdateTaskArgs*)parameter;
+  if (args == NULL || args->dataQueue == NULL) {
+    LOG(ELOG_LEVEL_ERROR, "Invalid parameters for check_update_task");
+    vTaskDelete(NULL);
+    return;
+  }
+  
+  QueueHandle_t dataQueue = args->dataQueue;
+  Version spiffs_version = args->spiffs_version;
   OTAStatus ota_status;
 
   LOG(ELOG_LEVEL_DEBUG, "Starting check Update Task");
@@ -52,7 +56,7 @@ void check_update_task(void* parameter) {
     // 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_littleFS(littlefs_ota, spiffs_version);
       check_for_new_version(ota, &ota_status);
     } else {
       LOG(ELOG_LEVEL_WARNING, "Server did not respond to ping, waiting...");
@@ -71,15 +75,15 @@ void check_update_task(void* parameter) {
   }
 }
 
-void check_and_update_littleFS(OTA littlefs) {
+void check_and_update_littleFS(OTA littlefs, Version current_spiffs_version_param) {
   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);
+  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_param.major, current_spiffs_version_param.minor, current_spiffs_version_param.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)) {
+    if (isVersionNewer(current_spiffs_version_param, REQUIRED_SPIFFS_VERSION) && isVersionNewer(current_spiffs_version_param, 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);
 
@@ -88,7 +92,7 @@ void check_and_update_littleFS(OTA littlefs) {
       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)) {
+    } else if (isVersionNewer(current_spiffs_version_param, REQUIRED_SPIFFS_VERSION)) {
       LOG(ELOG_LEVEL_ERROR, "New LittleFS Version is needed, but not found on server");
 
     // Catch case for the rest

src/tools/ota.h

@@ -15,13 +15,19 @@ void update_error(int err);
 // OTA Update functions
 void check_update_task(void* parameter);
 void run_ota_update_task(void* parameter);
-void check_and_update_littleFS(OTA littlefs);
+void check_and_update_littleFS(OTA littlefs, Version current_spiffs_version);
 void check_for_new_version(OTA ota, OTAStatus *status);
 bool check_for_internet_connection();
 
 // OTA Handler task
 void ota_handler_task(void *pvParameters);
 
+// Struct for check_update_task parameters
+typedef struct {
+    QueueHandle_t dataQueue;
+    Version spiffs_version;
+} CheckUpdateTaskArgs;
+
 typedef struct {
     OTAStatus ota_status;
     Version spiffs_version;

src/tools/tools.cpp

@@ -1,30 +1,9 @@
 #include <Arduino.h>
 #include "tools.h"
 #include <Elog.h>
-#include "../global_data/defines.h"
-#include <Preferences.h>
 #include "log.h"
 #include "esp_sntp.h"
 
-extern Preferences prefs;
-
-String processor(const String& var)
-{
-  if (var == level_sensor_range_key) {
-    return String(prefs.getFloat(level_sensor_range_key, -1));
-  } else if (var == water_level_min_key) {
-    return String(prefs.getFloat(water_level_min_key, -1));
-  } else if (var == water_level_max_key) {
-    return String(prefs.getFloat(water_level_max_key, -1));
-  } else if (var == water_volume_key) {
-    return String(prefs.getFloat(water_volume_key, -1));
-  } else if (var == ssid_key) {
-    return String(prefs.getString(ssid_key, ""));
-  }
-    
-  return String("");
-}
-
 void get_time_task(void* parameter) {
   LOG(ELOG_LEVEL_DEBUG, "Starting GetTimeTask");
   LOG(ELOG_LEVEL_DEBUG, "Trying to get time from Internet");

src/tools/tools.h

@@ -4,7 +4,6 @@
 
 void printSuffix(Print* _logOutput, int logLevel);
 void print_prefix(Print* _logOutput, int logLevel);
-String processor(const String& var);
 void get_time_task(void* parameter);
 
 void onTimeSync(struct timeval* tv);