Cómo usar MQTT con Raspberry Pi y ESP8266: 8 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

En este Instructable, explicaré qué es el protocolo MQTT y cómo se usa para comunicarse entre dispositivos. Luego, como demostración práctica, le mostraré cómo configurar un sistema simple de dos clientes, donde un módulo ESP8266 enviará un mensaje a un programa de Python cuando se presiona un botón. Específicamente, estoy usando un módulo Adafruit HUZZAH para este proyecto, una Raspberry Pi y una computadora de escritorio. La Raspberry Pi actuará como el intermediario MQTT y el cliente Python se ejecutará desde una computadora de escritorio separada (opcional, ya que esto podría ejecutarse en la Raspberry Pi).

Para seguir este Instructable, deberá tener algunos conocimientos básicos de electrónica y cómo usar el software Arduino. También debe estar familiarizado con el uso de una interfaz de línea de comandos (para Raspberry Pi). Con suerte, una vez que haya adquirido el conocimiento de lo que es MQTT y cómo usarlo en un escenario básico, podrá crear sus propios proyectos de IoT.

Partes requeridas

• 1 x Raspberry Pi, conectado a una red local (ejecutando Jessie)
• 1 x Módulo ESP8266 (Adafruit HUZZAH)
• 1 x tablero
• 3 x cables de puente (macho a macho)
• 1 x pulsador
• 1 resistencia de 10 k ohmios (código de color marrón-negro-naranja)

He creado este Instructable, ya que MQTT siempre me ha interesado como protocolo y hay muchas formas diferentes de utilizarlo. Sin embargo, parecía que no podía entender cómo codificar dispositivos para usarlo. Esto se debió a que no sabía / no entendía lo que estaba sucediendo realmente con mi "¡Hola, mundo!" desde el dispositivo A y enviarlo al dispositivo B. Por lo tanto, decidí escribir este Instructable para (con suerte) enseñarle cómo funciona, ¡y también para reforzar mi propia comprensión del mismo!

Paso 1: ¿Qué es MQTT?

MQTT, o MQ Telemetry Transport, es un protocolo de mensajería que permite que varios dispositivos se comuniquen entre sí. Actualmente, es un protocolo popular para Internet de las cosas, aunque se ha utilizado para otros fines, por ejemplo, Facebook Messenger. Curiosamente, MQTT se inventó en 1999, lo que significa que es tan antiguo como yo.

MQTT se basa en la idea de que los dispositivos pueden publicar o suscribirse a temas. Así por ejemplo. Si el Dispositivo # 1 ha registrado la temperatura de uno de sus sensores, puede publicar un mensaje que contenga el valor de temperatura que registró, en un tema (por ejemplo, "Temperatura"). Este mensaje se envía a un agente MQTT, que puede considerar como un conmutador / enrutador en una red de área local. Una vez que MQTT Broker haya recibido el mensaje, lo enviará a cualquier dispositivo (en este caso, Dispositivo # 2) que esté suscrito al mismo tema.

En este proyecto, publicaremos en un tema usando un ESP8266 y crearemos un script Python que se suscribirá a este mismo tema, a través de una Raspberry Pi que actuará como Broker MQTT. Lo bueno de MQTT es que es liviano, por lo que es perfecto para ejecutarlo en microcontroladores pequeños como un ESP8266, pero también está ampliamente disponible, por lo que también podemos ejecutarlo en un script de Python.

Con suerte, al final de este proyecto, comprenderá qué es MQTT y cómo usarlo para sus propios proyectos en el futuro.

Paso 2: Instalar MQTT Broker en Raspberry Pi

Para configurar nuestro sistema MQTT, necesitamos un corredor, como se explicó en el paso anterior. Para la Raspberry Pi, usaremos el broker MQTT "Mosquitto". Antes de instalar esto, siempre es mejor actualizar nuestra Raspberry Pi.

sudo apt-get update

sudo apt-get upgrade

Una vez hecho esto, instale mosquitto y luego los paquetes mosquitto-clients.

sudo apt-get install mosquitto -y

sudo apt-get install mosquitto-clients -y

Cuando haya terminado de instalar estos dos paquetes, necesitaremos configurar el intermediario. El archivo de configuración del broker mosquitto se encuentra en /etc/mosquitto/mosquitto.conf, así que ábralo con su editor de texto favorito. Si no tiene un editor de texto favorito o no sabe cómo usar ninguno de los editores de línea de comandos, usaré nano para que pueda seguir:

sudo nano /etc/mosquitto/mosquitto.conf

En la parte inferior de este archivo, debería ver la línea:

include_dir /etc/mosquitto/conf.d

Elimina esta línea. Agregue las siguientes líneas al final del archivo.

allow_anonymous falso

archivo_contraseña / etc / mosquitto / pwfile listener 1883

Al escribir esas líneas, le hemos dicho a mosquitto que no queremos que nadie se conecte a nuestro corredor que no proporcione un nombre de usuario y contraseña válidos (lo configuraremos en un segundo) y que queremos que mosquitto Escuche mensajes en el puerto número 1883.

Si no desea que el corredor requiera un nombre de usuario y contraseña, no incluya las dos primeras líneas que agregamos (es decir, allow_anonymous … y password_file …). Si ha hecho esto, continúe con el reinicio de la Raspberry Pi.

Ahora cierre (y guarde) ese archivo. Si está siguiendo el ejemplo de nano, presione CTRL + X y escriba Y cuando se le solicite.

Debido a que acabamos de decirle a mosquitto que los usuarios que intentan utilizar el agente MQTT deben estar autenticados, ¡ahora debemos decirle a mosquitto cuál es el nombre de usuario y la contraseña! Por lo tanto, escriba el siguiente comando, reemplazando el nombre de usuario con el nombre de usuario que le gustaría, luego ingrese la contraseña que le gustaría cuando se le solicite (Nota: si, al editar el archivo de configuración, especificó una ruta de acceso de password_file diferente, reemplace la ruta a continuación con la uno que usaste).

sudo mosquitto_passwd -c / etc / mosquitto / pwfile nombre de usuario

Como acabamos de cambiar el archivo de configuración de mosquitto, deberíamos reiniciar la Raspberry Pi.

sudo reiniciar

Una vez que la Raspberry Pi haya terminado de reiniciarse, ¡debería tener un bróker MQTT en pleno funcionamiento! A continuación, vamos a intentar interactuar con él, ¡utilizando varios dispositivos / métodos diferentes!

Paso 3: probar el corredor

Una vez que haya instalado mosquitto en la Raspberry Pi, puede realizar una prueba rápida, solo para asegurarse de que todo funcione correctamente. Para ello, existen dos comandos que podemos usar en la línea de comandos. mosquitto_pub y mosquitto_sub. En este paso, lo guiaré a través del uso de cada uno de estos para probar nuestro corredor.

Para probar el corredor, deberá abrir dos ventanas de línea de comando. Si está utilizando Putty u otro cliente SSH, esto es tan simple como abrir otra ventana SSH e iniciar sesión como de costumbre. Si accede a su Pi desde un terminal UNIX, esto es exactamente lo mismo. Si está utilizando la Raspberry Pi directamente, deberá abrir dos ventanas de terminal en el modo GUI (el comando startx se puede usar para iniciar la GUI).

Ahora que ha abierto dos ventanas, podemos comenzar con la prueba. En uno de los dos terminales, escriba el siguiente comando, reemplazando el nombre de usuario y la contraseña con los que configuró en el paso anterior.

mosquitto_sub -d -u nombre de usuario -P contraseña -t prueba

Si decidió no establecer un nombre de usuario y contraseña en el paso anterior, a partir de ahora, ignore los indicadores -u y -P en los comandos. Entonces, como ejemplo, el comando mosquitto_sub ahora sería:

mosquitto_sub -d -t prueba

El comando mosquitto_sub se suscribirá a un tema y mostrará cualquier mensaje que se envíe al tema especificado en la ventana de la terminal. Aquí, -d significa modo de depuración, por lo que todos los mensajes y la actividad se mostrarán en la pantalla. -u y -P deben explicarse por sí mismos. Finalmente, -t es el nombre del tema al que queremos suscribirnos, en este caso, "prueba".

A continuación, en la otra ventana de terminal, intentaremos publicar un mensaje en el tema "prueba". Escriba lo siguiente, recordando nuevamente cambiar el nombre de usuario y la contraseña:

mosquitto_pub -d -u nombre de usuario -P contraseña -t prueba -m "¡Hola, mundo!"

Cuando presiona enter, debería ver su mensaje "¡Hola, mundo!" aparecen en la primera ventana de terminal que usamos (para suscribirse). Si este es el caso, ¡está listo para comenzar a trabajar en el ESP8266!

Paso 4: Configuración del ESP8266 (Adafruit HUZZAH)

Este paso es específico para Adafruit HUZZAH (ya que eso es lo que estoy usando para completar este proyecto). Si está utilizando un dispositivo Arduino / ESP8266 diferente, es posible que desee omitir este paso. Sin embargo, le aconsejo que lo lea brevemente, en caso de que haya alguna información aquí que pueda ser relevante para usted.

Para este proyecto, voy a programar el HUZZAH con el software Arduino. Entonces, si aún no lo ha hecho, asegúrese de instalar el software Arduino (más reciente que 1.6.4). Puedes descargarlo aquí.

Una vez que haya instalado el software Arduino, ábralo y navegue hasta Archivo-> Preferencias. Aquí debería ver (cerca de la parte inferior de la ventana) un cuadro de texto con la etiqueta: "URL adicionales del administrador de tableros". En este cuadro de texto, copie y pegue el siguiente enlace:

arduino.esp8266.com/stable/package_esp8266com_index.json

Haga clic en Aceptar para guardar sus cambios. Ahora abra Board Manager (Herramientas-> Board-> Board Manager) y busque ESP8266. Instale el paquete comunitario esp8266 by ESP8266. Reinicie el software Arduino.

Ahora, antes de que podamos programar la placa, debemos seleccionar algunas opciones diferentes. En la opción de menú Herramientas, seleccione Adafruit HUZZAH ESP8266 para Placa, 80 MHz para la Frecuencia de CPU (puede usar 160 MHz si desea overclockearlo, pero por ahora voy a usar 80 MHz), 4M (3M SPIFFS) para el tamaño de Flash y 115200 para la velocidad de carga. Además, asegúrese de seleccionar el puerto COM que está utilizando (esto dependerá de su configuración).

Antes de que pueda cargar cualquier código, debe asegurarse de que HUZZAH esté en modo de cargador de arranque. Para habilitar esto, mantenga presionado el botón en la placa marcado GPIO0, y mientras lo mantiene presionado, mantenga presionado el botón Reset también. Luego, suelte el botón Reset y luego GPIO0. Si ha hecho esto correctamente, el LED rojo que se encendió cuando presionó GPIO0 ahora debería estar débilmente iluminado.

Para cargar el código en el microcontrolador, primero asegúrese de que el HUZZAH esté en modo de cargador de arranque, luego simplemente haga clic en el botón de carga en el IDE de Arduino.

Si tiene problemas para configurar HUZZAH, puede encontrar más información en el propio tutorial de Adafruit.

Paso 5: Programación del ESP8266

Ahora comenzaremos a programar el ESP8266, pero antes de que podamos comenzar, deberá instalar las siguientes bibliotecas en el administrador de bibliotecas de Arduino (Sketch-> Incluir bibliotecas-> Administrar bibliotecas)

• Rebote2
• PubSubClient

Una vez que haya instalado esas bibliotecas, podrá ejecutar el código que he incluido en este Instructable (MQTT_Publish.zip). Me aseguré de comentarlo para que pueda comprender lo que hace cada sección, y esto debería permitirle adaptarlo a sus necesidades.

Recuerde cambiar las constantes en la parte superior del código para que su ESP8266 pueda conectarse a su red WiFi y su MQTT Broker (la Raspberry Pi).

Si decidió no establecer un nombre de usuario y contraseña para MQTT Broker, descargue el archivo MQTT_PublishNoPassword.zip en su lugar.

Paso 6: Instalación del cliente Python (paho-mqtt)

¡Afortunadamente, este paso es muy simple! Para instalar el cliente mosquitto python, solo necesita escribir lo siguiente en la línea de comando (Linux / Mac) o incluso en el símbolo del sistema (Windows).

pip instalar paho-mqtt

Nota: el símbolo del sistema de Windows puede tener un problema al ejecutar el comando pip si no especificó que deseaba instalar pip y agregar python a su variable PATH cuando instaló Python. Hay varias formas de solucionar este problema, pero creo que simplemente reinstalar Python es la forma más fácil. En caso de duda, ¡dale un google!

Paso 7: Cliente Python - Suscripción

En este paso, vamos a configurar el script de Python (ya sea en la propia Raspberry Pi o en otra computadora conectada a la red) para manejar todos los mensajes que envía (publica) el ESP8266 al tema MQTT.

He incluido el código de Python a continuación (PythonMQTT_Subscribe.py), que se ha comentado para ayudarlo a comprender lo que está sucediendo, pero también explicaré algunas de las características principales aquí.

Si no estableció un nombre de usuario y contraseña para la conexión MQTT anteriormente, descargue el archivo PythonMQTT_SubscribeNoPassword.py en su lugar.

Paso 8: comunicación entre dispositivos ESP8266

Si desea configurar una red de IoT, por ejemplo, es posible que desee comunicarse entre dispositivos ESP8266. Afortunadamente, esto no es mucho más complejo que el código que hemos escrito antes, sin embargo, hay un par de cambios notables.

Para que un ESP envíe datos a otro, el primer ESP deberá publicar en el tema y el segundo ESP deberá suscribirse a ese tema. Esta configuración permitirá una conversación unidireccional: ESP (1) a ESP (2). Si queremos que ESP (2) responda a ESP (1), podemos crear un nuevo tema, al que ESP (2) publicará y ESP (1) se suscribirá. Afortunadamente, podemos tener varios suscriptores sobre el mismo tema, por lo que si desea enviar datos a varios sistemas, solo necesitará un tema (al que todos se suscriben, excepto el dispositivo que envía los datos, ya que estar publicando).

Si necesita ayuda para averiguar qué debe hacer cada dispositivo, piense en el sistema como una sala de personas. Si ESP (1) está publicando, puede imaginar este dispositivo como un "altavoz", y cualquier dispositivo que se suscriba al tema será "oyente" en este ejemplo.

He incluido un código de ejemplo a continuación, que demuestra cómo un ESP8266 puede suscribirse a un tema y escuchar ciertos mensajes: 1 y 0. Si se recibe 1, el LED integrado (para HUZZAH - GPIO 0) se enciende. Si se recibe 0, este LED se apaga.

Si desea procesar datos más complejos, debe hacerlo en la función ReceivedMessage (ver código).

Para sus propios proyectos, si necesita enviar y recibir datos, puede incorporar la función de publicación del ejemplo anterior en el código incluido en este paso. Esto debe manejarse en la función principal de Arduino loop ().

¡Recuerde cambiar las variables en la parte superior del código para que se adapten a su red!