Fast ADC readings ok, to verify timing and settling time

adc read ok, very slow
Merge branch 'debug'
2026-04-05 17:05:10 +02:00 · 2026-04-05 11:16:10 +02:00 · 2026-04-05 10:32:08 +02:00 · 2026-04-04 22:12:53 +02:00
12 changed files with 157 additions and 151 deletions
--- a/RotaxMonitor/platformio.ini
+++ b/RotaxMonitor/platformio.ini
@@ -25,11 +25,17 @@ upload_port = /dev/ttyACM2
 upload_speed = 921600

 ;Monitor configuration
-monitor_speed = 115200
 monitor_port = /dev/ttyACM2
+monitor_speed = 921600

 ; Build configuration
-build_type = debug
+build_type = release
+build_flags = 
+    -DARDUINO_USB_CDC_ON_BOOT=0
+    -DARDUINO_USB_MODE=0
+    -fstack-protector-all
+    -DCONFIG_FREERTOS_GENERATE_RUN_TIME_STATS=1
+    -DCONFIG_FREERTOS_USE_TRACE_FACILITY=1

 [env:esp32-s3-devkitc1-n16r8-debug]
 board = ${env:esp32-s3-devkitc1-n16r8.board}
@@ -43,8 +49,8 @@ upload_port = /dev/ttyACM2
 upload_speed = 921600

 ;Monitor configuration
-monitor_speed = 115200
 monitor_port = /dev/ttyACM2
+monitor_speed = 921600

 ; Debug configuration
 debug_tool = esp-builtin
--- a/RotaxMonitor/src/ADS1256.cpp
+++ b/RotaxMonitor/src/ADS1256.cpp
@@ -120,14 +120,14 @@ void ADS1256::setDRATE(uint8_t drate) //Setting DRATE (sampling frequency)
 {		
 	writeRegister(DRATE_REG, drate);
 	_DRATE = drate;
-	delay(200);
+	delayMicroseconds(500);
 }

 void ADS1256::setMUX(uint8_t mux) //Setting MUX (input channel)
 {	
 	writeRegister(MUX_REG, mux);
 	_MUX = mux;
-	delay(200);
+	//delayMicroseconds(500);
 }

 void ADS1256::setPGA(uint8_t pga) //Setting PGA (input voltage range)
@@ -138,7 +138,7 @@ void ADS1256::setPGA(uint8_t pga) //Setting PGA (input voltage range)
 	_ADCON = (_ADCON & 0b11111000) | (_PGA & 0b00000111); // Clearing and then setting bits 2-0 based on pga
 	
 	writeRegister(ADCON_REG, _ADCON);	
-	delay(200);
+	delayMicroseconds(1000); //Delay to allow the PGA to settle after changing its value
 	
 	updateConversionParameter(); //Update the multiplier according top the new PGA value
 }
@@ -501,8 +501,6 @@ void ADS1256::writeRegister(uint8_t registerAddress, uint8_t registerValueToWrit
  
  CS_HIGH();
  _spi->endTransaction();
-  delay(100);
-  
 }

 long ADS1256::readRegister(uint8_t registerAddress) //Reading a register
@@ -524,7 +522,7 @@ long ADS1256::readRegister(uint8_t registerAddress) //Reading a register

  CS_HIGH();
  _spi->endTransaction();
-  delay(100);
+
  return regValue;
 }

--- a/RotaxMonitor/src/devices.h
+++ b/RotaxMonitor/src/devices.h
@@ -1,5 +1,8 @@
 #pragma once

+// Library defines
+#define ADS1256_SPI_ALREADY_STARTED
+
 // Device Libraries
 #include <ADS1256.h>
 #include <AD5292.h>
--- a/RotaxMonitor/src/isr.cpp
+++ b/RotaxMonitor/src/isr.cpp
@@ -7,7 +7,6 @@
 void trig_isr(void *arg)
 {
    const int64_t time_us = esp_timer_get_time();
-    static uint8_t isr_firing_count = 0;

    // exit if invalid args
    if (!arg)
@@ -26,47 +25,29 @@ void trig_isr(void *arg)
    {
    case TRIG_FLAG_12P:
    case TRIG_FLAG_12N:
-        // if (isr_firing_count == 0)
-        {
        // only on first trigger to avoid multiple firing due to noise, to be fixed with hardware debounce
-            isr_firing_count++;
-            box->coils12.spark_ok = false; // reset spark ok flag on new trigger event
        box->coils12.trig_time = time_us;
        xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken);
-        }
        break;
    case TRIG_FLAG_34P:
    case TRIG_FLAG_34N:
-        // if (isr_firing_count == 0)
-        {
        // only on first trigger to avoid multiple firing due to noise, to be fixed with hardware debounce
-            isr_firing_count++;
-            box->coils34.spark_ok = false; // reset spark ok flag on new trigger event
        box->coils34.trig_time = time_us;
        xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken);
-        }
        break;
    case SPARK_FLAG_12:
-        // if (isr_firing_count > 0) // only consider spark if a trigger has been detected, otherwise noise on spark pin can cause false positives
-        {
-            isr_firing_count = 0; // reset trigger timeout counter on spark event
        box->coils34.spark_ok = false;
        box->coils12.spark_ok = true;
        box->coils12.spark_time = time_us;
        xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken);
        // vTaskNotifyGiveFromISR(task_handle, &xHigherPriorityTaskWoken);
-        }
        break;
    case SPARK_FLAG_34:
-        // if (isr_firing_count > 0) // only consider spark if a trigger has been detected, otherwise noise on spark pin can cause false positives
-        {
-            isr_firing_count = 0; // reset trigger timeout counter on spark event
        box->coils12.spark_ok = false;
        box->coils34.spark_ok = true;
        box->coils34.spark_time = time_us;
        xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken);
        // vTaskNotifyGiveFromISR(task_handle, &xHigherPriorityTaskWoken);
-        }
        break;
    default:
        break;
--- a/RotaxMonitor/src/isr.h
+++ b/RotaxMonitor/src/isr.h
@@ -29,6 +29,7 @@ static const uint32_t TRIG_FLAG_34N = (1 << 3);
 static const uint32_t SPARK_FLAG_NIL = (1 << 8);
 static const uint32_t SPARK_FLAG_12 = (1 << 9);
 static const uint32_t SPARK_FLAG_34 = (1 << 10);
+static const uint32_t SPARK_FLAG_TIMEOUT = (1 << 11);

 // Spark Status
 enum sparkStatus
@@ -98,6 +99,7 @@ struct ignitionBoxStatus
    // voltage from generator
    float volts_gen = 0.0;
    uint32_t n_queue_errors = 0;
+    uint32_t adc_read_time = 0;
 };

 struct isrParams
--- a/RotaxMonitor/src/main.cpp
+++ b/RotaxMonitor/src/main.cpp
@@ -12,14 +12,22 @@
 #include <devices.h>
 #include <ui.h>

+// FreeRTOS directives
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
 // #define CH_B_ENABLE
 #define TEST

-void printTaskList()
+float freqToRPM(float freq)
+{
+    return freq * 60.0f; // 1 pulse per revolution
+}
+
+void printTaskStats()
 {
    char buffer[1024];
-    Serial.println("Task Name\tState\tPrio\tStack\tNum");
-    vTaskList(buffer);
+    vTaskGetRunTimeStats(buffer);
    Serial.println(buffer);
 }

@@ -100,14 +108,15 @@ void loop()
    bool spiA_ok = true;
    bool spiB_ok = true;

-#ifndef TEST
    // Init 2 SPI interfaces
    SPIClass SPI_A(FSPI);
    spiA_ok = SPI_A.begin(SPI_A_SCK, SPI_A_MISO, SPI_A_MOSI);
+    SPI_A.setDataMode(SPI_MODE1); // ADS1256 requires SPI mode 1
+    #ifndef TEST
    SPIClass SPI_B(HSPI);
    spiB_ok = SPI_B.begin(SPI_B_SCK, SPI_B_MISO, SPI_B_MOSI);
+    SPI_B.setDataMode(SPI_MODE1); // ADS1256 requires SPI mode 1
    #endif
-
    if (!spiA_ok || !spiB_ok)
    {
        LOG_ERROR("Unable to Initialize SPI Busses");
@@ -117,13 +126,13 @@ void loop()
    }
    LOG_INFO("Init SPI OK");

-#ifndef TEST
    // Init ADC_A
-    dev.adc_a = new ADS1256(ADC_A_DRDY, ADC_A_RST, ADC_A_SYNC, ADC_A_CS, 2.5, &SPI_A);
+    dev.adc_a = new ADS1256(ADC_A_DRDY, ADS1256::PIN_UNUSED, ADC_A_SYNC, ADC_A_CS, 2.5, &SPI_A);
    dev.adc_a->InitializeADC();
    dev.adc_a->setPGA(PGA_1);
-    dev.adc_a->setDRATE(DRATE_1000SPS);
+    dev.adc_a->setDRATE(DRATE_7500SPS);

+#ifndef TEST
    // Init ADC_B
    dev.adc_a = new ADS1256(ADC_B_DRDY, ADC_B_RST, ADC_B_SYNC, ADC_B_CS, 2.5, &SPI_B);
    dev.adc_a->InitializeADC();
@@ -174,52 +183,56 @@ void loop()
    int64_t last = esp_timer_get_time();
    uint32_t missed_firings12 = 0;
    uint32_t missed_firings34 = 0;
+    uint32_t counter = 0;

    while (running)
    {
        if (xQueueReceive(rt_taskA_queue, &ignA, pdMS_TO_TICKS(1000)) == pdTRUE)
        {
-            if (ignA.coils12.spark_status == sparkStatus::SPARK_NEG_FAIL || ignA.coils12.spark_status == sparkStatus::SPARK_POS_FAIL)
+            float freq = (esp_timer_get_time() - last) / 1000000.0f; // in seconds
+            freq = freq > 0 ? 1.0f / freq : 0;                      // Calculate frequency (Hz)
+            last = esp_timer_get_time();
+
+            if (ignA.coils12.spark_status == sparkStatus::SPARK_POS_FAIL || ignA.coils12.spark_status == sparkStatus::SPARK_NEG_FAIL)
                missed_firings12++;
            if (ignA.coils34.spark_status == sparkStatus::SPARK_POS_FAIL || ignA.coils34.spark_status == sparkStatus::SPARK_NEG_FAIL)
                missed_firings34++;
+
            clearScreen();
            setCursor(0, 0);
-            printField("++ Timestamp", (uint32_t)ignA.timestamp, 0, 0);
+            printField("++ Timestamp", (uint32_t)ignA.timestamp);
            Serial.println("========== Coils 12 =============");
-            printField("Events", (uint32_t)ignA.coils12.n_events, 0, 1);
-            printField("Missed Firing", missed_firings12, 0, 2);
-            printField("Spark Dly", (uint32_t)ignA.coils12.spark_delay, 0, 3);
-            printField("Spark Sts", sparkStatusNames.at(ignA.coils12.spark_status), 0, 4);
-            // printField("Peak P_IN", ignA.coils12.peak_p_in, 0, 5);
-            // printField("Peak P_OUT", ignA.coils12.peak_p_out, 0, 6);
-            // printField("Peak N_IN", ignA.coils12.peak_n_in, 0, 7);
-            // printField("Peak N_OUT", ignA.coils12.peak_n_out, 0, 8);
-            printField("Soft Start ", softStartStatusNames.at(ignA.coils12.sstart_status), 0, 9);
+            printField("Events", (uint32_t)ignA.coils12.n_events);
+            printField("Missed Firing", missed_firings12);
+            printField("Spark Dly", (uint32_t)ignA.coils12.spark_delay);
+            printField("Spark Sts", sparkStatusNames.at(ignA.coils12.spark_status));
+            printField("Peak P_IN", ignA.coils12.peak_p_in);
+            printField("Peak N_IN", ignA.coils12.peak_n_in);
+            printField("Peak P_OUT", ignA.coils12.peak_p_out);
+            printField("Peak N_OUT", ignA.coils12.peak_n_out);
+            printField("Soft Start ", softStartStatusNames.at(ignA.coils12.sstart_status));

            Serial.println("========== Coils 34 =============");
-            printField("Events", (uint32_t)ignA.coils34.n_events, 0, 11);
-            printField("Missed Firing", missed_firings34, 0, 12);
-            printField("Spark Dly", (uint32_t)ignA.coils34.spark_delay, 0, 13);
-            printField("Spark Sts", sparkStatusNames.at(ignA.coils34.spark_status), 0, 14);
-            // printField("Peak P_IN", ignA.coils34.peak_p_in, 0, 15);
-            // printField("Peak P_OUT", ignA.coils34.peak_p_out, 0, 16);
-            // printField("Peak N_IN", ignA.coils34.peak_n_in, 0, 17);
-            // printField("Peak N_OUT", ignA.coils34.peak_n_out, 0, 18);
-            printField("Soft Start ", softStartStatusNames.at(ignA.coils34.sstart_status), 0, 19);
+            printField("Events", (uint32_t)ignA.coils34.n_events);
+            printField("Missed Firing", missed_firings34);
+            printField("Spark Dly", (uint32_t)ignA.coils34.spark_delay);
+            printField("Spark Sts", sparkStatusNames.at(ignA.coils34.spark_status));
+            printField("Peak P_IN", ignA.coils34.peak_p_in);
+            printField("Peak N_IN", ignA.coils34.peak_n_in);
+            printField("Peak P_OUT", ignA.coils34.peak_p_out);
+            printField("Peak N_OUT", ignA.coils34.peak_n_out);
+            printField("Soft Start ", softStartStatusNames.at(ignA.coils34.sstart_status));

            Serial.println("========== END =============");
            Serial.println();
-            auto delta = (esp_timer_get_time() - last) / 1000000.0f; //in seconds
-            delta = delta > 0 ? 1.0f / delta : 0; // Calculate frequency (Hz)
-            printField("Frequency (Hz)", delta, 0, 21);
-            printField("Queue Errors", (uint32_t)ignA.n_queue_errors, 0, 22);
-            last = esp_timer_get_time();
-        } else
+            printField("Engine RPM", freqToRPM(freq));
+            printField("ADC Read Time", (uint32_t)ignA.adc_read_time);
+            printField("Queue Errors", (uint32_t)ignA.n_queue_errors);
+        }
+        else
        {
-            setCursor(0, 22);
-            Serial.print("Waiting for data... ");;
-            Serial.flush();
+            Serial.println("Waiting for data... ");
+            delay(500);
        }
    }

--- a/RotaxMonitor/src/pins.h
+++ b/RotaxMonitor/src/pins.h
@@ -48,19 +48,17 @@
 // =====================
 #define ADC_A_CS     4
 #define ADC_A_DRDY   5
-#define ADC_A_RST    6
-#define ADC_A_SYNC   7
+#define ADC_A_SYNC   6

 #define ADC_B_CS     14
 #define ADC_B_DRDY   15
-#define ADC_B_RST    16
-#define ADC_B_SYNC   17
+#define ADC_B_SYNC   16

 // =====================
 // DIGITAL POT
 // =====================
-//#define POT_A_CS    1
-//#define POT_B_CS    2
+#define POT_A_CS    7
+#define POT_B_CS    17

 // =====================
 // TRIGGER INPUT INTERRUPTS
--- a/RotaxMonitor/src/tasks.cpp
+++ b/RotaxMonitor/src/tasks.cpp
@@ -1,4 +1,11 @@
 #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)
 {
@@ -51,6 +58,16 @@ void rtIgnitionTask(void *pvParameters)
        
    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);
@@ -107,25 +124,25 @@ void rtIgnitionTask(void *pvParameters)
        }
 #endif

-        // WAIT FOR SPARK TO HAPPEN OR TIMEOUT
-        // auto spark_timeout = ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(spark_timeout_max));
-        // 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;
-        // else
-        //     spark_flag = SPARK_FLAG_NIL;
+        // 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
-        auto sp = xTaskNotifyWait(
+        BaseType_t sp = pdFALSE;
+        sp = xTaskNotifyWait(
            0x00,         // non pulire all'ingresso
            ULONG_MAX,    // pulisci i primi 8 bit
            &spark_flag, // valore ricevuto
-            pdMS_TO_TICKS(spark_timeout_max)); // wait for spark event or timeout
+            portMAX_DELAY); // wait indefinitely, timeout handled by esp_timer

-        // timeout occurred, set spark flag to nil
-        if (sp == pdFALSE)
-        {
+        // 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
@@ -145,6 +162,7 @@ void rtIgnitionTask(void *pvParameters)
            continue;
        }

+        // Select coil status reference based on pickup_flag
        coilsStatus *coils;
        switch (pickup_flag)
        {
@@ -159,6 +177,7 @@ void rtIgnitionTask(void *pvParameters)
            break;
        }

+        // Select logic based on pickup and spark flags
        switch (pickup_flag)
        {
        case TRIG_FLAG_12P:
@@ -232,10 +251,10 @@ void rtIgnitionTask(void *pvParameters)
        {
            cycle12 = false;
            cycle34 = false;
-            // vTaskDelay(pdMS_TO_TICKS(1)); // delay 1ms to allow peak detectors to charge for negative cycle
            //  read adc channels: pickup12, out12 [ pos + neg ]
            if (adc) // read only if adc initialized
            {
+                uint32_t start_adc_read = esp_timer_get_time();
                // 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);
@@ -245,6 +264,7 @@ void rtIgnitionTask(void *pvParameters)
                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);
+                ign_box_sts.adc_read_time = (uint32_t)(esp_timer_get_time() - start_adc_read);
            }
            else // simulate adc read timig
                vTaskDelay(pdMS_TO_TICKS(1));
@@ -266,11 +286,15 @@ void rtIgnitionTask(void *pvParameters)
                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++;
+                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);
--- a/RotaxMonitor/src/tasks.h
+++ b/RotaxMonitor/src/tasks.h
@@ -16,7 +16,7 @@
 #include "devices.h"

 // Global Variables and Flags
-const uint8_t spark_timeout_max = 1; // in milliseconds
+const uint32_t spark_timeout_max = 500; // in microseconds

 // Debug Variables
 #ifdef DEBUG
@@ -27,6 +27,7 @@ static const std::map<const uint32_t, const char *> names = {
    {TRIG_FLAG_34N, "TRIG_FLAG_34N"},
    {SPARK_FLAG_12, "SPARK_FLAG_12"},
    {SPARK_FLAG_34, "SPARK_FLAG_34"},
+    {SPARK_FLAG_TIMEOUT, "SPARK_FLAG_TIMEOUT"},
 };
 #endif

--- a/RotaxMonitor/src/ui.h
+++ b/RotaxMonitor/src/ui.h
@@ -2,58 +2,35 @@

 #include <Arduino.h>

-static bool firstRun = true;
-
-void clearScreen(){
+void clearScreen()
+{
    Serial.print("\033[2J"); // clear screen
    Serial.print("\033[H");  // cursor home
    Serial.flush();
 }

-void setCursor(const uint8_t x, const uint8_t y) {
+void setCursor(const uint8_t x, const uint8_t y)
+{
    Serial.printf("\033[%d;%d", y, x + 1);
    Serial.flush();
 }

-void printField(const char name[], const uint32_t val, const uint8_t x, const uint8_t y) {
-    if (firstRun) {
-        setCursor(x,y);
+void printField(const char name[], const uint32_t val)
+{
    Serial.printf("%15s: %06d\n", name, val);
-        return;
-    }
-    setCursor(x+16, y);
-    Serial.print(val);
 }

-void printField(const char name[], const int64_t val, const uint8_t x, const uint8_t y) {
-    if (firstRun) {
-        setCursor(x,y);
+void printField(const char name[], const int64_t val)
+{
    Serial.printf("%15s: %06u\n", name, (uint64_t)val);
-        return;
-    }
-    setCursor(x+16, y);
-    Serial.print((uint64_t)val);
-    Serial.flush();
 }

-void printField(const char name[], const float val, const uint8_t x, const uint8_t y) {
-    if (firstRun) {
-        setCursor(x,y);
+void printField(const char name[], const float val)
+{
    Serial.printf("%15s: %4.2f\n", name, val);
-        return;
-    }
-    setCursor(x+16, y);
-    Serial.print(val);
-    Serial.flush();
 }

-void printField(const char name[], const char *val, const uint8_t x, const uint8_t y) {
-    if (firstRun) {
-        setCursor(x,y);
+void printField(const char name[], const char *val)
+{
    Serial.printf("%15s: %s\n", name, val);
-        return;
-    }
-    setCursor(x+16, y);
-    Serial.print(val);
-    Serial.flush();
 }
--- a/RotaxMonitorTester/platformio.ini
+++ b/RotaxMonitorTester/platformio.ini
@@ -16,7 +16,7 @@ lib_deps =
 	hideakitai/DebugLog@^0.8.4
 board_build.flash_size = 4MB
 board_build.partitions = default.csv
-monitor_speed = 115200
+monitor_speed = 921600
 build_type = release

 [env:esp32-devtest-debug]
@@ -27,7 +27,7 @@ lib_deps =
 	hideakitai/DebugLog@^0.8.4
 board_build.flash_size = 4MB
 board_build.partitions = default.csv
-monitor_speed = 115200
+monitor_speed = 921600
 build_type = debug
 build_flags = 
 	-O0
--- a/RotaxMonitorTester/src/main.cpp
+++ b/RotaxMonitorTester/src/main.cpp
@@ -18,13 +18,16 @@ static uint32_t count = 0;
 #define PAUSE_LONG_MIN 5000
 #define PAUSE_LONG_MAX PAUSE_LONG_MIN*100

+#define RPM_MIN 800
+#define RPM_MAX 5500
+
 void clearScreen(){
    Serial.print("\033[2J"); // clear screen
    Serial.print("\033[H");  // cursor home
    Serial.flush();
 }

-static double filtered = 0;
+static double filtered_rpm = 0;

 static const std::map<const uint32_t, const char *> pin2Name = {
    {PIN_TRIG_A12P, "HIGH_PIN_TRIG_A12P"},
@@ -54,7 +57,7 @@ static timerStatus stsA = {
 void setup()
 {

-  Serial.begin(115200);
+  Serial.begin(921600);
  delay(1000);
  LOG_ATTACH_SERIAL(Serial);

@@ -94,11 +97,11 @@ void loop()
    stsA.soft_start = false;
  }

-  double new_val = (float)(map(analogRead(FREQ_POT), 0, 4096, PAUSE_LONG_MIN, PAUSE_LONG_MAX));
-  filtered = filtered + 0.1 * (new_val - filtered);
-  stsA.pause_long_us = (uint32_t)filtered;
+  double new_rpm = (double)(map(analogRead(FREQ_POT), 0, 4096, RPM_MIN, RPM_MAX));
+  filtered_rpm = filtered_rpm + 0.1 * (new_rpm - filtered_rpm);
+  stsA.pause_long_us = (uint32_t)(60000000.0f / filtered_rpm / 2.0f);
  LOG_INFO("Spark Delay uS: ", stsA.spark_delay_us, "\tSoft Start: ", stsA.soft_start ? "TRUE" : "FALSE");
-  LOG_INFO("Pause: ", (uint32_t)(stsA.pause_long_us / 1000), "ms");
+  LOG_INFO("Engine Rpm: ", (uint32_t)(filtered_rpm));
  LOG_INFO("Coil Pulse: ", stsA.coil_pulse_us, "us");
  LOG_INFO("Spark Pulse: ", stsA.spark_pulse_us, "us");
Author	SHA1	Message	Date
Emanuele Trabattoni	5c9ef7e93b	Fast ADC readings ok, to verify timing and settling time	2026-04-05 17:05:10 +02:00
Emanuele Trabattoni	a2d0afa0c9	adc read ok, very slow	2026-04-05 11:16:10 +02:00
Emanuele Trabattoni	1109681eb5	Merge branch 'debug'	2026-04-05 10:32:08 +02:00
Emanuele Trabattoni	c5d80052e5	Thans to copilot, microsecond resolution to wait for spark. no missing firings detected	2026-04-04 22:12:53 +02:00