Montando un gateway BLE a MQTT con ESP32 y OpenMQTTGateway con proyecto al final

 

Hace tiempo adquirí un termómetro Xiaomi (LYWSD03MMC) que utilizan BLE (Bluetooth Low Energy) para enviar las lecturas realizadas. Como quiero que los datos sean publicados en un broker MQTT, este firmware OpenMQTTGateway me hace todo el trabajo. En esta entrada veremos como instalarlo desde Linux.

Instalaremos OpenMQTTGateway en un ESP32 concretamente una placa DOIT ESP32 DEVKIT V1. Para más información y otras placas soportadas, recomiendo ir a la url OpenMQTTGateway compatible boards.

Borrar restos de programas anteriores

Antes de comenzar, es conveniente borrar lo que anteriormente tenía el dispositivo ESP32. También sirve para borrar una incorrecta configuración del dispositivo, o cuando queremos cambiar los parámetros guardados. Para ello instalaremos la herramienta esptool. Hay dso maneras una mediante pip install esptool y la otra si usas Ubuntu o derivados, con apt install esptool elige la que más te guste. Recuerda que normalmente el usuario normal de Linux no tiene acceso al envío por puerto serie por lo que es conveniente en este caso acceder con sudo.

Si instalaste el esptool con pip install ejecuta lo siguiente para borrar la configuración antigua:

sudo esptool.py --chip esp32 erase_flash

Si lo hiciste con apt install lo haces con :

sudo esptool --chip esp32 erase_flash

Ejecutaremos el comando anterior con botón boot pulsado, luego soltaremos cuando veamos que empieza el proceso. Aunque puede que no sea neserario. Pruébalo directamente y fíjate en la salida por consola.

Descargamos los siguientes binarios:

https://github.com/espressif/arduino-esp32/raw/2.0.5/tools/sdk/esp32/bin/bootloader_dio_80m.bin

https://github.com/espressif/arduino-esp32/raw/2.0.5/tools/partitions/boot_app0.bin

Estos binarios también los descargamos aunque aquí lo hacemos con la versión que actualmente es la principal, recomiendo descargarlos de la siguiente página eligiendo la última versión. Lo que sí debes buscar son los archivos:

  • esp32dev-ble-firmware.bin
  • esp32dev-ble-partitions.bin

https://github.com/1technophile/OpenMQTTGateway/releases/download/v0.9.5/esp32dev-ble-firmware.bin

https://github.com/1technophile/OpenMQTTGateway/releases/download/v0.9.5/esp32dev-ble-partitions.bin

‘Flasheando’ el dispositivo.

Para flashear el dispositivo usaremos la herramienta esptool.py. En distribuciones derivadas de Ubuntu la instalaremos con:

pip install esptool o apt install esptool según vimos en el apartado anterior.

Ejecutaremos el siguiente comando con el botón boot del esp32 pulsado, luego soltaremos cuando veamos que empieza el proceso.

esptool.py --chip esp32 --port /dev/ttyUSB0 --baud 115200 --before default_reset --after hard_reset write_flash -z --flash_mode dio --flash_freq 80m --flash_size detect 0xe000 boot_app0.bin 0x1000 bootloader_dio_80m.bin 0x10000 esp32dev-ble-firmware.bin 0x8000 esp32dev-ble-partitions.bin

Una vez flasheado buscaremos la red wifi OpenMQTTGateway_ESP32_BLE y nos conectamos con el password wifi: your_password.

Configurando el dispositivo

Accedemos con el navegador a la ip 192.168.4.1 y configuramos a qué red wifi nos queremos conectar.

Para configurarlo pondremos como mínimo, la red WIFI a la que queremos conectarnos junto con la contraseña WIFI de dicha red y la dirección IP del servidor MQTT.

Verificando que funciona

mosquitto_sub -h "ip_del_servidor" -t "#" -v

Y vamos viendo todos los topics que va enviando.

Ojo que a lo mejor no se ve la red wifi porque necesita conectarse a un cargador de móvil.

Ejemplo de uso con termómetros Xiaomi LYWSD03MMC

Es necesario “flashear” el firmware de este dispositivo para que envíe sin cifrar la los valores de temperatura y humedad. Para ello hemos seguido el tutorial siguiente: https://github.com/atc1441/ATC_MiThermometer

Explicación de lo que haremos

En el siguiente gráfico se muestra lo que pretendemos hacer. Necesitaremos 3 Temómetros Xiaomi, un dispositivo ESP32, un router flasheado con Openwrt.

Primer paso

En un router recién flasheado con Openwrt y conectado a Internet accedemos por ssh al mismo e instalamos lo necesario.

opkg update; opkg install nano mosquitto-ssl mosquitto-client-nossl jq

Nuestro servidor de mosquitto lo configuramos para que sea pueda usar sin necesidad de contraseña y que escuche en todas las IPs del router. Además servimos por websockets en el puerto 8083.

nano /etc/mosquitto/mosquitto.conf

Y añadimos lo siguiente al principio:

bind_address 0.0.0.0
port 1883
listener 8083
protocol websockets
socket_domain ipv4
connection_messages true
log_timestamp true
allow_anonymous true

Reiniciamos el servidor de mosquitto para que cargue la nueva configuración (Por alguna razón el restart no me iba bien, por lo que lo paro y lo arranco):

/etc/init.d/mosquitto stop
/etc/init.d/mosquitto start

Creamos un archivo llamado escucha.sh en el router:

nano /root/escucha.sh

E introducimos lo siguiente:

#!/bin/sh
# Script: escucha.sh
# Lee las temperaturas del broker_input en formato json 
# y las transmite a broker_output en valores por separado.
# Configuracion del broker a escuchar 
broker_input="192.168.24.12"   # Cambialo por la IP de tu router
topic_input="home/OpenMQTTGateway_ESP32_BLE/BTtoMQTT/#"
port_input="1883"

# broker_output="broker.emqx.io"
broker_output="192.168.24.12" # Cambialo por la IP de tu router externo
port_output="1883"

topic_output="ciclo/temperatura"
topic_output1="ciclo/temperatura1"
topic_output2="ciclo/temperatura2"

MAC="A4:C1:38:xx:xx:x1" # Cambialo por las MAC de tu termometro
MAC1="A4:C1:38:xx:xx:x2" # Cambialo por las MAC1 de tu termometro
MAC2="A4:C1:38:xx:xx:x3" # Cambialo por las MAC2 de tu termometro

# Ponemos el cliente de mosquitto escuchando en el broker de entrada
mosquitto_sub -t $topic_input -h $broker_input -p $port_input| while read value; do
  
# Extraemos la temperatura "tempc" del json que nos ha llegado
  temperatura=$(echo $value | jq .tempc)
  Mac_leida=$(echo $value | jq .id)
  
# La Mac_leida tiene comillas dobles en el interior, las eliminamos con tr.
  Mac_leida=$(echo $Mac_leida | tr -d '"')

  if [ "$Mac_leida" = "$MAC" ]; then
    mosquitto_pub -t $topic_output -h $broker_output -m $temperatura -p $port_output
    echo "---$Mac_leida: $temperatura"
  fi
  if [ $Mac_leida = $MAC1 ]; then
    mosquitto_pub -t $topic_output1 -h $broker_output -m $temperatura -p $port_output
    echo "---$Mac_leida: $temperatura"
  fi
  if [ $Mac_leida = $MAC2 ]; then
    mosquitto_pub -t $topic_output2 -h $broker_output -m $temperatura -p $port_output
    echo "---$Mac_leida: $temperatura"
  fi
done

Lo convertimos en ejecutable con:

chmod +x /root/escucha.sh

Ahora haremos que el script se ejecute al iniciar el router. Para ello hacemos:

nano /etc/init.d/escucha

y metemos:

#!/bin/sh /etc/rc.common
# Example script
# Copyright (C) 2007 OpenWrt.org

START=99
STOP=15

start() {
        /root/escucha.sh &
}

stop() {
   kill -9 `ps |grep 'escucha'|grep -v grep|awk '{print $1}'`
   kill -9 `ps |grep 'mosquitto_sub'|grep -v grep|awk '{print $1}'`
}

Guardamos y le damos permiso de ejecución:

chmod +x /etc/init.d/escucha

Y haremos que arranque al encender el router con lo siguiente:

/etc/init.d/escucha enable

Segundo paso

Nos conectamos al ESP32 por wifi y configuramos los parámetros necesarios. En el servidor mqtt pondremos la ip de nuestro router. En mi caso es la 192.168.24.12 como ya vimos antes. El usuario y password lo dejamos en blanco porque no utilizaremos autenticación en nuestro dervidor mqtt.

Cuando esté todo accederás desde un ordenador con linux en el que previamente has instalado el paquete mosquitto-clients. En ubuntu y derivados sería:

sudo apt install mosquitto-clients -y

Una vez instalamos verificamos que el esp32 está enviando datos al servidor de mosquitto:

mosquitto_sub -h "ip_del_servidor" -t "#" -v

Si todo va bien veremos un montón de líneas que irán saliendo las que nos interesan son las que comienzan por:

home/OpenMQTTGateway_ESP32_BLE/BTtoMQTT/A4C138XXXXXX {"id":  "A4:C1:38:XX:XX:XX" , "na ...

Verifica que estás recibiendo los valores de temperatura correctos en esas lineas. Lo recibido es en formato json. En esa línea debe haber tempc: y hum: además de otros valores. Apunta la mac de los dispositivos que te vayan saliendo y que sean termómetros propios. Es muy fácil que aparezcan otros dispositivos del alrededor.

Las direcciones MAC de los termómetros las tienes que poner en el script que hicimos en el punto anterior.

para que funcione

Tercer paso

Ahora queda bajarnos la página web que te enlazo aquí en un archivo comprimido:

Descomprímela y abre el archivo js/config.js

Cambia en dicho archivo la dirección IP de tu servidor mosquitto (host = ‘192.168.24.12’). Es la ip que pusimos en el script dentro de broker output.

Abrimos la página index.html en nuestro navegador y esperamos a que comiencen a salir los valores de los termómetros.

Pruebas en caso de otras comprobacionesno funcionar

Ver conexiones en el servidor de mosquitto

Paramos el servidor mqtt con:

/etc/init.d/mosquitto stop

Lo arrancamos con lo siguiente para visualizar las conexiones:

mosquitto -c /etc/mosquitto/mosquitto.conf

Ver todo lo que se está publicando en el servidor

mosquitto_sub -h "ip_del_servidor" -t "#" -v

Resetear el ESP32 con configuración de fábrica

mosquitto_pub -t "home/OpenMQTTGateway_ESP32_BLE/commands/MQTTtoSYS/config" -m '{"cmd":"erase"}' -h "ip_del_servidor_mqtt_conectado"

Deja una respuesta

Tu dirección de correo electrónico no será publicada.

83 − 80 =