Domotización Domo

Este año el Educrea ha construido 2 domos que será semilleros y aulas botánicas. El siguiente paso la domotización.

El objetivo de este proyecto es poder ver los valores de sensores y controlar los motores, luces, etc., .. que estén en el domo desde cualquier lugar del mundo. Para ello quería establecer una conexión entre la arduino y la raspberry.

• NodeMcu (vale cualquier placa Arduino con modulo ESP)
• Raspberry (yo usé la 4B, 2GB de RAM)

• Led

• Dht22

• Sensor Humedad de suelo

Antes de encontrar el camino, gran parte de mi tiempo labré otros caminos que aunque no tuviesen salida, sí aprendí mucho de ellos.

Teniendo claro que mi objetivo era una app con la que pudieses controlar el domo desde cualquier parte del mundo.

Al principio por mi falta de experiencia con la Raspberry, me negué a usarla e intente hacer la domotización solo Arduino. Hice una app con app inventor y NodeMcu. Efectivamente pude encender y apagar ledes y ver valores de sensores, un control total sobre la Arduino. Pero, encontré 2 problemas que no podía resolver:

• Dificultad para dar una IP fija
• Falta de Seguridad

Después me metí en la Raspberry de lleno, aprendí a programarla desde cero con la terminal. Publique una página web básica, con una IP fija. Llegue hasta a darle claves RSA. El problema era que era tremendamente complicado y laborioso hacer una página con una interfaz atractiva, además habría de saber programar en PHP además de HTML5.

La última solución que le di fue Node-Red. Volvía para atrás, ahora solo utilizaría Arduino. Node-Red es relativamente parecido a App-Inventor, pero es más limitado. Te permite ver valores y controlar la placa pero nada más y además tiene unos sensores limitados. Así que además, de lo anterior, decidí no usarla por la falta de seguridad.

Lo primero de todo es formatear la SD. Yo he utilizado SD Card Formatter, pero hay múltiples programas. Esto lo hacemos para asegurar que no queda nada en la tarjeta y deshacer cualquier cambio que hicimos sobre la tarjeta.

Después toca escribir la imagen de "Home Assistant" en la SD. Yo utilice Balen Etcher, pero de nuevo, hay múltiples programas.

Links:

SD Card Formatter Download: https://www.sdcard.org/downloads/formatter/

Balena Etcher Download: https://www.balena.io/etcher/

Imagen of Home Assistant: https://github.com/home-assistant/operating-system...

Queremos que la raspberry no esté constantemente conectar al router. Para ello tenemos que crear una carpeta llamada "CONFIG", dentro de ella otra más "network" y dentro creamos una archivos sin extension llamado "my-network". Editamos "my-network" con Edit Note Pad (o el bloc de notas), e insertamos el siguiente código:

[802-11-wireless-security]
auth-alg=open
key-mgmt=wpa-psk
psk=MY_WLAN_SECRET_KEY

La UUID debe ser única , copiala del UUID Generator.
Para obtener la información de la red a la que estamos conectados, en el símbolo de sistema introducimos el siguiente comando:

netsh wlan show profile key=clear name="nombre de la wifi"

Además establecemos una IP fija:

[ipv4]
method=manual
address=192.168.1.111/24;192.168.1.1
dns=8.8.8.8;8.8.4.4;

Ante de nada tenemos que meternos en la pagina del router y vemos que valores de rango asigna a las IP. Ponemos uno superior, no podemos poner una IP que esté asignada a otro dispositivo. Podemos usar IP Scanner para comprobar que la IP no esta siendo utilizada.

NO hace falta que asignemos una ipv6 (aun no están operativas).

Links:

Note Pad Download: https://notepad-plus-plus.org/downloads/

UUID Generator: https://www.uuidgenerator.net/

Codigo e instrucciones de GitHub: https://github.com/home-assistant/operating-system...

Ip Scanner Download: https://www.advanced-ip-scanner.com/es/

Después de unos 5-10 minutos introducimos en nuestro buscador de preferencia "http://homeassistant.local:8123"/ "http://homeassistant:8123" o "http://"IP asignada":8123". La instalación tomará 20 minutos

Tienes que estar conectado a la misma red que los está tu home assistant. Recuerda que aún no has abierto el puerto.

Una vez instalado, crea un usuario y dale nombre al servidor. De vez en cuando verifica la configuración.

Ahora toca instalar unos add-ons. Antes de nada tienes que activar el modo avanzado porque sino no te podrás ver ciertos add-ons. El primero que tienes que descargar es File Editor, que te permite editar los archivos de la raspberry.

El segundo que tenemos que descargar es SSH & Web Terminal. Cambia la configuración y establece usuario, contraseña y las claves RSA. Que puedes generar con Putty Generator o con el siguiente comando De vez en cuando verifica la configuración:

ssh-keygen

Estas claves permiten modificar los archivos solo al ordenador con las claves RSA. Para comprobar que el SSH funciona metete con Putty con la IP, puerto 22. Además así puedes controlar la terminal de la raspberry (Hassio) desde tu ordenador con el protocolo SSH.

Link:

Putty Download: https://www.putty.org/

Este add-on te permite tener los archivos del home assistant en tu ordenador.

En la configuración establece usuario y contraseña, no hace falta que toques las IP. Para comprobar que funciona en archivos de de tu ordenador --> red. Escribe seguido de \\ copia la IP de tu home assistant.

Este fue mi primer contacto con Arduino y Raspberry.

Instala el add-on: ESP HOME. Crea un nuevo nudo y configurar la red y el usuario. Para flashear el código (hassio) a la tarjeta node_mcu utiliza esphome flasher. Una vez flasheado, puedes ver los valores desde la terminal. El código de los sensores lo puedes encontrar en la página oficial de ESP HOME.

PROBLEMA:

Tiene unos sensores limitados. Por ejemplo, no tiene el sensor de humedad de suelo. Y el control sobre los sensores que tiene no se extiende más que obtener los valores. Además solo tienes control sobre ledes. En conclusión es muy restrictivo.

Links:

Flash Drive Download: https://github.com/esphome/esphome-flasher/release...

Esp Home: https://esphome.io/

Por último probé con el protocolo Mqtt. Ya conocía la posibilidad de usarlo antes del ESP, pero me parecía muy complicado y no me veía capaz de sacarlo por eso probé una opción alternativa. Me equivocaba, aunque fue difícil, sí que fui capaz. Y a pesar de la dificultad que presenta sí que merece la pena porque te da total libertad sobre arduino.

Primero toca eliminar el add-on ESP Home, ya que puede dar problemas. Después ya descargas el add-on MQTT y en la configuración estableces un usuario. Después de reiniciar el servidor, te metes en la configuración del MQTT y metes el usuario.

Como estamos trabajando con placa ESP asegúrate de tener las placas ESP y bibliotecas ESP instaladas, además de:

• ESP8266WiFi.h
• PubSubClient.h
• DHTesp.h

El programa primero se conecta a la wifi y después al mqqt de tu servidor. Recibe los valores de los sensores y con el protocolo callback, está constantemente escuchando los mensajes que recibe de otro paquete y en función de lo que recibe enciende o apaga el led. Los valores de los sensores los publica en 3 paquetes diferentes (uno para el sensor del suelo y 2 para la Dht22 : temperatura y humedad)

#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include "DHTesp.h"
DHTesp dht;

#define LED D3
#define LED_placa 16

const char* WIFI_SSID = "MOVISTAR_F240";
const char* WIFI_PASSWORD = "onptaqd6WQhFaSE4GhS6";



// MQTT: ID, server IP, port, username and password
const PROGMEM char* MQTT_CLIENT_ID = "usuario_educrea";
const PROGMEM char* MQTT_SERVER_IP = "192.168.1.111";
const PROGMEM uint16_t MQTT_SERVER_PORT = 1883;
const PROGMEM char* MQTT_USER = "mqtt";
const PROGMEM char* MQTT_PASSWORD = "mqtt";



char* deviceId  = "educrea"; // Name of the sensor
char* stateTopic_humedad = "home-assistant/educrea/humedad"; // MQTT topic where values are published
char* stateTopic_suelo = "home-assistant/educrea/suelo";
char* stateTopic_temperatura = "home-assistant/educrea/temperatura";
int sensorPin = A0; // Pin to which the sensor is connected to
char buf[4]; // Buffer to store the sensor value
int updateInterval = 1000; // Interval in milliseconds

#define DHTPIN 2
#define DHTTYPE DHT22

WiFiClient wifiClient;
PubSubClient client(wifiClient);


void reconnect() {
  while (!client.connected()) {
    Serial.println("INFO: Attempting MQTT connection...");
    if (client.connect(MQTT_CLIENT_ID, MQTT_USER, MQTT_PASSWORD)) {
      Serial.println("INFO: connected");
    }
    else {
      Serial.print("ERROR: failed, rc=");
      Serial.print(client.state());
      Serial.println("DEBUG: try again in 5 seconds");
      delay(5000);
    }
  }
  client.subscribe("/educrea/luz");
}

void callback (char* topic, byte* payload, unsigned int length) {
  Serial.print("Mensaje :");
  Serial.println(topic);
  String message;

 
  Serial.print(message);

  for(int i=0; i<length; i++){
    message= message + (char)payload[i];
    }
   
  if (message == "1") {
    digitalWrite(LED, LOW);
    digitalWrite(LED_placa, LOW);
  }
  if (message == "0") {
    digitalWrite(LED, HIGH);
    digitalWrite(LED_placa, HIGH);
  }

  Serial.println(".");


}

void setup() {
  delay(1000);
  Serial.begin(115200);
  
  dht.setup(D2, DHTesp::DHT22);
  pinMode(LED,OUTPUT);
  pinMode(LED_placa,OUTPUT);
  
  
  Serial.println();
  Serial.print("Conectando");
  WiFi.mode(WIFI_STA);
  Serial.println(WIFI_SSID);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

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

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());

  client.setServer(MQTT_SERVER_IP, MQTT_SERVER_PORT);
  client.setCallback(callback);
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  float h = dht.getHumidity()*10;
  float t = dht.getTemperature()*10;
  int suelo_humedad = analogRead(sensorPin);
#if DEBUG
  Serial.print("Suelo: ");
  Serial.println(suelo_humedad);
  if (isnan(h) || isnan(t)) {
    Serial.println("ERROR: Failed to read from DHT sensor!");
    return;

  } else {
    Serial.print("Temperatura: ");
    Serial.println(t);
    Serial.print("Humedad: ");
    Serial.println(h);
  }
#endif
  client.publish(stateTopic_suelo, itoa(suelo_humedad, buf, 10));
  client.publish(stateTopic_humedad, itoa(h, buf, 10));
  client.publish(stateTopic_temperatura, itoa(t, buf, 10));
  delay(updateInterval);
  
}

Dentro del Home Assistant puedes comprobar que los paquetes están mandando información.

Con file editor, modifica el archivo Configuration.yaml, copia el código:

Estas estableciendo 3 sensores que escuchan a los 3 paquetes diferentes de Arduino. Luego para mandar mensajes al paquete del led establece un switch cuando está ON manda 1 y cuando está OFF manda 0.

# Configure a default setup of Home Assistant (frontend, api, etc)
default_config:

# Text to speech
tts:
  - platform: google_translate

group: !include groups.yaml
automation: !include automations.yaml
script: !include scripts.yaml
scene: !include scenes.yaml


# Uncomment this if you are using SSL/TLS, running in Docker container, etc.
# http:
#   base_url: example.duckdns.org:8123
# MQTT broker

sensor 1:
  platform: mqtt
  state_topic: 'home-assistant/educrea/humedad'
  name: 'Educrea_humedad'
  unit_of_measurement: '%'
  
sensor 2:
  platform: mqtt
  state_topic: 'home-assistant/educrea/suelo'
  name: 'Educrea_suelo'
  unit_of_measurement: '%'
 
sensor 3:
  platform: mqtt
  state_topic: 'home-assistant/educrea/temperatura'
  name: 'Educrea_temperatura'
  unit_of_measurement: 'ºC'

switch:
  - platform: mqtt
    unique_id: bedroom_switch
    name: "Led"
    state_topic: "/educrea/luz"
    command_topic: "/educrea/luz"
    payload_on: "1"
    payload_off: "0"
    state_on: "ON"
    state_off: "OFF"
    retain: true
    optimistic: true

Edita el panel de control e inserta los sensores y el switch con el nombre que le dimos antes. Tienen diferentes interfaces.

Home assistant a parte de la web tiene una aplicación para Android e IOS.

Lo más difícil ya está hecho, se puede decir que hemos construido la asfaltadora y el camino se hace automaticamente.

Solo queda abrir el puerto del router para poder acceder al home-asssistant desde remoto. Añadir usuarios. Implementar un sistema de riego (que es lo mismo que controlar un led pero con válvulas), además quiero probar hasta cuanto de lejos se puede llevar y a lo mejor meterle una cámara a la Arduino o a la Raspberry.