Second ADC debugging in process

RotaxMonitor/lib/ADS1256/ADS1256.h

@@ -1,11 +1,11 @@
-//ADS1256 header file
+// ADS1256 header file
 /*
  Name:		ADS1256.h
  Created:	2022/07/14
  Author:	Curious Scientist
  Editor:	Notepad++
  Comment: Visit https://curiousscientist.tech/blog/ADS1256-custom-library
- Special thanks to 
+ Special thanks to
  Abraão Queiroz for spending time on the code and suggesting corrections for ESP32 microcontrollers
  Benjamin Pelletier for pointing out and fixing an issue around the handling of the DRDY signal
 */
@@ -14,51 +14,55 @@
 #define _ADS1256_h
 
 #include <SPI.h>
+#include <Arduino.h>
 
-//Differential inputs
+// SPI Frequency
-#define DIFF_0_1 0b00000001 //A0 + A1 as differential input
+#define SPI_FREQ 1920000
-#define DIFF_2_3 0b00100011 //A2 + A3 as differential input
-#define DIFF_4_5 0b01000101 //A4 + A5 as differential input
-#define DIFF_6_7 0b01100111 //A6 + A7 as differential input
 
-//Single-ended inputs
+// Differential inputs
-#define SING_0 0b00001111 //A0 + GND (common) as single-ended input
+#define DIFF_0_1 0b00000001 // A0 + A1 as differential input
-#define SING_1 0b00011111 //A1 + GND (common) as single-ended input
+#define DIFF_2_3 0b00100011 // A2 + A3 as differential input
-#define SING_2 0b00101111 //A2 + GND (common) as single-ended input
+#define DIFF_4_5 0b01000101 // A4 + A5 as differential input
-#define SING_3 0b00111111 //A3 + GND (common) as single-ended input
+#define DIFF_6_7 0b01100111 // A6 + A7 as differential input
-#define SING_4 0b01001111 //A4 + GND (common) as single-ended input
-#define SING_5 0b01011111 //A5 + GND (common) as single-ended input
-#define SING_6 0b01101111 //A6 + GND (common) as single-ended input
-#define SING_7 0b01111111 //A7 + GND (common) as single-ended input
 
-//PGA settings			  //Input voltage range
+// Single-ended inputs
-#define PGA_1 0b00000000  //± 5 V
+#define SING_0 0b00001111 // A0 + GND (common) as single-ended input
-#define PGA_2 0b00000001  //± 2.5 V
+#define SING_1 0b00011111 // A1 + GND (common) as single-ended input
-#define PGA_4 0b00000010  //± 1.25 V
+#define SING_2 0b00101111 // A2 + GND (common) as single-ended input
-#define PGA_8 0b00000011  //± 625 mV
+#define SING_3 0b00111111 // A3 + GND (common) as single-ended input
-#define PGA_16 0b00000100 //± 312.5 mV
+#define SING_4 0b01001111 // A4 + GND (common) as single-ended input
+#define SING_5 0b01011111 // A5 + GND (common) as single-ended input
+#define SING_6 0b01101111 // A6 + GND (common) as single-ended input
+#define SING_7 0b01111111 // A7 + GND (common) as single-ended input
+
+// PGA settings			  //Input voltage range
+#define PGA_1 0b00000000  // ± 5 V
+#define PGA_2 0b00000001  // ± 2.5 V
+#define PGA_4 0b00000010  // ± 1.25 V
+#define PGA_8 0b00000011  // ± 625 mV
+#define PGA_16 0b00000100 // ± 312.5 mV
 #define PGA_32 0b00000101 //+ 156.25 mV
-#define PGA_64 0b00000110 //± 78.125 mV
+#define PGA_64 0b00000110 // ± 78.125 mV
 
-//Datarate						  //DEC
+// Datarate						  //DEC
-#define DRATE_30000SPS 0b11110000 //240
+#define DRATE_30000SPS 0b11110000 // 240
-#define DRATE_15000SPS 0b11100000 //224
+#define DRATE_15000SPS 0b11100000 // 224
-#define DRATE_7500SPS 0b11010000  //208
+#define DRATE_7500SPS 0b11010000  // 208
-#define DRATE_3750SPS 0b11000000  //192
+#define DRATE_3750SPS 0b11000000  // 192
-#define DRATE_2000SPS 0b10110000  //176
+#define DRATE_2000SPS 0b10110000  // 176
-#define DRATE_1000SPS 0b10100001  //161
+#define DRATE_1000SPS 0b10100001  // 161
-#define DRATE_500SPS 0b10010010   //146
+#define DRATE_500SPS 0b10010010	  // 146
-#define DRATE_100SPS 0b10000010   //130
+#define DRATE_100SPS 0b10000010	  // 130
-#define DRATE_60SPS 0b01110010    //114
+#define DRATE_60SPS 0b01110010	  // 114
-#define DRATE_50SPS 0b01100011    //99
+#define DRATE_50SPS 0b01100011	  // 99
-#define DRATE_30SPS 0b01010011    //83
+#define DRATE_30SPS 0b01010011	  // 83
-#define DRATE_25SPS 0b01000011    //67
+#define DRATE_25SPS 0b01000011	  // 67
-#define DRATE_15SPS 0b00110011    //51
+#define DRATE_15SPS 0b00110011	  // 51
-#define DRATE_10SPS 0b00100011    //35
+#define DRATE_10SPS 0b00100011	  // 35
-#define DRATE_5SPS 0b00010011     //19
+#define DRATE_5SPS 0b00010011	  // 19
-#define DRATE_2SPS 0b00000011     //3
+#define DRATE_2SPS 0b00000011	  // 3
 
-//Status register
+// Status register
 #define BITORDER_MSB 0
 #define BITORDER_LSB 1
 #define ACAL_DISABLED 0
@@ -66,7 +70,7 @@
 #define BUFFER_DISABLED 0
 #define BUFFER_ENABLED 1
 
-//Register addresses
+// Register addresses
 #define STATUS_REG 0x00
 #define MUX_REG 0x01
 #define ADCON_REG 0x02
@@ -79,7 +83,7 @@
 #define FSC1_REG 0x09
 #define FSC2_REG 0x0A
 
-//Command definitions
+// Command definitions
 #define WAKEUP 0b00000000
 #define RDATA 0b00000001
 #define RDATAC 0b00000011
@@ -96,26 +100,30 @@
 #define RESET 0b11111110
 //----------------------------------------------------------------
 
-
 class ADS1256
-{	
+{
 public:
-static constexpr int8_t PIN_UNUSED = -1;
+	static constexpr int8_t PIN_UNUSED = -1;
 
-	//Constructor
+	// Constructor
-	ADS1256(const int8_t DRDY_pin, const int8_t RESET_pin, const int8_t SYNC_pin, const int8_t CS_pin, float VREF, SPIClass* spi = &SPI);
+	ADS1256(const int8_t DRDY_pin, const int8_t RESET_pin, const int8_t SYNC_pin, const int8_t CS_pin, float VREF, SPIClass *spi = &SPI);
-	
+	~ADS1256()
-	//Initializing function
+	{
-	void InitializeADC();	
+		vSemaphoreDelete(m_drdyHigh);
-	//ADS1256(int drate, int pga, int byteOrder, bool bufen);
+		vSemaphoreDelete(m_drdyLow);
-	
+	}
-	//Read a register
+
+	// Initializing function
+	void InitializeADC();
+	// ADS1256(int drate, int pga, int byteOrder, bool bufen);
+
+	// Read a register
 	long readRegister(uint8_t registerAddress);
-	
-	//Write a register
-	void writeRegister(uint8_t registerAddress, uint8_t registerValueToWrite);	
 
-	//Individual methods
+	// Write a register
+	void writeRegister(uint8_t registerAddress, uint8_t registerValueToWrite);
+
+	// Individual methods
 	void setDRATE(uint8_t drate);
 	void setPGA(uint8_t pga);
 	uint8_t getPGA();
@@ -128,62 +136,80 @@ static constexpr int8_t PIN_UNUSED = -1;
 	uint8_t getAutoCal();
 	void setGPIO(uint8_t dir0, uint8_t dir1, uint8_t dir2, uint8_t dir3);
 	void writeGPIO(uint8_t dir0value, uint8_t dir1value, uint8_t dir2value, uint8_t dir3value);
-	uint8_t readGPIO(uint8_t gpioPin);	
+	uint8_t readGPIO(uint8_t gpioPin);
 	void setCLKOUT(uint8_t clkout);
-	void setSDCS(uint8_t sdcs);	
+	void setSDCS(uint8_t sdcs);
-	void sendDirectCommand(uint8_t directCommand);	
+	void sendDirectCommand(uint8_t directCommand);
 
-	//Get a single conversion
+	// Get a single conversion
 	long readSingle();
-	
+
-	//Single input continuous reading
+	// Single input continuous reading
 	long readSingleContinuous();
-	
+
-	//Cycling through the single-ended inputs
+	// Cycling through the single-ended inputs
-	long cycleSingle(); //Ax + COM
+	long cycleSingle(); // Ax + COM
-	
+
-	//Cycling through the differential inputs
+	// Cycling through the differential inputs
-	long cycleDifferential(); //Ax + Ay
+	long cycleDifferential(); // Ax + Ay
-		
+
-	//Converts the reading into a voltage value
+	// Converts the reading into a voltage value
 	float convertToVoltage(int32_t rawData);
-		
+
-	//Stop AD
+	// Stop AD
 	void stopConversion();
-	
+
+	// functions for callback
+	inline uint8_t getDRDYpin()
+	{
+		return m_DRDY_pin;
+	}
+
+	SemaphoreHandle_t getDRDYsemaphoreHigh()
+	{
+		return m_drdyHigh;
+	}
+
+	SemaphoreHandle_t getDRDYsemaphoreLow()
+	{
+		return m_drdyLow;
+	}
+
 private:
-	
+	SPIClass *_spi; // Pointer to an SPIClass object
-SPIClass* _spi; //Pointer to an SPIClass object
 
-void waitForLowDRDY(); // Block until DRDY is low
+	void waitForLowDRDY();	// Block until DRDY is low
-void waitForHighDRDY(); // Block until DRDY is high
+	void waitForHighDRDY(); // Block until DRDY is high
-void updateMUX(uint8_t muxValue);
+	void updateMUX(uint8_t muxValue);
-inline void CS_LOW();
+	inline void CS_LOW();
-inline void CS_HIGH();
+	inline void CS_HIGH();
 
-void updateConversionParameter(); //Refresh the conversion parameter based on the PGA
+	void updateConversionParameter(); // Refresh the conversion parameter based on the PGA
 
-float _VREF = 0; //Value of the reference voltage
+	float m_VREF = 0;				 // Value of the reference voltage
-float conversionParameter = 0; //PGA-dependent multiplier
+	float m_conversionParameter = 0; // PGA-dependent multiplier
-//Pins
+	// Pins
-int8_t _DRDY_pin; //Pin assigned for DRDY
+	int8_t m_DRDY_pin;	// Pin assigned for DRDY
-int8_t _RESET_pin; //Pin assigned for RESET
+	int8_t m_RESET_pin; // Pin assigned for RESET
-int8_t _SYNC_pin; //Pin assigned for SYNC
+	int8_t m_SYNC_pin;	// Pin assigned for SYNC
-int8_t _CS_pin; //Pin assigned for CS
+	int8_t m_CS_pin;	// Pin assigned for CS
 
-//Register values
+	// Register values
-byte _DRATE; //Value of the DRATE register
+	uint8_t m_DRATE;	 // Value of the DRATE register
-byte _ADCON; //Value of the ADCON register
+	uint8_t m_ADCON;	 // Value of the ADCON register
-byte _MUX; //Value of the MUX register
+	uint8_t m_MUX;		 // Value of the MUX register
-byte _PGA; //Value of the PGA (within ADCON)
+	uint8_t m_PGA;		 // Value of the PGA (within ADCON)
-byte _GPIO; //Value of the GPIO register
+	uint8_t m_GPIO;		 // Value of the GPIO register
-byte _STATUS; //Value of the status register
+	uint8_t m_STATUS;	 // Value of the status register
-byte _GPIOvalue; //GPIO value
+	uint8_t m_GPIOvalue; // GPIO value
-byte _ByteOrder; //Byte order
+	uint8_t m_ByteOrder; // Byte order
 
-byte _outputBuffer[3]; //3-byte (24-bit) buffer for the fast acquisition - Single-channel, continuous
+	uint8_t m_outputBuffer[3];	 // 3-byte (24-bit) buffer for the fast acquisition - Single-channel, continuous
-long _outputValue; //Combined value of the _outputBuffer[3]
+	int32_t m_outputValue;		 // Combined value of the m_outputBuffer[3]
-bool _isAcquisitionRunning; //bool that keeps track of the acquisition (running or not)
+	bool m_isAcquisitionRunning; // bool that keeps track of the acquisition (running or not)
-uint8_t _cycle; //Tracks the cycles as the MUX is cycling through the input channels
+	uint8_t m_cycle;			 // Tracks the cycles as the MUX is cycling through the input channels
+
+	SemaphoreHandle_t m_drdyHigh;
+	SemaphoreHandle_t m_drdyLow;
 };
 #endif

RotaxMonitor/platformio.ini

@@ -20,7 +20,6 @@ lib_deps =
 	hideakitai/PCA95x5@^0.1.3
 	me-no-dev/AsyncTCP@^3.3.2
 	me-no-dev/ESPAsyncWebServer@^3.6.0
-	adafruit/Adafruit NeoPixel@^1.15.4
 upload_protocol = esptool
 upload_port = /dev/ttyACM1
 upload_speed = 921600
@@ -28,15 +27,14 @@ monitor_port = /dev/ttyACM0
 monitor_speed = 921600
 build_type = release
 build_flags = 
-	-DCORE_DEBUG_LEVEL=5
+	-DCORE_DEBUG_LEVEL=3
 	-DARDUINO_USB_CDC_ON_BOOT=0
 	-DARDUINO_USB_MODE=0
 	-DCONFIG_ASYNC_TCP_MAX_ACK_TIME=5000
 	-DCONFIG_ASYNC_TCP_PRIORITY=21
-	-DCONFIG_ASYNC_TCP_QUEUE_SIZE=64
+	-DCONFIG_ASYNC_TCP_QUEUE_SIZE=128
 	-DCONFIG_ASYNC_TCP_RUNNING_CORE=1
-	-DCONFIG_ASYNC_TCP_STACK_SIZE=4096
+	-DCONFIG_ASYNC_TCP_STACK_SIZE=8192
-	-fstack-protector-all
 
 [env:esp32-s3-devkitc1-n16r8-debug]
 board = ${env:esp32-s3-devkitc1-n16r8.board}
@@ -46,7 +44,6 @@ platform = ${env:esp32-s3-devkitc1-n16r8.platform}
 framework = ${env:esp32-s3-devkitc1-n16r8.framework}
 lib_deps = 
 	${env:esp32-s3-devkitc1-n16r8.lib_deps}
-	adafruit/Adafruit NeoPixel@^1.15.4
 upload_protocol = esptool
 upload_port = /dev/ttyACM1
 upload_speed = 921600
@@ -59,7 +56,7 @@ build_flags =
 	-O0
 	-g3
 	-ggdb3
-	-DCORE_DEBUG_LEVEL=5
+	-DCORE_DEBUG_LEVEL=3
 	-DARDUINO_USB_CDC_ON_BOOT=0
 	-DARDUINO_USB_MODE=0
 	-DCONFIG_ASYNC_TCP_MAX_ACK_TIME=5000
@@ -67,4 +64,3 @@ build_flags =
 	-DCONFIG_ASYNC_TCP_QUEUE_SIZE=128
 	-DCONFIG_ASYNC_TCP_RUNNING_CORE=1
 	-DCONFIG_ASYNC_TCP_STACK_SIZE=8192
-	-fstack-protector-all

RotaxMonitor/src/datasave.cpp

@@ -47,31 +47,29 @@ void ignitionBoxStatusFiltered::update(const ignitionBoxStatus &new_status)
     }
     m_count++;
     // simple moving average calculation
-    m_last.timestamp = new_status.timestamp; // keep timestamp of latest status
+    m_last.timestamp = new_status.timestamp;                                         // keep timestamp of latest status
+    m_last.coils12.n_events = new_status.coils12.n_events;                           // sum events instead of averaging
+    m_last.coils12.n_missed_firing = new_status.coils12.n_missed_firing;             // sum missed firings instead of averaging
+    m_last.coils12.spark_status = new_status.coils12.spark_status;                   // take latest spark status
+    m_last.coils12.sstart_status = new_status.coils12.sstart_status;                 // take latest soft start status
+    filter(m_last.coils12.spark_delay, new_status.coils12.spark_delay, m_max_count); // incremental average calculation
+    filter(m_last.coils12.peak_p_in, new_status.coils12.peak_p_in, m_max_count);     // incremental average calculation
+    filter(m_last.coils12.peak_n_in, new_status.coils12.peak_n_in, m_max_count);     // incremental average calculation
+    filter(m_last.coils12.peak_p_out, new_status.coils12.peak_p_out, m_max_count);   // incremental average calculation
+    filter(m_last.coils12.peak_n_out, new_status.coils12.peak_n_out, m_max_count);   // incremental average calculation
 
-    m_last.coils12.n_events = new_status.coils12.n_events;               // sum events instead of averaging
+    m_last.coils34.n_events = new_status.coils34.n_events;                           // sum events instead of averaging
-    m_last.coils12.n_missed_firing = new_status.coils12.n_missed_firing; // sum missed firings instead of averaging
+    m_last.coils34.n_missed_firing = new_status.coils34.n_missed_firing;             // sum missed firings instead of averaging
-    m_last.coils12.spark_status = new_status.coils12.spark_status;       // take latest spark status
+    m_last.coils34.spark_status = new_status.coils34.spark_status;                   // take latest spark status
-    m_last.coils12.sstart_status = new_status.coils12.sstart_status;     // take latest soft start status
+    m_last.coils34.sstart_status = new_status.coils34.sstart_status;                 // take latest soft start status
-    m_last.coils12.spark_delay = new_status.coils12.spark_delay;         // incremental average calculation
+    filter(m_last.coils34.spark_delay, new_status.coils34.spark_delay, m_max_count); // incremental average calculation
-    m_last.coils12.peak_p_in = new_status.coils12.peak_p_in;             // incremental average calculation
+    filter(m_last.coils34.peak_p_in, new_status.coils34.peak_p_in, m_max_count);     // incremental average calculation
-    m_last.coils12.peak_n_in = new_status.coils12.peak_n_in;             // incremental average calculation
+    filter(m_last.coils34.peak_n_in, new_status.coils34.peak_n_in, m_max_count);     // incremental average calculation
-    m_last.coils12.peak_p_out = new_status.coils12.peak_p_out;           // incremental average calculation
+    filter(m_last.coils34.peak_p_out, new_status.coils34.peak_p_out, m_max_count);   // incremental average calculation
-    m_last.coils12.peak_n_out = new_status.coils12.peak_n_out;           // incremental average calculation
+    filter(m_last.coils34.peak_n_out, new_status.coils34.peak_n_out, m_max_count);   // incremental average calculation
-
+    filter(m_last.eng_rpm, new_status.eng_rpm, m_max_count);                         // incremental average calculation                   // incremental average calculation
-    m_last.coils34.n_events = new_status.coils34.n_events;               // sum events instead of averaging
+    filter(m_last.adc_read_time, m_last.adc_read_time, m_max_count);                 // incremental average calculation
-    m_last.coils34.n_missed_firing = new_status.coils34.n_missed_firing; // sum missed firings instead of averaging
+    m_last.n_queue_errors = new_status.n_queue_errors;
-    m_last.coils34.spark_status = new_status.coils34.spark_status;       // take latest spark status
-    m_last.coils34.sstart_status = new_status.coils34.sstart_status;     // take latest soft start status
-    m_last.coils34.spark_delay = new_status.coils34.spark_delay;         // incremental average calculation
-    m_last.coils34.peak_p_in = new_status.coils34.peak_p_in;             // incremental average calculation
-    m_last.coils34.peak_n_in = new_status.coils34.peak_n_in;             // incremental average calculation
-    m_last.coils34.peak_p_out = new_status.coils34.peak_p_out;           // incremental average calculation
-    m_last.coils34.peak_n_out = new_status.coils34.peak_n_out;           // incremental average calculation
-
-    m_last.eng_rpm = new_status.eng_rpm;               // incremental average calculation
-    m_last.adc_read_time = m_last.adc_read_time;       // incremental average calculation
-    m_last.n_queue_errors = new_status.n_queue_errors; // take last of queue errors since it's a cumulative count of errors in the queue, not an average value
 
     if (m_count >= m_max_count)
     {

RotaxMonitor/src/devices.h

@@ -26,9 +26,9 @@
 struct Devices
 {
     // Busses
-    std::unique_ptr<TwoWire> m_i2c = nullptr;
+    TwoWire *m_i2c = NULL;
-    std::unique_ptr<SPIClass> m_spi_a = nullptr;
+    SPIClass *m_spi_a = NULL;
-    std::unique_ptr<SPIClass> m_spi_b = nullptr;
+    SPIClass *m_spi_b = NULL;
 
     // Bus Mutextes
     std::mutex m_spi_a_mutex;
@@ -36,13 +36,13 @@ struct Devices
     std::mutex m_i2c_mutex;
 
     // Device Pointers
-    std::unique_ptr<AD5292> m_pot_a = nullptr;
+    AD5292 *m_pot_a = NULL;
-    std::unique_ptr<AD5292> m_pot_b = nullptr;
+    AD5292 *m_pot_b = NULL;
 
-    std::unique_ptr<ADS1256> m_adc_a = nullptr;
+    ADS1256 *m_adc_a = NULL;
-    std::unique_ptr<ADS1256> m_adc_b = nullptr;
+    ADS1256 *m_adc_b = NULL;
 
-    std::unique_ptr<ExternalIO> m_ext_io = nullptr;
+    ExternalIO *m_ext_io = NULL;
 };
 
 // Adc read channel wrapper to selet mux before reading

RotaxMonitor/src/isr.h

@@ -16,7 +16,7 @@
 
 #define CORE_0 0
 #define CORE_1 1
-#define RT_TASK_STACK 2048                          // in words
+#define RT_TASK_STACK 4096                          // in words
 #define RT_TASK_PRIORITY (configMAX_PRIORITIES - 5) // highest priority after wifi tasks
 
 struct isrParams

RotaxMonitor/src/main.cpp

@@ -16,23 +16,28 @@
 #include <ui.h>
 #include <led.h>
 
-// Defines to enable channel B
+#define CH_A_ENABLE
-// #define CH_B_ENABLE
+#define CH_B_ENABLE
+#define CH_A_RT_ENABLE
+#define CH_B_RT_ENABLE
+// #define I2C_ENABLE
+// #define WEB_ENABLE
 
 // Debug Defines
 #define WIFI_SSID "AstroRotaxMonitor"
 #define WIFI_PASSWORD "maledettirotax"
-#define PSRAM_MAX 4096
+#define PSRAM_MAX 1024
-#define QUEUE_MAX 256
+#define QUEUE_MAX 32
 
 void setup()
 {
-    Serial.begin(921600);
+    Serial.begin(115200);
     delay(250);
+    Serial.setTimeout(5000);
 
     // Setup Logger
     LOG_ATTACH_SERIAL(Serial);
-    LOG_SET_LEVEL(DebugLogLevel::LVL_INFO);
+    LOG_SET_LEVEL(DebugLogLevel::LVL_DEBUG);
 
     // Print Processor Info
     LOG_DEBUG("ESP32 Chip:", ESP.getChipModel());
@@ -46,7 +51,8 @@ void setup()
     LOG_DEBUG("ESP32 Heap:", ESP.getHeapSize());
     LOG_DEBUG("ESP32 Sketch:", ESP.getFreeSketchSpace());
 
-    // Init Wifi station
+// Init Wifi station
+#ifdef WEB_ENABLE
     LOG_INFO("Initializing WiFi...");
     WiFi.mode(WIFI_AP);
     IPAddress local_IP(10, 11, 12, 1);
@@ -68,6 +74,7 @@ void setup()
         vTaskDelay(pdMS_TO_TICKS(5000));
         esp_restart();
     }
+#endif
 
     // Initialize Interrupt pins on PICKUP detectors
     initTriggerPinsInputs();
@@ -83,7 +90,7 @@ void loop()
     led.setBrightness(0.025f);
     led.setStatus(RGBled::LedStatus::INIT);
 
-    std::shared_ptr<Devices> dev = std::make_shared<Devices>();
+    Devices dev;
     bool running = true;
     std::mutex fs_mutex;
     LITTLEFSGuard fsGuard;
@@ -91,17 +98,42 @@ void loop()
     //////// INIT SPI INTERFACES ////////
     bool spiA_ok = true;
     bool spiB_ok = true;
+    //////// INIT SPI INTERFACES ////////
     LOG_DEBUG("Init SPI Interfaces");
-    SPIClass SPI_A(FSPI);
+#ifdef CH_A_ENABLE
+    LOG_DEBUG("Begin Init SPI_A");
+    SPIClass SPI_A(HSPI);
     spiA_ok = SPI_A.begin(SPI_A_SCK, SPI_A_MISO, SPI_A_MOSI);
     SPI_A.setDataMode(SPI_MODE1); // ADS1256 requires SPI mode 1
-    LOG_DEBUG("Init SPI A ok");
+    LOG_DEBUG("Init SPI_A -> OK");
+    delay(500);
+    LOG_DEBUG("Begin Init ADC_A");
+    ADS1256 ADC_A(ADC_A_DRDY, ADS1256::PIN_UNUSED, ADS1256::PIN_UNUSED, ADC_A_CS, 2.5, &SPI_A);
+    ADC_A.InitializeADC();
+    ADC_A.setPGA(PGA_1);
+    ADC_A.setDRATE(DRATE_7500SPS);
+    dev.m_adc_a = &ADC_A;
+    dev.m_spi_a = &SPI_A;
+    LOG_DEBUG("Init ADC_A -> OK");
+    delay(1000);
+#endif
+
 #ifdef CH_B_ENABLE
-    delay(50);
+    LOG_DEBUG("Begin Init SPI_B");
-    SPIClass SPI_B(HSPI);
+    SPIClass SPI_B(FSPI);
     spiB_ok = SPI_B.begin(SPI_B_SCK, SPI_B_MISO, SPI_B_MOSI);
     SPI_B.setDataMode(SPI_MODE1); // ADS1256 requires SPI mode 1
-    LOG_DEBUG("Init SPI B ok");
+    LOG_DEBUG("Init SPI_B -> OK");
+    delay(500);
+    LOG_DEBUG("Begin Init ADC_B");
+    ADS1256 ADC_B(ADC_B_DRDY, ADS1256::PIN_UNUSED, ADS1256::PIN_UNUSED, ADC_B_CS, 2.5, &SPI_B);
+    ADC_B.InitializeADC();
+    ADC_B.setPGA(PGA_1);
+    ADC_B.setDRATE(DRATE_7500SPS);
+    dev.m_adc_b = &ADC_B;
+    dev.m_spi_b = &SPI_B;
+    LOG_DEBUG("Init ADC_B -> OK");
+    delay(1000);
 #endif
 
     if (!spiA_ok || !spiB_ok)
@@ -111,50 +143,11 @@ void loop()
         vTaskDelay(pdMS_TO_TICKS(5000));
         esp_restart();
     }
-    dev->m_spi_a.reset(&SPI_A);
-#ifdef CH_B_ENABLE
-    dev->m_spi_b.reset(&SPI_B);
-#endif
-    // Init ADCs
-    dev->m_adc_a = std::make_unique<ADS1256>(ADC_A_DRDY, ADS1256::PIN_UNUSED, ADS1256::PIN_UNUSED, ADC_A_CS, 2.5, &SPI_A);
-#ifdef CH_B_ENABLE
-    dev->m_adc_b = std::make_unique<ADS1256>(ADC_B_DRDY, ADS1256::PIN_UNUSED, ADS1256::PIN_UNUSED, ADC_B_CS, 2.5, &SPI_B);
-#endif
-    // Configure ADCs
-    dev->m_adc_a->InitializeADC();
-    dev->m_adc_a->setPGA(PGA_1);
-    // dev->m_adc_a->setDRATE(DRATE_15000SPS);
-#ifdef CH_B_ENABLE
-    dev->m_adc_b->InitializeADC();
-    dev->m_adc_b->setPGA(PGA_1);
-    dev->m_adc_b->setDRATE(DRATE_30000SPS);
-#endif
-    LOG_DEBUG("Init SPI OK");
-    
-    uint8_t chs[8] = {
-        SING_0, SING_1, SING_2, SING_3, SING_4, SING_5, SING_6, SING_7
-    };
-    float res[8];
 
-    while (Serial.read() != 's') // The conversion is stopped by a character received from the serial port
+    LOG_DEBUG("Init SPI -> OK");
-    {
-        clearScreen();
-        auto start = esp_timer_get_time();
-        for (int i = 0; i < 8; i++){
-           // dev->m_adc_a->setMUX(chs[i]);
-            res[i] = dev->m_adc_a->convertToVoltage(dev->m_adc_a->cycleSingle());
-        }
-        auto stop = esp_timer_get_time();
-        for (int j = 0; j < 8; j++){
-            Serial.printf("ADC_A SING_%d: %5.4f\n",j, res[j]);
-        }
-        Serial.printf("ADC Time: %u us\n", stop-start);
-        delay(100);
-        
-    }
-    dev->m_adc_a->stopConversion();
 
-    //////// INIT I2C INTERFACES ////////
+//////// INIT I2C INTERFACES ////////
+#ifdef I2C_ENABLE
     LOG_DEBUG("Init I2C Interfaces");
     bool i2c_ok = true;
     i2c_ok = Wire.begin(SDA, SCL, 100000);
@@ -165,11 +158,15 @@ void loop()
         vTaskDelay(pdMS_TO_TICKS(5000));
         esp_restart();
     }
+    LOG_DEBUG("Init I2c ok");
+    Serial.readStringUntil('\n');
 
     // Init IO Expanders
-    // dev->m_ext_io = std::make_unique<ExternalIO>(Wire, dev->m_i2c_mutex, EXPANDER_ALL_INTERRUPT);
+    dev->m_ext_io = std::make_unique<ExternalIO>(Wire, dev->m_i2c_mutex, EXPANDER_ALL_INTERRUPT);
+#endif
 
-    //////// INIT REALTIME TASKS PARAMETERS ////////
+//////// INIT REALTIME TASKS PARAMETERS ////////
+#ifdef CH_A_RT_ENABLE
     const rtIgnitionTask::rtTaskParams taskA_params{
         .rt_running = true,
         .name = "rtIgnTask_A",
@@ -199,8 +196,9 @@ void loop()
             .relay_out_34 = RELAY_OUT_A34,
         },
         .rt_queue = nullptr,
-        .dev = dev};
+        .dev = &dev};
-
+#endif
+#ifdef CH_B_RT_ENABLE
     const rtIgnitionTask::rtTaskParams taskB_params{
         .rt_running = true,
         .name = "rtIgnTask_B",
@@ -230,16 +228,30 @@ void loop()
             .relay_out_34 = RELAY_OUT_B34,
         },
         .rt_queue = nullptr,
-        .dev = dev};
+        .dev = &dev};
+#endif
 
     //////// SPAWN REALTIME TASKS ////////
-    auto task_A = rtIgnitionTask(taskA_params, PSRAM_MAX, QUEUE_MAX, CORE_0, fs_mutex);
+    bool tasK_A_rt = true;
-    delay(50);
+    bool task_B_rt = true;
+    BaseType_t ignA_task_success = pdPASS;
+    BaseType_t ignB_task_success = pdPASS;
+
+#ifdef CH_A_RT_ENABLE
+    auto task_A = rtIgnitionTask(taskA_params, PSRAM_MAX, QUEUE_MAX, CORE_1, fs_mutex);
+    ignA_task_success = task_A.getStatus() == rtIgnitionTask::OK ? pdPASS : pdFAIL;
+    //tasK_A_rt = task_A.start();
+    delay(1000);
+#endif
+
+#ifdef CH_B_RT_ENABLE
     auto task_B = rtIgnitionTask(taskB_params, PSRAM_MAX, QUEUE_MAX, CORE_1, fs_mutex);
+    ignB_task_success = task_B.getStatus() == rtIgnitionTask::OK ? pdPASS : pdFAIL;
+    //task_B_rt = task_B.start();
+    delay(1000);
+#endif
 
     // Ignition A on Core 0
-    auto ignA_task_success = task_A.getStatus() == rtIgnitionTask::OK ? pdPASS : pdFAIL;
-    auto ignB_task_success = task_B.getStatus() == rtIgnitionTask::OK ? pdPASS : pdFAIL;
     if (ignA_task_success != pdPASS || ignB_task_success != pdPASS)
     {
         LOG_ERROR("Unable to initialize ISR task");
@@ -247,10 +259,6 @@ void loop()
         vTaskDelay(pdMS_TO_TICKS(5000));
         esp_restart();
     }
-
-    const bool tasK_A_rt = task_A.start();
-    delay(50);
-    const bool task_B_rt = task_B.start();
     if (tasK_A_rt != true || task_B_rt != true)
     {
         led.setStatus(RGBled::LedStatus::ERROR);
@@ -263,18 +271,23 @@ void loop()
     }
 
     //////// SPAWN WEBSERVER and WEBSOCKET ////////
-    AstroWebServer webPage(80, LittleFS);
     ArduinoJson::JsonDocument json_data;
-    bool data_a, data_b;
+    bool data_a = false, data_b = false;
+#ifdef WEB_ENABLE
+    AstroWebServer webPage(80, LittleFS);
+    delay(1000);
     task_A.onMessage([&webPage, &json_data, &data_a](ignitionBoxStatusFiltered sts)
                      {
-        json_data["box_a"] = sts.toJson();
+    json_data["box_a"] = sts.toJson();
-        data_a = true; });
+    data_a = true; });
 
+    #ifdef CH_B_RT_ENABLE
     task_B.onMessage([&webPage, &json_data, &data_b](ignitionBoxStatusFiltered sts)
                      {
-        json_data["box_b"] = sts.toJson();
+    json_data["box_b"] = sts.toJson();
-        data_b = true; });
+    data_b = true; });
+    #endif
+#endif
 
     // task_A.enableSave(true, "ignitionA_test.csv");
     // task_B.enableSave(true, "ignitionB_test.csv");
@@ -285,12 +298,14 @@ void loop()
     while (running)
     {
         uint32_t this_loop = millis();
-        if (this_loop - monitor_loop > 2000)
+        if (this_loop - monitor_loop > 5000)
         {
             clearScreen();
             printRunningTasksMod(Serial);
             monitor_loop = millis();
         }
+        vTaskDelay(pdMS_TO_TICKS(10));
+#ifdef WEB_ENABLE
         if ((data_a && data_b) || (this_loop - data_loop > 500))
         {
             webPage.sendWsData(json_data.as<String>());
@@ -298,6 +313,7 @@ void loop()
             data_a = data_b = false;
             data_loop = millis();
         }
+#endif
     } //////////////// INNER LOOP /////////////////////
 
 } ////////////////////// MAIN LOOP //////////////////////

RotaxMonitor/src/tasks.cpp

@@ -16,9 +16,16 @@ void spark_timeout_callback(void *arg)
 void rtIgnitionTask::rtIgnitionTask_manager(void *pvParameters)
 {
     rtIgnitionTask *cls = (rtIgnitionTask *)pvParameters;
+    auto last_loop = millis();
+    uint32_t count(0);
     while (cls->m_running)
     {
         cls->run();
+        // if (millis() - last_loop > 2000) {
+        //     LOG_DEBUG("TASK [", cls->m_name.c_str(), "] Alive -", count++);
+        //     last_loop = millis();
+        // }
+        vTaskDelay(pdMS_TO_TICKS(1));
     }
 }
 
@@ -38,10 +45,12 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters)
     const rtTaskInterruptParams rt_int = params->rt_int; // copy to avoid external override
     const rtTaskIOParams rt_rst = params->rt_io;         // copy to avoid external override
     QueueHandle_t rt_queue = params->rt_queue;
-    Devices *dev = params->dev.get();
+    Devices *dev = params->dev;
-    ADS1256 *adc = params->name == "rtIgnTask_A" ? dev->m_adc_a.get() : dev->m_adc_b.get();
+    ExternalIO *io = dev->m_ext_io;
-    std::mutex &spi_mutex = params->name == "rtIgnTask_A" ? dev->m_spi_a_mutex : dev->m_spi_b_mutex;
+    // ADS1256 *adc = params->name == "rtIgnTask_A" ? dev->m_adc_a : dev->m_adc_b;
-    ExternalIO *io = dev->m_ext_io.get();
+    ADS1256 *adc = NULL;
+    // std::mutex &spi_mutex = params->name == "rtIgnTask_A" ? dev->m_spi_a_mutex : dev->m_spi_b_mutex;
+    std::mutex spi_mutex;
 
     TaskStatus_t rt_task_info;
     vTaskGetInfo(NULL, &rt_task_info, pdFALSE, eInvalid);
@@ -76,10 +85,6 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters)
         .ign_stat = &ign_box_sts,
         .rt_handle_ptr = rt_task_info.xHandle};
 
-    LOG_DEBUG("rtTask HDL Params OK, HDL* [", (uint32_t)rt_task_info.xHandle, "]");
-    LOG_DEBUG("rtTask ISR Params OK, ISR* [", (uint32_t)rt_int.isr_ptr, "]");
-    LOG_DEBUG("rtTask QUE Params OK, QUE* [", (uint32_t)rt_queue, "]");
-
     // Create esp_timer for microsecond precision timeout
     esp_timer_handle_t timeout_timer;
     esp_timer_create_args_t timer_args = {
@@ -87,7 +92,11 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters)
         .arg = (void *)rt_task_info.xHandle,
         .dispatch_method = ESP_TIMER_TASK,
         .name = "spark_timeout"};
-    esp_timer_create(&timer_args, &timeout_timer);
+    if (esp_timer_create(&timer_args, &timeout_timer) != ESP_OK)
+    {
+        LOG_INFO("rtTask [", params->name.c_str(), "] Fail to allocate timeoutTimer");
+        vTaskDelete(NULL);
+    }
 
     // Attach Pin Interrupts
     attachInterruptArg(digitalPinToInterrupt(rt_int.trig_pin_12p), rt_int.isr_ptr, (void *)&isr_params_t12p, RISING);
@@ -238,15 +247,16 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters)
                 std::lock_guard<std::mutex> lock(spi_mutex);
                 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_p_in = adc->convertToVoltage(adc->cycleSingle());
-                ign_box_sts.coils12.peak_n_in = adcReadChannel(adc, ADC_CH_PEAK_12N_IN);
+                ign_box_sts.coils12.peak_n_in = adc->convertToVoltage(adc->cycleSingle());
-                ign_box_sts.coils34.peak_p_in = adcReadChannel(adc, ADC_CH_PEAK_34P_IN);
+                ign_box_sts.coils34.peak_p_in = adc->convertToVoltage(adc->cycleSingle());
-                ign_box_sts.coils34.peak_n_in = adcReadChannel(adc, ADC_CH_PEAK_34N_IN);
+                ign_box_sts.coils34.peak_n_in = adc->convertToVoltage(adc->cycleSingle());
-                ign_box_sts.coils12.peak_p_out = adcReadChannel(adc, ADC_CH_PEAK_12P_OUT);
+                ign_box_sts.coils12.peak_p_out = adc->convertToVoltage(adc->cycleSingle());
-                ign_box_sts.coils12.peak_n_out = adcReadChannel(adc, ADC_CH_PEAK_12N_OUT);
+                ign_box_sts.coils12.peak_n_out = adc->convertToVoltage(adc->cycleSingle());
-                ign_box_sts.coils34.peak_p_out = adcReadChannel(adc, ADC_CH_PEAK_34P_OUT);
+                ign_box_sts.coils34.peak_p_out = adc->convertToVoltage(adc->cycleSingle());
-                ign_box_sts.coils34.peak_n_out = adcReadChannel(adc, ADC_CH_PEAK_34N_OUT);
+                ign_box_sts.coils34.peak_n_out = adc->convertToVoltage(adc->cycleSingle());
                 ign_box_sts.adc_read_time = (int32_t)(esp_timer_get_time() - start_adc_read);
+                adc->stopConversion();
             }
             else // simulate adc read timig
                 vTaskDelay(pdMS_TO_TICKS(c_adc_time));
@@ -299,6 +309,7 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters)
 ///////////// CLASS MEMBER DEFINITIONS /////////////
 rtIgnitionTask::rtIgnitionTask(const rtTaskParams params, const uint32_t history_size, const uint32_t queue_size, const uint8_t core, std::mutex &fs_mutex, fs::FS &filesystem) : m_params(params), m_filesystem(filesystem), m_fs_mutex(fs_mutex), m_core(core), m_max_history(history_size)
 {
+    LOG_WARN("Starting Manager for [", m_params.name.c_str(), "]");
     // create queue buffers
     m_queue = xQueueCreate(queue_size, sizeof(ignitionBoxStatus));
     if (!m_queue)
@@ -317,12 +328,12 @@ rtIgnitionTask::rtIgnitionTask(const rtTaskParams params, const uint32_t history
     m_active_history = std::unique_ptr<PSHistory>(&m_history_0);
     m_save_history = std::unique_ptr<PSHistory>(&m_history_1);
 
-    LOG_WARN("Starting Manager for [", m_params.name.c_str(), "]");
+    m_name = (std::string("man_") + m_params.name).c_str();
     // auto task_success = pdPASS;
     auto task_success = xTaskCreatePinnedToCore(
         rtIgnitionTask_manager,
-        (std::string("man_") + m_params.name).c_str(),
+        m_name.c_str(),
-        8192,
+        RT_TASK_STACK,
         (void *)this,
         m_params.rt_priority >> 2,
         &m_manager_handle,
@@ -361,14 +372,15 @@ void rtIgnitionTask::run()
         m_last_data = millis();
         m_manager_status = rtTaskStatus::RUNNING;
         // if history buffer is full swap buffers and if enabled save history buffer
-        if (m_counter_status >= m_active_history->size())
+        if (m_counter_status >= m_max_history)
         {
             LOG_DEBUG("Save for Buffer Full: ", m_counter_status);
             m_counter_status = 0;
             m_partial_save = false; // reset partial save flag on new data cycle
             std::swap(m_active_history, m_save_history);
             if (m_enable_save)
-                saveHistory(*m_save_history, m_history_path); // directly call the save task function to save without delay
+                // saveHistory(m_save_history, m_history_path); // directly call the save task function to save without delay
+                LOG_INFO("Save History");
         }
 
         // update filtered data
@@ -390,15 +402,14 @@ void rtIgnitionTask::run()
             if (m_counter_status > 0 && !m_partial_save)
             {
                 LOG_DEBUG("Save Partial: ", m_counter_status);
-                m_active_history->resize(m_counter_status);
+                // m_active_history->resize(m_counter_status);
-                saveHistory(*m_active_history, m_history_path);
+                // saveHistory(m_active_history, m_history_path);
-                m_active_history->resize(m_max_history);
+                // m_active_history->resize(m_max_history);
                 m_counter_status = 0;
                 m_partial_save = true;
             }
             m_manager_status = rtTaskStatus::IDLE;
         }
-        delay(5); // yeld to another task
     }
 }
 

RotaxMonitor/src/tasks.h

@@ -41,6 +41,7 @@ static const std::map<const uint32_t, const char *> names = {
 class rtIgnitionTask
 {
     using PSHistory = PSRAMVector<ignitionBoxStatus>;
+    // using PSHistory = std::vector<ignitionBoxStatus>;
 
 public:
     // RT task Interrupt parameters
@@ -84,7 +85,7 @@ public:
         const rtTaskInterruptParams rt_int; // interrupt pins to attach
         const rtTaskIOParams rt_io;         // reset ping for peak detectors
         QueueHandle_t rt_queue;             // queue for task io
-        const std::shared_ptr<Devices> dev;
+        Devices *dev;
     };
 
     enum rtTaskStatus
@@ -124,6 +125,7 @@ private: // static functions for FreeRTOS
 private:
     bool m_running = true;
     rtTaskStatus m_manager_status = INIT;
+    std::string m_name;
 
     rtTaskParams m_params;
     const uint8_t m_core;
@@ -154,6 +156,6 @@ private:
 
     static const uint32_t c_idle_time = 10000;       // in mS
     static const uint32_t c_spark_timeout_max = 500; // uS
-    static const uint8_t c_adc_time = 4;            // in mS
+    static const uint8_t c_adc_time = 4;             // in mS
-    static const uint8_t c_io_time = 2;             // in mS
+    static const uint8_t c_io_time = 2;              // in mS
 };

RotaxMonitor/src/utils.cpp

@@ -7,7 +7,7 @@
 
 #include "esp_heap_caps.h"
 #include "esp_system.h"
-#include "esp_spi_flash.h"
+#include "spi_flash_mmap.h"
 #include "esp_partition.h"
 #include "LittleFS.h"
 
@@ -49,23 +49,27 @@ void printBar(Print &printer, const char *label, size_t used, size_t total, cons
 {
     float perc = total > 0 ? ((float)used / total) : 0;
     int filled = perc * BAR_WIDTH;
+    char str[256] = {0};
+    uint16_t k(0);
 
-    printer.printf("%s%-12s [" COLOR_RESET, color, label);
+    k += sprintf(str, "%s%-12s [" COLOR_RESET, color, label);
 
     for (int i = 0; i < BAR_WIDTH; i++)
     {
         if (i < filled)
-            printer.printf("%s#%s", color, COLOR_RESET);
+            k += sprintf(&str[k], "%s#%s", color, COLOR_RESET);
         else
-            printer.printf("-");
+            k += sprintf(&str[k], "-");
     }
 
-    printer.printf("] %s%6.2f%%%s (%5.3f/%5.3f)MB\n",
+    sprintf(&str[k], "] %s%6.2f%%%s (%5.3f/%5.3f)MB\n",
                    color,
                    perc * 100.0,
                    COLOR_RESET,
                    (used / 1024.0f / 1024.0f),
                    (total / 1024.0f / 1024.0f));
+
+    printer.println(str);
 }
 
 void printRunningTasksMod(Print &printer, std::function<bool(const TaskStatus_t &a, const TaskStatus_t &b)> orderBy)
@@ -95,6 +99,7 @@ void printRunningTasksMod(Print &printer, std::function<bool(const TaskStatus_t
 
     // Compute system total runtime
     ulCurrentRunTime = ulTotalRunTime - ulLastRunTime;
+    ulCurrentRunTime = ulCurrentRunTime > 0 ? ulCurrentRunTime : 1;
     ulLastRunTime = ulTotalRunTime;
 
     // PRINT MEMORY INFO
@@ -134,17 +139,6 @@ void printRunningTasksMod(Print &printer, std::function<bool(const TaskStatus_t
                                  ESP_PARTITION_SUBTYPE_APP_FACTORY,
                                  NULL);
 
-    if (app_partition)
-    {
-        size_t totalAPP = app_partition->size; // dimensione reale partizione
-        size_t sketchSize = ESP.getSketchSize();
-        printBar(printer, "FLASH APP", sketchSize, totalAPP, COLOR_CYAN);
-    }
-    else
-    {
-        printer.printf(COLOR_YELLOW "%-12s [NOT FOUND]\n" COLOR_RESET, "FLASH APP");
-    }
-
     // ===== LITTLEFS (corretto con partition table) =====
     const esp_partition_t *fs_partition =
         esp_partition_find_first(ESP_PARTITION_TYPE_DATA,
@@ -164,7 +158,9 @@ void printRunningTasksMod(Print &printer, std::function<bool(const TaskStatus_t
 
     // ===== MIN HEAP =====
     size_t minHeap = esp_get_minimum_free_heap_size();
-    printer.printf("%s\nMin Heap Ever:%s %u KB\n\n", COLOR_RED, COLOR_RESET, minHeap / 1024);
+    printer.printf("%s\nMin Heap Ever:%s %u KB\n", COLOR_RED, COLOR_RESET, minHeap / 1024);
+    size_t max_block = heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM);
+    printer.printf("%s\nMax PSRAM Block:%s %u KB\n\n", COLOR_RED, COLOR_RESET, max_block / 1024);
 
     // Print Runtime Information
     printer.printf("Tasks: %u, Runtime: %lus, Period: %luus\r\n", uxArraySize, ulTotalRunTime / 1000000, ulCurrentRunTime);