From c9887a563e273da541aa86719fa54fa6ca5e9f21 Mon Sep 17 00:00:00 2001 From: Emanuele Trabattoni Date: Wed, 22 Apr 2026 15:14:25 +0200 Subject: [PATCH] more variables name refactoring --- RotaxMonitor/src/datasave.cpp | 84 ++++----- RotaxMonitor/src/datastruct.h | 40 ++--- RotaxMonitor/src/isr.cpp | 16 +- RotaxMonitor/src/isr.h | 8 +- RotaxMonitor/src/main.cpp | 28 +-- RotaxMonitor/src/pins_test.h | 84 --------- RotaxMonitor/src/tasks.cpp | 323 +++++++++++++++++----------------- RotaxMonitor/src/tasks.h | 30 ++-- RotaxMonitor/src/ui.cpp | 42 ++--- 9 files changed, 282 insertions(+), 373 deletions(-) delete mode 100644 RotaxMonitor/src/pins_test.h diff --git a/RotaxMonitor/src/datasave.cpp b/RotaxMonitor/src/datasave.cpp index 5fb8305..7031713 100644 --- a/RotaxMonitor/src/datasave.cpp +++ b/RotaxMonitor/src/datasave.cpp @@ -48,28 +48,28 @@ void ignitionBoxStatusFiltered::update(const ignitionBoxStatus &new_status) m_count++; // simple moving average calculation m_last.timestamp = new_status.timestamp; // keep timestamp of latest status - m_last.coils12.n_events = new_status.coils12.n_events; // sum events instead of averaging - m_last.coils12.n_missed_firing = new_status.coils12.n_missed_firing; // sum missed firings instead of averaging - m_last.coils12.spark_status = new_status.coils12.spark_status; // take latest spark status - m_last.coils12.sstart_status = new_status.coils12.sstart_status; // take latest soft start status - filter(m_last.coils12.spark_delay, new_status.coils12.spark_delay, m_max_count); // incremental average calculation - filter(m_last.coils12.peak_p_in, new_status.coils12.peak_p_in, m_max_count); // incremental average calculation - filter(m_last.coils12.peak_n_in, new_status.coils12.peak_n_in, m_max_count); // incremental average calculation - filter(m_last.coils12.peak_p_out, new_status.coils12.peak_p_out, m_max_count); // incremental average calculation - filter(m_last.coils12.peak_n_out, new_status.coils12.peak_n_out, m_max_count); // incremental average calculation + m_last.coils12.nEvents = new_status.coils12.nEvents; // sum events instead of averaging + m_last.coils12.nMissedFiring = new_status.coils12.nMissedFiring; // sum missed firings instead of averaging + m_last.coils12.sparkStatus = new_status.coils12.sparkStatus; // take latest spark status + m_last.coils12.softStartStatus = new_status.coils12.softStartStatus; // take latest soft start status + filter(m_last.coils12.sparkDelay, new_status.coils12.sparkDelay, m_max_count); // incremental average calculation + filter(m_last.coils12.peakPos, new_status.coils12.peakPos, m_max_count); // incremental average calculation + filter(m_last.coils12.peakNeg, new_status.coils12.peakNeg, m_max_count); // incremental average calculation + filter(m_last.coils12.trigLevelPos, new_status.coils12.trigLevelPos, m_max_count); // incremental average calculation + filter(m_last.coils12.trigLevelNeg, new_status.coils12.trigLevelNeg, m_max_count); // incremental average calculation - m_last.coils34.n_events = new_status.coils34.n_events; // sum events instead of averaging - m_last.coils34.n_missed_firing = new_status.coils34.n_missed_firing; // sum missed firings instead of averaging - m_last.coils34.spark_status = new_status.coils34.spark_status; // take latest spark status - m_last.coils34.sstart_status = new_status.coils34.sstart_status; // take latest soft start status - filter(m_last.coils34.spark_delay, new_status.coils34.spark_delay, m_max_count); // incremental average calculation - filter(m_last.coils34.peak_p_in, new_status.coils34.peak_p_in, m_max_count); // incremental average calculation - filter(m_last.coils34.peak_n_in, new_status.coils34.peak_n_in, m_max_count); // incremental average calculation - filter(m_last.coils34.peak_p_out, new_status.coils34.peak_p_out, m_max_count); // incremental average calculation - filter(m_last.coils34.peak_n_out, new_status.coils34.peak_n_out, m_max_count); // incremental average calculation - filter(m_last.eng_rpm, new_status.eng_rpm, m_max_count); // incremental average calculation // incremental average calculation - filter(m_last.adc_read_time, m_last.adc_read_time, m_max_count); // incremental average calculation - m_last.n_queue_errors = new_status.n_queue_errors; + m_last.coils34.nEvents = new_status.coils34.nEvents; // sum events instead of averaging + m_last.coils34.nMissedFiring = new_status.coils34.nMissedFiring; // sum missed firings instead of averaging + m_last.coils34.sparkStatus = new_status.coils34.sparkStatus; // take latest spark status + m_last.coils34.softStartStatus = new_status.coils34.softStartStatus; // take latest soft start status + filter(m_last.coils34.sparkDelay, new_status.coils34.sparkDelay, m_max_count); // incremental average calculation + filter(m_last.coils34.peakPos, new_status.coils34.peakPos, m_max_count); // incremental average calculation + filter(m_last.coils34.peakNeg, new_status.coils34.peakNeg, m_max_count); // incremental average calculation + filter(m_last.coils34.trigLevelPos, new_status.coils34.trigLevelPos, m_max_count); // incremental average calculation + filter(m_last.coils34.trigLevelNeg, new_status.coils34.trigLevelNeg, m_max_count); // incremental average calculation + filter(m_last.engRpm, new_status.engRpm, m_max_count); // incremental average calculation // incremental average calculation + filter(m_last.adcReadTime, m_last.adcReadTime, m_max_count); // incremental average calculation + m_last.nQueueErrors = new_status.nQueueErrors; if (m_count >= m_max_count) { @@ -95,29 +95,29 @@ const ArduinoJson::JsonDocument ignitionBoxStatusFiltered::toJson() const doc["timestamp"] = m_last.timestamp; doc["datavalid"] = m_data_valid ? "TRUE" : "FALSE"; - doc["coils12"]["n_events"] = m_last.coils12.n_events; - doc["coils12"]["n_missed_firing"] = m_last.coils12.n_missed_firing; - doc["coils12"]["spark_delay"] = m_last.coils12.spark_delay; - doc["coils12"]["spark_status"] = sparkStatusNames.at(m_last.coils12.spark_status); - doc["coils12"]["peak_p_in"] = m_last.coils12.peak_p_in; - doc["coils12"]["peak_n_in"] = m_last.coils12.peak_n_in; - doc["coils12"]["peak_p_out"] = m_last.coils12.peak_p_out; - doc["coils12"]["peak_n_out"] = m_last.coils12.peak_n_out; - doc["coils12"]["sstart_status"] = softStartStatusNames.at(m_last.coils12.sstart_status); + doc["coils12"]["nEvents"] = m_last.coils12.nEvents; + doc["coils12"]["nMissedFiring"] = m_last.coils12.nMissedFiring; + doc["coils12"]["sparkDelay"] = m_last.coils12.sparkDelay; + doc["coils12"]["sparkStatus"] = sparkStatusNames.at(m_last.coils12.sparkStatus); + doc["coils12"]["peakPos"] = m_last.coils12.peakPos; + doc["coils12"]["peakNeg"] = m_last.coils12.peakNeg; + doc["coils12"]["trigLevelPos"] = m_last.coils12.trigLevelPos; + doc["coils12"]["trigLevelNeg"] = m_last.coils12.trigLevelNeg; + doc["coils12"]["softStartStatus"] = softStartStatusNames.at(m_last.coils12.softStartStatus); - doc["coils34"]["n_events"] = m_last.coils34.n_events; - doc["coils34"]["n_missed_firing"] = m_last.coils34.n_missed_firing; - doc["coils34"]["spark_delay"] = m_last.coils34.spark_delay; - doc["coils34"]["spark_status"] = sparkStatusNames.at(m_last.coils34.spark_status); - doc["coils34"]["peak_p_in"] = m_last.coils34.peak_p_in; - doc["coils34"]["peak_n_in"] = m_last.coils34.peak_n_in; - doc["coils34"]["peak_p_out"] = m_last.coils34.peak_p_out; - doc["coils34"]["peak_n_out"] = m_last.coils34.peak_n_out; - doc["coils34"]["sstart_status"] = softStartStatusNames.at(m_last.coils34.sstart_status); + doc["coils34"]["nEvents"] = m_last.coils34.nEvents; + doc["coils34"]["nMissedFiring"] = m_last.coils34.nMissedFiring; + doc["coils34"]["sparkDelay"] = m_last.coils34.sparkDelay; + doc["coils34"]["sparkStatus"] = sparkStatusNames.at(m_last.coils34.sparkStatus); + doc["coils34"]["peakPos"] = m_last.coils34.peakPos; + doc["coils34"]["peakNeg"] = m_last.coils34.peakNeg; + doc["coils34"]["trigLevelPos"] = m_last.coils34.trigLevelPos; + doc["coils34"]["trigLevelNeg"] = m_last.coils34.trigLevelNeg; + doc["coils34"]["softStartStatus"] = softStartStatusNames.at(m_last.coils34.softStartStatus); - doc["eng_rpm"] = m_last.eng_rpm; - doc["adc_read_time"] = m_last.adc_read_time; - doc["n_queue_errors"] = m_last.n_queue_errors; + doc["engRpm"] = m_last.engRpm; + doc["adcReadTime"] = m_last.adcReadTime; + doc["nQueueErrors"] = m_last.nQueueErrors; } return doc; } diff --git a/RotaxMonitor/src/datastruct.h b/RotaxMonitor/src/datastruct.h index 5ded4d2..de801c5 100644 --- a/RotaxMonitor/src/datastruct.h +++ b/RotaxMonitor/src/datastruct.h @@ -16,7 +16,7 @@ static const uint32_t SPARK_FLAG_12 = (1 << 9); static const uint32_t SPARK_FLAG_34 = (1 << 10); // Spark Status -enum sparkStatus +enum sparkStatusEnum { SPARK_POS_OK, SPARK_NEG_OK, @@ -31,7 +31,7 @@ enum sparkStatus SPARK_SYNC_FAIL, }; -static const std::map sparkStatusNames = { +static const std::map sparkStatusNames = { {SPARK_POS_OK, "SPARK_POS_OK"}, {SPARK_NEG_OK, "SPARK_NEG_OK"}, {SPARK_POS_SKIP, "SPARK_POS_SKIP"}, @@ -45,14 +45,14 @@ static const std::map sparkStatusNames = { {SPARK_SYNC_FAIL, "SPARK_SYNC_FAIL"}, }; -enum softStartStatus +enum softStartStatusEnum { NORMAL, SOFT_START, ERROR, }; -const std::map softStartStatusNames = { +const std::map softStartStatusNames = { {NORMAL, "NORMAL"}, {SOFT_START, "SOFT_START"}, {ERROR, "ERROR"}, @@ -60,18 +60,17 @@ const std::map softStartStatusNames = { struct coilsStatus { - int64_t trig_time = 0; - int64_t spark_time = 0; - int32_t spark_delay = 0; // in microseconds - sparkStatus spark_status = sparkStatus::SPARK_POS_OK; - softStartStatus sstart_status = softStartStatus::NORMAL; - float peak_p_in = 0.0; - float peak_n_in = 0.0; - float peak_p_out = 0.0; - float peak_n_out = 0.0; - float level_spark = 0.0; - uint32_t n_events = 0; - uint32_t n_missed_firing = 0; + int64_t coilTime = 0; + int64_t sparkTime = 0; + int32_t sparkDelay = 0; // in microseconds + sparkStatusEnum sparkStatus = sparkStatusEnum::SPARK_POS_OK; + softStartStatusEnum softStartStatus = softStartStatusEnum::NORMAL; + float peakPos = 0.0; + float peakNeg = 0.0; + float trigLevelPos = 0.0; + float trigLevelNeg = 0.0; + uint32_t nEvents = 0; + uint32_t nMissedFiring = 0; }; // Task internal Status @@ -81,13 +80,12 @@ struct ignitionBoxStatus // coils pairs for each ignition coilsStatus coils12; coilsStatus coils34; - // voltage from generator - float volts_gen = 0.0; // enine rpm - int32_t eng_rpm = 0; + int32_t engRpm = 0; // debug values - uint32_t n_queue_errors = 0; - int32_t adc_read_time = 0; + uint32_t nQueueErrors = 0; + int32_t adcReadTime = 0; + int32_t ioReadWriteTime = 0; }; diff --git a/RotaxMonitor/src/isr.cpp b/RotaxMonitor/src/isr.cpp index c87ad0b..e1f641a 100644 --- a/RotaxMonitor/src/isr.cpp +++ b/RotaxMonitor/src/isr.cpp @@ -26,22 +26,22 @@ void trig_isr_A(void *arg) case TRIG_FLAG_12P: case TRIG_FLAG_12N: // only on first trigger to avoid multiple firing due to noise, to be fixed with hardware debounce - box->coils12.trig_time = time_us; + box->coils12.coilTime = time_us; xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); break; case TRIG_FLAG_34P: case TRIG_FLAG_34N: // only on first trigger to avoid multiple firing due to noise, to be fixed with hardware debounce - box->coils34.trig_time = time_us; + box->coils34.coilTime = time_us; xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); break; case SPARK_FLAG_12: - box->coils12.spark_time = time_us; + box->coils12.sparkTime = time_us; xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); break; case SPARK_FLAG_34: - box->coils34.spark_time = time_us; + box->coils34.sparkTime = time_us; xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); break; default: @@ -75,22 +75,22 @@ void trig_isr_B(void *arg) case TRIG_FLAG_12P: case TRIG_FLAG_12N: // only on first trigger to avoid multiple firing due to noise, to be fixed with hardware debounce - box->coils12.trig_time = time_us; + box->coils12.coilTime = time_us; xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); break; case TRIG_FLAG_34P: case TRIG_FLAG_34N: // only on first trigger to avoid multiple firing due to noise, to be fixed with hardware debounce - box->coils34.trig_time = time_us; + box->coils34.coilTime = time_us; xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); break; case SPARK_FLAG_12: - box->coils12.spark_time = time_us; + box->coils12.sparkTime = time_us; xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); break; case SPARK_FLAG_34: - box->coils34.spark_time = time_us; + box->coils34.sparkTime = time_us; xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); break; default: diff --git a/RotaxMonitor/src/isr.h b/RotaxMonitor/src/isr.h index 737d1a3..f9e9d01 100644 --- a/RotaxMonitor/src/isr.h +++ b/RotaxMonitor/src/isr.h @@ -1,17 +1,11 @@ #pragma once -// Test device Flag -// #define TEST - // Arduino Libraries #include #include "soc/gpio_struct.h" #include -#ifndef TEST + #include "pins.h" -#else -#include "pins_test.h" -#endif #include "datastruct.h" #define CORE_0 0 diff --git a/RotaxMonitor/src/main.cpp b/RotaxMonitor/src/main.cpp index 546d435..def1b8f 100644 --- a/RotaxMonitor/src/main.cpp +++ b/RotaxMonitor/src/main.cpp @@ -173,13 +173,13 @@ void loop() .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}, + .isrPtr = &trig_isr_A, + .trigPin_12p = TRIG_PIN_A12P, + .trigPin_12n = TRIG_PIN_A12N, + .trigPin_34p = TRIG_PIN_A34P, + .trigPin_34n = TRIG_PIN_A34N, + .sparkPin_12 = SPARK_PIN_A12, + .sparkPin_34 = SPARK_PIN_A34}, .rt_io = rtIgnitionTask::rtTaskIOParams{ .pot_cs_12 = POT_CS_A12, .pot_cs_34 = POT_CS_A34, @@ -205,13 +205,13 @@ void loop() .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}, + .isrPtr = &trig_isr_B, + .trigPin_12p = TRIG_PIN_B12P, + .trigPin_12n = TRIG_PIN_B12N, + .trigPin_34p = TRIG_PIN_B34P, + .trigPin_34n = TRIG_PIN_B34N, + .sparkPin_12 = SPARK_PIN_B12, + .sparkPin_34 = SPARK_PIN_B34}, .rt_io = rtIgnitionTask::rtTaskIOParams{ .pot_cs_12 = POT_CS_B12, .pot_cs_34 = POT_CS_B34, diff --git a/RotaxMonitor/src/pins_test.h b/RotaxMonitor/src/pins_test.h deleted file mode 100644 index fda0ee5..0000000 --- a/RotaxMonitor/src/pins_test.h +++ /dev/null @@ -1,84 +0,0 @@ -#pragma once -#include - -// ===================== -// UART DEBUG -// ===================== -#define UART_TX 1 // TX0 (USB seriale) -#define UART_RX 3 // RX0 - - -// ===================== -// SPI BUS -// ===================== -#define SPI_A_MOSI 23 -#define SPI_A_MISO 19 -#define SPI_A_SCK 18 - - -// ===================== -// I2C BUS -// ===================== -#define SDA 21 -#define SCL 22 - - -// ===================== -// ADC CONTROL (SPI + interrupt safe) -// ===================== -#define ADC_A_CS 5 // chip select -#define ADC_A_DRDY 34 // input only + interrupt perfetto -#define ADC_A_RST 27 // output -#define ADC_A_SYNC 26 // output - - -// ===================== -// DIGITAL OUT -// ===================== -#define POT_A_CS 25 -#define POT_B_CS 33 - - -// ===================== -// TRIGGER INPUT INTERRUPTS -// ===================== -#define TRIG_PIN_A12P 35 -#define TRIG_PIN_A12N 32 -#define TRIG_PIN_A34P 39 -#define TRIG_PIN_A34N 36 - - -// ===================== -// SPARK DETECT INTERRUPTS -// ===================== -#define SPARK_PIN_A12 4 -#define SPARK_PIN_A34 2 - -// ===================== -// PCA9555 (I2C EXPANDER) -// ===================== - -// --- RESET LINES --- -#define RST_EXT_A12P 0 -#define RST_EXT_A12N 1 -#define RST_EXT_A34P 2 -#define RST_EXT_A34N 3 - -// --- RELAY --- -#define SH_ARM_A34 8 - - -// Init Pin Functions -inline void initTriggerPinsInputs() -{ - pinMode(TRIG_PIN_A12P, INPUT_PULLDOWN); - pinMode(TRIG_PIN_A12N, INPUT_PULLDOWN); - pinMode(TRIG_PIN_A34P, INPUT_PULLDOWN); - pinMode(TRIG_PIN_A34N, INPUT_PULLDOWN); -} - -inline void initSparkPinInputs() -{ - pinMode(SPARK_PIN_A12, INPUT_PULLDOWN); - pinMode(SPARK_PIN_A34, INPUT_PULLDOWN); -} \ No newline at end of file diff --git a/RotaxMonitor/src/tasks.cpp b/RotaxMonitor/src/tasks.cpp index 42a3f3f..a3a3e1a 100644 --- a/RotaxMonitor/src/tasks.cpp +++ b/RotaxMonitor/src/tasks.cpp @@ -37,155 +37,156 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters) } // Task Parameters and Devices - rtTaskParams *params = (rtTaskParams *)pvParameters; - const rtTaskInterruptParams rt_int = params->rt_int; // copy to avoid external override - const rtTaskIOParams rt_rst = params->rt_io; // copy to avoid external override - QueueHandle_t rt_queue = params->rt_queue; + const rtTaskParams *params = (const rtTaskParams *)pvParameters; + const rtTaskInterruptParams rtInterrupts = params->rt_int; // copy to avoid external override + const rtTaskIOParams rtResets = params->rt_io; // copy to avoid external override + QueueHandle_t rtQueue = params->rt_queue; Devices *dev = params->dev; ExternalIO *io = dev->m_ext_io; ADS1256 *adc = params->name == "rtIgnTask_A" ? dev->m_adc_a : dev->m_adc_b; std::mutex &spi_mutex = params->name == "rtIgnTask_A" ? dev->m_spi_a_mutex : dev->m_spi_b_mutex; - TaskStatus_t rt_task_info; - vTaskGetInfo(NULL, &rt_task_info, pdFALSE, eInvalid); - + // Geta task name and additiona info for debug messages + TaskStatus_t rtTaskInfo; + vTaskGetInfo(NULL, &rtTaskInfo, pdFALSE, eInvalid); LOG_INFO("rtTask Params OK [", params->name.c_str(), "]"); - ignitionBoxStatus ign_box_sts; + // Status of ignition box for this task, to be used locally and passed to isr to get timing + ignitionBoxStatus ignBoxStatus; // Variables for ISR, static to be fixed in memory locations - isrParams isr_params_t12p{ + isrParams isrParams_t12p{ .flag = TRIG_FLAG_12P, - .ign_stat = &ign_box_sts, - .rt_handle_ptr = rt_task_info.xHandle}; - isrParams isr_params_t12n{ + .ign_stat = &ignBoxStatus, + .rt_handle_ptr = rtTaskInfo.xHandle}; + isrParams isrParams_t12n{ .flag = TRIG_FLAG_12N, - .ign_stat = &ign_box_sts, - .rt_handle_ptr = rt_task_info.xHandle}; - isrParams isr_params_t34p{ + .ign_stat = &ignBoxStatus, + .rt_handle_ptr = rtTaskInfo.xHandle}; + isrParams isrParams_t34p{ .flag = TRIG_FLAG_34P, - .ign_stat = &ign_box_sts, - .rt_handle_ptr = rt_task_info.xHandle}; - isrParams isr_params_t34n{ + .ign_stat = &ignBoxStatus, + .rt_handle_ptr = rtTaskInfo.xHandle}; + isrParams isrParams_t34n{ .flag = TRIG_FLAG_34N, - .ign_stat = &ign_box_sts, - .rt_handle_ptr = rt_task_info.xHandle}; - isrParams isr_params_sp12{ + .ign_stat = &ignBoxStatus, + .rt_handle_ptr = rtTaskInfo.xHandle}; + isrParams isrParams_sp12{ .flag = SPARK_FLAG_12, - .ign_stat = &ign_box_sts, - .rt_handle_ptr = rt_task_info.xHandle}; - isrParams isr_params_sp34{ + .ign_stat = &ignBoxStatus, + .rt_handle_ptr = rtTaskInfo.xHandle}; + isrParams isrParams_sp34{ .flag = SPARK_FLAG_34, - .ign_stat = &ign_box_sts, - .rt_handle_ptr = rt_task_info.xHandle}; + .ign_stat = &ignBoxStatus, + .rt_handle_ptr = rtTaskInfo.xHandle}; // Create esp_timer for microsecond precision timeout - esp_timer_handle_t timeout_timer; - esp_timer_create_args_t timer_args = { + esp_timer_handle_t timeoutTimer; + esp_timer_create_args_t timeoutTimerArgs = { .callback = spark_timeout_callback, - .arg = (void *)rt_task_info.xHandle, + .arg = (void *)rtTaskInfo.xHandle, .dispatch_method = ESP_TIMER_TASK, .name = "spark_timeout"}; - if (esp_timer_create(&timer_args, &timeout_timer) != ESP_OK) + if (esp_timer_create(&timeoutTimerArgs, &timeoutTimer) != ESP_OK) { LOG_INFO("rtTask [", params->name.c_str(), "] Fail to allocate timeoutTimer"); vTaskDelete(NULL); } // Attach Pin Interrupts - attachInterruptArg(digitalPinToInterrupt(rt_int.trig_pin_12p), rt_int.isr_ptr, (void *)&isr_params_t12p, RISING); - attachInterruptArg(digitalPinToInterrupt(rt_int.trig_pin_12n), rt_int.isr_ptr, (void *)&isr_params_t12n, RISING); - attachInterruptArg(digitalPinToInterrupt(rt_int.trig_pin_34p), rt_int.isr_ptr, (void *)&isr_params_t34p, RISING); - attachInterruptArg(digitalPinToInterrupt(rt_int.trig_pin_34n), rt_int.isr_ptr, (void *)&isr_params_t34n, RISING); - attachInterruptArg(digitalPinToInterrupt(rt_int.spark_pin_12), rt_int.isr_ptr, (void *)&isr_params_sp12, RISING); - attachInterruptArg(digitalPinToInterrupt(rt_int.spark_pin_34), rt_int.isr_ptr, (void *)&isr_params_sp34, RISING); + attachInterruptArg(digitalPinToInterrupt(rtInterrupts.trigPin_12p), rtInterrupts.isrPtr, (void *)&isrParams_t12p, RISING); + attachInterruptArg(digitalPinToInterrupt(rtInterrupts.trigPin_12n), rtInterrupts.isrPtr, (void *)&isrParams_t12n, RISING); + attachInterruptArg(digitalPinToInterrupt(rtInterrupts.trigPin_34p), rtInterrupts.isrPtr, (void *)&isrParams_t34p, RISING); + attachInterruptArg(digitalPinToInterrupt(rtInterrupts.trigPin_34n), rtInterrupts.isrPtr, (void *)&isrParams_t34n, RISING); + attachInterruptArg(digitalPinToInterrupt(rtInterrupts.sparkPin_12), rtInterrupts.isrPtr, (void *)&isrParams_sp12, RISING); + attachInterruptArg(digitalPinToInterrupt(rtInterrupts.sparkPin_34), rtInterrupts.isrPtr, (void *)&isrParams_sp34, RISING); LOG_INFO("rtTask ISR Attach OK [", params->name.c_str(), "]"); // Global rt_task_ptr variables - bool first_cycle = true; + bool firstCycle = true; bool cycle12 = false; bool cycle34 = false; - int64_t last_cycle_time = 0; - uint32_t n_errors = 0; + int64_t lastCycleTime = 0; + uint32_t nErrors = 0; while (params->rt_running) { - uint32_t pickup_flag = 0; - uint32_t spark_flag = 0; + uint32_t pickupFlag = 0; + uint32_t sparkFlag = 0; // WAIT FOR PICKUP SIGNAL xTaskNotifyWait( 0x00, // non pulire all'ingresso ULONG_MAX, // pulisci i primi 8 bit - &pickup_flag, // valore ricevuto + &pickupFlag, // valore ricevuto portMAX_DELAY); - if (first_cycle && pickup_flag != TRIG_FLAG_12P) // skip first cycle because of possible initial noise on pickup signals at startu + if (firstCycle && pickupFlag != TRIG_FLAG_12P) // skip first cycle because of possible initial noise on pickup signals at startu continue; // Start microsecond precision timeout timer - esp_timer_stop(timeout_timer); // stop timer in case it was running from previous cycle - esp_timer_start_once(timeout_timer, spark_timeout_max); + esp_timer_stop(timeoutTimer); // stop timer in case it was running from previous cycle + esp_timer_start_once(timeoutTimer, c_sparkTimeoutMax); // WAIT FOR SPARK TO HAPPEN OR TIMEOUT xTaskNotifyWait( 0x00, // non pulire all'ingresso ULONG_MAX, // pulisci i primi 8 bit - &spark_flag, // valore ricevuto + &sparkFlag, // valore ricevuto portMAX_DELAY); // wait indefinitely, timeout handled by esp_timer // Handle timeout or spark event - if (spark_flag != SPARK_FLAG_TIMEOUT) - esp_timer_stop(timeout_timer); + if (sparkFlag != SPARK_FLAG_TIMEOUT) + esp_timer_stop(timeoutTimer); // A trigger from pickup 12 is followed by a spark event on 34 or vice versa pickup 34 triggers spark on 12 - if ((pickup_flag == TRIG_FLAG_12P || pickup_flag == TRIG_FLAG_12N) && (spark_flag != SPARK_FLAG_12 && spark_flag != SPARK_FLAG_TIMEOUT)) + if ((pickupFlag == TRIG_FLAG_12P || pickupFlag == TRIG_FLAG_12N) && (sparkFlag != SPARK_FLAG_12 && sparkFlag != SPARK_FLAG_TIMEOUT)) { - ign_box_sts.coils12.spark_status = ign_box_sts.coils34.spark_status = sparkStatus::SPARK_SYNC_FAIL; + ignBoxStatus.coils12.sparkStatus = ignBoxStatus.coils34.sparkStatus = sparkStatusEnum::SPARK_SYNC_FAIL; continue; } - // Select coil status reference based on pickup_flag + // Select coil status reference based on pickupFlag coilsStatus *coils; - switch (pickup_flag) + switch (pickupFlag) { case TRIG_FLAG_12P: { - first_cycle = false; + firstCycle = false; // compute engine rpm from cycle time - auto current_time = esp_timer_get_time(); - auto cycle_time = current_time - last_cycle_time; - last_cycle_time = current_time; - ign_box_sts.eng_rpm = (int32_t)(60.0f / (cycle_time / 1000000.0f)); + auto currentTime = esp_timer_get_time(); + auto cycleTime = currentTime - lastCycleTime; + lastCycleTime = currentTime; + ignBoxStatus.engRpm = (int32_t)(60.0f / (cycleTime / 1000000.0f)); } case TRIG_FLAG_12N: - coils = &ign_box_sts.coils12; + coils = &ignBoxStatus.coils12; break; case TRIG_FLAG_34P: case TRIG_FLAG_34N: - coils = &ign_box_sts.coils34; + coils = &ignBoxStatus.coils34; break; } // Select logic based on pickup and spark flags - switch (pickup_flag) + switch (pickupFlag) { case TRIG_FLAG_12P: case TRIG_FLAG_34P: { // Timeout not occourred, expected POSITIVE edge spark OCCOURRED - if (spark_flag != SPARK_FLAG_TIMEOUT) + if (sparkFlag != SPARK_FLAG_TIMEOUT) { - coils->spark_delay = (int32_t)(coils->spark_time - coils->trig_time); - coils->sstart_status = softStartStatus::NORMAL; // because spark on positive edge - coils->spark_status = sparkStatus::SPARK_POS_OK; // do not wait for spark on negative edge + coils->sparkDelay = (int32_t)(coils->sparkTime - coils->coilTime); + coils->softStartStatus = softStartStatusEnum::NORMAL; // because spark on positive edge + coils->sparkStatus = sparkStatusEnum::SPARK_POS_OK; // do not wait for spark on negative edge } // Timeout occourred, expected POSITIVE edge spark NOT OCCOURRED - else if (spark_flag == SPARK_FLAG_TIMEOUT) + else if (sparkFlag == SPARK_FLAG_TIMEOUT) { - coils->spark_status = sparkStatus::SPARK_NEG_WAIT; - coils->sstart_status = softStartStatus::NORMAL; + coils->sparkStatus = sparkStatusEnum::SPARK_NEG_WAIT; + coils->softStartStatus = softStartStatusEnum::NORMAL; } continue; // Do nothing more on positive pulse } @@ -193,29 +194,29 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters) case TRIG_FLAG_12N: case TRIG_FLAG_34N: { - const bool expected_negative = coils->spark_status == sparkStatus::SPARK_NEG_WAIT; + const bool negativeSparkExpected = coils->sparkStatus == sparkStatusEnum::SPARK_NEG_WAIT; // Timeout not occourred, expected NEGATIVE edge spark OCCOURRED - if (spark_flag != SPARK_FLAG_TIMEOUT && expected_negative) + if (sparkFlag != SPARK_FLAG_TIMEOUT && negativeSparkExpected) { - coils->spark_delay = (int32_t)(coils->spark_time - coils->trig_time); - coils->sstart_status = softStartStatus::SOFT_START; - coils->spark_status = sparkStatus::SPARK_NEG_OK; + coils->sparkDelay = (int32_t)(coils->sparkTime - coils->coilTime); + coils->softStartStatus = softStartStatusEnum::SOFT_START; + coils->sparkStatus = sparkStatusEnum::SPARK_NEG_OK; } // Timeout occourred, expected POSITIVE edge spark NOT OCCOURRED - else if (spark_flag == SPARK_FLAG_TIMEOUT && expected_negative) + else if (sparkFlag == SPARK_FLAG_TIMEOUT && negativeSparkExpected) { - coils->sstart_status = softStartStatus::ERROR; - coils->spark_status = sparkStatus::SPARK_NEG_FAIL; + coils->softStartStatus = softStartStatusEnum::ERROR; + coils->sparkStatus = sparkStatusEnum::SPARK_NEG_FAIL; } // Timeout not occouured, unexpected negative edge spark - else if (spark_flag != SPARK_FLAG_TIMEOUT && !expected_negative) + else if (sparkFlag != SPARK_FLAG_TIMEOUT && !negativeSparkExpected) { - coils->sstart_status = softStartStatus::SOFT_START; - coils->spark_status = sparkStatus::SPARK_NEG_UNEXPECTED; + coils->softStartStatus = softStartStatusEnum::SOFT_START; + coils->sparkStatus = sparkStatusEnum::SPARK_NEG_UNEXPECTED; } // Wait for finish of negative pulse to save data to buffer - coils->n_events++; - if (pickup_flag == TRIG_FLAG_12N) + coils->nEvents++; + if (pickupFlag == TRIG_FLAG_12N) cycle12 = true; else cycle34 = true; @@ -228,92 +229,94 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters) if (cycle12 && cycle34) // wait for both 12 and 34 cycles to complete before sending data to main loop and resetting peak detectors { // disable interrupts during adc samples - disableInterrupt(digitalPinToInterrupt(rt_int.trig_pin_12p)); - disableInterrupt(digitalPinToInterrupt(rt_int.trig_pin_12n)); - disableInterrupt(digitalPinToInterrupt(rt_int.trig_pin_34p)); - disableInterrupt(digitalPinToInterrupt(rt_int.trig_pin_34n)); - disableInterrupt(digitalPinToInterrupt(rt_int.spark_pin_12)); - disableInterrupt(digitalPinToInterrupt(rt_int.spark_pin_34)); + disableInterrupt(digitalPinToInterrupt(rtInterrupts.trigPin_12p)); + disableInterrupt(digitalPinToInterrupt(rtInterrupts.trigPin_12n)); + disableInterrupt(digitalPinToInterrupt(rtInterrupts.trigPin_34p)); + disableInterrupt(digitalPinToInterrupt(rtInterrupts.trigPin_34n)); + disableInterrupt(digitalPinToInterrupt(rtInterrupts.sparkPin_12)); + disableInterrupt(digitalPinToInterrupt(rtInterrupts.sparkPin_34)); // reset coils 12 and 34 cycles cycle12 = false; cycle34 = false; - if (ign_box_sts.coils12.spark_status == sparkStatus::SPARK_POS_FAIL || ign_box_sts.coils12.spark_status == sparkStatus::SPARK_NEG_FAIL) - ign_box_sts.coils12.n_missed_firing++; - if (ign_box_sts.coils34.spark_status == sparkStatus::SPARK_POS_FAIL || ign_box_sts.coils34.spark_status == sparkStatus::SPARK_NEG_FAIL) - ign_box_sts.coils34.n_missed_firing++; + if (ignBoxStatus.coils12.sparkStatus == sparkStatusEnum::SPARK_POS_FAIL || ignBoxStatus.coils12.sparkStatus == sparkStatusEnum::SPARK_NEG_FAIL) + ignBoxStatus.coils12.nMissedFiring++; + if (ignBoxStatus.coils34.sparkStatus == sparkStatusEnum::SPARK_POS_FAIL || ignBoxStatus.coils34.sparkStatus == sparkStatusEnum::SPARK_NEG_FAIL) + ignBoxStatus.coils34.nMissedFiring++; // read adc channels: pickup12, out12 [ pos + neg ] if (adc) // read only if adc initialized { std::lock_guard lock(spi_mutex); - uint32_t start_adc_read = esp_timer_get_time(); + uint32_t startAdcReadTime = esp_timer_get_time(); // from peak detector circuits - ign_box_sts.coils12.peak_p_in = adc->convertToVoltage(adc->cycleSingle()); - ign_box_sts.coils12.peak_n_in = adc->convertToVoltage(adc->cycleSingle()); - ign_box_sts.coils34.peak_p_in = adc->convertToVoltage(adc->cycleSingle()); - ign_box_sts.coils34.peak_n_in = adc->convertToVoltage(adc->cycleSingle()); - ign_box_sts.coils12.peak_p_out = adc->convertToVoltage(adc->cycleSingle()); - ign_box_sts.coils12.peak_n_out = adc->convertToVoltage(adc->cycleSingle()); - ign_box_sts.coils34.peak_p_out = adc->convertToVoltage(adc->cycleSingle()); - ign_box_sts.coils34.peak_n_out = adc->convertToVoltage(adc->cycleSingle()); - ign_box_sts.adc_read_time = (int32_t)(esp_timer_get_time() - start_adc_read); + ignBoxStatus.coils12.peakPos = adc->convertToVoltage(adc->cycleSingle()); + ignBoxStatus.coils12.peakNeg = adc->convertToVoltage(adc->cycleSingle()); + ignBoxStatus.coils34.peakPos = adc->convertToVoltage(adc->cycleSingle()); + ignBoxStatus.coils34.peakNeg = adc->convertToVoltage(adc->cycleSingle()); + ignBoxStatus.coils12.trigLevelPos = adc->convertToVoltage(adc->cycleSingle()); + ignBoxStatus.coils12.trigLevelNeg = adc->convertToVoltage(adc->cycleSingle()); + ignBoxStatus.coils34.trigLevelPos = adc->convertToVoltage(adc->cycleSingle()); + ignBoxStatus.coils34.trigLevelNeg = adc->convertToVoltage(adc->cycleSingle()); adc->stopConversion(); + ignBoxStatus.adcReadTime = (int32_t)(esp_timer_get_time() - startAdcReadTime); } else // simulate adc read timig - vTaskDelay(pdMS_TO_TICKS(c_adc_time)); + vTaskDelay(pdMS_TO_TICKS(c_adcTime)); // reset peak detectors + sample and hold // outputs on io expander if (io) { + uint32_t startIoReadWriteTime = esp_timer_get_time(); // Discharge Pulse - io->extDigitalWrite(rt_rst.sh_disch_12, true); - io->extDigitalWrite(rt_rst.sh_disch_34, true); + io->extDigitalWrite(rtResets.sh_disch_12, true); + io->extDigitalWrite(rtResets.sh_disch_34, true); delayMicroseconds(250); - io->extDigitalWrite(rt_rst.sh_disch_12, false); - io->extDigitalWrite(rt_rst.sh_disch_34, false); + io->extDigitalWrite(rtResets.sh_disch_12, false); + io->extDigitalWrite(rtResets.sh_disch_34, false); // Safety delay delayMicroseconds(500); // Re-Arm Pulse - io->extDigitalWrite(rt_rst.sh_arm_12, true); - io->extDigitalWrite(rt_rst.sh_arm_34, true); + io->extDigitalWrite(rtResets.sh_arm_12, true); + io->extDigitalWrite(rtResets.sh_arm_34, true); delayMicroseconds(250); - io->extDigitalWrite(rt_rst.sh_arm_12, false); - io->extDigitalWrite(rt_rst.sh_arm_34, false); + io->extDigitalWrite(rtResets.sh_arm_12, false); + io->extDigitalWrite(rtResets.sh_arm_34, false); + ignBoxStatus.ioReadWriteTime = (int32_t)(esp_timer_get_time() - startIoReadWriteTime); } else - vTaskDelay(pdMS_TO_TICKS(c_io_time)); + vTaskDelay(pdMS_TO_TICKS(c_ioTime)); // send essage to main loop with ignition info, by copy so local static variable is ok - if (rt_queue) + if (rtQueue) { - ign_box_sts.timestamp = esp_timer_get_time(); // update data timestamp - if (xQueueSendToBack(rt_queue, (void *)&ign_box_sts, 0) != pdPASS) - ign_box_sts.n_queue_errors = ++n_errors; + ignBoxStatus.timestamp = esp_timer_get_time(); // update data timestamp + if (xQueueSendToBack(rtQueue, (void *)&ignBoxStatus, 0) != pdPASS) + ignBoxStatus.nQueueErrors = ++nErrors; } // enable interrupts ready for a new cycle - enableInterrupt(digitalPinToInterrupt(rt_int.trig_pin_12p)); - enableInterrupt(digitalPinToInterrupt(rt_int.trig_pin_12n)); - enableInterrupt(digitalPinToInterrupt(rt_int.trig_pin_34p)); - enableInterrupt(digitalPinToInterrupt(rt_int.trig_pin_34n)); - enableInterrupt(digitalPinToInterrupt(rt_int.spark_pin_12)); - enableInterrupt(digitalPinToInterrupt(rt_int.spark_pin_34)); + enableInterrupt(digitalPinToInterrupt(rtInterrupts.trigPin_12p)); + enableInterrupt(digitalPinToInterrupt(rtInterrupts.trigPin_12n)); + enableInterrupt(digitalPinToInterrupt(rtInterrupts.trigPin_34p)); + enableInterrupt(digitalPinToInterrupt(rtInterrupts.trigPin_34n)); + enableInterrupt(digitalPinToInterrupt(rtInterrupts.sparkPin_12)); + enableInterrupt(digitalPinToInterrupt(rtInterrupts.sparkPin_34)); } } // Delete the timeout timer - esp_timer_stop(timeout_timer); - esp_timer_delete(timeout_timer); + esp_timer_stop(timeoutTimer); + esp_timer_delete(timeoutTimer); LOG_WARN("rtTask Ending [", params->name.c_str(), "]"); // Ignition A Interrupts DETACH - detachInterrupt(rt_int.trig_pin_12p); - detachInterrupt(rt_int.trig_pin_12n); - detachInterrupt(rt_int.trig_pin_34p); - detachInterrupt(rt_int.trig_pin_34n); - detachInterrupt(rt_int.spark_pin_12); - detachInterrupt(rt_int.spark_pin_34); + detachInterrupt(rtInterrupts.trigPin_12p); + detachInterrupt(rtInterrupts.trigPin_12n); + detachInterrupt(rtInterrupts.trigPin_34p); + detachInterrupt(rtInterrupts.trigPin_34n); + detachInterrupt(rtInterrupts.sparkPin_12); + detachInterrupt(rtInterrupts.sparkPin_34); // delete present task vTaskDelete(NULL); } @@ -417,7 +420,7 @@ void rtIgnitionTask::run() } else { - if (millis() - m_dataLast > c_idle_time) + if (millis() - m_dataLast > c_idleTime) { if (m_statusCounter > 0 && !m_savePartial) { @@ -497,7 +500,7 @@ void rtIgnitionTask::onMessage(std::function ca m_onFilteredStatusUpdate = callaback; } -void rtIgnitionTask::saveHistory(const rtIgnitionTask::PSHistory &history, const std::filesystem::path &file_name) +void rtIgnitionTask::saveHistory(const rtIgnitionTask::PSHistory &history, const std::filesystem::path &fileName) { // Lock filesystem mutex to avoid concurrent access std::lock_guard fs_lock(m_filesystemMutex); @@ -510,26 +513,26 @@ void rtIgnitionTask::saveHistory(const rtIgnitionTask::PSHistory &history, const } // create complete file path - const std::filesystem::path mount_point = std::filesystem::path(m_filesystem.mountpoint()); - std::filesystem::path file_path = file_name; - if (file_name.root_path() != mount_point) - file_path = mount_point / file_name; + const std::filesystem::path mountPoint = std::filesystem::path(m_filesystem.mountpoint()); + std::filesystem::path filePath = fileName; + if (fileName.root_path() != mountPoint) + filePath = mountPoint / fileName; // if firt save remove old file and create new - auto save_flags = std::ios::out; + auto saveFlags = std::ios::out; 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 - LOG_INFO("Saving history to Flash, new file:", file_path.c_str()); + saveFlags |= std::ios::trunc; // overwrite existing file + m_filesystem.remove(filePath.c_str()); // ensure file is removed before saving to avoid issues with appending to existing file in SPIFFS + LOG_INFO("Saving history to Flash, new file:", filePath.c_str()); } else // else append to existing file { - save_flags |= std::ios::app; // append to new file - LOG_INFO("Saving history to Flash, appending to existing file:", file_path.c_str()); + saveFlags |= std::ios::app; // append to new file + LOG_INFO("Saving history to Flash, appending to existing file:", filePath.c_str()); } - std::ofstream ofs(file_path, save_flags); + std::ofstream ofs(filePath, saveFlags); if (ofs.fail()) { LOG_ERROR("Failed to open file for writing"); @@ -550,25 +553,25 @@ void rtIgnitionTask::saveHistory(const rtIgnitionTask::PSHistory &history, const for (const auto &entry : history) { ofs << std::to_string(entry.timestamp) << "," - << std::to_string(entry.coils12.n_events) << "," - << std::to_string(entry.coils12.spark_delay) << "," - << std::string(sparkStatusNames.at(entry.coils12.spark_status)) << "," - << std::to_string(entry.coils12.peak_p_in) << "," - << std::to_string(entry.coils12.peak_n_in) << "," - << std::to_string(entry.coils12.peak_p_out) << "," - << std::to_string(entry.coils12.peak_n_out) << "," - << std::string(softStartStatusNames.at(entry.coils12.sstart_status)) << "," - << std::to_string(entry.coils34.n_events) << "," - << std::to_string(entry.coils34.spark_delay) << "," - << std::string(sparkStatusNames.at(entry.coils34.spark_status)) << "," - << std::to_string(entry.coils34.peak_p_in) << "," - << std::to_string(entry.coils34.peak_n_in) << "," - << std::to_string(entry.coils34.peak_p_out) << "," - << std::to_string(entry.coils34.peak_n_out) << "," - << std::string(softStartStatusNames.at(entry.coils34.sstart_status)) << "," - << std::to_string(entry.eng_rpm) << "," - << std::to_string(entry.adc_read_time) << "," - << std::to_string(entry.n_queue_errors); + << std::to_string(entry.coils12.nEvents) << "," + << std::to_string(entry.coils12.sparkDelay) << "," + << std::string(sparkStatusNames.at(entry.coils12.sparkStatus)) << "," + << std::to_string(entry.coils12.peakPos) << "," + << std::to_string(entry.coils12.peakNeg) << "," + << std::to_string(entry.coils12.trigLevelPos) << "," + << std::to_string(entry.coils12.trigLevelNeg) << "," + << std::string(softStartStatusNames.at(entry.coils12.softStartStatus)) << "," + << std::to_string(entry.coils34.nEvents) << "," + << std::to_string(entry.coils34.sparkDelay) << "," + << std::string(sparkStatusNames.at(entry.coils34.sparkStatus)) << "," + << std::to_string(entry.coils34.peakPos) << "," + << std::to_string(entry.coils34.peakNeg) << "," + << std::to_string(entry.coils34.trigLevelPos) << "," + << std::to_string(entry.coils34.trigLevelNeg) << "," + << std::string(softStartStatusNames.at(entry.coils34.softStartStatus)) << "," + << std::to_string(entry.engRpm) << "," + << std::to_string(entry.adcReadTime) << "," + << std::to_string(entry.nQueueErrors); ofs << std::endl; ofs.flush(); } diff --git a/RotaxMonitor/src/tasks.h b/RotaxMonitor/src/tasks.h index b0b170d..6ed3a07 100644 --- a/RotaxMonitor/src/tasks.h +++ b/RotaxMonitor/src/tasks.h @@ -22,9 +22,6 @@ // DEVICES #include "devices.h" -// Global Variables and Flags -const uint32_t spark_timeout_max = 500; // in microseconds - // Debug Variables #ifdef DEBUG static const std::map names = { @@ -46,13 +43,13 @@ public: // RT task Interrupt parameters struct rtTaskInterruptParams { - void (*isr_ptr)(void *); - const uint8_t trig_pin_12p; - const uint8_t trig_pin_12n; - const uint8_t trig_pin_34p; - const uint8_t trig_pin_34n; - const uint8_t spark_pin_12; - const uint8_t spark_pin_34; + void (*isrPtr)(void *); + const uint8_t trigPin_12p; + const uint8_t trigPin_12n; + const uint8_t trigPin_34p; + const uint8_t trigPin_34n; + const uint8_t sparkPin_12; + const uint8_t sparkPin_34; }; // RT Task Peak Detector Reset pins @@ -125,7 +122,7 @@ private: bool m_running = true; rtTaskStatus m_managerStatus = INIT; rtTaskParams m_params; - + const uint8_t m_core; std::string m_managerTaskName; TaskHandle_t m_rtHandle = nullptr; @@ -139,7 +136,7 @@ private: 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; @@ -153,8 +150,9 @@ private: 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 - static const uint8_t c_adc_time = 4; // in mS - static const uint8_t c_io_time = 2; // in mS + // Global Variables and Flags + static const uint32_t c_sparkTimeoutMax = 500; // in microseconds + static const uint32_t c_idleTime = 10000; // in mS + static const uint8_t c_adcTime = 4; // in mS + static const uint8_t c_ioTime = 2; // in mS }; diff --git a/RotaxMonitor/src/ui.cpp b/RotaxMonitor/src/ui.cpp index 80e31e5..e060b9e 100644 --- a/RotaxMonitor/src/ui.cpp +++ b/RotaxMonitor/src/ui.cpp @@ -44,30 +44,30 @@ void printInfo(const ignitionBoxStatus &info) setCursor(0, 0); printField("++ Timestamp ++", (uint32_t)info.timestamp); Serial.println("========== Coils 12 ============="); - printField("Events", info.coils12.n_events); - printField("Events Missed", info.coils12.n_missed_firing); - printField("Spark Dly", (uint32_t)info.coils12.spark_delay); - printField("Spark Sts", sparkStatusNames.at(info.coils12.spark_status)); - printField("Peak P_IN", info.coils12.peak_p_in); - printField("Peak N_IN", info.coils12.peak_n_in); - printField("Peak P_OUT", info.coils12.peak_p_out); - printField("Peak N_OUT", info.coils12.peak_n_out); - printField("Soft Start ", softStartStatusNames.at(info.coils12.sstart_status)); + printField("Events", info.coils12.nEvents); + printField("Events Missed", info.coils12.nMissedFiring); + printField("Spark Dly", (uint32_t)info.coils12.sparkDelay); + printField("Spark Sts", sparkStatusNames.at(info.coils12.sparkStatus)); + printField("Peak P_IN", info.coils12.peakPos); + printField("Peak N_IN", info.coils12.peakNeg); + printField("Peak P_OUT", info.coils12.trigLevelPos); + printField("Peak N_OUT", info.coils12.trigLevelNeg); + printField("Soft Start ", softStartStatusNames.at(info.coils12.softStartStatus)); Serial.println("========== Coils 34 ============="); - printField("Events", info.coils34.n_events); - printField("Events Missed", info.coils34.n_missed_firing); - printField("Spark Dly", (uint32_t)info.coils34.spark_delay); - printField("Spark Sts", sparkStatusNames.at(info.coils34.spark_status)); - printField("Peak P_IN", info.coils34.peak_p_in); - printField("Peak N_IN", info.coils34.peak_n_in); - printField("Peak P_OUT", info.coils34.peak_p_out); - printField("Peak N_OUT", info.coils34.peak_n_out); - printField("Soft Start ", softStartStatusNames.at(info.coils34.sstart_status)); + printField("Events", info.coils34.nEvents); + printField("Events Missed", info.coils34.nMissedFiring); + printField("Spark Dly", (uint32_t)info.coils34.sparkDelay); + printField("Spark Sts", sparkStatusNames.at(info.coils34.sparkStatus)); + printField("Peak P_IN", info.coils34.peakPos); + printField("Peak N_IN", info.coils34.peakNeg); + printField("Peak P_OUT", info.coils34.trigLevelPos); + printField("Peak N_OUT", info.coils34.trigLevelNeg); + printField("Soft Start ", softStartStatusNames.at(info.coils34.softStartStatus)); Serial.println("============ END ==============="); Serial.println(); - printField("Engine RPM", info.eng_rpm); - printField("ADC Read Time", info.adc_read_time); - printField("Queue Errors", info.n_queue_errors); + printField("Engine RPM", info.engRpm); + printField("ADC Read Time", info.adcReadTime); + printField("Queue Errors", info.nQueueErrors); }