Proyecto
Javier Peña Rizos
Francisco Mariscal Muñoz
Javier Peña Rizos
Francisco Mariscal Muñoz
¿En que consiste el proyecto?
Este proyecto consiste en una caja con varios sensores que se puede usar para detectar varias anomalías en el entorno, según el uso que se le quiera dar a la misma.
Por ejemplo, en caso de querer medir el nivel de gases que hay en el entorno, la caja puede ser usada para esa función, mostrando el nivel de gases que hay y activando el zumbador (buzzer) en caso de ser demasiado elevado.
También tenemos un sensor de campos magneticos (HALL).
En caso de querer seleccionar otro sensor como por ejemplo el de humedad, solo hay que utilizar el Módulo codificador de rotación KY040(encoder), al igual que para seleccionar cualquier otro sensor de la caja.
La caja cuenta con un Módulo de pantalla LCD para mostrar toda la información seleccionada, como por ejemplo el sensor que seleccionas.
Todo esto está conectado a un Arduino ESP32.
También se encarga de subir datos a internet mediante Thingspeak donde se podrán observar las gráficas de los datos que recojen los propios sensores, los cuales tienen un campo propio para cada uno.
Caja Impresa en 3D
Sensor de Campos Magnéticos
Módulo codificador de rotación
Módulo Buzzer (Zumbador)
LCD (para la hora) de cristal líquido (E-ink)
Sensor Temperatura
Sensor de Humedad DHT11
Sensor de Gases MQ-8
Arduino ESP32
Primero hemos creado una cuenta en Thingspeak, a continuación hemos creado un canal nuevo con nuestro nombre y apellidos, le añadimos una descripción y le añadimos y rellenamos unos campos.
Editamos el código de la práctica 4.14 para configurarlo para subir datos a internet, instalamos las librerías correspondientes para que funcione el código.
Hemos creado 4 campos para subir datos de todos los sensores, cada uno para un sensor distinto:
Campo 1: Sensor de Gases MQ-8.
Campo 2: Sensor de Temperatura (DHT11).
Campo 3: Sensor de Humedad (DHT11).
Campo 4: Sensor de campos Magnéticos KY003.
Como se puede ver, asi está hecha la configuración del proyecto en Thingspeak.
Montaje
DHT11: Conectado a el pin GPIO 25 del Arduino ESP32.
Sensor de Campos Magnéticos KY003: Conectado a el pin GPIO 34 del Arduino ESP32.
Módulo Buzzer (Zumbador) KY012: Conectado a el pin GPIO 26 del Arduino ESP32.
Sensor de Gases MQ-2: conectada la entrada analogica al GPIO21 del Arduino ESP32
Módulo codificador de rotación KY040: Rotación (Encoder CLK) conectada a el pin GPIO 27, Dirección (Encoder DT) conectada al pin GPIO 32 y Botón (Encoder SW) conectado al pin GPIO 33 del Arduino ESP32.
Módulo de pantalla LCD: LCD SDA conectado a el pin GPIO 4 y LCD SCL conectado a el pin GPIO 5 del Arduino ESP32.
Todo está conectado a su respectiva alimentación y tierra. Todos los componentes se alimentan con 3,3 voltios
Para poder usar la placa Arduino ESP32 hemos tenido que instalar unos drivers específicos para la placa, debemos hacer clic derecho en el archivo silabser.inf y nos dará la opción de instalarlo, a partir de ahí, podremos usar la placa en el programa Arduino IDE.
Código Usado en el Proyecto
#include <dummy.h>
#include <Wire.h>
#include <Adafruit_ADS1X15.h>
#include <MD_MAX72xx.h>
#include <DHT.h>
#include <WiFi.h>
// ----------------------
// CONFIGURACIÓN DE HARDWARE - ESP32
// ----------------------
//sensor humedad
#define DHTPIN 25
#define DHTTYPE DHT11
//sensor HALL
#define HALL_PIN 34
#define BUZZER_PIN 26
//encoder
#define ENC_CLK 27
#define ENC_DT 32
#define ENC_SW 33
//datos
#define MAX_DEVICES 1
#define CLK_PIN 18
#define DATA_PIN 23
#define CS_PIN 15
// ----------------------
// LCD I2C PERSONALIZADO
// ----------------------
#define LCD_ADDR 0x27
#define SDA_PIN 4
#define SCL_PIN 5
#define LCD_COLS 16
#define LCD_ROWS 2
#define LCD_RS 0
#define LCD_RW 1
#define LCD_EN 2
#define LCD_BL 3
// ----------------------
// OBJETOS
// ----------------------
Adafruit_ADS1115 ads;
MD_MAX72XX mx = MD_MAX72XX(MD_MAX72XX::FC16_HW, CS_PIN, MAX_DEVICES);
DHT dht(DHTPIN, DHTTYPE);
// ----------------------
// VARIABLES CREADAS
// ----------------------
int sensorIndex = 0;
const int totalSensores = 3;
const char* sensorNames[] = {"MQ8 (H2)", "DHT11 (T/H)", "HALL (MAG)"};
volatile int lastClkState;
volatile int encoderDirection = 0;
// ======== MQ8 ESPECÍFICO ========
float MQ8_UMBRAL = 2.0; // Ajustable según calibración
// Constantes de calibración MQ8
const float MQ8_RL = 10.0; // Resistencia de carga (10k ohm)
const float MQ8_RO = 1.0; // Resistencia en aire limpio (aproximado)
const float MQ8_A = 976.97; // Parámetro de calibración
const float MQ8_B = -0.688; // Exponente de calibración
// ================================
// ----------------------
// WIFI Y THINGSPEAK
// ----------------------
/*
casa fran
String apiKey = "URMYVI41J1J2N6CD";
const char* ssid = "TP-LINK_7D30";
const char* password = "08768049";
const char* server = "api.thingspeak.com";
*/
String apiKey = "URMYVI41J1J2N6CD";
const char* ssid = "Electroalum";
const char* password = "c@lderon14";
const char* server = "api.thingspeak.com";
WiFiClient client;
unsigned long lastSendTime = 0;
const unsigned long SEND_INTERVAL = 20000;
// ----------------------
// VARIABLES DE CONTROL BUZZER
// ----------------------
static unsigned long buzzerStartTime = 0;
static boolean buzzerActive = false;
// ----------------------
// VARIABLES DE CONTROL LCD
// ----------------------
boolean lcdDisponible = false;
boolean ads1115Disponible = false;
boolean dhtDisponible = false;
// ----------------------
// ESTADO DE LA APLICACIÓN
// ----------------------
enum AppState {
MENU_SELECTOR,
SENSOR_ACTIVO
};
AppState appState = MENU_SELECTOR;
// Timing variables
unsigned long lastMenuDisplay = 0;
unsigned long lastSensorDisplay = 0;
unsigned long lastEncoderMove = 0;
unsigned long lastButtonPress = 0;
unsigned long lastWiFiCheck = 0;
const unsigned long MENU_DISPLAY_INTERVAL = 300;
const unsigned long SENSOR_DISPLAY_INTERVAL = 500;
const unsigned long ENCODER_DEBOUNCE = 150;
const unsigned long BUTTON_DEBOUNCE = 300;
const unsigned long WIFI_CHECK_INTERVAL = 10000;
// ----------------------
// DECLARACIÓN ANTICIPADA
// ----------------------
void IRAM_ATTR handleEncoder();
void playToneNonBlocking(uint8_t pin, unsigned int frequency);
void stopBuzzer();
void updateBuzzerState();
void limpiarMatriz();
void inicializarLCD();
void escribirLCD(uint8_t fila, uint8_t columna, const char* texto);
void limpiarLCD();
void enviarByteLCD(uint8_t valor, uint8_t modo);
void mostrarMenuSelector();
void mostrarSensor();
void mostrarMQ8();
void mostrarDHT11();
void mostrarHall();
void leerEncoder();
void enviarAThingSpeak();
float leerMQ8Voltaje();
float calcularPPMHidrogenoMQ8(float voltaje);
// =============================================
// NUEVA ARQUITECTURA LCD - SIN THROTTLING
// =============================================
void enviarBytePCF8574(uint8_t valor) {
Wire.beginTransmission(LCD_ADDR);
Wire.write(valor);
Wire.endTransmission();
}
void pulsarEnable(uint8_t datos) {
// Enable = 1
uint8_t conEnable = datos | (1 << LCD_EN);
enviarBytePCF8574(conEnable);
delayMicroseconds(1);
// Enable = 0
uint8_t sinEnable = datos & ~(1 << LCD_EN);
enviarBytePCF8574(sinEnable);
delayMicroseconds(1);
}
void enviarByteLCD(uint8_t valor, uint8_t modo) {
if (!lcdDisponible) return;
// Preparar byte con backlight encendido
uint8_t datosAlta = (valor & 0xF0) | (1 << LCD_BL);
uint8_t datosBaja = ((valor << 4) & 0xF0) | (1 << LCD_BL);
// RS: 0=comando, 1=dato
if (modo == 1) { // Dato
datosAlta |= (1 << LCD_RS);
datosBaja |= (1 << LCD_RS);
} else { // Comando
datosAlta &= ~(1 << LCD_RS);
datosBaja &= ~(1 << LCD_RS);
}
// Enviar alta nibble
pulsarEnable(datosAlta);
delayMicroseconds(50);
// Enviar baja nibble
pulsarEnable(datosBaja);
delayMicroseconds(50);
}
void inicializarLCD() {
Wire.begin(SDA_PIN, SCL_PIN);
delay(500);
// Probar conexión
Wire.beginTransmission(LCD_ADDR);
if (Wire.endTransmission() != 0) {
lcdDisponible = false;
Serial.println("✗ LCD I2C NO encontrado en 0x27");
return;
}
lcdDisponible = true;
Serial.println("✓ LCD I2C encontrado en 0x27");
delay(200);
// Secuencia de inicialización en 4-bit
enviarByteLCD(0x33, 0); // 8-bit
delay(10);
enviarByteLCD(0x32, 0); // 4-bit
delay(10);
enviarByteLCD(0x28, 0); // 4-bit, 2 líneas, 5x8 font
delay(10);
enviarByteLCD(0x0C, 0); // Display ON, cursor OFF, blink OFF
delay(10);
enviarByteLCD(0x06, 0); // Incremento automático
delay(10);
enviarByteLCD(0x01, 0); // Clear display
delay(20);
Serial.println("✓ LCD inicializado correctamente");
}
void limpiarLCD() {
if (!lcdDisponible) return;
enviarByteLCD(0x01, 0); // Clear
delay(20);
enviarByteLCD(0x80, 0); // Home (0,0)
delay(10);
}
void escribirLCD(uint8_t fila, uint8_t columna, const char* texto) {
if (!lcdDisponible || !texto) return;
// Calcular dirección DDRAM
uint8_t addr = (fila == 0) ? 0x80 : 0xC0;
addr += columna;
// Enviar comando de posición
enviarByteLCD(addr, 0);
delay(5);
// Escribir caracteres
for (int i = 0; texto[i] != '\0' && i < (LCD_COLS - columna); i++) {
enviarByteLCD(texto[i], 1); // Modo DATO
delay(1);
}
}
// ----------------------
// FUNCIONES BUZZER NO-BLOQUEANTE
// ----------------------
void playToneNonBlocking(uint8_t pin, unsigned int frequency) {
if (!buzzerActive) {
ledcAttach(pin, frequency, 8);
ledcWrite(pin, 128);
buzzerActive = true;
buzzerStartTime = millis();
}
}
void stopBuzzer() {
if (buzzerActive) {
ledcWrite(BUZZER_PIN, 0);
buzzerActive = false;
}
}
void updateBuzzerState() {
if (buzzerActive && (millis() - buzzerStartTime > 100)) {
stopBuzzer();
}
}
// ==============================
// FUNCIONES MQ8 - HIDRÓGENO
// ==============================
/**
* Calcula la relación Rs/R0 a partir del voltaje
* Rs = (Vcc - V_out) * RL / V_out
* Asumiendo Vcc = 5V y RL = 10k
*/
float calcularRsR0MQ8(float voltaje) {
float V_out = voltaje;
float Vcc = 3.3; // Voltaje del ESP32
if (V_out == 0) return 0;
float Rs = ((Vcc - V_out) * MQ8_RL) / V_out;
float ratio = Rs / MQ8_RO;
return ratio;
}
/**
* Calcula PPM de Hidrógeno (H2) usando curva característica MQ8
* PPM = A * (Rs/R0)^B
* Para MQ8: A=976.97, B=-0.688
*/
float calcularPPMHidrogenoMQ8(float voltaje) {
if (voltaje <= 0) return 0;
float ratio = calcularRsR0MQ8(voltaje);
if (ratio <= 0) return 0;
float ppm = MQ8_A * pow(ratio, MQ8_B);
return max(0.f, ppm); // No permitir valores negativos
}
// ----------------------
// SETUP
// ----------------------
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("\n\n=== INICIANDO ESP32 ===");
Serial.println("=== MODO: MQ8 (SENSOR DE HIDRÓGENO) ===");
// Inicializar LCD PRIMERO
inicializarLCD();
Serial.print("Conectando a WiFi: ");
Serial.println(ssid);
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
int intentos = 0;
while (WiFi.status() != WL_CONNECTED && intentos < 20) {
delay(500);
Serial.print(".");
intentos++;
}
Serial.println();
if (WiFi.status() == WL_CONNECTED) {
Serial.println("✓ WiFi conectado");
} else {
Serial.println("✗ WiFi NO conectado (continuando)");
}
// Inicializar Matriz LED
mx.begin();
Serial.println("✓ Matriz LED iniciada");
// ADS1115
Serial.print("Detectando ADS1115...");
Wire.beginTransmission(0x48);
if (Wire.endTransmission() == 0) {
ads1115Disponible = ads.begin();
if (ads1115Disponible) {
Serial.println(" ✓ ADS1115 detectado");
} else {
Serial.println(" ✗ ADS1115 no responde");
}
} else {
Serial.println(" ✗ ADS1115 no encontrado");
ads1115Disponible = false;
}
// DHT
Serial.print("Detectando DHT11...");
dht.begin();
delay(100);
float test_h = dht.readHumidity();
if (!isnan(test_h)) {
dhtDisponible = true;
Serial.println(" ✓ DHT11 detectado");
} else {
dhtDisponible = false;
Serial.println(" ✗ DHT11 no responde");
}
// Pines digitales
pinMode(HALL_PIN, INPUT);
pinMode(BUZZER_PIN, OUTPUT);
digitalWrite(BUZZER_PIN, LOW);
pinMode(ENC_CLK, INPUT_PULLUP);
pinMode(ENC_DT, INPUT_PULLUP);
pinMode(ENC_SW, INPUT_PULLUP);
lastClkState = digitalRead(ENC_CLK);
attachInterrupt(digitalPinToInterrupt(ENC_CLK), handleEncoder, FALLING);
Serial.println("✓ Interrupciones del encoder configuradas");
appState = MENU_SELECTOR;
if (lcdDisponible) {
limpiarLCD();
escribirLCD(0, 0, "SISTEMA LISTO");
escribirLCD(1, 0, "Gira encoder");
}
Serial.println("=== SETUP COMPLETADO ===\n");
delay(500);
}
// ----------------------
// LOOP PRINCIPAL
// ----------------------
void loop() {
unsigned long currentTime = millis();
// WiFi check en background
if (currentTime - lastWiFiCheck > WIFI_CHECK_INTERVAL) {
if (WiFi.status() != WL_CONNECTED) {
Serial.println("WiFi reconectando...");
WiFi.disconnect();
WiFi.begin(ssid, password);
}
lastWiFiCheck = currentTime;
}
// Actualizar buzzer
updateBuzzerState();
// Leer encoder y botón
leerEncoder();
// Mostrar menú o sensor
if (appState == MENU_SELECTOR) {
if (currentTime - lastMenuDisplay > MENU_DISPLAY_INTERVAL) {
mostrarMenuSelector();
lastMenuDisplay = currentTime;
}
}
else if (appState == SENSOR_ACTIVO) {
if (currentTime - lastSensorDisplay > SENSOR_DISPLAY_INTERVAL) {
mostrarSensor();
lastSensorDisplay = currentTime;
}
}
// Enviar a ThingSpeak
if (currentTime - lastSendTime >= SEND_INTERVAL) {
enviarAThingSpeak();
lastSendTime = currentTime;
}
delay(20);
}
// ----------------------
// MANEJO DE INTERRUPCIONES ENCODER
// ----------------------
void IRAM_ATTR handleEncoder() {
int clkState = digitalRead(ENC_CLK);
int dtState = digitalRead(ENC_DT);
if (clkState != lastClkState && clkState == LOW) {
if (dtState == HIGH) {
encoderDirection = 1;
} else {
encoderDirection = -1;
}
}
lastClkState = clkState;
}
// ----------------------
// LECTURA DEL ENCODER Y BOTÓN
// ----------------------
void leerEncoder() {
unsigned long currentTime = millis();
// Procesar movimiento del encoder
if (encoderDirection != 0) {
if (currentTime - lastEncoderMove > ENCODER_DEBOUNCE) {
sensorIndex += encoderDirection;
if (sensorIndex < 0) sensorIndex = totalSensores - 1;
if (sensorIndex >= totalSensores) sensorIndex = 0;
encoderDirection = 0;
lastEncoderMove = currentTime;
// Si estamos en sensor, giro vuelve a menú
if (appState == SENSOR_ACTIVO) {
appState = MENU_SELECTOR;
limpiarLCD();
limpiarMatriz();
}
playToneNonBlocking(BUZZER_PIN, 300);
Serial.print("Encoder -> Sensor: ");
Serial.println(sensorIndex);
}
}
// Botón del encoder
if (digitalRead(ENC_SW) == LOW) {
if (currentTime - lastButtonPress > BUTTON_DEBOUNCE) {
lastButtonPress = currentTime;
playToneNonBlocking(BUZZER_PIN, 600);
// alternar entre menú y sensor
if (appState == MENU_SELECTOR) {
appState = SENSOR_ACTIVO;
limpiarLCD();
limpiarMatriz();
Serial.print("Botón -> Sensor activo: ");
Serial.println(sensorIndex);
} else {
appState = MENU_SELECTOR;
limpiarLCD();
limpiarMatriz();
Serial.println("Botón -> Volviendo a menú");
}
}
}
}
// ----------------------
// MOSTRAR MENÚ SELECTOR
// ----------------------
void mostrarMenuSelector() {
limpiarMatriz();
limpiarLCD();
if (lcdDisponible) {
char buffer[20];
snprintf(buffer, sizeof(buffer), "SEL: %s", sensorNames[sensorIndex]);
escribirLCD(0, 0, buffer);
escribirLCD(1, 0, "Pulsa btn");
}
// Matriz: barras según sensor
for (int i = 0; i <= sensorIndex; i++) {
mx.setColumn(i, 0xFF);
}
}
// ----------------------
// MOSTRAR DATOS DEL SENSOR
// ----------------------
void mostrarSensor() {
limpiarMatriz();
limpiarLCD();
switch(sensorIndex) {
case 0:
mostrarMQ8();
break;
case 1:
mostrarDHT11();
break;
case 2:
mostrarHall();
break;
}
}
// ======================================
// MQ8 (SENSOR DE HIDRÓGENO)
// ======================================
void mostrarMQ8() {
if (!ads1115Disponible) {
if (lcdDisponible) {
escribirLCD(0, 0, "MQ8:");
escribirLCD(1, 0, "NO DETECTADO");
}
Serial.println("MQ8: Sensor no disponible");
return;
}
int16_t adc0 = ads.readADC_SingleEnded(0);
float voltaje = adc0 * 0.0001875;
// Calcular PPM de Hidrógeno
float ppm_h2 = calcularPPMHidrogenoMQ8(voltaje);
char buffer1[20];
char buffer2[20];
// Mostrar PPM de H2
snprintf(buffer1, sizeof(buffer1), "H2: %.1f ppm", ppm_h2);
// Determinar estado (alarma si supera umbral)
if (ppm_h2 >= MQ8_UMBRAL) {
snprintf(buffer2, sizeof(buffer2), "ALARMA!!!");
if (!buzzerActive) {
playToneNonBlocking(BUZZER_PIN, 1000);
}
// Visualización en matriz - barras llenas
for (int i = 0; i < 8; i++) {
mx.setColumn(i, 0xFF);
}
} else {
snprintf(buffer2, sizeof(buffer2), "Normal");
stopBuzzer();
// Visualización en matriz - barras proporcionales
int barras = (int)((ppm_h2 / MQ8_UMBRAL) * 8);
barras = constrain(barras, 0, 8);
for (int i = 0; i < barras; i++) {
mx.setColumn(i, 0xFF);
}
}
if (lcdDisponible) {
escribirLCD(0, 0, buffer1);
escribirLCD(1, 0, buffer2);
}
Serial.print("MQ8 - Voltaje: ");
Serial.print(voltaje);
Serial.print("V | H2: ");
Serial.print(ppm_h2);
Serial.println(" ppm");
}
// ----------------------
// DHT11 - TEMPERATURA Y HUMEDAD
// ----------------------
void mostrarDHT11() {
if (!dhtDisponible) {
if (lcdDisponible) {
escribirLCD(0, 0, "DHT:");
escribirLCD(1, 0, "NO DETECTADO");
}
Serial.println("DHT: Sensor no disponible");
return;
}
float h = dht.readHumidity();
float t = dht.readTemperature();
if (isnan(h) || isnan(t)) {
if (lcdDisponible) {
escribirLCD(0, 0, "DHT:");
escribirLCD(1, 0, "ERROR");
}
stopBuzzer();
return;
}
char buffer1[16], buffer2[16];
snprintf(buffer1, sizeof(buffer1), "T:%.1fC", t);
snprintf(buffer2, sizeof(buffer2), "H:%.0f%%", h);
if (lcdDisponible) {
escribirLCD(0, 0, buffer1);
escribirLCD(1, 0, buffer2);
}
int barras = (int)((t / 40) * 8);
barras = constrain(barras, 0, 8);
for (int i = 0; i < barras; i++) {
mx.setColumn(i, 0xFF);
}
Serial.print("DHT11 - T:");
Serial.print(t);
Serial.print("C H:");
Serial.print(h);
Serial.println("%");
stopBuzzer();
}
// ----------------------
// HALL KY-003 - SENSOR MAGNÉTICO
// ----------------------
void mostrarHall() {
int estado = digitalRead(HALL_PIN);
if (estado == LOW) {
if (lcdDisponible) {
escribirLCD(0, 0, "MAGNETICO:");
escribirLCD(1, 0, "DETECTADO!");
}
for (int i = 0; i < 4; i++) {
mx.setColumn(i, 0xFF);
}
if (!buzzerActive) {
playToneNonBlocking(BUZZER_PIN, 1500);
}
Serial.println("HALL: DETECTADO");
} else {
if (lcdDisponible) {
escribirLCD(0, 0, "MAGNETICO:");
escribirLCD(1, 0, "NO DETECTADO");
}
stopBuzzer();
Serial.println("HALL: NO DETECTADO");
}
}
// ----------------------
// ENVIAR A THINGSPEAK (VERSIÓN MEJORADA)
// ----------------------
void enviarAThingSpeak() {
if (WiFi.status() != WL_CONNECTED) {
Serial.println("✗ ThingSpeak: WiFi no conectado");
return;
}
// Leer todos los sensores
float voltajeMQ8 = leerMQ8Voltaje();
float temperatura = dht.readTemperature();
float humedad = dht.readHumidity();
int magnetico = digitalRead(HALL_PIN);
// Validar que los datos sean válidos
if (isnan(temperatura) || isnan(humedad)) {
Serial.println("✗ ThingSpeak: Datos de DHT inválidos");
return;
}
// Construir el POST
String postStr = "api_key=" + apiKey;
postStr += "&field1=" + String(voltajeMQ8, 4); // Voltaje MQ8
postStr += "&field2=" + String(temperatura, 2); // Temperatura
postStr += "&field3=" + String(humedad, 1); // Humedad
postStr += "&field4=" + String(magnetico); // Magnético
Serial.println("Conectando a ThingSpeak...");
if (client.connect(server, 80)) {
// Headers HTTP correctos con CRLF
client.print("POST /update HTTP/1.1\r\n");
client.print("Host: api.thingspeak.com\r\n");
client.print("User-Agent: ESP32\r\n");
client.print("Connection: close\r\n");
client.print("Content-Type: application/x-www-form-urlencoded\r\n");
client.print("Content-Length: ");
client.print(postStr.length());
client.print("\r\n\r\n");
client.print(postStr);
// Esperar y leer la respuesta
unsigned long timeout = millis() + 5000;
while (client.connected() && millis() < timeout) {
if (client.available()) {
String line = client.readStringUntil('\n');
// Verificar si recibimos respuesta 200 OK
if (line.indexOf("200") > 0) {
Serial.println("✓ ThingSpeak: HTTP 200 OK - Datos enviados correctamente");
}
// Mostrar el ID de entrada retornado
if (line.length() > 0 && line[0] >= '0' && line[0] <= '9') {
Serial.print(" ID de entrada ThingSpeak: ");
Serial.println(line);
}
}
}
client.stop();
Serial.println("Conexión cerrada\n");
} else {
Serial.println("✗ ThingSpeak: No se pudo conectar al servidor");
}
}
// ----------------------
// LEER VOLTAJE MQ8
// ----------------------
float leerMQ8Voltaje() {
if (!ads1115Disponible) return 0.0;
int16_t adc0 = ads.readADC_SingleEnded(0);
return adc0 * 0.0001875;
}
// ----------------------
// MATRIZ LED
// ----------------------
void limpiarMatriz() {
mx.clear();
}
Ejemplo de datos que aparecen en el monitor serie
Botón: Cuando pulsamos el botón del encoder podremos alternar entre menú y sensor seleccionado. En este caso se ve como selecciona el Sensor 1(Temperatura y humedad "DHT11), si lo volvemos a pulsar nos lleva de nuevo al menu para seleccionar otro sensor
DHT11: El sensor se encarga de recoger el nivel de temperatura y humedad que hay en el ambiente y muestra los datos en el monitor serie.
Encoder: Al rotarlo se puede alternar entre los sensores que se pueden seleccionar para posteriormente usar el botón y seleccionar el sensor que se va a usar. En este caso se puede ver que selecciona el Sensor 2 (Campos magnéticos)
Botón: En este caso el botón se usa para seleccionar el Sensor 2 (boton del encoder)
Hall: El Sensor se encarga de medir el nivel de campos magnéticos en sus alrededores y muestra en pantalla el resultado, en este caso dice "DETECTADO" por lo cual sabemos que ha detectado un campo magnético.
Botón: En este caso se usa el botón para volver al menú para así volver a seleccionar otro sensor.
Encoder: El Encoder selecciona el Sensor 0 (Gases).
Botón: Usamos el botón para selecciónar el sensor ya escogido con el Encoder.
MQ8: Mide el nivel de hidrógeno que hay en el ambiente y como no detecta ningún nivel de este mismo no proporciona voltaje.
Botón: Volvemos a usar el botón para volver al menú.
Sensor 0: Gases
Sensor 1: Temperatura y humedad (Es el mismo sensor pero se divide en dos apartados, "Temperatura" y "Humedad").
Sensor 2: Campos magnéticos