From fdba6d5ad58c4736c72e5c3524a333c148949bd7 Mon Sep 17 00:00:00 2001 From: Emanuele Trabattoni Date: Sat, 11 Apr 2026 16:39:59 +0200 Subject: [PATCH] refactor continued, at least it compiles --- RotaxMonitor/lib/led/led.h | 2 +- RotaxMonitor/src/datasave.h | 4 - RotaxMonitor/src/devices.h | 48 ++++-- RotaxMonitor/src/main.cpp | 307 +++++++++++------------------------- RotaxMonitor/src/pins.h | 2 +- RotaxMonitor/src/tasks.cpp | 22 ++- RotaxMonitor/src/tasks.h | 36 +++-- 7 files changed, 162 insertions(+), 259 deletions(-) diff --git a/RotaxMonitor/lib/led/led.h b/RotaxMonitor/lib/led/led.h index 5972709..a6da94e 100644 --- a/RotaxMonitor/lib/led/led.h +++ b/RotaxMonitor/lib/led/led.h @@ -47,7 +47,7 @@ public: }; public: - RGBled(const uint8_t pin = LED); + RGBled(const uint8_t pin = 48); ~RGBled(); void setStatus(const LedStatus s); diff --git a/RotaxMonitor/src/datasave.h b/RotaxMonitor/src/datasave.h index c39d21b..b27308a 100644 --- a/RotaxMonitor/src/datasave.h +++ b/RotaxMonitor/src/datasave.h @@ -48,7 +48,3 @@ private: void filter(int32_t &old, const int32_t value, const uint32_t k); void filter(float &old, const float value, const uint32_t k); }; - -// Task and function declarations -void saveHistoryTask(void *pvParameters); -void save_history(const PSRAMVector &history, const std::filesystem::path &file_path); diff --git a/RotaxMonitor/src/devices.h b/RotaxMonitor/src/devices.h index d43d2c1..740ff0e 100644 --- a/RotaxMonitor/src/devices.h +++ b/RotaxMonitor/src/devices.h @@ -3,33 +3,53 @@ // Library defines #define ADS1256_SPI_ALREADY_STARTED +// System Includes +#include + // Device Libraries #include #include #include // ADC Channel mapping -#define ADC_CH_PEAK_12P_IN SING_0 -#define ADC_CH_PEAK_12N_IN SING_1 -#define ADC_CH_PEAK_34P_IN SING_2 -#define ADC_CH_PEAK_34N_IN SING_3 -#define ADC_CH_PEAK_12P_OUT SING_4 -#define ADC_CH_PEAK_12N_OUT SING_5 -#define ADC_CH_PEAK_34P_OUT SING_6 -#define ADC_CH_PEAK_34N_OUT SING_7 +#define ADC_CH_PEAK_12P_IN SING_0 +#define ADC_CH_PEAK_12N_IN SING_1 +#define ADC_CH_PEAK_34P_IN SING_2 +#define ADC_CH_PEAK_34N_IN SING_3 +#define ADC_CH_PEAK_12P_OUT SING_4 +#define ADC_CH_PEAK_12N_OUT SING_5 +#define ADC_CH_PEAK_34P_OUT SING_6 +#define ADC_CH_PEAK_34N_OUT SING_7 // Device Pointer structs for tasks -struct Devices { - AD5292 *pot_a = NULL, *pot_b = NULL; - ADS1256 *adc_a = NULL, *adc_b = NULL; - PCA9555* io = NULL; +struct Devices +{ + std::unique_ptr m_spi_a = nullptr; + std::unique_ptr m_spi_b = nullptr; + + std::unique_ptr m_pot_a = nullptr; + std::unique_ptr m_pot_b = nullptr; + + std::unique_ptr m_adc_a = nullptr; + std::unique_ptr m_adc_b = nullptr; + + std::unique_ptr m_expander_a = nullptr; + std::unique_ptr m_expander_b = nullptr; + std::unique_ptr m_expander_inputs_ab = nullptr; + + std::mutex m_spi_a_mutex; + std::mutex m_spi_b_mutex; + + std::mutex m_i2c_mutex; }; // Adc read channel wrapper to selet mux before reading -inline float adcReadChannel(ADS1256* adc, const uint8_t ch){ +inline float adcReadChannel(ADS1256 *adc, const uint8_t ch) +{ adc->setMUX(ch); // scarta 3 conversioni - for (int i = 0; i < 3; i++) { + for (int i = 0; i < 3; i++) + { adc->readSingle(); } // ora lettura valida a 30kSPS → ~100 µs di settling diff --git a/RotaxMonitor/src/main.cpp b/RotaxMonitor/src/main.cpp index 81fd5eb..cd5f6e0 100644 --- a/RotaxMonitor/src/main.cpp +++ b/RotaxMonitor/src/main.cpp @@ -18,7 +18,7 @@ // Defines to enable channel B #define CH_B_ENABLE -//#define TEST +// #define TEST // Debug Defines #define WIFI_SSID "AstroRotaxMonitor" @@ -52,7 +52,7 @@ void setup() IPAddress gateway(10, 11, 12, 1); IPAddress subnet(255, 255, 255, 0); WiFi.softAPConfig(local_IP, gateway, subnet); - WiFi.setTxPower(WIFI_POWER_5dBm); // reduce wifi power + WiFi.setTxPower(WIFI_POWER_5dBm); // reduce wifi power if (WiFi.softAP(WIFI_SSID, WIFI_PASSWORD)) { LOG_INFO("WiFi AP Mode Started"); @@ -81,71 +81,9 @@ void loop() RGBled led; led.setStatus(RGBled::LedStatus::INIT); bool running = true; - const uint32_t max_queue = 128; - const uint32_t filter_k = 10; + std::mutex fs_mutex; - PSRAMVector ignA_history_0(max_history); - PSRAMVector ignA_history_1(max_history); - auto *active_history_A = &ignA_history_0; - auto *writable_history_A = &ignA_history_1; - -#ifdef CH_B_ENABLE - PSRAMVector ignB_history_0(max_history); - PSRAMVector ignB_history_1(max_history); - auto *active_history_B = &ignB_history_0; - auto *writable_history_B = &ignB_history_1; -#endif - - // Resources Initialization - Devices dev; - // Task handle - TaskHandle_t trigA_TaskHandle = NULL; - TaskHandle_t trigB_TaskHandle = NULL; - // Data Queue for real time task to main loop communication - QueueHandle_t rt_taskA_queue = xQueueCreate(max_queue, sizeof(ignitionBoxStatus)); - QueueHandle_t rt_taskB_queue = xQueueCreate(max_queue, sizeof(ignitionBoxStatus)); - - rtTaskParams taskA_params{ - .rt_running = true, - .dev = std::make_shared(dev), - .rt_queue = rt_taskA_queue, - .rt_int = rtTaskInterruptParams{ - .isr_ptr = &trig_isr_A, - .trig_pin_12p = TRIG_PIN_A12P, - .trig_pin_12n = TRIG_PIN_A12N, - .trig_pin_34p = TRIG_PIN_A34P, - .trig_pin_34n = TRIG_PIN_A34N, - .spark_pin_12 = SPARK_PIN_A12, - .spark_pin_34 = SPARK_PIN_A34}, - .rt_io = rtTaskIOParams{.rst_io_peak = 0, .rst_io_sh = 0}}; - -#ifdef CH_B_ENABLE - rtTaskParams taskB_params{ - .rt_running = true, - .dev = &dev, - .rt_queue = rt_taskB_queue, - .rt_int = rtTaskInterruptParams{ - .isr_ptr = &trig_isr_B, - .trig_pin_12p = TRIG_PIN_B12P, - .trig_pin_12n = TRIG_PIN_B12N, - .trig_pin_34p = TRIG_PIN_B34P, - .trig_pin_34n = TRIG_PIN_B34N, - .spark_pin_12 = SPARK_PIN_B12, - .spark_pin_34 = SPARK_PIN_B34}, - .rt_io = rtTaskIOParams{.rst_io_peak = SS_FORCE_A, .rst_io_sh = SS_INIBHIT_A12}}; -#endif - - if (!rt_taskA_queue || !rt_taskB_queue) - { - LOG_ERROR("Unable To Create task queues"); - LOG_ERROR("5 seconds to restart..."); - vTaskDelay(pdMS_TO_TICKS(5000)); - esp_restart(); - } - else - LOG_DEBUG("Task Variables OK"); - - // Spi ok flags + //////// INIT SPI PORTS //////// bool spiA_ok = true; bool spiB_ok = true; // Init 2 SPI interfaces @@ -153,11 +91,9 @@ void loop() spiA_ok = SPI_A.begin(SPI_A_SCK, SPI_A_MISO, SPI_A_MOSI); SPI_A.setDataMode(SPI_MODE1); // ADS1256 requires SPI mode 1 #ifdef CH_B_ENABLE -#ifndef TEST SPIClass SPI_B(HSPI); spiB_ok = SPI_B.begin(SPI_B_SCK, SPI_B_MISO, SPI_B_MOSI); SPI_B.setDataMode(SPI_MODE1); // ADS1256 requires SPI mode 1 -#endif #endif if (!spiA_ok || !spiB_ok) { @@ -168,52 +104,91 @@ void loop() } LOG_DEBUG("Init SPI OK"); -#ifndef TEST - // Init ADC_A - dev.adc_a = new ADS1256(ADC_A_DRDY, ADS1256::PIN_UNUSED, ADS1256::PIN_UNUSED, ADC_A_CS, 2.5, &SPI_A); - dev.adc_a->InitializeADC(); - dev.adc_a->setPGA(PGA_1); - dev.adc_a->setDRATE(DRATE_7500SPS); -#endif -#ifdef CH_B_ENABLE -#ifndef TEST - // Init ADC_B - dev.adc_a = new ADS1256(ADC_B_DRDY, ADS1256::PIN_UNUSED, ADS1256::PIN_UNUSED, ADC_B_CS, 2.5, &SPI_B); - dev.adc_a->InitializeADC(); - dev.adc_a->setPGA(PGA_1); - dev.adc_a->setDRATE(DRATE_1000SPS); -#endif -#endif + // Resources Initialization + std::shared_ptr dev = std::make_shared(); + dev->m_spi_a = std::make_unique(SPI_A); + dev->m_spi_b = std::make_unique(SPI_B); - LOG_DEBUG("Init ADC OK"); + // Init ADC_A + dev->m_adc_a = std::make_unique(ADC_A_DRDY, ADS1256::PIN_UNUSED, ADS1256::PIN_UNUSED, ADC_A_CS, 2.5, &SPI_A); + dev->m_adc_b = std::make_unique(ADC_B_DRDY, ADS1256::PIN_UNUSED, ADS1256::PIN_UNUSED, ADC_B_CS, 2.5, &SPI_B); + + dev->m_adc_a->InitializeADC(); + dev->m_adc_a->setPGA(PGA_1); + dev->m_adc_a->setDRATE(DRATE_7500SPS); + + dev->m_adc_b->InitializeADC(); + dev->m_adc_b->setPGA(PGA_1); + dev->m_adc_b->setDRATE(DRATE_7500SPS); + + const rtIgnitionTask::rtTaskParams taskA_params{ + .rt_running = true, + .name = "rtIgnTask_A", + .rt_stack_size = RT_TASK_STACK, + .rt_priority = RT_TASK_PRIORITY, + .rt_int = rtIgnitionTask::rtTaskInterruptParams{ + .isr_ptr = &trig_isr_A, + .trig_pin_12p = TRIG_PIN_A12P, + .trig_pin_12n = TRIG_PIN_A12N, + .trig_pin_34p = TRIG_PIN_A34P, + .trig_pin_34n = TRIG_PIN_A34N, + .spark_pin_12 = SPARK_PIN_A12, + .spark_pin_34 = SPARK_PIN_A34}, + .rt_io = rtIgnitionTask::rtTaskIOParams{ + .pot_cs_12 = POT_CS_A12, + .pot_cs_34 = POT_CS_A34, + .ss_force = SS_FORCE_A, + .ss_inhibit_12 = SS_INIBHIT_A12, + .ss_inhibit_34 = SS_INHIBIT_A34, + .sh_disch_12 = SH_DISCH_A12, + .sh_disch_34 = SH_DISCH_A34, + .sh_arm_12 = SH_ARM_A12, + .sh_arm_34 = SH_ARM_A34, + .relay_in_12 = RELAY_IN_A12, + .relay_in_34 = RELAY_OUT_A12, + .relay_out_12 = RELAY_IN_A34, + .relay_out_34 = RELAY_OUT_A34, + }, + .rt_queue = nullptr, + .dev = dev}; + + const rtIgnitionTask::rtTaskParams taskB_params{ + .rt_running = true, + .name = "rtIgnTask_B", + .rt_stack_size = RT_TASK_STACK, + .rt_priority = RT_TASK_PRIORITY, + .rt_int = rtIgnitionTask::rtTaskInterruptParams{ + .isr_ptr = &trig_isr_B, + .trig_pin_12p = TRIG_PIN_B12P, + .trig_pin_12n = TRIG_PIN_B12N, + .trig_pin_34p = TRIG_PIN_B34P, + .trig_pin_34n = TRIG_PIN_B34N, + .spark_pin_12 = SPARK_PIN_B12, + .spark_pin_34 = SPARK_PIN_B34}, + .rt_io = rtIgnitionTask::rtTaskIOParams{ + .pot_cs_12 = POT_CS_B12, + .pot_cs_34 = POT_CS_B34, + .ss_force = SS_FORCE_B, + .ss_inhibit_12 = SS_INIBHIT_B12, + .ss_inhibit_34 = SS_INHIBIT_B34, + .sh_disch_12 = SH_DISCH_B12, + .sh_disch_34 = SH_DISCH_B34, + .sh_arm_12 = SH_ARM_B12, + .sh_arm_34 = SH_ARM_B34, + .relay_in_12 = RELAY_IN_B12, + .relay_in_34 = RELAY_OUT_B12, + .relay_out_12 = RELAY_IN_B34, + .relay_out_34 = RELAY_OUT_B34, + }, + .rt_queue = nullptr, + .dev = dev}; + + auto task_A = rtIgnitionTask(taskA_params, 1024, 128, CORE_0, fs_mutex); + auto task_B = rtIgnitionTask(taskA_params, 1024, 128, CORE_1, fs_mutex); // Ignition A on Core 0 - auto ignA_task_success = pdPASS; - ignA_task_success = xTaskCreatePinnedToCore( - rtIgnitionTask_realtime, - "rtTask_A", - RT_TASK_STACK, - (void *)&taskA_params, - RT_TASK_PRIORITY, - &trigA_TaskHandle, - CORE_0); - delay(100); // give some time to the thread to start - - // Ignition B on Core 1 - auto ignB_task_success = pdPASS; - -#ifdef CH_B_ENABLE - ignB_task_success = xTaskCreatePinnedToCore( - rtIgnitionTask_realtime, - "rtTask_B", - RT_TASK_STACK, - (void *)&taskB_params, - RT_TASK_PRIORITY, // priorità leggermente più alta - &trigB_TaskHandle, - CORE_1); - delay(100); // give some time to the thread to start -#endif - + auto ignA_task_success = task_A.getStatus() == rtIgnitionTask::OK ? pdPASS : pdFAIL; + auto ignB_task_success = task_B.getStatus() == rtIgnitionTask::OK ? pdPASS : pdFAIL; if (ignA_task_success != pdPASS || ignB_task_success != pdPASS) { LOG_ERROR("Unable to initialize ISR task"); @@ -225,123 +200,23 @@ void loop() LOG_DEBUG("Real Time Tasks A & B initialized"); led.setStatus(RGBled::LedStatus::OK); - bool partial_save = false; // flag to indicate if a partial save has been done after a timeout - auto last_data = millis(); - auto last_info = millis(); - - uint32_t counter_a = 0; - uint32_t counter_b = 0; - uint32_t wait_count = 0; - - ignitionBoxStatus ign_info_A; - ignitionBoxStatus ign_info_B; - - ignitionBoxStatusFiltered ign_info_avg_A(filter_k); - ignitionBoxStatusFiltered ign_info_avg_B(filter_k); - LITTLEFSGuard fsGuard; WebPage webPage(80, LittleFS); // Initialize webserver and Websocket + uint32_t last_loop = millis(); //////////////// INNER LOOP ///////////////////// while (running) { - auto dataA = pdFALSE; - auto dataB = pdFALSE; + led.setStatus(RGBled::LedStatus::IDLE); + delay(100); - dataA = xQueueReceive(rt_taskA_queue, &ign_info_A, 0); - if (counter_a >= active_history_A->size()) // not concurrent with write task - { - counter_a = 0; - partial_save = false; // reset partial save flag on new data cycle - swapHistory(active_history_A, writable_history_A); - save_history(*writable_history_A, "ignition_historyA.csv"); // directly call the save task function to save without delay - } - -#ifdef CH_B_ENABLE - dataB = xQueueReceive(rt_taskB_queue, &ign_info_B, 0); - if (counter_b >= active_history_B->size()) // not concurrent with write task - { - counter_b = 0; - partial_save = false; // reset partial save flag on new data cycle - swapHistory(active_history_B, writable_history_B); - save_history(*writable_history_B, "ignition_historyB.csv"); // directly call the save task function to save without delay - } -#endif - // Update last data - if (dataA == pdTRUE || dataB == pdTRUE) - last_data = millis(); - - // Update Led color - if (dataA == pdTRUE && dataB == pdFALSE) - led.setStatus(RGBled::DATA_A); - else if (dataB == pdTRUE && dataA == pdFALSE) - led.setStatus(RGBled::DATA_B); - else - led.setStatus(RGBled::DATA_ALL); - - if (dataA == pdTRUE) - { - (*active_history_A)[counter_a++ % active_history_A->size()] = ign_info_A; - ign_info_avg_A.update(ign_info_A); // update moving average with latest ignition status - // Serial.printf("Data Received A: %d/%d\n\r", counter_a, (*active_history_A).size()); - if (counter_a % filter_k == 0) // send data every 10 samples - { - ArduinoJson::JsonDocument wsData; - wsData["box_a"] = ign_info_avg_A.toJson(); - wsData["box_b"] = JsonObject(); - webPage.sendWsData(wsData.as()); - } - } -#ifdef CH_B_ENABLE - if (dataB == pdTRUE) - { - (*active_history_B)[counter_b++ % active_history_B->size()] = ign_info_B; - ign_info_avg_B.update(ign_info_B); // update moving average with latest ignition status - // Serial.printf("Data Received B: %d/%d\n\r", counter_b, (*active_history_B).size()); - if (counter_b % filter_k == 0) // send data every 10 samples - { - ArduinoJson::JsonDocument wsData; - wsData["box_a"] = JsonObject(); - wsData["box_b"] = ign_info_avg_B.toJson(); - webPage.sendWsData(wsData.as()); - } - } -#endif - if (dataA == pdFALSE && dataB == pdFALSE && (millis() - last_data) > 2000) - { - if (!partial_save && counter_a > 0) // if timeout occurs but we have unsaved data, save it before next timeout - { - active_history_A->resize(counter_a); // resize active history to actual number of records received to avoid saving empty records - save_history(*active_history_A, "ignition_history_A.csv"); - active_history_A->resize(max_history); // resize back to max history size for next data cycle -#ifdef CH_B_ENABLE - active_history_B->resize(counter_a); // resize active history to actual number of records received to avoid saving empty records - save_history(*active_history_B, "ignition_history_B.csv"); - active_history_B->resize(max_history); // resize back to max history size for next data cycle -#endif - counter_a = 0; // reset counter after saving - counter_b = 0; // reset counter after saving - - partial_save = true; - first_save = true; - } - // Serial.printf("[%d] Waiting for data...\r", wait_count++); - led.setStatus(RGBled::LedStatus::IDLE); - delay(100); - } - - if ((millis() - last_info) > 1000) + if ((millis() - last_loop) > 1000) { clearScreen(); Serial.println(); printRunningTasksMod(Serial); - last_info = millis(); + last_loop = millis(); } } //////////////// INNER LOOP ///////////////////// - if (trigA_TaskHandle) - vTaskDelete(trigA_TaskHandle); - if (trigB_TaskHandle) - vTaskDelete(trigB_TaskHandle); - } ////////////////////// MAIN LOOP ////////////////////// diff --git a/RotaxMonitor/src/pins.h b/RotaxMonitor/src/pins.h index f690ccf..1104ac2 100644 --- a/RotaxMonitor/src/pins.h +++ b/RotaxMonitor/src/pins.h @@ -122,7 +122,7 @@ #define POT_CS_B34 1 // --- SOFT START FORCE LINES --- -#define SS_FORCE_A 2 +#define SS_FORCE_B 2 #define SS_INIBHIT_B12 3 #define SS_INHIBIT_B34 4 diff --git a/RotaxMonitor/src/tasks.cpp b/RotaxMonitor/src/tasks.cpp index bdb1469..647b66b 100644 --- a/RotaxMonitor/src/tasks.cpp +++ b/RotaxMonitor/src/tasks.cpp @@ -38,8 +38,8 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters) const rtTaskIOParams rt_rst = params->rt_io; // copy to avoid external override QueueHandle_t rt_queue = params->rt_queue; Devices *dev = params->dev.get(); - ADS1256 *adc = dev->adc_a; - PCA9555 *io = dev->io; + ADS1256 *adc = dev->m_adc_a.get(); + PCA9555 *io = dev->m_expander_a.get(); TaskStatus_t rt_task_info; vTaskGetInfo(NULL, &rt_task_info, pdFALSE, eInvalid); @@ -282,7 +282,7 @@ 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 = LittleFS) : m_params(params), m_filesystem(filesystem), m_fs_mutex(fs_mutex), m_core(core) +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) { // create queue buffers m_queue = xQueueCreate(queue_size, sizeof(ignitionBoxStatus)); @@ -299,8 +299,8 @@ rtIgnitionTask::rtIgnitionTask(const rtTaskParams params, const uint32_t history m_history_0.resize(history_size); m_history_1.resize(history_size); // assing active and writable history - m_active_history = std::make_unique(m_history_0.data()); - m_save_history = std::make_unique(m_history_1.data()); + m_active_history = std::unique_ptr(&m_history_0); + m_save_history = std::unique_ptr(&m_history_1); LOG_WARN("Starting Manager for [", m_params.name.c_str(), "]"); auto task_success = xTaskCreate( @@ -349,7 +349,7 @@ void rtIgnitionTask::run() m_partial_save = false; // reset partial save flag on new data cycle std::swap(m_active_history, m_save_history); if (m_enable_save) - save_history(*m_save_history, m_history_path); // directly call the save task function to save without delay + saveHistory(*m_save_history, m_history_path); // directly call the save task function to save without delay } // update filtered data @@ -361,8 +361,16 @@ void rtIgnitionTask::run() } else { - if (millis() - m_last_data > c_idle_time) + if (millis() - m_last_data > c_idle_time){ + if (m_counter_status > 0 && !m_partial_save){ + 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; + } m_manager_status = rtTaskStatus::IDLE; + } delay(5); // yeld to another task } } diff --git a/RotaxMonitor/src/tasks.h b/RotaxMonitor/src/tasks.h index 3686925..a37cd9d 100644 --- a/RotaxMonitor/src/tasks.h +++ b/RotaxMonitor/src/tasks.h @@ -13,6 +13,7 @@ #include #include #include +#include // ISR #include "isr.h" @@ -39,6 +40,8 @@ static const std::map names = { class rtIgnitionTask { using PSHistory = PSRAMVector; + +public: // RT task Interrupt parameters struct rtTaskInterruptParams { @@ -55,19 +58,19 @@ class rtIgnitionTask struct rtTaskIOParams { const uint32_t expander_addr; - const uint8_t pot_cs_a12; - const uint8_t pot_cs_a34; - const uint8_t ss_force_a; - const uint8_t ss_inhibit_a12; - const uint8_t ss_inhibit_a34; - const uint8_t sh_disch_a12; - const uint8_t sh_disch_a34; - const uint8_t sh_arm_a12; - const uint8_t sh_arm_a34; - const uint8_t relay_in_a12; - const uint8_t relay_in_a34; - const uint8_t relay_out_a12; - const uint8_t relay_out_a34; + const uint8_t pot_cs_12; + const uint8_t pot_cs_34; + const uint8_t ss_force; + const uint8_t ss_inhibit_12; + const uint8_t ss_inhibit_34; + const uint8_t sh_disch_12; + const uint8_t sh_disch_34; + const uint8_t sh_arm_12; + const uint8_t sh_arm_34; + const uint8_t relay_in_12; + const uint8_t relay_in_34; + const uint8_t relay_out_12; + const uint8_t relay_out_34; }; // RT task parameters @@ -75,12 +78,12 @@ class rtIgnitionTask { bool rt_running; // run flag, false to terminate const std::string name; - const std::shared_ptr dev; const uint32_t rt_stack_size; const uint32_t rt_priority; const rtTaskInterruptParams rt_int; // interrupt pins to attach const rtTaskIOParams rt_io; // reset ping for peak detectors QueueHandle_t rt_queue; // queue for task io + const std::shared_ptr dev; }; enum rtTaskStatus @@ -109,7 +112,7 @@ public: void enableSave(const bool enable, const std::filesystem::path filename); private: - void rtIgnitionTask::saveHistory(const rtIgnitionTask::PSHistory &history, const std::filesystem::path &file_name); + void saveHistory(const rtIgnitionTask::PSHistory &history, const std::filesystem::path &file_name); private: // static functions for FreeRTOS static void rtIgnitionTask_manager(void *pvParameters); @@ -128,6 +131,7 @@ private: 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; @@ -144,7 +148,7 @@ private: ignitionBoxStatusFiltered m_info_filtered; static const uint32_t c_idle_time = 2000; // in mS - static const uint8_t c_spark_timeout_max = 500; // uS + static const uint32_t c_spark_timeout_max = 500; // uS static const uint8_t c_adc_time = 4; // in mS static const uint8_t c_io_time = 2; // in mS };