fix: param config via bluetooth

Author: AlexandreHiroyuki

src/context/GlobalData.hpp

@@ -19,6 +19,13 @@ enum class MessageType { LOG };
 #define MESSAGE_LOG_NAME_SIZE    32
 #define MESSAGE_LOG_MESSAGE_SIZE 2048
 
+#define RECEIVED_UART_MESSAGE_SIZE 256
+
+// Line received from BLE UART (copied off the GATT callback into this queue).
+struct ReceivedUartMessage {
+  char text[RECEIVED_UART_MESSAGE_SIZE];
+};
+
 // Message structure for queue
 struct Message {
   struct {
@@ -52,6 +59,9 @@ struct GlobalData {
   // FreeRTOS queue for inter-task communication
   QueueHandle_t communicationQueue;
 
+  // Raw lines from BLE RX; processed in CommunicationTask (not in NimBLE callback).
+  QueueHandle_t receivedUartMessages;
+
 
   /* Communication should only write on the variables below when the robot is in
    * IDLE mode */

src/main.cpp

@@ -28,17 +28,12 @@ void app_main() {
     return;
   }
 
-  // globalData.ledCommandQueue = xQueueCreate(10, sizeof(LedCommand));
-  // if(globalData.ledCommandQueue == NULL) {
-  //   ESP_LOGE("Main", "Failed to create LED command queue");
-  //   return;
-  // }
-
-  // Storage::write(globalData.randomNumber.load(std::memory_order_relaxed));
-  // Storage::write(globalData.randomChar.load(std::memory_order_relaxed));
-  // Storage::write(globalData.randomFloat.load(std::memory_order_relaxed));
-  // Storage::write(globalData.randomBool.load(std::memory_order_relaxed));
-
+  globalData.receivedUartMessages =
+      xQueueCreate(10, sizeof(ReceivedUartMessage));
+  if(globalData.receivedUartMessages == NULL) {
+    ESP_LOGE("Main", "Failed to create receivedUartMessages queue");
+    return;
+  }
 
   // Task
   // 1 word = 4 bytes

src/storage/storage.hpp

@@ -2,8 +2,10 @@
 #define STORAGE_HPP
 
 #include <atomic>
+#include <cerrno>
 #include <cstdio>
 #include <cstdlib>
+#include <cstring>
 #include <dirent.h>
 #include <iostream>
 #include <mutex>
@@ -36,7 +38,8 @@ class Storage {
   };
 
   esp_err_t mount_storage(std::string mount_path) {
-    if(is_mounted()) {
+    std::lock_guard<std::mutex> lock(fs_mutex);
+    if(mount_status) {
       ESP_LOGE(logger_tag.c_str(),
                "FATFS already mounted at %s. To mount at %s, first unmount the "
                "previous path.",
@@ -54,16 +57,19 @@ class Storage {
                esp_err_to_name(mount_result));
       mount_status = false;
       return ESP_FAIL;
-    } else {
-      ESP_LOGI(logger_tag.c_str(), "FATFS mounted successfully at %s",
-               mount_point.c_str());
-      mount_status = true;
-      return ESP_OK;
     }
+    ESP_LOGI(logger_tag.c_str(), "FATFS mounted successfully at %s",
+             mount_point.c_str());
+    mount_status = true;
+    return ESP_OK;
   }
 
   esp_err_t list_files() {
-    if(!is_mounted()) return ESP_FAIL;
+    std::lock_guard<std::mutex> lock(fs_mutex);
+    if(!mount_status) {
+      ESP_LOGD(logger_tag.c_str(), "FATFS not mounted.");
+      return ESP_FAIL;
+    }
 
     DIR           *directory_handle;
     struct dirent *directory_entry;
@@ -83,14 +89,19 @@ class Storage {
 
   esp_err_t save_data(std::string file_path, char *data_buffer,
                       size_t data_size, const char *mode = "wb") {
-    if(!is_mounted()) return ESP_FAIL;
+    std::lock_guard<std::mutex> lock(fs_mutex);
+    if(!mount_status) {
+      ESP_LOGD(logger_tag.c_str(), "FATFS not mounted.");
+      return ESP_FAIL;
+    }
 
     std::string full_path   = mount_point + "/" + file_path;
     FILE       *file_handle = fopen(full_path.c_str(), mode);
 
     if(file_handle == NULL) {
-      ESP_LOGE(logger_tag.c_str(), "Failed to open file %s for writing",
-               file_path.c_str());
+      ESP_LOGE(logger_tag.c_str(),
+               "Failed to open file %s for writing: %s (%s)", file_path.c_str(),
+               full_path.c_str(), strerror(errno));
       return ESP_FAIL;
     }
 
@@ -105,14 +116,19 @@ class Storage {
 
   esp_err_t load_data(std::string file_path, char *data_buffer,
                       size_t data_size) {
-    if(!is_mounted()) return ESP_FAIL;
+    std::lock_guard<std::mutex> lock(fs_mutex);
+    if(!mount_status) {
+      ESP_LOGD(logger_tag.c_str(), "FATFS not mounted.");
+      return ESP_FAIL;
+    }
 
     std::string full_path   = mount_point + "/" + file_path;
     FILE       *file_handle = fopen(full_path.c_str(), "r");
 
     if(file_handle == NULL) {
-      ESP_LOGE(logger_tag.c_str(), "Failed to open file %s for reading",
-               file_path.c_str());
+      ESP_LOGE(logger_tag.c_str(),
+               "Failed to open file %s for reading: %s (%s)", file_path.c_str(),
+               full_path.c_str(), strerror(errno));
       return ESP_FAIL;
     }
 
@@ -128,14 +144,19 @@ class Storage {
 
   esp_err_t load_data(std::string file_path, char **data_buffer,
                       size_t *file_size) {
-    if(!is_mounted()) return ESP_FAIL;
+    std::lock_guard<std::mutex> lock(fs_mutex);
+    if(!mount_status) {
+      ESP_LOGD(logger_tag.c_str(), "FATFS not mounted.");
+      return ESP_FAIL;
+    }
 
     std::string full_path   = mount_point + "/" + file_path;
     FILE       *file_handle = fopen(full_path.c_str(), "rb");
 
     if(file_handle == NULL) {
-      ESP_LOGE(logger_tag.c_str(), "Failed to open file %s for reading",
-               file_path.c_str());
+      ESP_LOGE(logger_tag.c_str(),
+               "Failed to open file %s for reading: %s (%s)", file_path.c_str(),
+               full_path.c_str(), strerror(errno));
       return ESP_FAIL;
     }
 
@@ -158,7 +179,11 @@ class Storage {
   }
 
   esp_err_t delete_data(std::string file_path) {
-    if(!is_mounted()) return ESP_FAIL;
+    std::lock_guard<std::mutex> lock(fs_mutex);
+    if(!mount_status) {
+      ESP_LOGD(logger_tag.c_str(), "FATFS not mounted.");
+      return ESP_FAIL;
+    }
 
     std::string full_path = mount_point + "/" + file_path;
     if(remove(full_path.c_str()) != 0) {
@@ -187,15 +212,20 @@ class Storage {
   // Vector serialization helpers
   template <typename ElementType>
   esp_err_t write_vector(const std::vector<ElementType> &vector_data,
-                        std::string file_path) {
-    if(!is_mounted()) return ESP_FAIL;
+                         std::string                     file_path) {
+    std::lock_guard<std::mutex> lock(fs_mutex);
+    if(!mount_status) {
+      ESP_LOGD(logger_tag.c_str(), "FATFS not mounted.");
+      return ESP_FAIL;
+    }
 
     std::string full_path   = mount_point + "/" + file_path;
     FILE       *file_handle = fopen(full_path.c_str(), "wb");
 
     if(file_handle == NULL) {
-      ESP_LOGE(logger_tag.c_str(), "Failed to open file %s for writing",
-               file_path.c_str());
+      ESP_LOGE(logger_tag.c_str(),
+               "Failed to open file %s for writing: %s (%s)", file_path.c_str(),
+               full_path.c_str(), strerror(errno));
       return ESP_FAIL;
     }
 
@@ -214,8 +244,12 @@ class Storage {
 
   template <typename ElementType>
   esp_err_t read_vector(std::vector<ElementType> &vector_data,
-                        std::string file_path) {
-    if(!is_mounted()) return ESP_FAIL;
+                        std::string               file_path) {
+    std::lock_guard<std::mutex> lock(fs_mutex);
+    if(!mount_status) {
+      ESP_LOGD(logger_tag.c_str(), "FATFS not mounted.");
+      return ESP_FAIL;
+    }
 
     std::string full_path   = mount_point + "/" + file_path;
     FILE       *file_handle = fopen(full_path.c_str(), "rb");
@@ -245,7 +279,10 @@ class Storage {
 
   // Check if file exists
   bool file_exists(std::string file_path) {
-    if(!is_mounted()) return false;
+    std::lock_guard<std::mutex> lock(fs_mutex);
+    if(!mount_status) {
+      return false;
+    }
 
     std::string full_path   = mount_point + "/" + file_path;
     FILE       *file_handle = fopen(full_path.c_str(), "r");
@@ -265,25 +302,18 @@ class Storage {
   std::string                      mount_point;
   esp_vfs_fat_sdmmc_mount_config_t fat_mount_config;
   bool                             mount_status;
+  mutable std::mutex               fs_mutex;
 
   Storage() {
     wear_leveling_handle = WL_INVALID_HANDLE;
     mount_point          = "/data";
     logger_tag           = "Storage";
 
     fat_mount_config.format_if_mount_failed = true;
-    fat_mount_config.max_files              = 5;
+    fat_mount_config.max_files              = 16;
     fat_mount_config.allocation_unit_size   = CONFIG_WL_SECTOR_SIZE;
     mount_status                            = false;
   }
-
-  bool is_mounted() {
-    if(!mount_status) {
-      ESP_LOGD(logger_tag.c_str(), "FATFS not mounted.");
-    }
-
-    return mount_status;
-  }
 };
 
 // Static member definitions

src/tasks/CommunicationTask/CommunicationTask.hpp

@@ -6,6 +6,8 @@
 #include <cstring>
 #include <string>
 
+#include "esp_log.h"
+
 #include "nimble-nordic-uart/nimble-nordic-uart.h"
 
 #include "cli/cli.hpp"
@@ -23,25 +25,27 @@ void uartStatusChangeCallback(enum nordic_uart_callback_type callback_type) {
   }
 }
 
-// Callback para receber dados da UART BLE
+// NimBLE GATT callback: only enqueue — CLI runs in communicationTaskLoop.
 void uartReceiveCallback(struct ble_gatt_access_ctxt *ctxt) {
-  // Get the actual data length from the mbuf
   uint16_t data_len = ctxt->om->om_len;
 
-  // Create a null-terminated buffer to safely handle the data
-  char   buffer[256];
-  size_t copy_len =
-      (data_len < sizeof(buffer) - 1) ? data_len : sizeof(buffer) - 1;
-  memcpy(buffer, ctxt->om->om_data, copy_len);
-  buffer[copy_len] = '\0';
-
-  ESP_LOGI("CommunicationTask", "BLE UART received data: %s (len: %d)", buffer,
-           data_len);
+  ReceivedUartMessage uartMsg{};
+  size_t              copy_len = (data_len < RECEIVED_UART_MESSAGE_SIZE - 1)
+                                   ? data_len
+                                   : RECEIVED_UART_MESSAGE_SIZE - 1;
+  memcpy(uartMsg.text, ctxt->om->om_data, copy_len);
+  uartMsg.text[copy_len] = '\0';
+
+  if(xQueueSend(globalData.receivedUartMessages, &uartMsg, 0) != pdTRUE) {
+    ESP_LOGW("CommunicationTask",
+             "receivedUartMessages full, dropping (len=%u)",
+             static_cast<unsigned>(data_len));
+  }
+}
 
-  // Execute CLI command and check return value
+static void processReceivedUartLine(char *buffer) {
   int cliResult = cli(buffer);
 
-  // If CLI returned an error, log and push error message to queue
   if(cliResult != CLI_SUCCESS) {
     switch(cliResult) {
     case CLI_ERROR_EMPTY_COMMAND:
@@ -80,17 +84,37 @@ void processMessage(const Message &msg) {
   }
 }
 
+static void drainOutgoingMessages() {
+  Message receivedMessage;
+  while(xQueueReceive(globalData.communicationQueue, &receivedMessage, 0) ==
+        pdTRUE) {
+    processMessage(receivedMessage);
+  }
+}
+
 void communicationTaskLoop(void *params) {
   (void)params;
   nordic_uart_start("TT_SEMREH", uartStatusChangeCallback);
   nordic_uart_yield(uartReceiveCallback);
 
-  Message receivedMessage;
+  Message             receivedMessage;
+  ReceivedUartMessage uartMsg;
 
   for(;;) {
+    while(xQueueReceive(globalData.receivedUartMessages, &uartMsg, 0) ==
+          pdTRUE) {
+      ESP_LOGI("CommunicationTask", "BLE UART received data: %s", uartMsg.text);
+      processReceivedUartLine(uartMsg.text);
+      drainOutgoingMessages();
+    }
+
     if(xQueueReceive(globalData.communicationQueue, &receivedMessage,
                      pdMS_TO_TICKS(100)) == pdTRUE) {
       processMessage(receivedMessage);
+      while(xQueueReceive(globalData.communicationQueue, &receivedMessage, 0) ==
+            pdTRUE) {
+        processMessage(receivedMessage);
+      }
     }
 
     vTaskDelay(pdMS_TO_TICKS(10));