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

Pins and devices refactoring in progress

Browse Source
This commit is contained in:
Emanuele Trabattoni
2026-03-26 18:22:22 +01:00
parent 68ed8a2282
commit a0710f7ee7
7 changed files with 314 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
RotaxMonitor/src/tasks.h
View File

@@ -10,111 +10,158 @@
// DEVICES
#include "devices.h"
const auto spark_timeout_max = 1;
//Global Variables and Flags
static bool rt_task_running = true;
const auto spark_timeout_max = 1; // convert to microsecond timer
void ignitionA_task(void *pvParameters) {
if (!pvParameters) {
LOG_ERROR("Null device parameters");
vTaskDelete(NULL);
}
Devices* dev = (Devices*) pvParameters;
ADS1256* adc = dev->adc;
// Ignition A Interrupts
attachInterrupt(TRIG_A12P, trig_isr_a, RISING);
attachInterrupt(TRIG_A34P, trig_isr_a, RISING);
attachInterrupt(TRIG_A12N, trig_isr_a, RISING);
attachInterrupt(TRIG_A34N, trig_isr_a, RISING);
attachInterrupt(SPARK_A12, spark_a, RISING);
attachInterrupt(SPARK_A34, spark_a, RISING);
uint32_t pickup_flag;
uint32_t spark_flag;
while (true) {
while (rt_task_running) {
// WAIT FOR PICKUP SIGNAL
xTaskNotifyWait(
0x00, // non pulire all'ingresso
ULONG_MAX, // pulisci tutti i bit all'uscita
0x000000FF, // pulisci i primi 8 bit
&pickup_flag, // valore ricevuto
portMAX_DELAY
);
// WAIT FOR SPARK TO HAPPEN
auto spark_timeout = xTaskNotifyWait(
0x00, // non pulire all'ingresso
ULONG_MAX, // pulisci tutti i bit all'uscita
&spark_flag, // valore ricevuto
0x0000FF00, // pulisci gli 8 bit successivi
&spark_flag, // valore ricevuto
spark_timeout_max
);
// 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_A12P || pickup_flag == TRIG_FLAG_A12N) && spark_flag != SPARK_A12) {
ignA_status.trig12_start = ignA_status.trig34_start = -1;
ignA_status.spark12_start = ignA_status.spark34_start = -1;
ignA_status.spark12_delay = ignA_status.spark34_delay = -1;
ignA_status.soft12_engaged = ignA_status.soft34_engaged = false;
ignA_status.spark12_status = ignA_status.spark12_status = sparkStatus::SPARK_SYNC_FAIL;
ignA_status.coils12.spark_status = ignA_status.coils34.spark_status = sparkStatus::SPARK_SYNC_FAIL;
// Save error on circular buffer and skip to next cycle //
// [TODO]
continue;
}
bool new_data12 = false;
const uint32_t combined_flags = pickup_flag & spark_flag;
coilsStatus* c;
switch (combined_flags)
{
case TRIG_A12P:
case TRIG_A12N:
case SPARK_A12:
c = &ignA_status.coils12;
case TRIG_A34P:
case TRIG_A34N:
case SPARK_A34:
c = &ignA_status.coils34;
}
bool new_data = false;
switch (pickup_flag) {
case TRIG_FLAG_A12P: {
// CASES for NEGATIVE cycle triggering of pickup and sparks 12 & 34
case TRIG_FLAG_A12P:
case TRIG_FLAG_A34P:
{
// Timeout not occourred, expected POSITIVE edge spark OCCOURRED
if (spark_timeout == pdPASS) {
ignA_status.spark12_delay = ignA_status.spark12_start - ignA_status.trig12_start;
ignA_status.soft12_engaged = false; // because spark on positive edge
ignA_status.spark12_status = sparkStatus::SPARK_POS_OK; // do not wait for spark on negative edge
c->spark_delay = c->spark_time - c->trig_time;
c->soft_start_status = softStartStatus::NORMAL; // because spark on positive edge
c->spark_status = sparkStatus::SPARK_POS_OK; // do not wait for spark on negative edge
}
// Timeout occourred, expected POSITIVE edge spark NOT OCCOURRED
else if (spark_timeout == pdFAIL) {
ignA_status.spark12_status = sparkStatus::SPARK_NEG_WAIT;
ignA_status.soft12_engaged = false;
c->spark_status = sparkStatus::SPARK_NEG_WAIT;
c->soft_start_status = softStartStatus::NORMAL;
}
// Do nothing more on positive pulse
break;
new_data = false;
break; // Do nothing more on positive pulse
}
case TRIG_FLAG_A12N: {
bool expected_negative12 = ignA_status.spark12_status == sparkStatus::SPARK_NEG_WAIT;
// CASES for NEGATIVE cycle triggering of pickup and sparks 12 & 34
case TRIG_FLAG_A12N:
case TRIG_FLAG_A34N:
{
const bool expected_negative12 = c->spark_status == sparkStatus::SPARK_NEG_WAIT;
// Timeout not occourred, expected NEGATIVE edge spark OCCOURRED
if (spark_timeout == pdPASS && expected_negative12) {
ignA_status.spark12_delay = ignA_status.spark12_start - ignA_status.trig12_start;
ignA_status.soft12_engaged = true;
ignA_status.spark12_status == sparkStatus::SPARK_NEG_OK;
c->spark_delay = c->spark_time - c->trig_time;
c->soft_start_status = softStartStatus::SOFT_START;
c->spark_status == sparkStatus::SPARK_NEG_OK;
}
// Timeout occourred, expected POSITIVE edge spark NOT OCCOURRED
else if (spark_timeout == pdFAIL && expected_negative12) {
ignA_status.soft12_engaged = false;
ignA_status.spark12_status = sparkStatus::SPARK_NEG_FAIL;
c->soft_start_status = softStartStatus::NORMAL;
c->spark_status = sparkStatus::SPARK_NEG_FAIL;
}
// Timeout not occouured, unexpected negative edge spark
else if (spark_timeout == pdPASS && !expected_negative12) {
ignA_status.soft12_engaged = true;
ignA_status.spark12_status = sparkStatus::SPARK_NEG_UNEXPECTED;
c->soft_start_status = softStartStatus::SOFT_START;
c->spark_status = sparkStatus::SPARK_NEG_UNEXPECTED;
}
// Save status on circular buffer
new_data12 = true;
// Wait for finish of negative pulse to save data to buffer
new_data = true;
break;
}
case TRIG_FLAG_A34P:
case TRIG_FLAG_A34N:
break;
default:
LOG_ERROR("Invalid A Interrupt");
}
vTaskDelay(pdMS_TO_TICKS(1)); // delay 1ms to allow peak detectors to charge
if (new_data12) {
if (new_data) {
vTaskDelay(pdMS_TO_TICKS(1)); // delay 1ms to allow peak detectors to charge for negative cycle
// read adc channels: pickup12, out12 [ pos + neg ]
ignA_status.volts12_pickup = adcReadChannel(adc, PICKUP_IN_A12);
ignA_status.volts12_out = adcReadChannel(adc, PICKUP_OUT_A12);
// reset peak detectors
digitalWrite(RST_A12P, HIGH);
digitalWrite(RST_A12N, HIGH);
vTaskDelay(pdMS_TO_TICKS(1));
digitalWrite(RST_A12P, HIGH);
digitalWrite(RST_A12N, HIGH);
ignA_status.coils12.pickup_volts = adcReadChannel(adc, IN_A12_P);
ignA_status.coils12.output_volts = adcReadChannel(adc, PICKUP_OUT_A12);
ignA_status.coils34.pickup_volts = adcReadChannel(adc, PICKUP_IN_A34);
ignA_status.coils34.output_volts = adcReadChannel(adc, PICKUP_OUT_A34);
// reset peak detectors -> gli output sono sull'expander
//digitalWrite(RST_A12P, HIGH);
//digitalWrite(RST_A12N, HIGH);
//vTaskDelay(pdMS_TO_TICKS(1));
//digitalWrite(RST_A12P, HIGH);
//digitalWrite(RST_A12N, HIGH);
// save on circluar buffer 12
}
}
// Ignition A Interrupts DETACH
detachInterrupt(TRIG_A12P);
detachInterrupt(TRIG_A34P);
detachInterrupt(TRIG_A12N);
detachInterrupt(TRIG_A34N);
detachInterrupt(SPARK_A12);
detachInterrupt(SPARK_A34);
// delete present task
vTaskDelete(NULL);
}
void ignitionB_task(void *pvParameters) {
uint32_t notifiedValue;
// Ignition B Interrupts
attachInterrupt(TRIG_B12P, trig_isr_b, RISING);
attachInterrupt(TRIG_B34P, trig_isr_b, RISING);
attachInterrupt(TRIG_B12N, trig_isr_b, RISING);
attachInterrupt(TRIG_B34N, trig_isr_b, RISING);
attachInterrupt(SPARK_B12, spark_b, RISING);
attachInterrupt(SPARK_B34, spark_b, RISING);
while (true) {
// attende eventi
xTaskNotifyWait(