Estoy seguro que te suena la frase anglosajona plug & play, allá por 1995 Microsoft lanzo Windows 95 que fue su primera versión compatible con esta funcionalidad. Como ves me he ido muy lejos, tan lejos como la primera versión de Zigbee que data del 2003. Además, te he dado una pista plug & play, nada es más fácil que añadir un dispositivo Zigbee a tu controlador Zigbee, en segundos lo incluyes en tu red y en segundos lo tienes operativo para poderlo añadir a tus escenas con el controlador domótico de tu elección.
En este artículo no voy a profundizar en el protocolo Zigbee, porque lo que me interesa es que tengas la visión de como se interactúa desde un punto de vista práctico con este protocolo (Zigbee) desde otro protocolo como MQTT.
Para ello nos vamos a apoyar en la pasarela zigbee2mqtt.
Esta pasarela es Open Source y muy básicamente traduce mensajes MQTT a comandos Zigbee.
Si has leído alguno de mis otros artículos sobre Tasmota o ESPHome, te darás cuenta de que sitúo al protocolo MQTT por delante de todos los demás, es un protocolo integrador, donde cabe todo y de todo. Prueba de ello es la cantidad de pasarelas MQTT (gateways) que han aparecido.
Existen pasarelas con el protocolo BLE (bluetooth), Lora, 433 MHz/315 MHz, protocolo Z-Wave, GSM o Zigbee, que básicamente integran tus dispositivos de cualquier protocolo con MQTT, controlándolos publicando mensajes.
Lógicamente, los dispositivos deben de ser compatibles, el personal de zigbee2mqtt sabe que cuántos más dispositivos existan, más se utilizara su plataforma. A día de hoy indican 2149 de 295 fabricantes distintos.
Mira este enlace de la web de zigbe2mqtt por si quieres más información.
Sin más introducción, disfruta del artículo.
Indice de contenidos
¿Qué es Zigbee?
Zigbee es un protocolo que se utiliza para vincular dispositivos inteligentes como luces, enchufes y cerraduras a una red doméstica.
Pero no todo es idílico, Zigbee no es un protocolo Open Source, existe una organización Connectivity Standards Alliance (antes Zigbee Alliance) que vela por el estándar Zigbee de la cual debes de ser miembro para poder certificar tus productos.
Hasta aquí todo aceptable, el problema sucede cuando los fabricantes de dispositivos añaden capas propietarias a sus dispositivos, es decir, código fuera del estándar, provocando (solo es un ejemplo) que los dispositivos de un fabricante como IKEA no sean compatibles con el controlador de AQARA y viceversa, ya que sus dispositivos solo saben comunicarse con sus propios controladores Zigbee.
Resumiendo:
Mucho cuidado con lo que compras, procura verificar antes su compatibilidad, puede encontrar sorpresas.
Características sobre Zigbee
- Es una tecnología Wireless como la que puedes tener en tu casa.
- Trabaja a una frecuencia de 2.4 GHz como el wifi o el bluetooth de tu casa.
- El protocolo está bastante estandarizado y dispositivos de distintos fabricantes pueden comunicarse entre ellos, pero como te he comentado antes pueden existir problemas si algún fabricante ha implantado código propietario.
- Trabaja en una topología de red en malla.
- Es muy económico, entre 10 € y 20 € hay miles de dispositivos a tu disposición.
- Es seguro, utiliza encriptación AES 128 bits.
- Poco consumo, lo que implica larga duración de las pilas, entre 6 y 12 meses.
- El rango de trabajo de los dispositivos es de 10-20 metros en interiores y 75-300 exteriores.
- Los dispositivos necesitan de un controlador o hub.
¿Cómo funciona Zigbee?
Cada dispositivo tiene un transmisor que utiliza la frecuencia 2.4 GHz para comunicarse entre ellos en una distancia entre 10 y 20 metros en interiores, es poco, pero gracias a esto tiene un muy bajo consumo, que es clave en el despegue que ha tenido este protocolo en los 2 últimos años.
Los dispositivos Zigbee pueden comunicarse entre ellos. Incluso pueden repetir o enrutar una comunicación enviándola a otro dispositivo, esto hace que puedan existir varios caminos alternativos para llegar a un dispositivo, es la esencia de una red en malla.
¿Qué es una red en malla?
Una red en malla es una red donde uno o varios dispositivos pueden actuar como repetidores o enrutadores, si lo piensas un poco te darás cuenta que al repetir la señal pueden alcanzar distancias más largas que los rangos por defecto que tiene, que son entre 10 y 20 metros. Es poco, pero con el uso de repetidores/enrutadores puedes aumentar esa distancia. Esto es un dato importante, no debe de asustarte la distancia.
Al existir dispositivos Zigbee que enrutan tráfico dentro de la red tipo malla implica que estos dispositivos actualizan de una manera dinámica su tabla de rutas, aportando robustez y eficiencia, puede haber más de un camino para llegar de un nodo a otro. Por otro lado, tú, como usuario, no puedes indicar que dispositivo se conecta con otro de una manera implícita, es la propia red tipo malla quien se encarga de esta tarea.
Es verdad que podemos interactuar a bajo nivel con los dispositivos Zigbee, pero no mucho más allá del comando tipo: actualiza a tus vecinos (actualiza tu tabla de rutas) o reiníciate, redescubrir dispositivo, etc.
Desde la consola de zigbee2mqtt existen opciones para leer y escribir atributos a vuestros dispositivos
¿Qué hay en una red Zigbee?
Llegados a este punto, es el momento en el que todas las piezas empiecen a encajar, ya verás.
En esta imagen puedes ver la estructura de la red tipo malla que te explico más adelante
En la estructura de una red Zigbee existen 3 tipos de roles para cada dispositivo
- Coordinator: todas las redes necesitan de un administrador, el coordinador cumple esa función, crea la red, enruta paquetes, pueden aceptar conexiones y solo puede haber uno como en la peli de «Los Inmortales» . También es un punto central de la red que si está conectado en algún dispositivo como una Raspberry 3 o 4 puede comunicarse con otras partes de tu red doméstica o internet. Existen muchos adaptadores en el mercado, yo para este artículo voy a utilizar el adaptador Conbee II de la empresa Phoscon
- Router: el enrutador, parecido al coordinador, pero no admite conexiones, es decir, no puede emparejar nuevos dispositivos. Estos dispositivos no deben de alimentarse a pilas, es decir, son dispositivo que directamente (normalmente es así) se conectan a tu red eléctrica o a través de un adaptador de corriente. Estos dispositivos hablan con todos los dispositivos dentro de su rango de alcance y repiten las comunicaciones. Ejemplos, un conmutador inteligente o un enchufe inteligente como puedes ver en la imagen.
- End Devices: funcionan mediante batería (normalmente tipo botón), no enrutan comunicaciones, no hablan con otros End Devices solo lo hacen con el coordinador y los enrutadores. Están preparados para entrar en modo bajo consumo, conectándose únicamente cuando lo necesiten. Ejemplos, un sensor de apertura o un sensor de presencia como el que se ve en la siguiente imagen.
Ejemplo con Zigbee y Zigbee2MQTT
Para ver este ejemplo voy a montar un pequeño laboratorio en una Raspberry Pi 3+ y para facilitarme el montaje voy a echar mano de Docker y Docker-compose. Repito es un laboratorio, aunque os voy a indicar paso a paso como hacerlo, no lo voy a explicar en detalle, no es la finalidad de este artículo.
Lo verdaderamente importante es que veas como podemos interactuar con el protocolo Zigbee con zibee2mqtt, añadir dispositivos y manejarlos
Para este laboratorio vamos a montar sobre una RPI 3+:
- Una versión de Debian Buster de 64 bits.
- La plataforma Docker que nos permite añadir fácilmente las aplicaciones necesarias en un pispás.
- Los contenedores MQTT y zigbee2mqtt.
Pero si eres un echao o echada pa lante, sígueme.
Hardware necesario
- RPI 3+ o RPI 4 (enlace Amazon).
- Tarjeta de memoria SSD 16 o 32 GB (enlace Amazon).
- Adaptador Combee II (enlace Amazon).
- SONOFF SNZB-03 (enlace Amazon).
- SONOFF BASICZBR3 (enlace Amazon).
Paso 1. Descarga e instalación del sistema operativo para RPI 3+
- En este enlace puedes descargarte la imagen Debian versión Buster Lite para tu RPI 3+ (vale también para RPI 4, elige el fichero que acaba en .zip 2021-05-07-raspios-buster-arm64-lite.zip
- Una vez descargado, descomprímelo y tendrás algo como esto: 2021-05-07-raspios-buster-arm64-lite.img
- Sube la imagen con tu herramienta favorita, balenaEtcher en mi caso, sobre una tarjeta SSD de 32 GB.
- Inserta la tarjeta de memoria en la RPI 3+, conecta un teclado y monitor y si toda ha ido bien, te pedirá usuario: pi y clave: raspberry. Por lo tanto, ya estás dentro.
- Con el comando sudo raspi-config configura wifi (en mi caso), teclado ES y activo acceso remoto ssh, Rendimiento GPU Memory 16, Localisation Option y Hostname raspizigbee.
- Escanea tu red con Angry IP (Windows) o LanScan (Mac) y descubre la IP asignada a tu RPI
- Accedemos remotamente a la RPI 3+ via ssh desde el terminal, ya sea Linux o Mac o bien con putty si accedes desde PC/Windows. Actualizamos el sistema operativo.
|
1 2 3 4 |
# actualiza repositorios sudo apt update # actualizar tu version de linux debian buster sudo apt-get upgrade |
Paso 2 Instalación docker
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
# Instalacion paquetes para securizar las comunicaciones sudo apt-get install apt-transport-https ca-certificates curl gnupg lsb-release # curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg # echo "deb [arch=arm64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null # actualizamos repositorios sudo apt update #instalamos docker apt-cache policy docker-ce sudo apt-get install docker-ce docker-ce-cli containerd.io #reiniciamos sudo reboot now #test servicio docker sudo systemctl status docker # gestion de usuarios sudo usermod -aG docker ${USER} su - ${USER} # Comprobamos que nos aparece el grupo docker id -nG |
Estado del servicio Docker
Pertenencia al grupo docker
Paso 3. Instalación docker-compose
- Vas a instalar dopcker-compose con el gestor de paquetes pip de python, muy sencillo.
|
1 2 3 4 5 6 |
# Instalacion del gestor de paquetes PIP sudo apt install -y libffi-dev libssl-dev sudo apt install -y python3-pip # Instalacion de docker-compose (tarda unos minutos) sudo pip3 install docker-compose |
- Vamos a probar la instalación, para ello vas a crear el fichero típico docker-compose.yml y vas a configurar un servidor Http.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
# Comprobamos la version instalada (1.29.2 en mi caso) docker-compose --version # Creamos y editamos el fichero docker-compose.yml nano docker-compose.yml # Escribe o copia esta configuracion en el editor nano anterior, muy importante mantener los dos espacios para que el fichero este prefectamente indentado version: '3.7' services: hello-world: image: python:3.8-alpine ports: - "80:8000" command: "python -m http.server 8000" # Para comprobar que el fichero esta perfectamente indentado puedes instalarte este comprobador de sintaxis de ficheros YAML sudo apt install yamllint # Una vez instalado lo ejecutamos contra nuestro fichero yamllint docker-compose.yml |
- Si tienes algún error el programa te lo indica, en mi caso ha detectado espacios vacíos al final de las líneas, 3 y 5. Es un error muy típico cuando se copia y se pega.
Ejemplo:
- Edita de nuevo el fichero, borra esos espacios y vuelve a comprobar el fichero.
- Ahora, sin errores, levantamos el servicio docker-compose con la configuración de pruebas.
|
1 |
docker-compose up -d |
- Abre el navegador y añade http://la_ip_de_tu_rpi
Ya lo tienes, todo preparado para instalar MQTT y zigbee2mqtt
Paso 4. Instalación de MQTT
- Borra lo hecho anteriormente
|
1 2 3 4 5 6 7 |
# Borramos la imagen anterior # Paramos los servicios y nos quedamos con el nombre del servicio, en este caso: pi_hello-world_1 docker-compose stop # Borramos el contenedor docker rm pi_hello-world_1 # Borra el fichero docker-compose.yml rm docker-compose.yml |
- Crea la estructura de carpetas y ficheros necesaria para MQTT
|
1 2 3 4 5 6 7 8 9 |
# Comprueba que estas en la carpeta personal del usuario PI (/home/pi) pwd # crea la carpeta raiz para todos los contenedores mkdir containers cd containers/ # Estructura para MQTT mkdir -p /home/pi/containers/mosquitto/{config,data,log} # Crea y edita el fichero de configuracion para MQTT nano mosquitto/config/mosquitto.conf |
- fichero mosquitto.conf
|
1 2 3 4 5 6 |
port 1883 listener 9001 allow_anonymous true protocol websockets persistence true persistence_location /mosquitto/data/ log_dest file /mosquitto/log/mosquitto.log |
- Fichero docker-compose.yml
|
1 2 |
# En /home/pi/containers, crea y edita el fichero docker-compose.yml nano docker-compose.yml |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
# Copia esta configuración al fichero docker-compose.yml y guardalo version: '3.7' services: mosquitto: image: eclipse-mosquitto container_name: mosquitto restart: always ports: - "1883:1883" - "9001:9001" volumes: - /home/pi/containers/mosquitto/config:/mosquitto/config - /home/pi/containers/mosquitto/data:/mosquitto/data - /home/pi/containers/mosquitto/log:/mosquitto/log - /etc/localtime:/etc/localtime:ro user: "1000:1000" |
|
1 2 3 4 5 6 |
# Comprueba que no tiene errores sintacticos yamllint docker-compose.yml # Arranca el servicio mqtt docker-compose up -d # Comprueba que este levantado docker-compose ps |
Te debe de aparece en estado UP
|
1 2 |
# Por ultimo comprobar que el puerto 1883 esta en modo escucha netstat -tulpen |
Te debe de aparecer algo asi
- Comprobar que se pueden publicar y subscribirse a mensajes mqtt
|
1 2 |
# Primero instalamos el cliente MQTT en nuestra RPI sudo apt install mosquitto-clients |
Ahora vas a conectarte desde dos sesiones diferentes a tu RPI, para ver las pantallas simultáneamente voy a utilizar iTerm2 para MAC, si utilizas Windows Mobaterm es muy buena elección y si eres usuario de Linux TMUX debe de ser tu elección.
En uno de los terminales subscríbete a todos los mensajes, cuando lo ejecutes, el programa mosquitto_sub se queda a la espera de mensajes.
|
1 |
mosquitto_sub -t '#' |
En el otro terminal publica un mensaje.
|
1 |
mosquitto_pub -t 'test/tralara' -m 'mensaje de test' |
Automáticamente, aparece el mensaje en el primer terminal.
Paso 5. Instalación zigbee2mqtt
- Conecta el adaptador Conbee II a un puerto USB de tu RPI. Es recomendable no conectar directamente el adaptador a la RPI, puedes utilizar un alargador, la razón es por las posibles interferencias que puedan surgir. También es recomendable tener un hub USB con alimentación externa.
- Descubre en que puerto se ha conectado, apuntalo, es importante, ya que lo necesitaras más adelante. Con uno de estos dos comandos puede localizar tu adaptador Zigbee
|
1 2 |
dmesg | grep tty ls -l /dev/serial/by-id |
- Creamos la estructura de carpetas y el fichero de configuración, sitúate en /home/pi/containers
|
1 2 3 4 5 6 7 |
mkdir -p /home/pi/containers/zigbee2mqtt cd zigbee2mqtt # al ejecutar este comando descargamos un fichero configuration.yaml, creamos una carpeta /data wget https://raw.githubusercontent.com/Koenkk/zigbee2mqtt/master/data/configuration.yaml -P data # editar el fichero configuration.yaml cd data nano configuration.yaml |
Modificamos el fichero para adecuarlo a nuestra instalación
|
1 2 3 4 5 6 7 |
homeassistant: false permit_join: true mqtt: base_topic: zigbee2mqtt server: mqtt://192.168.1.39:1883 serial: port: /dev/ttyACM0 |
- Editamos de nuevo el fichero docker-compose.yml
|
1 2 |
cd /home/pi/containers nano docker-compose.yml |
Y añadimos la parte del servicio zigbee2mqtt
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
version: '3.7' services: mosquitto: image: eclipse-mosquitto container_name: mosquitto restart: always ports: - "1883:1883" - "9001:9001" volumes: - /home/pi/containers/mosquitto/config:/mosquitto/config - /home/pi/containers/mosquitto/data:/mosquitto/data - /home/pi/containers/mosquitto/log:/mosquitto/log - /etc/localtime:/etc/localtime:ro user: "1000:1000" zigbee2mqtt: container_name: zigbee2mqtt image: koenkk/zigbee2mqtt restart: unless-stopped volumes: - /home/pi/containers/zigbee2mqtt/data:/app/data - /run/udev:/run/udev:ro ports: # Frontend port - 8080:8080 environment: - TZ=Europe/Madrid devices: # Make sure this matched your adapter location - /dev/ttyACM0:/dev/ttyACM0 group_add: - dialout user: 1000:1000 |
Comprobamos la sintaxis y si todo va bien arrancamos el servicio zigbee2mqtt
|
1 2 |
yamllint docker-compose.yml docker-compose up -d zigbee2mqtt |
- Comprueba si todo se ha iniciado correctamente accediendo al LOG
|
1 |
docker-compose logs -f zigbee2mqtt |
- Comprueba también las publicaciones MQTT con MQTT-Explorer
Ya tienes todo el tinglado montado:
- Instalación de la versión Debian Buster Lite para RPI
- Instalación de docker y docker-compose
- Instalación MQTT
- Instalación ZIGBEE2MQTT
Ahora vamos a salirnos fuera del terminal y vas a configurar un entorno web para poder interactuar con zigbee2mqtt, añadiendo dispositivos a tu red zigbee
Paso 6. Instalación entorno FrontEnd: la consola zigbee2mqtt
- El entorno FrontEnd no es más que una vista de todo el entorno Zigbee a través de un navegador. Está muy muy bien. Algunas características:
- Renombrar los dispositivos para que sean más reconocibles
- Interactuar con ellos, ON/OFF
- Sacar un mapa de la malla zigbee y ver la calidad de la señal con cada dispositivo
- Un montón de ajustes, MQTT, FrontEnd, integración con Home Assistant, seguridad, configuración del adaptador Zigbee
- Para disfrutarlo vas a añadir una línea al final del fichero de configuración de zigbee2mqtt configuration.yaml
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
# Home Assistant integration (MQTT discovery) homeassistant: false # allow new devices to join permit_join: true # MQTT settings mqtt: # MQTT base topic for zigbee2mqtt MQTT messages base_topic: zigbee2mqtt # MQTT server URL server: mqtt://192.168.1.39:1883 # MQTT server authentication, uncomment if required: # user: my_user # password: my_password frontend: true |
Para y arranca el servicio zigbee2mqtt
|
1 2 |
pi@raspizigbee:~/containers $ docker-compose stop zigbee2mqtt pi@raspizigbee:~/containers $ docker-compose up -d zigbee2mqtt |
Y vuelve a lanzar el comando para visualizar los LOGs en tiempo real, este comando déjalo activo siempre porque volveremos una y otra vez.
|
1 |
pi@raspizigbee:~/containers $ docker-compose logs -f zigbee2mqtt |
En la salida del comando anterior busca esta línea, que te indica que la parte frontend de zigbee2mqtt está levantada y a la escucha.
- Accede al entorno frontend desde tu navegador http://la_ip_de_tu_rpi:8080
Has llegado al punto donde podemos añadir dispositivos a nuestro entorno para interactuar con ellos, que es la idea de este articulo. Voy a trabajar con dos dispositivos, uno que solo envía mensajes SONOFF SNZB-03 (sensor de movimiento) y otro que envía y recibe SONOFF BASICZBR3 (conmutador)
Paso 6. Añadir dispositivos
El añadir dispositivos es muy simple y rápido, esta es la secuencia:
- Emparejamiento, normalmente se hace poniendo el adaptador Zigbee en modo inclusión e iniciando el emparejamiento desde el dispositivo, pulsando en algún interruptor o botón.
- Configurando el dispositivo, cambiando el nombre a algo más legible
- Ejecutar comandos, lectura, escritura y estado: /get, /set, /state
Añadir dispositivo SONOFF SNZB-03
Este dispositivo es un detector de presencia. Pocas cosas en domótica son tan sencilla como añadir un dispositivo a un entorno Zigbee.
Abre el SNZB-03 para quitar el papelito que aísla la pila para que no consuma y ciérralo
Verás que por un lateral tiene un pequeño orificio, con un clip o similar presiónalo durante 5 segundos, el LED que lleva debe de parpadear tres veces. Y ya está.
Vista LOGs zigbee2mqtt
Vista FrontEnd
Además, en el fichero configuratio.yaml de Zigbee también se ha añadido el dispositivo descubierto
|
1 2 3 4 5 6 7 8 9 10 11 |
homeassistant: false permit_join: true mqtt: base_topic: zigbee2mqtt server: mqtt://192.168.1.39:1883 frontend: true serial: port: /dev/ttyACM0 devices: '0x00124b00251a19fb': friendly_name: '0x00124b00251a19fb' |
- En la página de SONOFF SNZB-03 de zigbee2mqtt puedes ver los datos que este dispositivo puede mostrar. En este dispositivo no se le pueden enviar comandos, tipo /get o tipo /set, es decir, es autónomo, está en reposo y solo publica información cuando detecta presencia ON y vuelve a su posición de reposo a los 60 segundos aproximadamente si no ha detectado nada más.
Vista LOGs
- Datos expuestos:
- Occupancy (binary): valor binario que publica si ha detectado o no presencia (occupancy)
- Battery_low (binary): valor binario que publica el estado de la carga de la batería (battery_low)
- Battery (numeric): valor numérico que publica, en porcentaje, la carga de la batería (battery)
- Voltage (numeric): valor numérico que publica el voltaje de la batería en mili Voltios (voltage)
- Linkquality (numeric): valor numérico que publica la calidad de la señal, es un dato muy importante que se sitúa entre 0 y 255. Si este valor está por debajo de 85 posiblemente tendrás problemas de conectividad (linkquality)
Vista desde MQTT Explorer
Añadir dispositivo SONOFF BASICZBR3
Este dispositivo es un conmutador, que admite lectura y escritura de comandos /get y /set y algunos más como verás a continuación.
Para emparejarlo, como este dispositivo no tiene batería, debes de conectarlo a la red eléctrica, para ello debes de abrirlo, aflojar los tornillos y conectar los cables.
Importante no confundir la entrada Line IN de la salida Line OUT del conmutador, en Line IN conectará los cables que van a tu red eléctrica y en el conector Line OUT la bombilla, lámpara, o el aparato que hayas decidido encender/apagar.
Una vez conectado los cables, conéctalo a cualquier enchufe de casa y pulsa durante más de 5 segundos el botón del conmutador que está en la parte superior del dispositivo. El relé conmuta varias veces. Y ya está.
Vista de los LOGs
También en la consola aparece este nuevo dispositivo.
Voy a aprovechar para personalizar los nombres de ambos dispositivos, lo puedes hacer desde los botones azules a la derecha de los dispositivos. Así aparecerán con estos nombres tanto en MQTT-Explorer como el LOG de zigbee2mqtt
Todo lo que hemos realizado hasta ahora es para llegar a este momento, el momento en el cual podemos interactuar con nuestros dispuestos a través de mensajes MQTT que nuestra pasarela zigbee2mqtt traduce para que el dispositivo Zigbee nos obedezca.
Si abres la página de este dispositivo en zigbee2mqtt ves que expone dos tipos de datos.
Datos expuestos:
- Switch (conmutador): valor binario que publica el estado de ON o OFF. Este dispositivo admite comandos /set y /get
- Mensaje al topic zigbee2mqtt/FRIENDLY_NAME/set con la carga útil (payload) -> {«state»: «ON»}, {«state»: «OFF»} o {«state»: «TOGGLE»}
- Mensaje al topic zigbee2mqtt/FRIENDLY_NAME/get con la carga útil (payload) -> {«state»: «»}
- Linkquality (numeric): valor numérico que publica la calidad de la señal, es un dato muy importante que se sitúa entre 0 y 255. Si este valor está por debajo de 85 posiblemente tendrás problemas de conectividad (linkquality)
Hemos llegado al punto deseado y principal motivo del artículo, has añadido dispositivos y vamos a interactuar con ellos, cuya operativa es similar a los otros 2000 dispositivos compatibles, es decir, aprendido uno, aprendido todos.
Abre el terminal para conectarte a tu RPI y vas a comprobarlo tu mismo. Mantén dos sesiones simultáneas, para así ver en tiempo real la ejecución de los comandos y su resultado.
Comandos:
|
1 2 3 4 5 6 7 |
pi@raspizigbee:~ $ mosquitto_pub -t 'zigbee2mqtt/Conmutar Lampara Salon/get' -m '{"state":""}' pi@raspizigbee:~ $ mosquitto_pub -t 'zigbee2mqtt/Conmutar Lampara Salon/set' -m '{"state":"OFF"}' pi@raspizigbee:~ $ mosquitto_pub -t 'zigbee2mqtt/Conmutar Lampara Salon/set' -m '{"state":"ON"}' pi@raspizigbee:~ $ mosquitto_pub -t 'zigbee2mqtt/Conmutar Lampara Salon/set' -m '{"state":"TOGGLE"}' |
Y su resultado:
|
1 2 3 4 5 6 7 8 |
zigbee2mqtt | Zigbee2MQTT:info 2022-04-17 13:10:43: MQTT publish: topic 'zigbee2mqtt/Conmutar Lampara Salon', payload '{"linkquality":255,"state":"ON"}' zigbee2mqtt | Zigbee2MQTT:info 2022-04-17 13:11:08: MQTT publish: topic 'zigbee2mqtt/Conmutar Lampara Salon', payload '{"linkquality":255,"state":"OFF"}' zigbee2mqtt | Zigbee2MQTT:info 2022-04-17 13:11:15: MQTT publish: topic 'zigbee2mqtt/Conmutar Lampara Salon', payload '{"linkquality":255,"state":"ON"}' zigbee2mqtt | Zigbee2MQTT:info 2022-04-17 13:11:22: MQTT publish: topic 'zigbee2mqtt/Conmutar Lampara Salon', payload '{"linkquality":255,"state":"OFF"}' |
En el dispositivo se encenderá un LED rojo cada vez que pases por el estado ON
También la consola de zigbe2mqtt te permite dibujar mapas de conexión, indicando aparte la calidad de la conexión (255), el rol que cumple cada dispositivo. Los mapas están muy bien, aunque cuando tienes muchos dispositivos se puede convertir en una telaraña de conexiones.
Conclusión sobre Zigbee y Zigbee2MQTT
Al margen de la dificultad que puede implicar montar el laboratorio, pero que si tienes algún conocimiento sobre plataformas Docker y unas horas de haber trasteado con una RPI, no te va a resultar nada complejo, te he mostrado de una manera práctica como añadir dispositivos e interactuar con ellos.
La red tipo malla que soporta el protocolo Zigbee es robusta y efectiva. El precio de los dispositivos es muy bajo (10-20 €) y su consumo eléctrico es muy bajo (batería/pilas duran 6 meses – 1 año).
Es verdad que solo con zigbee2mqtt no puedes crear automatizaciones o escenas, por el simple hecho que no es su cometido, para poner la guinda en el pastel necesitaras de Home Assistant, OpenHAB o Jeedom aunque te vale cualquier plataforma que sepa trabajar con un broker MQTT. Así de simple.
Zigbee2mqtt tiene más de 2000 dispositivos compatibles, y has visto lo fácil que es añadir dispositivos, pero ojo tiene mucha miga, la consola tiene muchas opciones que su investigación podría ser tu siguiente paso.
Por último, quédate con esta palabra MATTER, es un protocolo, pero lo importante es lo que está detrás, fabricantes, desarrolladores y vendedores, todos de la mano para estandarizar la conectividad entre dispositivos y controladores. No digo más que luego todo se sabe.
Me ha encantado hacer este artículo, espero lo disfrutes igualmente.
Gracias a Depositphotos por la cesión de las imágenes.