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

Tasks, ISR, Pin refactoring and renaming

Browse Source
This commit is contained in:
Emanuele Trabattoni
2026-03-30 15:50:17 +02:00
parent e0af350b89
commit 1adbf7fdb9
6 changed files with 247 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
RotaxMonitor/src/tasks.h
View File

@@ -15,8 +15,7 @@
#include "devices.h"
// Global Variables and Flags
static bool rt_task_running = true;
const auto spark_timeout_max = 2; // in milliseconds
const uint8_t spark_timeout_max = 2; // in milliseconds
// Debug Variables
#ifdef DEBUG
@@ -51,36 +50,20 @@ struct rtTaskResets
const uint8_t rst_io_34n;
};
// RT Task Adc channels
struct rtTaskAdChannels
{
const uint8_t adc_gen;
const uint8_t adc_spark_12;
const uint8_t adc_spark_34;
const uint8_t adc_peak_12p_in;
const uint8_t adc_peak_12n_in;
const uint8_t adc_peak_34p_in;
const uint8_t adc_peak_34n_in;
const uint8_t adc_peak_12p_out;
const uint8_t adc_peak_12n_out;
const uint8_t adc_peak_34p_out;
const uint8_t adc_peak_34n_out;
};
// RT task parameters
struct rtTaskParams
{
bool rt_running; // run flag, false to terminate
Devices *dev;
QueueHandle_t rt_queue;
const rtTaskInterrupts rt_int; // interrupt pins to attach
const rtTaskResets rt_resets; // reset ping for peak detectors
const rtTaskAdChannels rt_adcch; // adc channels
const QueueHandle_t rt_queue;
const rtTaskInterrupts rt_int; // interrupt pins to attach
const rtTaskResets rt_resets; // reset ping for peak detectors
};
void ignitionA_task(void *pvParameters)
void rtIgnitionTask(void *pvParameters)
{
// Invalid real time task parameters, exit immediate
if (!pvParameters)
{
LOG_ERROR("Null task parameters");
@@ -88,22 +71,42 @@ void ignitionA_task(void *pvParameters)
}
// Task Parameters and Devices
const rtTaskParams *params = (const rtTaskParams *)pvParameters;
const rtTaskInterrupts rt_int = params->rt_int; // copy to avoid external override
const rtTaskResets rt_rst = params->rt_resets; // copy to avoid external override
const rtTaskAdChannels rt_adcch = params->rt_adcch; // copy to avoid external override
rtTaskParams *params = (rtTaskParams *)pvParameters;
const rtTaskInterrupts rt_int = params->rt_int; // copy to avoid external override
const rtTaskResets rt_rst = params->rt_resets; // copy to avoid external override
QueueHandle_t queue = params->rt_queue;
Devices *dev = params->dev;
ADS1256 *adc = dev->adc_a;
PCA9555 *io = dev->io;
// Variables for ISR, static to be fixed in memory locations
static ignitionBoxStatus ign_box_sts; // common for all ISR calls
static isrParams isr_params_t12p{ // only call flag changes
.flag = TRIG_FLAG_12P,
.ign_stat = &ign_box_sts};
static isrParams isr_params_t12n{
.flag = TRIG_FLAG_12N,
.ign_stat = &ign_box_sts};
static isrParams isr_params_t34p{
.flag = TRIG_FLAG_34P,
.ign_stat = &ign_box_sts};
static isrParams isr_params_t34n{
.flag = TRIG_FLAG_34N,
.ign_stat = &ign_box_sts};
static isrParams isr_params_sp12{
.flag = SPARK_FLAG_12,
.ign_stat = &ign_box_sts};
static isrParams isr_params_sp34{
.flag = SPARK_FLAG_34,
.ign_stat = &ign_box_sts};
// Attach Pin Interrupts
attachInterruptArg(rt_int.trig_pin_12p, rt_int.isr_ptr, (void *)TRIG_FLAG_12P, RISING);
attachInterruptArg(rt_int.trig_pin_12n, rt_int.isr_ptr, (void *)TRIG_FLAG_12N, RISING);
attachInterruptArg(rt_int.trig_pin_34p, rt_int.isr_ptr, (void *)TRIG_FLAG_34P, RISING);
attachInterruptArg(rt_int.trig_pin_34n, rt_int.isr_ptr, (void *)TRIG_FLAG_34N, RISING);
attachInterruptArg(rt_int.spark_pin_12, rt_int.isr_ptr, (void *)SPARK_FLAG_12, RISING);
attachInterruptArg(rt_int.spark_pin_34, rt_int.isr_ptr, (void *)SPARK_FLAG_34, RISING);
attachInterruptArg(rt_int.trig_pin_12p, rt_int.isr_ptr, (void *)&isr_params_t12p, RISING);
attachInterruptArg(rt_int.trig_pin_12n, rt_int.isr_ptr, (void *)&isr_params_t12n, RISING);
attachInterruptArg(rt_int.trig_pin_34p, rt_int.isr_ptr, (void *)&isr_params_t34p, RISING);
attachInterruptArg(rt_int.trig_pin_34n, rt_int.isr_ptr, (void *)&isr_params_t34n, RISING);
attachInterruptArg(rt_int.spark_pin_12, rt_int.isr_ptr, (void *)&isr_params_sp12, RISING);
attachInterruptArg(rt_int.spark_pin_34, rt_int.isr_ptr, (void *)&isr_params_sp34, RISING);
// Compute Reset Pin Bitmask
const uint16_t rst_bitmask = (1 << rt_rst.rst_io_12p) |
@@ -113,7 +116,7 @@ void ignitionA_task(void *pvParameters)
uint32_t it = 0;
uint32_t q_fail_count = 0;
while (rt_task_running)
while (params->rt_running)
{
// Global task variables
uint32_t pickup_flag = 0;
@@ -147,8 +150,8 @@ void ignitionA_task(void *pvParameters)
// WAIT FOR SPARK TO HAPPEN
auto spark_timeout = ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(spark_timeout_max));
if (ignA_status.spark12 || ignA_status.spark34) // otherwise timeout if none is set in the ISR
spark_flag = ignA_status.spark12 ? SPARK_FLAG_12 : SPARK_FLAG_34;
if (ign_box_sts.coils12.spark_ok || ign_box_sts.coils34.spark_ok) // otherwise timeout if none is set in the ISR
spark_flag = ign_box_sts.coils12.spark_ok ? SPARK_FLAG_12 : SPARK_FLAG_34;
xTaskNotifyStateClear(NULL);
ulTaskNotifyValueClear(NULL, 0xFFFFFFFF);
@@ -163,22 +166,22 @@ void ignitionA_task(void *pvParameters)
// 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)
{
ignA_status.coils12.spark_status = ignA_status.coils34.spark_status = sparkStatus::SPARK_SYNC_FAIL;
ign_box_sts.coils12.spark_status = ign_box_sts.coils34.spark_status = sparkStatus::SPARK_SYNC_FAIL;
// Save error on circular buffer and skip to next cycle //
LOG_ERROR("Spark Mismatch");
continue;
}
coilsStatus *c;
coilsStatus *coils;
switch (pickup_flag)
{
case TRIG_FLAG_12P:
case TRIG_FLAG_12N:
c = &ignA_status.coils12;
coils = &ign_box_sts.coils12;
break;
case TRIG_FLAG_34P:
case TRIG_FLAG_34N:
c = &ignA_status.coils34;
coils = &ign_box_sts.coils34;
break;
}
@@ -192,19 +195,19 @@ void ignitionA_task(void *pvParameters)
// Timeout not occourred, expected POSITIVE edge spark OCCOURRED
if (spark_timeout == pdPASS)
{
c->spark_delay = c->spark_time - c->trig_time;
c->sstart_status = softStartStatus::NORMAL; // because spark on positive edge
c->spark_status = sparkStatus::SPARK_POS_OK; // do not wait for spark on negative edge
coils->spark_delay = 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
#ifdef DEBUG
LOG_INFO("Trigger Spark POSITIVE");
LOG_INFO("Spark12 Delay Timer: ", (int)c->spark_delay);
LOG_INFO("Spark12 Delay Timer: ", (int)coils->spark_delay);
#endif
}
// Timeout occourred, expected POSITIVE edge spark NOT OCCOURRED
else if (spark_timeout == pdFAIL)
{
c->spark_status = sparkStatus::SPARK_NEG_WAIT;
c->sstart_status = softStartStatus::NORMAL;
coils->spark_status = sparkStatus::SPARK_NEG_WAIT;
coils->sstart_status = softStartStatus::NORMAL;
}
new_data = false;
break; // Do nothing more on positive pulse
@@ -213,29 +216,29 @@ void ignitionA_task(void *pvParameters)
case TRIG_FLAG_12N:
case TRIG_FLAG_34N:
{
const bool expected_negative12 = c->spark_status == sparkStatus::SPARK_NEG_WAIT;
const bool expected_negative12 = coils->spark_status == sparkStatus::SPARK_NEG_WAIT;
// Timeout not occourred, expected NEGATIVE edge spark OCCOURRED
if (spark_timeout == pdPASS && expected_negative12)
{
c->spark_delay = c->spark_time - c->trig_time;
c->sstart_status = softStartStatus::SOFT_START;
c->spark_status == sparkStatus::SPARK_NEG_OK;
coils->spark_delay = coils->spark_time - coils->trig_time;
coils->sstart_status = softStartStatus::SOFT_START;
coils->spark_status == sparkStatus::SPARK_NEG_OK;
#ifdef DEBUG
LOG_INFO("Trigger Spark NEGATIVE");
LOG_INFO("Spark12 Delay Timer: ", (int)ignA_status.coils12.spark_delay);
LOG_INFO("Spark12 Delay Timer: ", (int)ign_box_sts.coils12.spark_delay);
#endif
}
// Timeout occourred, expected POSITIVE edge spark NOT OCCOURRED
else if (spark_timeout == pdFAIL && expected_negative12)
{
c->sstart_status = softStartStatus::NORMAL;
c->spark_status = sparkStatus::SPARK_NEG_FAIL;
coils->sstart_status = softStartStatus::NORMAL;
coils->spark_status = sparkStatus::SPARK_NEG_FAIL;
}
// Timeout not occouured, unexpected negative edge spark
else if (spark_timeout == pdPASS && !expected_negative12)
{
c->sstart_status = softStartStatus::SOFT_START;
c->spark_status = sparkStatus::SPARK_NEG_UNEXPECTED;
coils->sstart_status = softStartStatus::SOFT_START;
coils->spark_status = sparkStatus::SPARK_NEG_UNEXPECTED;
}
// Wait for finish of negative pulse to save data to buffer
new_data = true;
@@ -252,19 +255,15 @@ void ignitionA_task(void *pvParameters)
// read adc channels: pickup12, out12 [ pos + neg ]
if (adc) // read only if adc initialized
{
ignA_status.volts_gen = adcReadChannel(adc, rt_adcch.adc_gen);
// from peak detector circuits
ignA_status.coils12.peak_p_in = adcReadChannel(adc, rt_adcch.adc_peak_12p_in);
ignA_status.coils12.peak_n_in = adcReadChannel(adc, rt_adcch.adc_peak_12n_in);
ignA_status.coils34.peak_p_in = adcReadChannel(adc, rt_adcch.adc_peak_34p_in);
ignA_status.coils34.peak_n_in = adcReadChannel(adc, rt_adcch.adc_peak_34n_in);
ignA_status.coils12.peak_p_out = adcReadChannel(adc, rt_adcch.adc_peak_12p_out);
ignA_status.coils12.peak_n_out = adcReadChannel(adc, rt_adcch.adc_peak_12n_out);
ignA_status.coils34.peak_p_out = adcReadChannel(adc, rt_adcch.adc_peak_34p_out);
ignA_status.coils34.peak_n_out = adcReadChannel(adc, rt_adcch.adc_peak_34n_out);
// from sample and hold triggered from spark interrupt
ignA_status.coils12.trigger_spark = adcReadChannel(adc, rt_adcch.adc_spark_12);
ignA_status.coils34.trigger_spark = adcReadChannel(adc, rt_adcch.adc_spark_34);
ign_box_sts.coils12.peak_p_in = adcReadChannel(adc, ADC_CH_PEAK_12P_IN);
ign_box_sts.coils12.peak_n_in = adcReadChannel(adc, ADC_CH_PEAK_12N_IN);
ign_box_sts.coils34.peak_p_in = adcReadChannel(adc, ADC_CH_PEAK_34P_IN);
ign_box_sts.coils34.peak_n_in = adcReadChannel(adc, ADC_CH_PEAK_34N_IN);
ign_box_sts.coils12.peak_p_out = adcReadChannel(adc, ADC_CH_PEAK_12P_OUT);
ign_box_sts.coils12.peak_n_out = adcReadChannel(adc, ADC_CH_PEAK_12N_OUT);
ign_box_sts.coils34.peak_p_out = adcReadChannel(adc, ADC_CH_PEAK_34P_OUT);
ign_box_sts.coils34.peak_n_out = adcReadChannel(adc, ADC_CH_PEAK_34N_OUT);
}
else // simulate adc read timig
vTaskDelay(pdMS_TO_TICKS(6));
@@ -281,13 +280,14 @@ void ignitionA_task(void *pvParameters)
else
vTaskDelay(pdMS_TO_TICKS(2));
// send essage to main loop with ignition info
// send essage to main loop with ignition info, by copy so local static variable is ok
if (queue)
ignA_status.timestamp = esp_timer_get_time(); // update data timestamp
if (xQueueSendToBack(queue, (void*)&ignA_status, pdMS_TO_TICKS(1)) != pdPASS) {
q_fail_count++;
LOG_ERROR("Failed to send to queue");
}
ign_box_sts.timestamp = esp_timer_get_time(); // update data timestamp
if (xQueueSendToBack(queue, (void *)&ign_box_sts, pdMS_TO_TICKS(1)) != pdPASS)
{
q_fail_count++;
LOG_ERROR("Failed to send to queue");
}
}
}
LOG_WARN("Ending realTime Task");