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

ADC Testing

Browse Source
This commit is contained in:
Emanuele Trabattoni
2026-04-17 09:13:05 +02:00
parent 1b7a531d54
commit 5aa5aaa07a
5 changed files with 530 additions and 530 deletions
Download Patch File Download Diff File Expand all files Collapse all files

704
RotaxMonitor/lib/ADS1256/ADS1256.cpp
View File

File diff suppressed because it is too large Load Diff

48
RotaxMonitor/src/datasave.cpp
View File

@@ -1,8 +1,6 @@
#include "datasave.h" #include "datasave.h"
#include <math.h> #include <math.h>
LITTLEFSGuard::LITTLEFSGuard() LITTLEFSGuard::LITTLEFSGuard()
{ {
if (!LittleFS.begin(true, "/littlefs", 10, "littlefs")) if (!LittleFS.begin(true, "/littlefs", 10, "littlefs"))
@@ -12,7 +10,7 @@ LITTLEFSGuard::LITTLEFSGuard()
else else
{ {
LOG_INFO("LittleFS mounted successfully"); LOG_INFO("LittleFS mounted successfully");
LOG_INFO("LittleFS Free KBytes:", (LittleFS.totalBytes() - LittleFS.usedBytes()) /1024); LOG_INFO("LittleFS Free KBytes:", (LittleFS.totalBytes() - LittleFS.usedBytes()) / 1024);
} }
} }
@@ -51,28 +49,29 @@ void ignitionBoxStatusFiltered::update(const ignitionBoxStatus &new_status)
// simple moving average calculation // 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_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.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.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 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 m_last.coils12.spark_delay = new_status.coils12.spark_delay; // incremental average calculation
filter(m_last.coils12.peak_p_in, new_status.coils12.peak_p_in, m_max_count); // incremental average calculation m_last.coils12.peak_p_in = new_status.coils12.peak_p_in; // incremental average calculation
filter(m_last.coils12.peak_n_in, new_status.coils12.peak_n_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.coils12.peak_p_out, new_status.coils12.peak_p_out, m_max_count); // incremental average calculation m_last.coils12.peak_p_out = new_status.coils12.peak_p_out; // 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.peak_n_out = new_status.coils12.peak_n_out; // incremental average calculation
m_last.coils34.n_events = new_status.coils34.n_events; // sum events instead of averaging m_last.coils34.n_events = new_status.coils34.n_events; // sum events instead of averaging
m_last.coils34.n_missed_firing = new_status.coils34.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.coils34.spark_status = new_status.coils34.spark_status; // take latest spark status 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.sstart_status = new_status.coils34.sstart_status; // take latest soft start status
filter(m_last.coils34.spark_delay, new_status.coils34.spark_delay, m_max_count); // incremental average calculation m_last.coils34.spark_delay = new_status.coils34.spark_delay; // incremental average calculation
filter(m_last.coils34.peak_p_in, new_status.coils34.peak_p_in, m_max_count); // incremental average calculation m_last.coils34.peak_p_in = new_status.coils34.peak_p_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.coils34.peak_n_in = new_status.coils34.peak_n_in; // incremental average calculation
filter(m_last.coils34.peak_p_out, new_status.coils34.peak_p_out, m_max_count); // incremental average calculation m_last.coils34.peak_p_out = new_status.coils34.peak_p_out; // incremental average calculation
filter(m_last.coils34.peak_n_out, new_status.coils34.peak_n_out, m_max_count); // incremental average calculation m_last.coils34.peak_n_out = new_status.coils34.peak_n_out; // incremental average calculation
filter(m_last.eng_rpm, new_status.eng_rpm, m_max_count); // incremental average calculation // incremental average calculation
filter(m_last.adc_read_time, m_last.adc_read_time, m_max_count); // incremental average calculation m_last.eng_rpm = new_status.eng_rpm; // 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 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) if (m_count >= m_max_count)
{ {
@@ -124,4 +123,3 @@ const ArduinoJson::JsonDocument ignitionBoxStatusFiltered::toJson() const
} }
return doc; return doc;
} }

7
RotaxMonitor/src/devices.h
View File

@@ -43,18 +43,13 @@ struct Devices
std::unique_ptr<ADS1256> m_adc_b = nullptr; std::unique_ptr<ADS1256> m_adc_b = nullptr;
std::unique_ptr<ExternalIO> m_ext_io = nullptr; std::unique_ptr<ExternalIO> m_ext_io = nullptr;
}; };
// Adc read channel wrapper to selet mux before reading // Adc read channel wrapper to selet mux before reading
inline float adcReadChannel(ADS1256 *adc, const uint8_t ch) inline float adcReadChannel(ADS1256 *adc, const uint8_t ch)
{ {
adc->setMUX(ch); adc->setMUX(ch);
// scarta 3 conversioni adc->readSingle();
for (int i = 0; i < 5; i++)
{
adc->readSingle();
}
// ora lettura valida a 30kSPS → ~100 µs di settling // ora lettura valida a 30kSPS → ~100 µs di settling
return adc->convertToVoltage(adc->readSingle()); return adc->convertToVoltage(adc->readSingle());
} }

35
RotaxMonitor/src/main.cpp
View File

@@ -53,7 +53,7 @@ void setup()
IPAddress gateway(10, 11, 12, 1); IPAddress gateway(10, 11, 12, 1);
IPAddress subnet(255, 255, 255, 0); IPAddress subnet(255, 255, 255, 0);
WiFi.softAPConfig(local_IP, gateway, subnet); WiFi.softAPConfig(local_IP, gateway, subnet);
WiFi.setTxPower(WIFI_POWER_13dBm); // reduce wifi power WiFi.setTxPower(WIFI_POWER_5dBm); // reduce wifi power
if (WiFi.softAP(WIFI_SSID, WIFI_PASSWORD)) if (WiFi.softAP(WIFI_SSID, WIFI_PASSWORD))
{ {
LOG_INFO("WiFi AP Mode Started"); LOG_INFO("WiFi AP Mode Started");
@@ -117,20 +117,43 @@ void loop()
#endif #endif
// Init ADCs // 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); 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 #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); 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 #endif
// Configure ADCs // Configure ADCs
dev->m_adc_a->InitializeADC(); dev->m_adc_a->InitializeADC();
dev->m_adc_a->setPGA(PGA_1); dev->m_adc_a->setPGA(PGA_1);
dev->m_adc_a->setDRATE(DRATE_7500SPS); // dev->m_adc_a->setDRATE(DRATE_15000SPS);
#ifdef CH_B_ENABLE #ifdef CH_B_ENABLE
dev->m_adc_b->InitializeADC(); dev->m_adc_b->InitializeADC();
dev->m_adc_b->setPGA(PGA_1); dev->m_adc_b->setPGA(PGA_1);
dev->m_adc_b->setDRATE(DRATE_7500SPS); dev->m_adc_b->setDRATE(DRATE_30000SPS);
#endif #endif
LOG_DEBUG("Init SPI OK"); 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
{
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 ////////
LOG_DEBUG("Init I2C Interfaces"); LOG_DEBUG("Init I2C Interfaces");
bool i2c_ok = true; bool i2c_ok = true;

30
RotaxMonitor/src/tasks.cpp
View File

@@ -40,14 +40,13 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters)
QueueHandle_t rt_queue = params->rt_queue; QueueHandle_t rt_queue = params->rt_queue;
Devices *dev = params->dev.get(); Devices *dev = params->dev.get();
ADS1256 *adc = params->name == "rtIgnTask_A" ? dev->m_adc_a.get() : dev->m_adc_b.get(); ADS1256 *adc = params->name == "rtIgnTask_A" ? dev->m_adc_a.get() : dev->m_adc_b.get();
std::mutex& spi_mutex = params->name == "rtIgnTask_A" ? dev->m_spi_a_mutex : dev->m_spi_b_mutex; std::mutex &spi_mutex = params->name == "rtIgnTask_A" ? dev->m_spi_a_mutex : dev->m_spi_b_mutex;
ExternalIO* io = dev->m_ext_io.get(); ExternalIO *io = dev->m_ext_io.get();
TaskStatus_t rt_task_info; TaskStatus_t rt_task_info;
vTaskGetInfo(NULL, &rt_task_info, pdFALSE, eInvalid); vTaskGetInfo(NULL, &rt_task_info, pdFALSE, eInvalid);
const auto rt_task_name = pcTaskGetName(rt_task_info.xHandle); LOG_INFO("rtTask Params OK [", params->name.c_str(), "]");
LOG_INFO("rtTask Params OK [", rt_task_name, "]");
ignitionBoxStatus ign_box_sts; ignitionBoxStatus ign_box_sts;
@@ -98,7 +97,7 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters)
attachInterruptArg(digitalPinToInterrupt(rt_int.spark_pin_12), rt_int.isr_ptr, (void *)&isr_params_sp12, 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); attachInterruptArg(digitalPinToInterrupt(rt_int.spark_pin_34), rt_int.isr_ptr, (void *)&isr_params_sp34, RISING);
LOG_INFO("rtTask ISR Attach OK [", rt_task_name, "]"); LOG_INFO("rtTask ISR Attach OK [", params->name.c_str(), "]");
// Global rt_task_ptr variables // Global rt_task_ptr variables
bool first_cycle = true; bool first_cycle = true;
@@ -236,7 +235,7 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters)
// read adc channels: pickup12, out12 [ pos + neg ] // read adc channels: pickup12, out12 [ pos + neg ]
if (adc) // read only if adc initialized if (adc) // read only if adc initialized
{ {
std::lock_guard<std::mutex> lock (spi_mutex); std::lock_guard<std::mutex> lock(spi_mutex);
uint32_t start_adc_read = esp_timer_get_time(); uint32_t start_adc_read = esp_timer_get_time();
// from peak detector circuits // 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 = adcReadChannel(adc, ADC_CH_PEAK_12P_IN);
@@ -256,10 +255,23 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters)
// outputs on io expander // outputs on io expander
if (io) if (io)
{ {
// [TODO] code to reset sample and hold and arm trigger level detectors // Discharge Pulse
io->extDigitalWrite(rt_rst.sh_disch_12, true);
io->extDigitalWrite(rt_rst.sh_disch_34, true);
delayMicroseconds(250);
io->extDigitalWrite(rt_rst.sh_disch_12, false);
io->extDigitalWrite(rt_rst.sh_disch_34, false);
// Safety delay
delayMicroseconds(500);
// Re-Arm Pulse
io->extDigitalWrite(rt_rst.sh_arm_12, true);
io->extDigitalWrite(rt_rst.sh_arm_34, true);
delayMicroseconds(250);
io->extDigitalWrite(rt_rst.sh_arm_12, false);
io->extDigitalWrite(rt_rst.sh_arm_34, false);
} }
else else
vTaskDelay(pdMS_TO_TICKS(2)); vTaskDelay(pdMS_TO_TICKS(c_io_time));
// send essage to main loop with ignition info, by copy so local static variable is ok // send essage to main loop with ignition info, by copy so local static variable is ok
if (rt_queue) if (rt_queue)
@@ -272,7 +284,7 @@ void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters)
} }
// Delete the timeout timer // Delete the timeout timer
esp_timer_delete(timeout_timer); esp_timer_delete(timeout_timer);
LOG_WARN("rtTask Ending [", rt_task_name, "]"); LOG_WARN("rtTask Ending [", params->name.c_str(), "]");
// Ignition A Interrupts DETACH // Ignition A Interrupts DETACH
detachInterrupt(rt_int.trig_pin_12p); detachInterrupt(rt_int.trig_pin_12p);
detachInterrupt(rt_int.trig_pin_12n); detachInterrupt(rt_int.trig_pin_12n);