BME/ESP32-WiFi-BME
SHA256
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

DEBUG:POO-ADC continuo

Browse Source
This commit is contained in:
semarnat committed 2026-05-21 00:09:03 -06:00
1 parent 082995d264
commit 13eeef7700
1 file changed
+106 -76
Download Patch File Download Diff File Expand all files Collapse all files
src/main.cpp
+106 -76
View File
@@ -2,100 +2,130 @@
#include "esp_adc/adc_continuous.h" #include "esp_adc/adc_continuous.h"
// API ESP-IDF para ADC modo continuo (uso de DMA) // API ESP-IDF para ADC modo continuo (uso de DMA)
adc_channel_t CHANNEL = ADC_CHANNEL_3;
#define MS_BLOQUE 10 #define MS_BLOQUE 10
#define HZ_ADC 1000 // Limitado a 611 - 83333 para el ESP32-S3 const uint32_t HZ_ADC = 1000; // Limitado a 611 - 83333 para el ESP32-S3
#define CANAL 3
const uint32_t MUESTRAS_BLOQUE = (HZ_ADC * MS_BLOQUE) / 1000; const uint32_t MUESTRAS_BLOQUE = (HZ_ADC * MS_BLOQUE) / 1000;
const uint32_t FRAME_SIZE = MUESTRAS_BLOQUE * 4; // Constante física SOC_ADC_DIGI_RESULT_BYTES uint8_t dma_buffer[MUESTRAS_BLOQUE * SOC_ADC_DIGI_RESULT_BYTES] = {0};
const uint32_t POOL_SIZE = FRAME_SIZE * 4; // Buffer DMA de 4 veces el tamaño del FRAME_SIZE uint16_t samples_buffer[MUESTRAS_BLOQUE] = {0};
uint8_t dma_buffer[FRAME_SIZE] = {0};
adc_channel_t channels[1] = {ADC_CHANNEL_3};
volatile bool dma_data_ready = false; class ADC_BME {
adc_continuous_handle_t handle_ADC1_1 = NULL; private:
uint32_t _FRAME_SIZE;
uint32_t _POOL_SIZE;
uint32_t _HZ_ADC;
adc_channel_t _channel;
uint8_t* _dma_buffer;
volatile bool dma_data_ready = false;
adc_continuous_handle_t handle_ADC = NULL;
// DEBUG static bool IRAM_ATTR adc_dma_callback(adc_continuous_handle_t handle, const adc_continuous_evt_data_t *edata, void *user_data){
uint16_t DRAM_contador = 0; ADC_BME* adc =static_cast<ADC_BME*>(user_data);
adc->dma_data_ready = true;
return false;
}
public:
bool IRAM_ATTR adc_dma_callback(adc_continuous_handle_t handle, const adc_continuous_evt_data_t *edata, void *user_data){ void config(const uint32_t muestras_bloque, adc_channel_t channel, const uint32_t hz_adc, uint8_t* dma_buffer){
dma_data_ready = true; _FRAME_SIZE=muestras_bloque*4;
return false; _POOL_SIZE=_FRAME_SIZE*4;
} _channel=channel;
_HZ_ADC=hz_adc;
_dma_buffer=dma_buffer;
}
void setupADC(adc_channel_t *canales, uint8_t numChannels){ void setup(){
adc_continuous_handle_cfg_t ADC1_1_config = { adc_continuous_handle_cfg_t ADC_config = {
.max_store_buf_size = POOL_SIZE, .max_store_buf_size = _POOL_SIZE,
.conv_frame_size = FRAME_SIZE, .conv_frame_size = _FRAME_SIZE,
}; };
ESP_ERROR_CHECK(adc_continuous_new_handle(&ADC1_1_config, &handle_ADC1_1)); ESP_ERROR_CHECK(adc_continuous_new_handle(&ADC_config, &handle_ADC));
adc_digi_pattern_config_t channel_config = {0}; adc_digi_pattern_config_t channel_config = {0};
channel_config.channel = canales[0]; channel_config.channel = _channel;
channel_config.atten = ADC_ATTEN_DB_12; channel_config.atten = ADC_ATTEN_DB_12;
channel_config.bit_width = ADC_BITWIDTH_12; channel_config.bit_width = ADC_BITWIDTH_12;
channel_config.unit = ADC_UNIT_1; channel_config.unit = ADC_UNIT_1;
adc_continuous_config_t adc_config = { adc_continuous_config_t adc_config = {
.pattern_num = numChannels, .pattern_num = 1,
.adc_pattern = &channel_config, .adc_pattern = &channel_config,
.sample_freq_hz = HZ_ADC, .sample_freq_hz = _HZ_ADC,
.conv_mode = ADC_CONV_SINGLE_UNIT_1, .conv_mode = ADC_CONV_SINGLE_UNIT_1,
}; };
ESP_ERROR_CHECK(adc_continuous_config(handle_ADC1_1, &adc_config)); ESP_ERROR_CHECK(adc_continuous_config(handle_ADC, &adc_config));
adc_continuous_evt_cbs_t cb_config = { adc_continuous_evt_cbs_t cb_config = {
.on_conv_done = adc_dma_callback, .on_conv_done = adc_dma_callback,
.on_pool_ovf = NULL .on_pool_ovf = NULL
}; };
ESP_ERROR_CHECK(adc_continuous_register_event_callbacks(handle_ADC1_1, &cb_config, NULL)); ESP_ERROR_CHECK(adc_continuous_register_event_callbacks(handle_ADC, &cb_config, this));
ESP_ERROR_CHECK(adc_continuous_start(handle_ADC1_1)); ESP_ERROR_CHECK(adc_continuous_start(handle_ADC));
Serial.println("DMA Iniciado con sistema de bandera."); Serial.println("DMA Iniciado con sistema de bandera.");
} }
uint32_t read(uint16_t* samples_buffer) {
if (!dma_data_ready) {
return 0;
}
dma_data_ready = false;
uint32_t ret_num = 0;
// Leer datos DMA
esp_err_t ret = adc_continuous_read(handle_ADC,_dma_buffer,_FRAME_SIZE,&ret_num,0);
if (ret != ESP_OK)
return 0;
// Buffer temporal parseado
adc_continuous_data_t parsed_data[MUESTRAS_BLOQUE];
uint32_t parsed_count = 0;
// Parsear datos
esp_err_t parse_ret =
adc_continuous_parse_data(
handle_ADC,
_dma_buffer,
ret_num,
parsed_data,
&parsed_count
);
if (parse_ret != ESP_OK) {
return 0;
}
uint32_t valid_samples = 0;
// Copiar muestras limpias
for (uint32_t i = 0; i < parsed_count; i++) {
if (!parsed_data[i].valid)
continue;
samples_buffer[valid_samples] = parsed_data[i].raw_data;
valid_samples++;
}
return valid_samples;
}
};
ADC_BME adc1_3;
void setup() { void setup() {
Serial.begin(230400); Serial.begin(230400);
setupADC(channels, 1); adc1_3.config(MUESTRAS_BLOQUE, CHANNEL, HZ_ADC, dma_buffer);
adc1_3.setup();
} }
void loop() { void loop() {
if (dma_data_ready) { uint32_t count = adc1_3.read(samples_buffer);
dma_data_ready = false;
uint32_t ret_num = 0;
// Leer los datos crudos del DMA for (uint32_t i = 0; i < count; i++) {
esp_err_t ret = adc_continuous_read(handle_ADC1_1, dma_buffer, FRAME_SIZE, &ret_num, 0); Serial.printf("%u\n",samples_buffer[i]);
if (ret == ESP_OK) {
adc_continuous_data_t parsed_data[MUESTRAS_BLOQUE];
uint32_t parsed_count = 0;
//API oficial documentada para extraer la información (reemplaza a los p->type2)
esp_err_t parse_ret = adc_continuous_parse_data(handle_ADC1_1,
dma_buffer,
ret_num,
parsed_data,
&parsed_count);
if (parse_ret == ESP_OK) {
for (uint32_t i = 0; i < parsed_count; i++) {
if (parsed_data[i].valid) {
DRAM_contador++;
// Imprimir resultados
Serial.printf("Unidad: ADC%u | Canal: %u | Valor: %04lu | Debug: %u\n",
parsed_data[i].unit + 1,
parsed_data[i].channel,
parsed_data[i].raw_data,
DRAM_contador);
DRAM_contador = (DRAM_contador >= HZ_ADC) ? 0 : DRAM_contador;
}
}
}
}
} }
} }