Programar fácil con Arduino

Programar fácil con Arduino, entiende cómo funciona el mundo.

  • Blog
  • ¿Quién soy?
  • Podcast
  • Curso Arduino [GRATIS]
  • Curso Domótica [GRATIS]
  • Acceder
Usted está aquí: Inicio / Domótica / Primeros pasos con Zigbee y Zigbee2MQTT

Primeros pasos con Zigbee y Zigbee2MQTT

Charly Pascual

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.

zigbee2mqtt

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

  • 1 ¿Qué es Zigbee?
  • 2 ¿Cómo funciona Zigbee?
  • 3 ¿Qué hay en una red Zigbee?
  • 4 Ejemplo con Zigbee y Zigbee2MQTT
  • 5 Conclusión sobre Zigbee y Zigbee2MQTT
Zigbee-y-Zigbee2mqtt

¿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.

Condensadores-o-capacitores

Condensador Eléctrico

Si te preguntas cuál es el componente eléctrico que a lo largo del tiempo ha sufrido pocas modificaciones y que no se ha encontrado un sustituto que … [+ info...]

sistemas-embebidos

Sistemas embebidos con Carlos Aldea

Bienvenidos a un nuevo capítulo de «La tecnología para todos«. Hoy nos acompaña Carlos Aldea, un resiliente aprendiz que lleva un sinfín de peleas … [+ info...]

Zigbee-y-Zigbee2mqtt

Primeros pasos con Zigbee y Zigbee2MQTT

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 … [+ info...]

Copyright © 2022 · Programar Fácil · Aviso legal

Utilizamos cookies propios y de terceros para mejorar nuestros servicios y experiencia de usuario. Si continua navegando, consideramos que acepta su uso.Aceptar Política de privacidad y cookies
Política de cookies

Privacy Overview

This website uses cookies to improve your experience while you navigate through the website. Out of these, the cookies that are categorized as necessary are stored on your browser as they are essential for the working of basic functionalities of the website. We also use third-party cookies that help us analyze and understand how you use this website. These cookies will be stored in your browser only with your consent. You also have the option to opt-out of these cookies. But opting out of some of these cookies may affect your browsing experience.
Necessary
Siempre activado
Necessary cookies are absolutely essential for the website to function properly. This category only includes cookies that ensures basic functionalities and security features of the website. These cookies do not store any personal information.
Non-necessary
Any cookies that may not be particularly necessary for the website to function and is used specifically to collect user personal data via analytics, ads, other embedded contents are termed as non-necessary cookies. It is mandatory to procure user consent prior to running these cookies on your website.
GUARDAR Y ACEPTAR