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 jqNuestro 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.confY 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 trueReiniciamos 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
doneLo convertimos en ejecutable con:
chmod +x /root/escucha.shAhora haremos que el script se ejecute al iniciar el router. Para ello hacemos:
nano /etc/init.d/escuchay 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 -yUna vez instalamos verificamos que el esp32 está enviando datos al servidor de mosquitto:
mosquitto_sub -h "ip_del_servidor" -t "#" -vSi 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 stopLo arrancamos con lo siguiente para visualizar las conexiones:
mosquitto -c /etc/mosquitto/mosquitto.confVer 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"