Hassio cómo integrar tu proyecto de domotica con Home Assistant

En este tutorial, aprenderás cómo integrar tu proyecto de domotica basado en NodeMCU con Home Assistant (Hassio). Utilizando un NodeMCU V3, un conjunto de sensores y actuadores, y el protocolo MQTT, podrás controlar y monitorear tus dispositivos desde la plataforma de domótica Home Assistant.

Materiales necesarios:

• NodeMCU V3
• Sensor de luz (fotocelda)
• Sensor de movimiento (PIR SR501)
• Sensor de temperatura (DS18B20)
• Botón
• Dos relés
• Cables de conexión
• Breadboard (opcional)
• Servidor Home Assistant instalado y en funcionamiento

Paso 1: Conexión de los componentes

Realiza las conexiones necesarias entre los componentes. Puedes utilizar una breadboard para facilitar las conexiones. Asegúrate de seguir el esquema de conexiones adecuado para cada componente.

Paso 2: Carga del código en el NodeMCU

Utiliza el Arduino IDE para cargar el código en el NodeMCU. El código estará disponible en el blog como referencia. Asegúrate de tener las bibliotecas necesarias instaladas, como la biblioteca LiquidCrystal_I2C, OneWire, DallasTemperature, WiFi y PubSubClient.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <WiFi.h>
#include <PubSubClient.h>

#define ONE_WIRE_BUS 4

LiquidCrystal_I2C lcd(0x27, 16, 2);
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

const int fotoPin = A0;
const int pirPin = 2;
const int buttonPin = 3;
const int relay1Pin = 5;
const int relay2Pin = 6;

const char* ssid = "Tu_SSID";
const char* password = "Tu_Contraseña";
const char* mqttServer = "Tu_Direccion_IP_Broker";
const int mqttPort = 1883;
const char* mqttUser = "Tu_Usuario";
const char* mqttPassword = "Tu_Contraseña";

WiFiClient espClient;
PubSubClient client(espClient);

unsigned long uptime;
char uptimeString[10];

void setup() {
  lcd.begin(16, 2);
  lcd.backlight();

  pinMode(pirPin, INPUT);
  pinMode(buttonPin, INPUT_PULLUP);
  pinMode(relay1Pin, OUTPUT);
  pinMode(relay2Pin, OUTPUT);

  sensors.begin();

  connectWiFi();
  connectMQTT();

  lcd.print("Proyecto Domotica");
  lcd.setCursor(0, 1);
  lcd.print("Iniciando...");
  delay(2000);
  lcd.clear();

  uptime = millis();
}

void loop() {
  client.loop();

  int fotoValue = readPhotoCell();
  String lightLevel = getLightLevel(fotoValue);
  String motionState = getMotionState();
  int buttonState = readButtonState();
  float temperature = readTemperature();
  String temperatureState = getTemperatureState(temperature);
  String ipAddress = getIPAddress();
  String uptimeString = getUptimeString();

  displayData(lightLevel, motionState, temperature, temperatureState, buttonState);

  publishMQTT("domotica/luz", lightLevel);
  publishMQTT("domotica/movimiento", motionState);
  publishMQTT("domotica/temperatura", temperatureState);
  publishMQTT("domotica/ip", ipAddress);
  publishMQTT("domotica/uptime", uptimeString);
  publishMQTT("domotica/conexion", getWiFiStatus());

  delay(1000);
}

void connectWiFi() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi Conectado");
  Serial.print("Dirección IP: ");
  Serial.println(WiFi.localIP());
}

void connectMQTT() {
  client.setServer(mqttServer, mqttPort);
  client.setCallback(callback);

  while (!client.connected()) {
    if (client.connect("ESP32Client", mqttUser, mqttPassword)) {
      Serial.println("MQTT Conectado");
      client.subscribe("domotica/relay1");
      client.subscribe("domotica/relay2");
    } else {
      Serial.print("Error de conexión MQTT. Código de estado: ");
      Serial.print(client.state());
      Serial.println(" Intentando nuevamente en 5 segundos...");
      delay(5000);
    }
  }
}

void publishMQTT(const char* topic, const char* payload) {
  if (client.connected()) {
    client.publish(topic, payload);
  }
}

void callback(char* topic, byte* payload, unsigned int length) {
  String topicStr = String(topic);

  if (topicStr == "domotica/relay1") {
    if (payload[0] == '1') {
      digitalWrite(relay1Pin, HIGH);  // Enciende el relay1
    } else if (payload[0] == '0') {
      digitalWrite(relay1Pin, LOW);   // Apaga el relay1
    }
  }

  if (topicStr == "domotica/relay2") {
    if (payload[0] == '1') {
      digitalWrite(relay2Pin, HIGH);  // Enciende el relay2
    } else if (payload[0] == '0') {
      digitalWrite(relay2Pin, LOW);   // Apaga el relay2
    }
  }
}

int readPhotoCell() {
  return analogRead(fotoPin);
}

String getLightLevel(int fotoValue) {
  if (fotoValue >= 0 && fotoValue <= 333) {
    return "Poca luz";
  } else if (fotoValue >= 334 && fotoValue <= 666) {
    return "Buena luz";
  } else if (fotoValue >= 667 && fotoValue <= 1023) {
    return "Excelente luz";
  } else {
    return "N/A";
  }
}

String getMotionState() {
  int pirValue = digitalRead(pirPin);
  return (pirValue == HIGH) ? "Movimiento detectado" : "Sin movimiento";
}

int readButtonState() {
  return digitalRead(buttonPin);
}

float readTemperature() {
  sensors.requestTemperatures();
  return sensors.getTempCByIndex(0);
}

String getTemperatureState(float temperature) {
  if (temperature >= -10 && temperature <= 15) {
    return "Hace frio";
  } else if (temperature > 15 && temperature < 29) {
    return "Temperatura agradable";
  } else {
    return "Hace calor";
  }
}

String getIPAddress() {
  return WiFi.localIP().toString();
}

String getUptimeString() {
  unsigned long currentUptime = millis();
  unsigned long seconds = (currentUptime - uptime) / 1000;
  unsigned long minutes = seconds / 60;
  unsigned long hours = minutes / 60;
  snprintf(uptimeString, sizeof(uptimeString), "%02lu:%02lu:%02lu", hours, minutes % 60, seconds % 60);
  return String(uptimeString);
}

String getWiFiStatus() {
  return WiFi.isConnected() ? "Conectado" : "Desconectado";
}

void displayData(String lightLevel, String motionState, float temperature, String temperatureState, int buttonState) {
  lcd.setCursor(0, 0);
  lcd.print("Luz: ");
  lcd.print(lightLevel);
  lcd.setCursor(0, 1);
  lcd.print("PIR: ");
  lcd.print(motionState);

  lcd.setCursor(8, 0);
  lcd.print("Temp: ");
  lcd.print(temperature);
  lcd.write(0xDF); // Imprime el símbolo del grado Celsius

  lcd.setCursor(0, 1);
  lcd.print("Boton: ");
  lcd.print(buttonState == LOW ? "Presionado  " : "No presionado");

  lcd.setCursor(0, 1);
  lcd.print("Temp: ");
  lcd.print(temperatureState);
}

Paso 3: Configuración del entorno de Home Assistant

Asegúrate de tener Home Assistant instalado y en funcionamiento en tu servidor. Puedes instalarlo en un dispositivo Raspberry Pi u otro servidor compatible siguiendo los pasos proporcionados en la documentación oficial de Home Assistant.

Paso 4: Configuración del broker MQTT en Home Assistant

Abre el archivo de configuración configuration.yaml de Home Assistant y agrega la configuración necesaria para el broker MQTT. Esto permitirá la comunicación entre el NodeMCU y Home Assistant a través del protocolo MQTT. Asegúrate de especificar la dirección IP del broker MQTT, el puerto, el nombre de usuario y la contraseña que estás utilizando en tu proyecto de domótica.

mqtt:
  broker: IP_DEL_BROKER
  port: 1883
  username: TU_USUARIO
  password: TU_CONTRASEÑA

Paso 5: Configuración de los dispositivos en Home Assistant (Hassio)

En el mismo archivo de configuración configuration.yaml, agrega las configuraciones correspondientes a los dispositivos que deseas controlar y monitorear en Home Assistant. Esto incluirá los sensores de luz, movimiento y temperatura, el botón y los dos relés. Asegúrate de asignar un unique_id único a cada dispositivo para evitar conflictos.

# Sensor de luz
sensor:
  - platform: mqtt
    state_topic: "domotica/luz"
    name: "Sensor de Luz"
    unit_of_measurement: ""
    unique_id: sensor_luz

# Sensor de movimiento
binary_sensor:
  - platform: mqtt
    state_topic: "domotica/movimiento"
    name: "Sensor de Movimiento"
    device_class: motion
    unique_id: binary_sensor_movimiento

# Sensor de temperatura
sensor:
  - platform: mqtt
    state_topic: "domotica/temperatura"
    name: "Sensor de Temperatura"
    unit_of_measurement: "°C"
    unique_id: sensor_temperatura

# Sensor de botón
binary_sensor:
  - platform: mqtt
    state_topic: "domotica/boton"
    name: "Sensor de Botón"
    device_class: occupancy
    unique_id: binary_sensor_boton

# Switch del relé 1
switch:
  - platform: mqtt
    name: "Relé 1"
    state_topic: "domotica/relay1"
    command_topic: "domotica/relay1/set"
    payload_on: "1"
    payload_off: "0"
    optimistic: false
    unique_id: switch_rele1

# Switch del relé 2
switch:
  - platform: mqtt
    name: "Relé 2"
    state_topic: "domotica/relay2"
    command_topic: "domotica/relay2/set"
    payload_on: "1"
    payload_off: "0"
    optimistic: false
    unique_id: switch_rele2

Paso 6: Reinicio de Home Assistant (Hassio)

Guarda los cambios en el archivo de configuración y reinicia el servicio de Home Assistant para aplicar la configuración actualizada. Esto permitirá que Home Assistant reconozca los dispositivos configurados y esté listo para recibir y enviar datos a través del broker MQTT.

Paso 7: Verificación de los dispositivos en Home Assistant (Hassio)

Después de reiniciar Home Assistant, abre la interfaz de Home Assistant en tu navegador web. Verifica que los dispositivos configurados, como los sensores de luz, movimiento y temperatura, el botón y los relés, estén presentes en la interfaz. Puedes personalizar su apariencia y ubicación según tus preferencias.

Paso 8: Control y monitoreo de los dispositivos domotica

¡Felicidades! Ahora puedes controlar y monitorear tus dispositivos desde la plataforma de domótica Home Assistant. Utiliza la interfaz de Home Assistant para ver el estado de los sensores, encender o apagar los relés y realizar acciones basadas en los cambios de estado de los dispositivos.

Conclusión

En este tutorial, has aprendido cómo integrar tu proyecto de domótica basado en NodeMCU con Home Assistant. A través de la comunicación MQTT, has logrado controlar y monitorear tus dispositivos desde la plataforma de domótica. ¡Experimenta y personaliza tu sistema de domótica según tus necesidades y preferencias!

No olvides visitar mis otros post Domotica a tu portón con NodeMCU, MQTT y control remoto RF