fix water

src/global_data/water_data_queue.cpp

@@ -1,30 +1,39 @@
 #include "water_data_queue.h"
 #include <Arduino.h>
 
-QueueHandle_t waterDataQueue = nullptr;
+SemaphoreHandle_t waterDataMutex = nullptr;
+WaterData latestWaterDataCache = {0.0f, 0.0f, 0.0f};
 
-void initWaterDataQueue() {
+void initWaterDataSync() {
-    // Create queue that can hold 5 WaterData structures
+    // Create mutex for thread-safe access to latest data cache
-    waterDataQueue = xQueueCreate(5, sizeof(WaterData));
+    waterDataMutex = xSemaphoreCreateMutex();
     
-    if (waterDataQueue == nullptr) {
+    if (waterDataMutex == nullptr) {
-        Serial.println("Failed to create water data queue");
+        Serial.println("Failed to create water data mutex");
+    }
+}
+
+void updateLatestWaterData(const WaterData& newData) {
+    // Update the cache with new data (called by producer)
+    if (xSemaphoreTake(waterDataMutex, pdMS_TO_TICKS(10)) == pdTRUE) {
+        latestWaterDataCache = newData;
+        xSemaphoreGive(waterDataMutex);
     }
 }
 
 WaterData getLatestWaterData() {
-    WaterData latestData;
+    WaterData result;
     
-    // Try to receive the latest data without blocking
+    // Always return the latest cached data
-    if (xQueueReceive(waterDataQueue, &latestData, 0) == pdPASS) {
+    if (xSemaphoreTake(waterDataMutex, pdMS_TO_TICKS(10)) == pdTRUE) {
-        // Put the data back in the queue so other consumers can get it too
+        result = latestWaterDataCache;  // Copy the latest data
-        xQueueSendToBack(waterDataQueue, &latestData, 0);
+        xSemaphoreGive(waterDataMutex);
-        return latestData;
+        return result;
     }
     
-    // Return default values if queue is empty
+    // Fallback: if mutex fails, return default values
-    latestData.level = 0.0f;
+    result.level = 0.0f;
-    latestData.liters = 0.0f;
+    result.liters = 0.0f;
-    latestData.percentage = 0.0f;
+    result.percentage = 0.0f;
-    return latestData;
+    return result;
 }

src/global_data/water_data_queue.h

@@ -1,12 +1,16 @@
 #pragma once
 #include "global_data.h"
-#include "freertos/queue.h"
+#include "freertos/semphr.h"
 
-// Create a queue handle for WaterData
+// Mutex and cache for thread-safe water data access
-extern QueueHandle_t waterDataQueue;
+extern SemaphoreHandle_t waterDataMutex;
+extern WaterData latestWaterDataCache;
 
-// Initialize the water data queue
+// Initialize the water data synchronization
-void initWaterDataQueue();
+void initWaterDataSync();
 
-// Helper function to get latest water data
+// Helper function to get latest water data (always returns most recent)
-WaterData getLatestWaterData();
+WaterData getLatestWaterData();
+
+// Internal function for producer to update latest data
+void updateLatestWaterData(const WaterData& newData);

src/main.cpp

@@ -60,8 +60,8 @@ void setup()
     LOG(ELOG_LEVEL_DEBUG, "Init Sensor");
     init_sensor();
 
-    LOG(ELOG_LEVEL_DEBUG, "Init Water Data Queue");
+    LOG(ELOG_LEVEL_DEBUG, "Init Water Data Sync");
-    initWaterDataQueue();
+    initWaterDataSync();
 
     LOG(ELOG_LEVEL_DEBUG, "Beginning LittleFS");
     LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED);

src/sensor/sensor.cpp

@@ -106,16 +106,14 @@ void read_sensor_task(void* parameter)
         shunt_data.shunt_voltage = shunt_voltage;
         shunt_data.shunt_current = shunt_current;
 
-        // Create water data structure and send to queue
+        // Create water data structure and update latest data
         WaterData current_water_data;
         current_water_data.level = cm_over_zero;
         current_water_data.liters = liters;
         current_water_data.percentage = percentage_rounded;
         
-        // Send to queue, don't block if queue is full
+        // Update the latest water data (thread-safe)
-        if (waterDataQueue != nullptr) {
+        updateLatestWaterData(current_water_data);
-            xQueueSendToBack(waterDataQueue, &current_water_data, 0);
-        }
 
         delay(20000);
     }