307 lines
12 KiB
C++
307 lines
12 KiB
C++
#include "tasks.h"
|
|
#include <esp_timer.h>
|
|
|
|
// Timeout callback for microsecond precision
|
|
void spark_timeout_callback(void* arg) {
|
|
TaskHandle_t handle = (TaskHandle_t)arg;
|
|
xTaskNotify(handle, SPARK_FLAG_TIMEOUT, eSetValueWithOverwrite);
|
|
}
|
|
|
|
void rtIgnitionTask(void *pvParameters)
|
|
{
|
|
|
|
// Invalid real time rt_task_ptr parameters, exit immediate
|
|
if (!pvParameters)
|
|
{
|
|
LOG_ERROR("Null rt_task_ptr parameters");
|
|
vTaskDelete(NULL);
|
|
}
|
|
LOG_INFO("rtTask Params OK");
|
|
|
|
// Task Parameters and Devices
|
|
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 rt_queue = params->rt_queue;
|
|
TaskHandle_t rt_handle_ptr = *params->rt_handle_ptr;
|
|
Devices *dev = params->dev;
|
|
ADS1256 *adc = dev->adc_a;
|
|
PCA9555 *io = dev->io;
|
|
|
|
ignitionBoxStatus ign_box_sts;
|
|
|
|
// Variables for ISR, static to be fixed in memory locations
|
|
static isrParams isr_params_t12p{
|
|
.flag = TRIG_FLAG_12P,
|
|
.ign_stat = &ign_box_sts,
|
|
.rt_handle_ptr = rt_handle_ptr};
|
|
static isrParams isr_params_t12n{
|
|
.flag = TRIG_FLAG_12N,
|
|
.ign_stat = &ign_box_sts,
|
|
.rt_handle_ptr = rt_handle_ptr};
|
|
static isrParams isr_params_t34p{
|
|
.flag = TRIG_FLAG_34P,
|
|
.ign_stat = &ign_box_sts,
|
|
.rt_handle_ptr = rt_handle_ptr};
|
|
static isrParams isr_params_t34n{
|
|
.flag = TRIG_FLAG_34N,
|
|
.ign_stat = &ign_box_sts,
|
|
.rt_handle_ptr = rt_handle_ptr};
|
|
static isrParams isr_params_sp12{
|
|
.flag = SPARK_FLAG_12,
|
|
.ign_stat = &ign_box_sts,
|
|
.rt_handle_ptr = rt_handle_ptr};
|
|
static isrParams isr_params_sp34{
|
|
.flag = SPARK_FLAG_34,
|
|
.ign_stat = &ign_box_sts,
|
|
.rt_handle_ptr = rt_handle_ptr};
|
|
|
|
LOG_INFO("rtTask ISR Params OK");
|
|
|
|
// Create esp_timer for microsecond precision timeout
|
|
esp_timer_handle_t timeout_timer;
|
|
esp_timer_create_args_t timer_args = {
|
|
.callback = spark_timeout_callback,
|
|
.arg = (void*)rt_handle_ptr,
|
|
.dispatch_method = ESP_TIMER_TASK,
|
|
.name = "spark_timeout"
|
|
};
|
|
esp_timer_create(&timer_args, &timeout_timer);
|
|
|
|
// 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);
|
|
|
|
LOG_INFO("rtTask ISR Attach OK");
|
|
|
|
// Compute Reset Pin Bitmask
|
|
const uint16_t rst_bitmask = (1 << rt_rst.rst_io_12p) |
|
|
(1 << rt_rst.rst_io_12n) |
|
|
(1 << rt_rst.rst_io_34p) |
|
|
(1 << rt_rst.rst_io_34n);
|
|
|
|
LOG_WARN("rtTask Init Correct");
|
|
// Global rt_task_ptr variables
|
|
bool first_cycle = true;
|
|
bool cycle12 = false;
|
|
bool cycle34 = false;
|
|
|
|
while (params->rt_running)
|
|
{
|
|
uint32_t pickup_flag = 0;
|
|
uint32_t spark_flag = 0;
|
|
|
|
// WAIT FOR PICKUP SIGNAL
|
|
xTaskNotifyWait(
|
|
0x00, // non pulire all'ingresso
|
|
ULONG_MAX, // pulisci i primi 8 bit
|
|
&pickup_flag, // 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
|
|
{
|
|
continue;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
Serial.print("\033[2J"); // clear screen
|
|
Serial.print("\033[H"); // cursor home
|
|
LOG_INFO("Iteration [", it++, "]");
|
|
|
|
if (!names.contains(pickup_flag))
|
|
{
|
|
LOG_ERROR("Wrong Pickup Flag");
|
|
LOG_ERROR("Pickup Flags: ", printBits(pickup_flag).c_str());
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
LOG_INFO("Pickup Trigger: ", names.at(pickup_flag));
|
|
}
|
|
#endif
|
|
|
|
// 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);
|
|
|
|
spark_flag = SPARK_FLAG_NIL; // default value in case of timeout, to be set by ISR if spark event occours
|
|
// WAIT FOR SPARK TO HAPPEN OR TIMEOUT
|
|
BaseType_t sp = pdFALSE;
|
|
sp = xTaskNotifyWait(
|
|
0x00, // non pulire all'ingresso
|
|
ULONG_MAX, // pulisci i primi 8 bit
|
|
&spark_flag, // valore ricevuto
|
|
portMAX_DELAY); // wait indefinitely, timeout handled by esp_timer
|
|
|
|
// Handle timeout or spark event
|
|
if (spark_flag == SPARK_FLAG_TIMEOUT) {
|
|
spark_flag = SPARK_FLAG_NIL;
|
|
} else {
|
|
// Spark occurred, stop the timer
|
|
esp_timer_stop(timeout_timer);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
// LOG_INFO("Spark Flags: ", printBits(spark_flag).c_str());
|
|
LOG_INFO("Spark12:", ign_box_sts.coils12.spark_ok ? "TRUE" : "FALSE");
|
|
LOG_INFO("Spark34:", ign_box_sts.coils34.spark_ok ? "TRUE" : "FALSE");
|
|
if (names.contains(spark_flag))
|
|
LOG_INFO("Spark Trigger:", names.at(spark_flag));
|
|
#endif
|
|
xTaskNotifyStateClear(NULL);
|
|
ulTaskNotifyValueClear(NULL, 0xFFFFFFFF);
|
|
|
|
// 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_NIL))
|
|
{
|
|
ign_box_sts.coils12.spark_status = ign_box_sts.coils34.spark_status = sparkStatus::SPARK_SYNC_FAIL;
|
|
continue;
|
|
}
|
|
|
|
// Select coil status reference based on pickup_flag
|
|
coilsStatus *coils;
|
|
switch (pickup_flag)
|
|
{
|
|
case TRIG_FLAG_12P:
|
|
first_cycle = false;
|
|
case TRIG_FLAG_12N:
|
|
coils = &ign_box_sts.coils12;
|
|
break;
|
|
case TRIG_FLAG_34P:
|
|
case TRIG_FLAG_34N:
|
|
coils = &ign_box_sts.coils34;
|
|
break;
|
|
}
|
|
|
|
// Select logic based on pickup and spark flags
|
|
switch (pickup_flag)
|
|
{
|
|
case TRIG_FLAG_12P:
|
|
case TRIG_FLAG_34P:
|
|
{
|
|
// Timeout not occourred, expected POSITIVE edge spark OCCOURRED
|
|
if (spark_flag != SPARK_FLAG_NIL)
|
|
{
|
|
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("Spark on POSITIVE pulse");
|
|
LOG_INFO("Spark Delay Time: ", (int32_t)coils->spark_delay);
|
|
#endif
|
|
}
|
|
// Timeout occourred, expected POSITIVE edge spark NOT OCCOURRED
|
|
else if (spark_flag == SPARK_FLAG_NIL)
|
|
{
|
|
coils->spark_status = sparkStatus::SPARK_NEG_WAIT;
|
|
coils->sstart_status = softStartStatus::NORMAL;
|
|
}
|
|
continue; // Do nothing more on positive pulse
|
|
}
|
|
// CASES for NEGATIVE cycle triggering of pickup and sparks 12 & 34
|
|
case TRIG_FLAG_12N:
|
|
case TRIG_FLAG_34N:
|
|
{
|
|
const bool expected_negative = coils->spark_status == sparkStatus::SPARK_NEG_WAIT;
|
|
// Timeout not occourred, expected NEGATIVE edge spark OCCOURRED
|
|
if (spark_flag != SPARK_FLAG_NIL && expected_negative)
|
|
{
|
|
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("Spark on NEGATIVE pulse");
|
|
LOG_INFO("Spark Delay Time: ", (int32_t)coils->spark_delay);
|
|
#endif
|
|
}
|
|
// Timeout occourred, expected POSITIVE edge spark NOT OCCOURRED
|
|
else if (spark_flag == SPARK_FLAG_NIL && expected_negative)
|
|
{
|
|
coils->sstart_status = softStartStatus::ERROR;
|
|
coils->spark_status = sparkStatus::SPARK_NEG_FAIL;
|
|
}
|
|
// Timeout not occouured, unexpected negative edge spark
|
|
else if (spark_flag != SPARK_FLAG_NIL && !expected_negative)
|
|
{
|
|
coils->sstart_status = softStartStatus::SOFT_START;
|
|
coils->spark_status = sparkStatus::SPARK_NEG_UNEXPECTED;
|
|
}
|
|
// Wait for finish of negative pulse to save data to buffer
|
|
coils->n_events++;
|
|
if (pickup_flag == TRIG_FLAG_12N)
|
|
cycle12 = true;
|
|
else
|
|
cycle34 = true;
|
|
break;
|
|
}
|
|
default:
|
|
#ifdef DEUG
|
|
LOG_ERROR("Invalid Interrupt");
|
|
LOG_ERROR("Pickup Flags: ", printBits(pickup_flag).c_str());
|
|
LOG_ERROR("Spark Flags: ", printBits(spark_flag).c_str());
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
if (cycle12 && cycle34) // wait for both 12 and 34 cycles to complete before sending data to main loop and resetting peak detectors
|
|
{
|
|
cycle12 = false;
|
|
cycle34 = false;
|
|
// read adc channels: pickup12, out12 [ pos + neg ]
|
|
if (adc) // read only if adc initialized
|
|
{
|
|
// from peak detector circuits
|
|
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(1));
|
|
|
|
// reset peak detectors + sample and hold
|
|
// outputs on io expander
|
|
if (io)
|
|
{
|
|
const uint16_t iostat = io->read();
|
|
io->write(iostat | rst_bitmask);
|
|
vTaskDelay(pdMS_TO_TICKS(1));
|
|
io->write(iostat & ~rst_bitmask);
|
|
}
|
|
else
|
|
vTaskDelay(pdMS_TO_TICKS(1));
|
|
|
|
// send essage to main loop with ignition info, by copy so local static variable is ok
|
|
if (rt_queue)
|
|
ign_box_sts.timestamp = esp_timer_get_time(); // update data timestamp
|
|
if (xQueueSendToBack(rt_queue, (void *)&ign_box_sts, 0) != pdPASS)
|
|
{
|
|
static uint32_t n_errors = 0;
|
|
n_errors++;
|
|
ign_box_sts.n_queue_errors = n_errors;
|
|
LOG_ERROR("Failed to send to rt_queue");
|
|
}
|
|
}
|
|
}
|
|
// Delete the timeout timer
|
|
esp_timer_delete(timeout_timer);
|
|
LOG_WARN("Ending realTime Task");
|
|
// 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);
|
|
// delete present task
|
|
vTaskDelete(NULL);
|
|
}
|