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

Fixed spark timing compute

Browse Source
This commit is contained in:
Emanuele Trabattoni
2026-03-26 14:09:55 +01:00
parent b573f64a39
commit 68ed8a2282
3 changed files with 143 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
RotaxMonitor/src/isr.h
View File

@@ -33,7 +33,8 @@ TaskHandle_t trigA_TaskHandle = NULL;
TaskHandle_t trigB_TaskHandle = NULL;
// Spark Status
enum sparkStatus {
enum sparkStatus
{
SPARK_POS_OK,
SPARK_NEG_OK,
SPARK_POS_SKIP,
@@ -48,16 +49,17 @@ enum sparkStatus {
};
// Task internal Status
struct ignitionBoxStatus {
struct ignitionBoxStatus
{
// start time from ISR
int64_t trig12_start;
int64_t trig34_start;
int64_t trig12_start = 0;
int64_t trig34_start = 0;
// time at which spark occours
int64_t trig12_end;
int64_t trig34_end;
int64_t spark12_start = 0;
int64_t spark34_start = 0;
// computed delay from pickup to spark
int64_t spark12_delay;
int64_t spark34_delay;
int64_t spark12_delay = 0;
int64_t spark34_delay = 0;
// spark status
sparkStatus spark12_status = sparkStatus::SPARK_POS_OK;
sparkStatus spark34_status = sparkStatus::SPARK_POS_OK;
@@ -65,13 +67,13 @@ struct ignitionBoxStatus {
bool soft12_engaged = false;
bool soft34_engaged = false;
// peak voltage from circuits 12 and 34
float volts12_pickup;
float volts34_pickup;
float volts12_pickup = 0.0;
float volts34_pickup = 0.0;
// peak voltage from conditioned output 12 and 34
float volts12_out;
float volts34_out;
float volts12_out = 0.0;
float volts34_out = 0.0;
// voltage from generator
float volts_gen;
float volts_gen = 0.0;
};
ignitionBoxStatus ignA_status;
@@ -82,7 +84,8 @@ ignitionBoxStatus ingB_statusBuffer[IGN_BUF_SIZE];
// Pin to flag Map
static uint32_t pin2trig[49];
void initTriggerPinMapping() {
void initTriggerPinMapping()
{
pin2trig[TRIG_A12P] = TRIG_FLAG_A12P;
pin2trig[TRIG_A12N] = TRIG_FLAG_A12N;
pin2trig[TRIG_A34P] = TRIG_FLAG_A34P;
@@ -94,7 +97,8 @@ void initTriggerPinMapping() {
};
static uint32_t pin2spark[49];
void initSparkPinMapping() {
void initSparkPinMapping()
{
pin2spark[SPARK_A12] = SPARK_FLAG_A12;
pin2spark[SPARK_A34] = SPARK_FLAG_A34;
pin2spark[SPARK_B12] = SPARK_FLAG_B12;
@@ -105,64 +109,80 @@ void initSparkPinMapping() {
// ISR (Pass return bitmask to ISR management function)
// one function for each wake up pin conncted to a trigger
// =====================
void IRAM_ATTR trig_isr_a() {
void IRAM_ATTR trig_isr_a()
{
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
auto startTime = esp_timer_get_time();
const int64_t startTime = esp_timer_get_time();
if (!trigA_TaskHandle) return; // exit if task is not running
uint32_t status = GPIO.status;
uint32_t flags = 0;
while (status) {
while (status)
{
uint32_t pin = __builtin_ctz(status); // trova primo bit attivo
status &= ~(1 << pin); // clear bit
flags |= pin2trig[pin];
}
if (flags & (TRIG_FLAG_A12P | TRIG_FLAG_A12N))
ignA_status.trig12_start = startTime;
else
if (flags & TRIG_FLAG_A12P)
ignA_status.trig12_start = startTime;
if (flags & TRIG_FLAG_A34P)
ignA_status.trig34_start = startTime;
if (trigA_TaskHandle) {
xTaskNotifyFromISR(trigA_TaskHandle, flags, eSetBits, &xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
}
void IRAM_ATTR spark_a() {
void IRAM_ATTR spark_a()
{
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
uint32_t spark_flag = GPIO.status1.val & SPARK_A12 ? SPARK_FLAG_A12 : SPARK_FLAG_A34 ;
if (trigA_TaskHandle) {
const int64_t startTime = esp_timer_get_time();
if (!trigA_TaskHandle) return;
uint32_t spark_flag = GPIO.status1.val & SPARK_A12 ? SPARK_FLAG_A12 : SPARK_FLAG_A34;
if (spark_flag & SPARK_FLAG_A12)
ignA_status.spark12_start = startTime;
if (spark_flag & SPARK_FLAG_A34)
ignA_status.spark34_start = startTime;
xTaskNotifyFromISR(trigA_TaskHandle, spark_flag, eSetBits, &xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
}
void IRAM_ATTR trig_isr_b() {
void IRAM_ATTR trig_isr_b()
{
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
const int64_t startTime = esp_timer_get_time();
if (!trigB_TaskHandle) return; // exit if task is not running
uint32_t status = GPIO.status1.val;
uint32_t status = GPIO.status;
uint32_t flags = 0;
while (status) {
while (status)
{
uint32_t pin = __builtin_ctz(status); // trova primo bit attivo
status &= ~(1 << pin); // clear bit
flags |= pin2trig[pin];
}
if (trigB_TaskHandle) {
if (flags & TRIG_FLAG_B12P)
ignB_status.trig12_start = startTime;
if (flags & TRIG_FLAG_B34P)
ignB_status.trig34_start = startTime;
xTaskNotifyFromISR(trigB_TaskHandle, flags, eSetBits, &xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
}
void IRAM_ATTR spark_b() {
void IRAM_ATTR spark_b()
{
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
uint32_t spark_flag = GPIO.status1.val & SPARK_B12 ? SPARK_FLAG_B12 : SPARK_FLAG_B34 ;
if (trigB_TaskHandle) {
const int64_t startTime = esp_timer_get_time();
if (!trigB_TaskHandle) return;
uint32_t spark_flag = GPIO.status1.val & SPARK_B12 ? SPARK_FLAG_B12 : SPARK_FLAG_B34;
if (spark_flag & SPARK_FLAG_B12)
ignB_status.spark12_start = startTime;
if (spark_flag & SPARK_FLAG_B34)
ignB_status.spark34_start = startTime;
xTaskNotifyFromISR(trigB_TaskHandle, spark_flag, eSetBits, &xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
}

30
RotaxMonitor/src/main.cpp
View File

@@ -12,8 +12,8 @@
#include <tasks.h>
#include <devices.h>
void setup() {
void setup()
{
delay(250);
Serial.begin(115200);
@@ -38,7 +38,6 @@ void setup() {
pinMode(TRIG_B34P, INPUT_PULLDOWN);
pinMode(TRIG_B34N, INPUT_PULLDOWN);
initTriggerPinMapping();
// Initialize Interrupt pins on spark detectors
pinMode(SPARK_A12, INPUT_PULLDOWN);
pinMode(SPARK_A34, INPUT_PULLDOWN);
@@ -65,7 +64,8 @@ void setup() {
SPI.begin();
}
void loop() {
void loop()
{
// global variables
bool running = true;
Devices dev;
@@ -81,32 +81,30 @@ void loop() {
ignitionA_task,
"ignitionA_task",
TASK_STACK,
(void*) &dev,
(void *)&dev,
TASK_PRIORITY,
&trigA_TaskHandle,
CORE_0
);
CORE_0);
// Ignition A on Core 1
// Ignition B on Core 1
auto ignB_task_success = xTaskCreatePinnedToCore(
ignitionB_task,
"ignitionB_task",
TASK_STACK,
(void*) &dev,
(void *)&dev,
TASK_PRIORITY, // priorità leggermente più alta
&trigA_TaskHandle,
CORE_1
);
CORE_1);
if ((ignA_task_success && ignB_task_success) != pdPASS){
if ((ignA_task_success && ignB_task_success) != pdPASS)
{
LOG_ERROR("Unble to initialize ISR task");
}
LOG_INFO("Real Time Tasks A&B initialized");
////////////////////// MAIN LOOP //////////////////////
while (running) {
while (running)
{
}
if (trigA_TaskHandle)
@@ -115,5 +113,3 @@ void loop() {
vTaskDelete(trigB_TaskHandle);
////////////////////// MAIN LOOP //////////////////////
}

11
RotaxMonitor/src/tasks.h
View File

@@ -34,13 +34,11 @@ void ignitionA_task(void *pvParameters) {
&spark_flag, // valore ricevuto
spark_timeout_max
);
// Save current time to compute delay from pickup to spark
auto curr_time = esp_timer_get_time();
// 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.trig12_end = ignA_status.trig34_end = -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;
@@ -50,14 +48,12 @@ void ignitionA_task(void *pvParameters) {
}
bool new_data12 = false;
bool new_data34 = false;
switch (pickup_flag) {
case TRIG_FLAG_A12P: {
// Timeout not occourred, expected POSITIVE edge spark OCCOURRED
if (spark_timeout == pdPASS) {
ignA_status.trig12_end = curr_time;
ignA_status.spark12_delay = ignA_status.trig12_end - ignA_status.trig12_end;
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
}
@@ -73,8 +69,7 @@ void ignitionA_task(void *pvParameters) {
bool expected_negative12 = ignA_status.spark12_status == sparkStatus::SPARK_NEG_WAIT;
// Timeout not occourred, expected NEGATIVE edge spark OCCOURRED
if (spark_timeout == pdPASS && expected_negative12) {
ignA_status.trig12_end = curr_time;
ignA_status.spark12_delay = ignA_status.trig12_end - ignA_status.trig12_end;
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;
}