Proyecto 2: Lectura de Sensores con ESP32, Home Assistant y Grafana

ECHO (5V) ──[ 1 kΩ ]──┬── GPIO 18 (3.3 V)
                      │
                   [ 2 kΩ ]
                      │
                     GND

docker run -d \
  --name homeassistant \
  --restart=unless-stopped \
  -v /ruta/local/config:/config \
  --network=host \
  ghcr.io/home-assistant/home-assistant:stable

docker run -d \
  --name mosquitto \
  --restart=unless-stopped \
  -p 1883:1883 \
  -v /ruta/local/mosquitto:/mosquitto/config \
  eclipse-mosquitto

Topic: homeassistant/sensor/alarma_distancia/config
{
  "name": "Distancia Alarma",
  "state_topic": "casa/alarma/distancia",
  "unit_of_measurement": "cm",
  "device_class": "distance",
  "unique_id": "alarma_distancia_01",
  "icon": "mdi:ruler"
}

Topic: homeassistant/number/alarma_servo/config
{
  "name": "Servo Alarma",
  "command_topic": "casa/alarma/servo/set",
  "state_topic": "casa/alarma/servo/estado",
  "min": 0,
  "max": 180,
  "step": 1,
  "unique_id": "alarma_servo_01",
  "icon": "mdi:angle-acute"
}

recorder:
  db_url: mysql://usuario:password@localhost/homeassistant?charset=utf8mb4
  purge_keep_days: 30
  include:
    entities:
      - sensor.distancia_alarma

docker run -d \
  --name grafana \
  --restart=unless-stopped \
  -p 3000:3000 \
  grafana/grafana-oss

SELECT
  s.last_updated_ts * 1000 AS time_msec,
  CAST(s.state AS DECIMAL(10,2)) AS distancia_cm
FROM states s
JOIN states_meta m ON s.metadata_id = m.metadata_id
WHERE m.entity_id = 'sensor.distancia_alarma'
  AND s.state NOT IN ('unknown', 'unavailable', '')
  AND s.last_updated_ts BETWEEN $__unixEpochFrom() AND $__unixEpochTo()
ORDER BY s.last_updated_ts;

float medirDistanciaCm() {
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);

  // Timeout de 30 ms ~= 5 m de alcance. Sin timeout, pulseIn()
  // bloquea hasta 1 segundo cuando no hay eco de retorno.
  unsigned long duracion = pulseIn(PIN_ECHO, HIGH, 30000UL);
  if (duracion == 0) return -1.0;   // fuera de rango o sin eco

  // 343 m/s = 0.0343 cm/us; se divide por 2 porque el sonido
  // recorre el trayecto de ida y vuelta.
  return (duracion * 0.0343f) / 2.0f;
}

float medirConFiltro() {
  float m[3];
  for (int i = 0; i < 3; i++) {
    m[i] = medirDistanciaCm();
    delay(20);
  }
  // Ordenamiento de tres elementos: la mediana descarta el
  // valor atípico que produce una reflexión sucia.
  if (m[0] > m[1]) { float t = m[0]; m[0] = m[1]; m[1] = t; }
  if (m[1] > m[2]) { float t = m[1]; m[1] = m[2]; m[2] = t; }
  if (m[0] > m[1]) { float t = m[0]; m[0] = m[1]; m[1] = t; }
  return m[1];
}

void iniciarAlarma() {
  ledcWriteTone(PIN_PARLANTE, FRECUENCIA_ALARMA_HZ);  // 2000 Hz
}

void detenerAlarma() {
  ledcWriteTone(PIN_PARLANTE, 0);
}

if (!alarmaActiva && distancia > 0 && distancia < UMBRAL_CM) {
  alarmaActiva = true;
  iniciarAlarma();
} else if (alarmaActiva && (distancia < 0 || distancia > UMBRAL_CM + HISTERESIS_CM)) {
  alarmaActiva = false;
  detenerAlarma();
}

void publicarDistancia(float distancia) {
  char payload[16];
  dtostrf(distancia, 1, 1, payload);
  mqtt.publish(TOPIC_DISTANCIA, payload);
}

void alRecibirMensaje(char* topic, byte* payload, unsigned int length) {
  String mensaje;
  for (unsigned int i = 0; i < length; i++) mensaje += (char)payload[i];

  if (String(topic) == TOPIC_SERVO_SET) {
    int angulo = mensaje.toInt();
    angulo = constrain(angulo, 0, 180);
    servo.write(angulo);

    // Se confirma la posición alcanzada para que Home Assistant
    // refleje el estado real y no solo el comando enviado.
    mqtt.publish(TOPIC_SERVO_ESTADO, String(angulo).c_str());
  }
}

void reconectarMQTT() {
  while (!mqtt.connected()) {
    if (mqtt.connect(CLIENT_ID, MQTT_USER, MQTT_PASS)) {
      mqtt.subscribe(TOPIC_SERVO_SET);
      publicarConfiguracionDiscovery();
    } else {
      delay(3000);
    }
  }
}

/*
 * Proyecto 2: Lectura de sensores — Alarma de proximidad IoT
 * Universidad de Viña del Mar — Curso de Electrónica, Robótica e IoT
 *
 * ═══════════════════════════════════════════════════════════════
 *  PINOUT (ESP32 DevKit V1):
 * ═══════════════════════════════════════════════════════════════
 *   HC-SR04 TRIG -> GPIO 5
 *   HC-SR04 ECHO -> GPIO 18  (¡vía divisor 1k/2k! ECHO entrega 5 V)
 *   Parlante/buzzer -> GPIO 25
 *   Servo SG90 (señal) -> GPIO 13
 *
 * ═══════════════════════════════════════════════════════════════
 *  LO QUE HACE:
 * ═══════════════════════════════════════════════════════════════
 *   1. Se conecta a WiFi y al broker MQTT local.
 *   2. Publica su configuración MQTT Discovery para que Home
 *      Assistant cree las entidades automáticamente.
 *   3. Mide la distancia cada 500 ms con filtro de mediana.
 *   4. Activa el parlante si hay un objeto bajo el umbral.
 *   5. Publica cada lectura por MQTT.
 *   6. Escucha comandos de ángulo y mueve el servomotor.
 *
 * ═══════════════════════════════════════════════════════════════
 *  LIBRERÍAS (Arduino IDE -> Administrar bibliotecas):
 * ═══════════════════════════════════════════════════════════════
 *   - PubSubClient (by Nick O'Leary)
 *   - ESP32Servo (by Kevin Harrington)
 *   - WiFi.h (built-in core ESP32)
 * ═══════════════════════════════════════════════════════════════
 */

#include <WiFi.h>
#include <PubSubClient.h>
#include <ESP32Servo.h>

// ═══════════════════════════════════════════════════════════════
//  CONFIGURACIÓN — AJUSTAR ESTOS VALORES
// ═══════════════════════════════════════════════════════════════

const char* WIFI_SSID     = "XXXXX";
const char* WIFI_PASSWORD = "XXXXX";

const char* MQTT_HOST = "192.168.1.100";   // IP del computador con Mosquitto
const int   MQTT_PORT = 1883;
const char* MQTT_USER = "esp32";
const char* MQTT_PASS = "XXXXX";
const char* CLIENT_ID = "esp32_alarma_01";

// ─── Topics MQTT ───
const char* TOPIC_DISTANCIA    = "casa/alarma/distancia";
const char* TOPIC_SERVO_SET    = "casa/alarma/servo/set";
const char* TOPIC_SERVO_ESTADO = "casa/alarma/servo/estado";
const char* TOPIC_DISC_SENSOR  = "homeassistant/sensor/alarma_distancia/config";
const char* TOPIC_DISC_SERVO   = "homeassistant/number/alarma_servo/config";

// ─── Pines ───
#define PIN_TRIG     5
#define PIN_ECHO     18
#define PIN_PARLANTE 25
#define PIN_SERVO    13

// ─── Parámetros de operación ───
const float UMBRAL_CM            = 20.0;   // distancia que gatilla la alarma
const float HISTERESIS_CM        = 5.0;    // margen para apagarla
const int   FRECUENCIA_ALARMA_HZ = 2000;   // tono del buzzer
const unsigned long INTERVALO_MEDICION_MS = 500;

// ═══════════════════════════════════════════════════════════════
//  GLOBALES
// ═══════════════════════════════════════════════════════════════

WiFiClient      wifiClient;
PubSubClient    mqtt(wifiClient);
Servo           servo;

bool          alarmaActiva   = false;
unsigned long ultimaMedicion = 0;

// ═══════════════════════════════════════════════════════════════
//  SENSOR DE PROXIMIDAD
// ═══════════════════════════════════════════════════════════════

float medirDistanciaCm() {
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);

  // Timeout de 30 ms (~5 m). Sin él, pulseIn() bloquea hasta 1 s
  // cada vez que no hay eco de retorno.
  unsigned long duracion = pulseIn(PIN_ECHO, HIGH, 30000UL);
  if (duracion == 0) return -1.0;

  // 0.0343 cm/us a 20 °C; se divide por 2 (ida y vuelta).
  return (duracion * 0.0343f) / 2.0f;
}

// Mediana de 3 muestras: descarta reflexiones espurias.
float medirConFiltro() {
  float m[3];
  for (int i = 0; i < 3; i++) {
    m[i] = medirDistanciaCm();
    delay(20);
  }
  if (m[0] > m[1]) { float t = m[0]; m[0] = m[1]; m[1] = t; }
  if (m[1] > m[2]) { float t = m[1]; m[1] = m[2]; m[2] = t; }
  if (m[0] > m[1]) { float t = m[0]; m[0] = m[1]; m[1] = t; }
  return m[1];
}

// ═══════════════════════════════════════════════════════════════
//  PARLANTE
// ═══════════════════════════════════════════════════════════════

void iniciarAlarma() {
  ledcWriteTone(PIN_PARLANTE, FRECUENCIA_ALARMA_HZ);
  Serial.println("[ALARMA] Objeto detectado — sonando");
}

void detenerAlarma() {
  ledcWriteTone(PIN_PARLANTE, 0);
  Serial.println("[ALARMA] Zona despejada — silencio");
}

// ═══════════════════════════════════════════════════════════════
//  MQTT
// ═══════════════════════════════════════════════════════════════

// Publica los mensajes de MQTT Discovery. Van RETENIDOS (último
// parámetro = true) para que Home Assistant recree las entidades
// aunque se reinicie después que la ESP32.
void publicarConfiguracionDiscovery() {
  String sensorCfg = "{"
    "\"name\":\"Distancia Alarma\","
    "\"state_topic\":\"casa/alarma/distancia\","
    "\"unit_of_measurement\":\"cm\","
    "\"device_class\":\"distance\","
    "\"unique_id\":\"alarma_distancia_01\","
    "\"icon\":\"mdi:ruler\""
  "}";
  mqtt.publish(TOPIC_DISC_SENSOR, sensorCfg.c_str(), true);

  String servoCfg = "{"
    "\"name\":\"Servo Alarma\","
    "\"command_topic\":\"casa/alarma/servo/set\","
    "\"state_topic\":\"casa/alarma/servo/estado\","
    "\"min\":0,\"max\":180,\"step\":1,"
    "\"unique_id\":\"alarma_servo_01\","
    "\"icon\":\"mdi:angle-acute\""
  "}";
  mqtt.publish(TOPIC_DISC_SERVO, servoCfg.c_str(), true);

  Serial.println("[MQTT] Configuración Discovery publicada");
}

void alRecibirMensaje(char* topic, byte* payload, unsigned int length) {
  String mensaje;
  for (unsigned int i = 0; i < length; i++) mensaje += (char)payload[i];

  Serial.println("[MQTT] " + String(topic) + " -> " + mensaje);

  if (String(topic) == TOPIC_SERVO_SET) {
    int angulo = constrain(mensaje.toInt(), 0, 180);
    servo.write(angulo);
    // Confirmar la posición real alcanzada, no solo el comando.
    mqtt.publish(TOPIC_SERVO_ESTADO, String(angulo).c_str());
    Serial.println("[SERVO] Movido a " + String(angulo) + " grados");
  }
}

void reconectarMQTT() {
  int intentos = 0;
  while (!mqtt.connected() && intentos < 5) {
    Serial.print("[MQTT] Conectando...");
    if (mqtt.connect(CLIENT_ID, MQTT_USER, MQTT_PASS)) {
      Serial.println(" OK");
      // Las suscripciones NO sobreviven a la caída de sesión:
      // hay que rehacerlas en cada reconexión.
      mqtt.subscribe(TOPIC_SERVO_SET);
      publicarConfiguracionDiscovery();
      return;
    }
    Serial.println(" fallo, rc=" + String(mqtt.state()));
    intentos++;
    delay(3000);
  }
}

void publicarDistancia(float distancia) {
  char payload[16];
  dtostrf(distancia, 1, 1, payload);
  mqtt.publish(TOPIC_DISTANCIA, payload);
}

// ═══════════════════════════════════════════════════════════════
//  WIFI
// ═══════════════════════════════════════════════════════════════

void conectarWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("[WiFi] Conectando");

  int intentos = 0;
  while (WiFi.status() != WL_CONNECTED && intentos < 40) {
    delay(500);
    Serial.print(".");
    intentos++;
  }

  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\n[WiFi] OK. IP: " + WiFi.localIP().toString());
  } else {
    Serial.println("\n[WiFi] Sin conexión. La alarma local sigue operativa.");
  }
}

// ═══════════════════════════════════════════════════════════════
//  SETUP
// ═══════════════════════════════════════════════════════════════

void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println("\n═══════════════════════════════");
  Serial.println(" Alarma de proximidad IoT — UVM");
  Serial.println("═══════════════════════════════");

  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECHO, INPUT);
  digitalWrite(PIN_TRIG, LOW);

  // LEDC en modo tono para el parlante.
  // NOTA: esta firma corresponde al core ESP32 v3.x.
  // En el core v2.x se usa: ledcSetup(canal, freq, res) +
  // ledcAttachPin(pin, canal), y ledcWriteTone(canal, freq).
  ledcAttach(PIN_PARLANTE, FRECUENCIA_ALARMA_HZ, 8);
  ledcWriteTone(PIN_PARLANTE, 0);

  servo.setPeriodHertz(50);            // SG90 opera a 50 Hz
  servo.attach(PIN_SERVO, 500, 2400);  // ancho de pulso en us
  servo.write(90);                     // posición inicial centrada

  conectarWiFi();

  mqtt.setServer(MQTT_HOST, MQTT_PORT);
  mqtt.setCallback(alRecibirMensaje);
  reconectarMQTT();

  Serial.println("[SETUP] Sistema operativo. Umbral: " +
                 String(UMBRAL_CM) + " cm");
}

// ═══════════════════════════════════════════════════════════════
//  LOOP
// ═══════════════════════════════════════════════════════════════

void loop() {
  // Mantener viva la conexión MQTT sin bloquear la medición.
  if (WiFi.status() == WL_CONNECTED) {
    if (!mqtt.connected()) reconectarMQTT();
    mqtt.loop();
  }

  if (millis() - ultimaMedicion < INTERVALO_MEDICION_MS) return;
  ultimaMedicion = millis();

  float distancia = medirConFiltro();

  // ─── Lógica de alarma: local y autónoma ───
  // Se ejecuta aunque no haya WiFi ni servidor disponible.
  if (!alarmaActiva && distancia > 0 && distancia < UMBRAL_CM) {
    alarmaActiva = true;
    iniciarAlarma();
  } else if (alarmaActiva &&
             (distancia < 0 || distancia > UMBRAL_CM + HISTERESIS_CM)) {
    alarmaActiva = false;
    detenerAlarma();
  }

  // ─── Telemetría ───
  if (distancia > 0) {
    Serial.println("[SENSOR] " + String(distancia, 1) + " cm" +
                   (alarmaActiva ? "  [ALARMA]" : ""));
    if (mqtt.connected()) publicarDistancia(distancia);
  } else {
    Serial.println("[SENSOR] Fuera de rango");
  }
}