Obbart/AstroRotaxMonitor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

task variable name refactoring

Browse Source
This commit is contained in:
Emanuele Trabattoni
2026-04-22 14:17:35 +02:00
parent d700578256
commit 15ca82b6df
2 changed files with 86 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
RotaxMonitor/src/tasks.cpp
View File

@@ -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<PSHistory>(&m_history_0);
m_save_history = std::unique_ptr<PSHistory>(&m_history_1);
m_historyActive = std::unique_ptr<PSHistory>(&m_historyBuf0);
m_historyInactive = std::unique_ptr<PSHistory>(&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<void(ignitionBoxStatusFiltered)> 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<std::mutex> fs_lock(m_fs_mutex);
std::lock_guard<std::mutex> 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)

44
RotaxMonitor/src/tasks.h
View File

@@ -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;
const uint32_t m_historyMax;
bool m_historySaveEnable = false;
std::filesystem::path m_historyPath;
PSHistory m_historyBuf0;
PSHistory m_historyBuf1;
std::unique_ptr<PSHistory> m_historyActive;
std::unique_ptr<PSHistory> m_historyInactive;
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<PSHistory> m_active_history;
std::unique_ptr<PSHistory> m_save_history;
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<void(ignitionBoxStatusFiltered)> m_on_message_cb = nullptr;
std::function<void(ignitionBoxStatusFiltered)> m_onFilteredStatusUpdate = nullptr;
static const uint32_t c_idle_time = 10000; // in mS
static const uint32_t c_spark_timeout_max = 500; // uS