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

Compare commits

base: BME/ESP32-WiFi-BME:9d2172fa7d8414314056f6db15f03885517aaee44c39623aeca1214a0acc356d
BME/ESP32-WiFi-BME:main BME/ESP32-WiFi-BME:develop BME/ESP32-WiFi-BME:feature/websocket BME/ESP32-WiFi-BME:feature/adc-timer-buffers
BME/ESP32-WiFi-BME:v1.0.0
..
compare: BME/ESP32-WiFi-BME:feature/adc-timer-buffers
BME/ESP32-WiFi-BME:main BME/ESP32-WiFi-BME:develop BME/ESP32-WiFi-BME:feature/websocket BME/ESP32-WiFi-BME:feature/adc-timer-buffers
BME/ESP32-WiFi-BME:v1.0.0
4 Commits
9d2172fa7d .. feature/adc-timer-buffers
Author SHA256 Message Date
semarnat 1c7f7fce4a Feature: Funcional 2026-05-21 13:14:05 -06:00
semarnat 13eeef7700 DEBUG:POO-ADC continuo 2026-05-21 00:09:03 -06:00
semarnat 082995d264 Clear:ADC1-DMA feature 2026-05-18 23:50:21 -06:00
semarnat 8a0cdd9b47 ADC1-DMA feature 2026-05-18 23:47:52 -06:00
9 changed files with 4 additions and 643 deletions
Expand all files Collapse all files

No files matched your search

.gitignore
-1
View File
@@ -3,4 +3,3 @@ compile_commands.json
.clangd
.vscode
.cache
.venv
README.md
-431
View File
@@ -1,433 +1,2 @@
# ESP32-WiFi-BME
API modular para adquisición ADC continua usando DMA en ESP32-S3 y transmisión binaria mediante WebSocket utilizando FreeRTOS.
---
# Arquitectura General
```text
ADC -> DMA -> RingBuffer -> WebSocket
```
El proyecto está dividido en APIs modulares independientes:
- `ADCconf`
- `WiFiConf`
- `WebSocketHandler`
Cada API encapsula una funcionalidad específica para facilitar integración, mantenimiento y reutilización.
---
# ADCconf API
API encargada de configurar y manejar el ADC continuo utilizando DMA mediante la API ESP-IDF.
## Características
- ADC continuo
- DMA
- Parseo automático de muestras
- Callback mediante interrupciones
- Conversión de datos crudos a `uint16_t`
---
## Configuración
### Inclusión
```cpp
#include "ADCconf.h"
```
---
### Definición de buffers
```cpp
#define MS_BLOQUE 10
adc_channel_t CHANNEL = ADC_CHANNEL_3;
const uint32_t HZ_ADC = 1000;
const uint32_t MUESTRAS_BLOQUE =
(HZ_ADC * MS_BLOQUE) / 1000;
uint8_t dma_buffer[
MUESTRAS_BLOQUE *
SOC_ADC_DIGI_RESULT_BYTES
] = {0};
uint16_t samples_buffer[
MUESTRAS_BLOQUE
] = {0};
```
---
### Crear objeto ADC
```cpp
ADC_BME adc1_3;
```
---
### Configuración ADC
```cpp
adc1_3.config(
MUESTRAS_BLOQUE,
CHANNEL,
HZ_ADC,
dma_buffer
);
```
---
### Inicializar ADC
```cpp
adc1_3.setup();
```
---
### Lectura de muestras
```cpp
uint32_t count =
adc1_3.read(samples_buffer);
```
La función retorna:
- `0` si no existen datos disponibles
- cantidad de muestras válidas si existen datos DMA
---
## Flujo Interno
```text
ADC HW
↓
DMA Buffer
↓
adc_continuous_read()
↓
adc_continuous_parse_data()
↓
samples_buffer[]
```
---
# WiFiConf API
API modular para configuración WiFi en modo STA.
---
## Características
- Configuración IP estática
- Manejo de eventos WiFi
- Reconexión automática
- Encapsulación de configuración de red
---
## Inclusión
```cpp
#include "WiFiConf.h"
```
---
## Crear objeto WiFi
```cpp
wifi_conf sta_esp32;
```
---
## Configuración de red
```cpp
const char* SSID = "MiRed";
const char* PASSWD = "password";
IPAddress local_ip(192,168,0,220);
IPAddress gateway(192,168,0,1);
IPAddress subnet(255,255,255,0);
IPAddress dns1(192,168,0,1);
IPAddress dns2(1,1,1,1);
```
---
## Conexión WiFi
```cpp
sta_esp32.conectar(
SSID,
PASSWD,
local_ip,
gateway,
subnet,
dns1,
dns2
);
```
---
## Eventos Implementados
La API maneja automáticamente:
- conexión WiFi
- desconexión
- reconexión
- obtención de IP
---
# WebSocketHandler API
API encargada de manejar eventos WebSocket.
---
## Características
- detección de clientes
- conexión/desconexión
- recepción de mensajes
- manejo de bandera global de conexión
---
## Inclusión
```cpp
#include "WebSocketHandler.h"
```
---
## Crear servidor WebSocket
```cpp
WebSocketsServer webSocket(81);
```
---
## Inicialización
```cpp
webSocket.begin();
webSocket.onEvent(webSocketEvent);
```
---
## Loop principal
```cpp
webSocket.loop();
```
---
## Transmisión BIN
```cpp
webSocket.broadcastBIN(
(uint8_t*)buffer,
size
);
```
---
## Handler de eventos
```cpp
void webSocketEvent(
uint8_t num,
WStype_t type,
uint8_t * payload,
size_t length
);
```
---
## Eventos soportados
### Cliente conectado
```cpp
WStype_CONNECTED
```
---
### Cliente desconectado
```cpp
WStype_DISCONNECTED
```
---
### Mensajes recibidos
```cpp
WStype_TEXT
```
---
# Integración con FreeRTOS
El sistema utiliza multitarea mediante FreeRTOS.
---
## ADCTask
Responsable de:
- adquisición ADC
- lectura DMA
- inserción en RingBuffer
---
## WebSocketTask
Responsable de:
- `webSocket.loop()`
- transmisión BIN
- extracción del RingBuffer
---
# RingBuffer
Se utiliza `xRingbuffer` para desacoplar:
```text
Adquisición ADC
```
de:
```text
Transmisión WebSocket
```
---
## Creación
```cpp
RingbufHandle_t bufferHandle =
xRingbufferCreate(
SIZE_BUFFER,
RINGBUF_TYPE_NOSPLIT
);
```
---
## Inserción
```cpp
xRingbufferSend(
bufferHandle,
samples_buffer,
count * sizeof(uint16_t),
pdMS_TO_TICKS(1000)
);
```
---
## Recepción
```cpp
uint16_t* receivedMessage =
(uint16_t*)xRingbufferReceive(
bufferHandle,
&receivedMessageSize,
pdMS_TO_TICKS(1000)
);
```
---
# Cliente Python
Ejemplo de recepción de datos binarios.
```python
from websocket import create_connection
import struct
ws = create_connection(
"ws://192.168.0.220:81"
)
while True:
data = ws.recv()
if isinstance(data, bytes):
samples = struct.unpack(
f"<{len(data)//2}H",
data
)
print(samples)
```
---
# Compilación
El proyecto esta construido en PlatformIO, para compilar el poryecto es importante instalar sus herramientas en el sistema.
# Dependencias
```ini
lib_deps =
links2004/WebSockets
```
---
# Hardware Compatible
- ESP32-S3 DevKitC-1
- ESP32-S3 N8
---
# Autor
Sebastian Mariano Flores
include/WebSocketHandler.h
-6
View File
@@ -1,6 +0,0 @@
#pragma once
#include "Arduino.h"
#include <WebSocketsServer.h>
void webSocketEvent( uint8_t num, WStype_t type, uint8_t * payload, size_t length );
include/WiFiConf.h
-27
View File
@@ -1,27 +0,0 @@
#pragma once
#include "Arduino.h"
#include "Network.h"
#include <WiFi.h>
extern volatile bool websocket_connected;
class wifi_conf {
private:
const char* _ssid;
const char* _passwd;
void handler_WiFi(arduino_event_id_t event, arduino_event_info_t info);
public:
void conectar(
const char* ssid,
const char* passwd,
IPAddress local_ip,
IPAddress gateway,
IPAddress subnet,
IPAddress dns1,
IPAddress dns2
);
};
platformio.ini
-1
View File
@@ -23,4 +23,3 @@ board_build.partitions = default_16MB.csv
board_build.extra_flags =
-DBOARD_HAS_PSRAM
-DCORE_DEBUG_LEVEL=5
lib_deps = links2004/WebSockets@^2.7.3
src/WebSocketHandler.cpp
-17
View File
@@ -1,17 +0,0 @@
#include "WebSocketHandler.h"
void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length) {
switch(type) {
case WStype_CONNECTED:
Serial.printf("[%u] Cliente conectado\n", num);
break;
case WStype_DISCONNECTED:
Serial.printf("[%u] Cliente desconectado\n", num);
break;
case WStype_TEXT:
Serial.printf("[%u] Mensaje: %s\n", num, payload);
break;
}
}
src/WiFiConf.cpp
-52
View File
@@ -1,52 +0,0 @@
#include "WiFiConf.h"
extern volatile bool websocket_connected;
void wifi_conf::handler_WiFi(arduino_event_id_t event, arduino_event_info_t info) {
switch(event){
case ARDUINO_EVENT_WIFI_STA_CONNECTED:
websocket_connected = true;
Serial.printf("Wi-Fi conectado\n");
break;
case ARDUINO_EVENT_WIFI_STA_GOT_IP:
Serial.printf( "IP Address: %s\n", IPAddress(info.got_ip.ip_info.ip.addr).toString().c_str() );
break;
case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
websocket_connected = false;
Serial.printf("WiFi: Desconectado\n");
Serial.printf("DEBUG: Reconectando...\n");
WiFi.STA.connect(_ssid,_passwd);
break;
}
}
void wifi_conf::conectar(
const char* ssid,
const char* passwd,
IPAddress local_ip,
IPAddress gateway,
IPAddress subnet,
IPAddress dns1,
IPAddress dns2
) {
_ssid = ssid;
_passwd = passwd;
Network.begin();
Network.onEvent([this](arduino_event_id_t event, arduino_event_info_t info){
handler_WiFi(event, info);
});
WiFi.STA.begin();
WiFi.STA.config( local_ip, gateway, subnet, dns1, dns2);
WiFi.STA.connect(_ssid, _passwd);
}
src/main.cpp
+4 -79
View File
@@ -1,101 +1,26 @@
#include "Arduino.h"
#include "freertos/ringbuf.h"
#include "ADCconf.h"
#include "WiFiConf.h"
#include "WebSocketHandler.h"
#include <WebSocketsServer.h>
// API ESP-IDF para ADC modo continuo (uso de DMA)
#define MS_BLOQUE 10
adc_channel_t CHANNEL = ADC_CHANNEL_3;
#define MS_BLOQUE 10
const uint32_t HZ_ADC = 1000; // Limitado a 611 - 83333 para el ESP32-S3
const uint32_t MUESTRAS_BLOQUE = (HZ_ADC * MS_BLOQUE) / 1000;
uint8_t dma_buffer[MUESTRAS_BLOQUE * SOC_ADC_DIGI_RESULT_BYTES] = {0};
uint16_t samples_buffer[MUESTRAS_BLOQUE] = {0};
const uint32_t SIZE_BUFFER = MUESTRAS_BLOQUE*10;
ADC_BME adc1_3;
// Conf de ESP32-S3 en modo STA
const char* SSID="debian";
const char* PASSWD="aH2T9GFA";
IPAddress local_ip(10,42,0,100);
IPAddress gateway(40,42,0,1);
IPAddress subnet(255,255,255,0);
IPAddress dns1(10,42,0,1);
IPAddress dns2(1,1,1,1);
wifi_conf sta_esp32;
WebSocketsServer webSocket(81);
volatile bool websocket_connected = false;
// FreeRTOS
TaskHandle_t ADCTaskHandle = NULL;
TaskHandle_t WebSocketTaskHandle = NULL;
RingbufHandle_t bufferHandle = xRingbufferCreate(SIZE_BUFFER, RINGBUF_TYPE_NOSPLIT);
void ADCTask(void *parameter);
void WebSocketTask(void *parameter);
void setup() {
Serial.begin(230400);
sta_esp32.conectar(SSID, PASSWD, local_ip, gateway, subnet, dns1, dns2);
webSocket.begin();
webSocket.onEvent(webSocketEvent);
adc1_3.config(MUESTRAS_BLOQUE, CHANNEL, HZ_ADC, dma_buffer);
adc1_3.setup();
//Iniciar el buffer circular
if (bufferHandle == NULL) {
Serial.printf("Failed to create ring buffer!");
return;
}
xTaskCreatePinnedToCore( ADCTask, "ADCTask", 10000, NULL, 1, &ADCTaskHandle, 0);
xTaskCreatePinnedToCore( WebSocketTask, "WebSocketTask", 10000, NULL, 1, &WebSocketTaskHandle, 1);
}
void loop() {
}
uint32_t count = adc1_3.read(samples_buffer);
void ADCTask(void *parameter){
for(;;) {
if (!websocket_connected) {
vTaskDelay(pdMS_TO_TICKS(100));
continue;
}
const uint32_t count = adc1_3.read(samples_buffer);
if (count > 0) {
if (xRingbufferSend(bufferHandle, samples_buffer, count * sizeof(uint16_t), pdMS_TO_TICKS(1000)) != pdTRUE) {
Serial.println("Failed to send message to ring buffer!");
}
}
vTaskDelay(pdMS_TO_TICKS(10));
}
}
void WebSocketTask(void *parameter){
for(;;) {
webSocket.loop();
size_t receivedMessageSize;
uint16_t* receivedMessage = (uint16_t*)xRingbufferReceive(bufferHandle, &receivedMessageSize, pdMS_TO_TICKS(1000));
// 6. Check if the receive operation was successful
if (receivedMessage != NULL) {
webSocket.broadcastBIN((uint8_t*)receivedMessage, receivedMessageSize);
vRingbufferReturnItem(bufferHandle, (void*)receivedMessage);
} else {
Serial.println("Failed t+o receive message from ring buffer!");
}
for (uint32_t i = 0; i < count; i++) {
Serial.printf("%u\n",samples_buffer[i]);
}
}
test/Cliente-Websocket/cliente.py
-29
View File
@@ -1,29 +0,0 @@
import struct
from websocket import create_connection
ws = create_connection("ws://10.42.0.100:81")
print("Conectado")
i = 0
try:
while True:
data = ws.recv()
i += 1
if isinstance(data, bytes):
# Convertir bytes -> uint16_t
samples = struct.unpack(f"<{len(data) // 2}H", data)
print("ADC:", samples)
else:
print("TXT:", data)
print(f"DEBUG {i}")
except KeyboardInterrupt:
print("Cerrando conexión")
ws.close()