From 15ca82b6df1912712619c9eaed16fc07ddb37a0f Mon Sep 17 00:00:00 2001 From: Emanuele Trabattoni Date: Wed, 22 Apr 2026 14:17:35 +0200 Subject: [PATCH] task variable name refactoring --- RotaxMonitor/src/tasks.cpp | 125 +++++++++++++++++++------------------ RotaxMonitor/src/tasks.h | 46 +++++++------- 2 files changed, 86 insertions(+), 85 deletions(-) diff --git a/RotaxMonitor/src/tasks.cpp b/RotaxMonitor/src/tasks.cpp index 8905726..42a3f3f 100644 --- a/RotaxMonitor/src/tasks.cpp +++ b/RotaxMonitor/src/tasks.cpp @@ -319,28 +319,28 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters) } ///////////// CLASS MEMBER DEFINITIONS ///////////// -rtIgnitionTask::rtIgnitionTask(const rtTaskParams params, const uint32_t history_size, const uint32_t queue_size, const uint8_t core, std::mutex &fs_mutex, fs::FS &filesystem) : m_params(params), m_filesystem(filesystem), m_fs_mutex(fs_mutex), m_core(core), m_max_history(history_size) +rtIgnitionTask::rtIgnitionTask(const rtTaskParams params, const uint32_t history_size, const uint32_t queue_size, const uint8_t core, std::mutex &fs_mutex, fs::FS &filesystem) : m_params(params), m_filesystem(filesystem), m_filesystemMutex(fs_mutex), m_core(core), m_historyMax(history_size) { LOG_WARN("Starting Manager for [", m_params.name.c_str(), "]"); // create queue buffers - m_queue = xQueueCreate(queue_size, sizeof(ignitionBoxStatus)); - if (!m_queue) + m_rtQueueHandle = xQueueCreate(queue_size, sizeof(ignitionBoxStatus)); + if (!m_rtQueueHandle) { LOG_ERROR("Unable To Create Task [", params.name.c_str(), "] queues"); - m_manager_status = rtTaskStatus::ERROR; + m_managerStatus = rtTaskStatus::ERROR; return; } else - m_params.rt_queue = m_queue; + m_params.rt_queue = m_rtQueueHandle; try { // create PSram history vectors - m_history_0 = PSHistory(history_size); - m_history_1 = PSHistory(history_size); + m_historyBuf0 = PSHistory(history_size); + m_historyBuf1 = PSHistory(history_size); // assing active and writable history - m_active_history = std::unique_ptr(&m_history_0); - m_save_history = std::unique_ptr(&m_history_1); + m_historyActive = std::unique_ptr(&m_historyBuf0); + m_historyInactive = std::unique_ptr(&m_historyBuf1); } catch (std::bad_alloc &e) { @@ -348,86 +348,87 @@ rtIgnitionTask::rtIgnitionTask(const rtTaskParams params, const uint32_t history return; } - m_name = (std::string("man_") + m_params.name).c_str(); + m_managerTaskName = (std::string("man_") + m_params.name).c_str(); auto task_success = xTaskCreatePinnedToCore( rtIgnitionTask_manager, - m_name.c_str(), + m_managerTaskName.c_str(), RT_TASK_STACK, (void *)this, m_params.rt_priority >> 2, - &m_manager_handle, + &m_managerHandle, m_core); if (task_success != pdPASS) { LOG_ERROR("Unable To Create Manager for [", params.name.c_str(), "]"); - m_manager_status = rtTaskStatus::ERROR; + m_managerStatus = rtTaskStatus::ERROR; return; } // average every 10 samples - m_info_filtered = ignitionBoxStatusFiltered(10); - m_last_data = millis(); - m_manager_status = rtTaskStatus::OK; + m_statusFiltered = ignitionBoxStatusFiltered(m_filterSize); + m_dataLast = millis(); + m_managerStatus = rtTaskStatus::OK; } rtIgnitionTask::~rtIgnitionTask() { - if (m_rt_handle) - vTaskDelete(m_rt_handle); - if (m_manager_handle) - vTaskDelete(m_manager_handle); - if (m_queue) - vQueueDelete(m_queue); + if (m_rtHandle) + vTaskDelete(m_rtHandle); + if (m_managerHandle) + vTaskDelete(m_managerHandle); + if (m_rtQueueHandle) + vQueueDelete(m_rtQueueHandle); } void rtIgnitionTask::run() { // receive new data from the queue - auto new_data = xQueueReceive(m_queue, &m_last_status, 0); // non blocking receive + auto new_data = xQueueReceive(m_rtQueueHandle, &m_statusLast, 0); // non blocking receive if (new_data == pdPASS) { - m_last_data = millis(); - m_manager_status = rtTaskStatus::RUNNING; + m_dataLast = millis(); + m_managerStatus = rtTaskStatus::RUNNING; // if history buffer is full swap buffers and if enabled save history buffer - if (m_counter_status >= m_max_history) + if (m_statusCounter >= m_historyMax) { - LOG_DEBUG("Save for Buffer Full: ", m_counter_status); - m_counter_status = 0; - m_partial_save = false; // reset partial save flag on new data cycle - std::swap(m_active_history, m_save_history); - if (m_enable_save) - saveHistory(*m_save_history, m_history_path); // directly call the save task function to save without delay + LOG_DEBUG("Save for Buffer Full: ", m_statusCounter); + m_statusCounter = 0; + m_savePartial = false; // reset partial save flag on new data cycle + std::swap(m_historyActive, m_historyInactive); + if (m_historySaveEnable) + saveHistory(*m_historyInactive, m_historyPath); // directly call the save task function to save without delay LOG_INFO("Save History"); } // update filtered data - m_info_filtered.update(m_last_status); - (*m_active_history)[m_counter_status] = m_last_status; + m_statusFiltered.update(m_statusLast); + (*m_historyActive)[m_statusCounter] = m_statusLast; - if (m_on_message_cb && m_counter_status % 10 == 0) + // callback + if (m_onFilteredStatusUpdate && m_statusCounter % m_filterSize == 0) { - m_on_message_cb(m_info_filtered); + m_onFilteredStatusUpdate(m_statusFiltered); } // update data counter - m_counter_status++; + m_statusCounter++; } else { - if (millis() - m_last_data > c_idle_time) + if (millis() - m_dataLast > c_idle_time) { - if (m_counter_status > 0 && !m_partial_save) + if (m_statusCounter > 0 && !m_savePartial) { - LOG_DEBUG("Save Partial: ", m_counter_status); - m_active_history->resize(m_counter_status); - saveHistory(*m_active_history, m_history_path); - m_active_history->resize(m_max_history); - m_counter_status = 0; - m_partial_save = true; + LOG_DEBUG("Save Partial: ", m_statusCounter); + m_historyActive->resize(m_statusCounter); + saveHistory(*m_historyActive, m_historyPath); + m_historyActive->resize(m_historyMax); + m_statusCounter = 0; + m_savePartial = true; } - m_manager_status = rtTaskStatus::IDLE; + m_managerStatus = rtTaskStatus::IDLE; } } } @@ -441,22 +442,22 @@ const bool rtIgnitionTask::start() m_params.rt_stack_size, (void *)&m_params, m_params.rt_priority, - &m_rt_handle, + &m_rtHandle, m_core); - const bool success = task_success == pdPASS && m_rt_handle != nullptr; + const bool success = task_success == pdPASS && m_rtHandle != nullptr; if (success) - m_manager_status = rtTaskStatus::IDLE; + m_managerStatus = rtTaskStatus::IDLE; return success; } const bool rtIgnitionTask::stop() { LOG_WARN("Ending Task [", m_params.name.c_str(), "]"); - if (m_rt_handle) + if (m_rtHandle) { m_params.rt_running = false; - m_rt_handle = nullptr; - m_manager_status = rtTaskStatus::STOPPED; + m_rtHandle = nullptr; + m_managerStatus = rtTaskStatus::STOPPED; return true; } return false; @@ -464,26 +465,26 @@ const bool rtIgnitionTask::stop() const ignitionBoxStatus rtIgnitionTask::getLast() const { - return m_last_status; + return m_statusLast; } const ignitionBoxStatusFiltered rtIgnitionTask::getFiltered() const { - return m_info_filtered; + return m_statusFiltered; } const rtIgnitionTask::rtTaskStatus rtIgnitionTask::getStatus() const { - return m_manager_status; + return m_managerStatus; } void rtIgnitionTask::enableSave(const bool enable, const std::filesystem::path filename) { - m_enable_save = enable; + m_historySaveEnable = enable; if (enable && !filename.empty()) { LOG_WARN("Save History Enabled Task [", m_params.name.c_str(), "]"); - m_history_path = m_filesystem.mountpoint() / filename; + m_historyPath = m_filesystem.mountpoint() / filename; } else { @@ -493,13 +494,13 @@ void rtIgnitionTask::enableSave(const bool enable, const std::filesystem::path f void rtIgnitionTask::onMessage(std::function callaback) { - m_on_message_cb = callaback; + m_onFilteredStatusUpdate = callaback; } void rtIgnitionTask::saveHistory(const rtIgnitionTask::PSHistory &history, const std::filesystem::path &file_name) { // Lock filesystem mutex to avoid concurrent access - std::lock_guard fs_lock(m_fs_mutex); + std::lock_guard fs_lock(m_filesystemMutex); // Check for free space if (LittleFS.totalBytes() - LittleFS.usedBytes() < history.size() * sizeof(ignitionBoxStatus)) // check if at least 1MB is free for saving history @@ -516,7 +517,7 @@ void rtIgnitionTask::saveHistory(const rtIgnitionTask::PSHistory &history, const // if firt save remove old file and create new auto save_flags = std::ios::out; - if (m_first_save) + if (m_saveFirst) { save_flags |= std::ios::trunc; // overwrite existing file m_filesystem.remove(file_path.c_str()); // ensure file is removed before saving to avoid issues with appending to existing file in SPIFFS @@ -536,14 +537,14 @@ void rtIgnitionTask::saveHistory(const rtIgnitionTask::PSHistory &history, const } // write csv header - if (m_first_save) + if (m_saveFirst) { ofs << "TS,EVENTS_12,DLY_12,STAT_12,V_12_1,V_12_2,V_12_3,V_12_4,IGNITION_MODE_12," << "EVENTS_34,DLY_34,STAT_34,V_34_1,V_34_2,V_34_3,V_34_4,IGNITION_MODE_34," << "ENGINE_RPM,ADC_READTIME,N_QUEUE_ERRORS" << std::endl; ofs.flush(); - m_first_save = false; + m_saveFirst = false; } for (const auto &entry : history) diff --git a/RotaxMonitor/src/tasks.h b/RotaxMonitor/src/tasks.h index 7b90902..b0b170d 100644 --- a/RotaxMonitor/src/tasks.h +++ b/RotaxMonitor/src/tasks.h @@ -123,35 +123,35 @@ private: // static functions for FreeRTOS private: bool m_running = true; - rtTaskStatus m_manager_status = INIT; - std::string m_name; - + rtTaskStatus m_managerStatus = INIT; rtTaskParams m_params; + const uint8_t m_core; + std::string m_managerTaskName; + TaskHandle_t m_rtHandle = nullptr; + TaskHandle_t m_managerHandle = nullptr; + QueueHandle_t m_rtQueueHandle = nullptr; - TaskHandle_t m_rt_handle = nullptr; - TaskHandle_t m_manager_handle = nullptr; - QueueHandle_t m_queue = nullptr; - - bool m_enable_save = false; - std::filesystem::path m_history_path; - const uint32_t m_max_history; - PSHistory m_history_0; - PSHistory m_history_1; - std::unique_ptr m_active_history; - std::unique_ptr m_save_history; + const uint32_t m_historyMax; + bool m_historySaveEnable = false; + std::filesystem::path m_historyPath; + PSHistory m_historyBuf0; + PSHistory m_historyBuf1; + std::unique_ptr m_historyActive; + std::unique_ptr m_historyInactive; + + bool m_savePartial = false; + bool m_saveFirst = true; fs::FS &m_filesystem; - std::mutex &m_fs_mutex; + std::mutex &m_filesystemMutex; - bool m_partial_save = false; - bool m_first_save = true; + uint8_t m_filterSize = 10; + uint32_t m_statusCounter = 0; + uint32_t m_dataLast = 0; + ignitionBoxStatus m_statusLast; + ignitionBoxStatusFiltered m_statusFiltered; - uint32_t m_counter_status = 0; - uint32_t m_last_data = 0; - ignitionBoxStatus m_last_status; - ignitionBoxStatusFiltered m_info_filtered; - - std::function m_on_message_cb = nullptr; + std::function m_onFilteredStatusUpdate = nullptr; static const uint32_t c_idle_time = 10000; // in mS static const uint32_t c_spark_timeout_max = 500; // uS