MicroPython: introducción a MQTT en ESP32/ESP8266

En este artículo, vamos a explorar cómo utilizar MicroPython para implementar el protocolo MQTT en los microcontroladores ESP32/ESP8266. MQTT es un protocolo de mensajería ligero y eficiente que se utiliza comúnmente en sistemas de IoT para la comunicación entre dispositivos. Aprenderemos paso a paso cómo configurar la conexión MQTT en nuestros microcontroladores y cómo enviar y recibir mensajes de manera sencilla y efectiva. ¡Sigue leyendo para descubrir cómo llevar tus proyectos de IoT al siguiente nivel con MicroPython y MQTT!

En este tutorial, le mostraremos cómo usar MQTT para intercambiar datos entre dos placas ESP32/ESP8266 que ejecutan firmware MicroPython. Como ejemplo, intercambiamos mensajes de texto simples entre dos placas ESP. La idea es utilizar los conceptos aprendidos aquí para intercambiar valores o comandos de sensores.

MicroPython: introducción a MQTT en ESP32/ESP8266

nota: este tutorial Es compatible tanto con el ESP32 como con el ESP8266. Tableros de desarrollo.

requisitos

Antes de continuar con este tutorial, asegúrese de que se cumplan los siguientes requisitos previos:

Firmware de MicroPython

Para programar ESP32 y ESP8266 con MicroPython, utilizamos uPyCraft IDE como entorno de programación. Siga los siguientes tutoriales para instalar uPyCraft IDE y actualizar el firmware MicroPython en su placa:

  • Instale uPyCraft IDE: PC con Windows, MacOS X o Linux Ubuntu
  • Flashear/cargar firmware MicroPython a ESP32 y ESP8266

corredor MQTT

MicroPython: introducción a MQTT en ESP32/ESP8266

Para utilizar MQTT necesita un corredor. Usamos corredor de mosquitos instalado en una Raspberry Pi. Lea cómo instalar Mosquitto Broker en Raspberry Pi.

Si no está familiarizado con MQTT, asegúrese de leer nuestro tutorial introductorio: ¿Qué es MQTT y cómo funciona?

Piezas requeridas

Para este tutorial necesitarás dos placas ESP32 o dos ESP8266:

También necesitas una Raspberry Pi y los siguientes accesorios:

Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!

MicroPython: introducción a MQTT en ESP32/ESP8266

Descripción del proyecto

Aquí hay una descripción general de alto nivel del proyecto que construiremos:

MicroPython: introducción a MQTT en ESP32/ESP8266
  • ESP#1 publica noticias sobre el Hola Tema. Publica un mensaje “Hola” seguido de un contador (Hola 1, Hola 2, Hola 3,…). Publica un nuevo mensaje cada 5 segundos.
  • ESP#1 está suscrito a notificación Tema sobre cómo recibir notificaciones de la placa ESP#2.
  • ESP#2 está suscrito a Hola Tema. ESP #1 publicado en este tema. Por lo tanto, ESP#2 recibe mensajes ESP#1.
  • Cuando ESP#2 recibe los mensajes, envía un mensaje que dice «recibido». Este mensaje estará en el notificación Tema. ESP#1 está suscrito a este tema y por lo tanto recibe el mensaje.

Preparar ESP#1

Empecemos a preparar el ESP No. 1:

  • Está suscrito al notificación Tema
  • Se publicó en el Hola Tema

Importando la biblioteca umqttsimple

Para usar MQTT con ESP32/ESP8266 y MicroPython necesita el umqttsimple Biblioteca.

1. Crea un nuevo archivo presionando archivo nuevo Botón.

MicroPython: introducción a MQTT en ESP32/ESP8266

2. Entendido umqttsimple Código de biblioteca en él. Puedes hacer click en el umqttsimple Código de biblioteca en el siguiente enlace:

3. Guarde el archivo presionando Ahorrar Botón.

MicroPython: introducción a MQTT en ESP32/ESP8266

4. Nombra este nuevo archivo “umqttsimple.py» y presione DE ACUERDO.

MicroPython: introducción a MQTT en ESP32/ESP8266

5. presione eso Descargar y ejecutar Botón.

MicroPython: introducción a MQTT en ESP32/ESP8266

6. El archivo debe guardarse en el Dispositivo Carpeta llamada “umqttsimple.py“, como se destaca en la imagen a continuación.

MicroPython: introducción a MQTT en ESP32/ESP8266

Ahora puede utilizar las funciones de la biblioteca en su código importando la biblioteca.

arranque.py

Abre esto arranque.py archivo y copie el siguiente código en ESP#1.

# Complete project details at https://RandomNerdTutorials.com

import time
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
esp.osdebug(None)
import gc
gc.collect()

ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'
mqtt_server="REPLACE_WITH_YOUR_MQTT_BROKER_IP"
mqtt_user="REPLACE_WITH_YOUR_MQTT_USERNAME"
mqtt_pass="REPLACE_WITH_YOUR_MQTT_PASSWORD"

#EXAMPLE IP ADDRESS
#mqtt_server="192.168.1.144"
client_id = ubinascii.hexlify(machine.unique_id())
topic_sub = b'notification'
topic_pub = b'hello'

last_message = 0
message_interval = 5
counter = 0

station = network.WLAN(network.STA_IF)

station.active(True)
station.connect(ssid, password)

while station.isconnected() == False:
  pass

print('Connection successful')
print(station.ifconfig())

Ver código sin formato

Cómo funciona el código

Debe importar todas las siguientes bibliotecas:

import time
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp

Establezca la depuración en «Ninguno» y habilite el recolector de basura.

esp.osdebug(None)
import gc
gc.collect()

En las siguientes variables debe ingresar sus credenciales de red, la dirección IP de su corredor, el nombre de usuario del corredor y la contraseña correspondiente.

ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'
mqtt_server="REPLACE_WITH_YOUR_MQTT_BROKER_IP"
mqtt_user="REPLACE_WITH_YOUR_MQTT_USERNAME"
mqtt_pass="REPLACE_WITH_YOUR_MQTT_PASSWORD"

Por ejemplo, la dirección IP de nuestro corredor es: 192.168.1.144.

Nota: Lea este tutorial para aprender cómo obtener la dirección IP de su corredor.

Para crear un cliente MQTT necesitamos obtener el ID ESP único. Esto lo hacemos en la siguiente línea (estará en la Identificación del cliente Variable).

client_id = ubinascii.hexlify(machine.unique_id())

A continuación, escriba el tema al que ESP#1 está suscrito y el tema al que publicará mensajes:

topic_sub = b'notification'
topic_pub = b'hello'

Luego cree las siguientes variables:

last_message = 0
message_interval = 5
counter = 0

El Ultimo mensaje La variable contiene la hora en la que se envió un mensaje por última vez. Intervalo de mensajes es el tiempo entre cada mensaje enviado. Aquí lo configuramos en 5 segundos (eso significa que se enviará un mensaje nuevo cada 5 segundos). El Cambiar La variable es simplemente un contador agregado al mensaje.

Posteriormente, realizamos los trámites de conexión a la red.

station = network.WLAN(network.STA_IF)

station.active(True)
station.connect(ssid, password)

while station.isconnected() == False:
  pass

print('Connection successful')
print(station.ifconfig())

principal.py

En el principal.py En este archivo escribimos el código para publicar y recibir los mensajes. Copia el siguiente código en el tuyo. principal.py Archivo.

# Complete project details at https://RandomNerdTutorials.com

def sub_cb(topic, msg):
  print((topic, msg))
  if topic == b'notification' and msg == b'received':
    print('ESP received hello message')

def connect_and_subscribe():
  global client_id, mqtt_server, topic_sub
  client = MQTTClient(client_id, mqtt_server, user=mqtt_user, password=mqtt_pass)
  client.set_callback(sub_cb)
  client.connect()
  client.subscribe(topic_sub)
  print('Connected to %s MQTT broker, subscribed to %s topic' % (mqtt_server, topic_sub))
  return client

def restart_and_reconnect():
  print('Failed to connect to MQTT broker. Reconnecting...')
  time.sleep(10)
  machine.reset()

try:
  client = connect_and_subscribe()
except OSError as e:
  restart_and_reconnect()

while True:
  try:
    client.check_msg()
    if (time.time() - last_message) > message_interval:
      msg = b'Hello #%d' % counter
      client.publish(topic_pub, msg)
      last_message = time.time()
      counter += 1
  except OSError as e:
    restart_and_reconnect()

Ver código sin formato

Así es como funciona el código

Lo primero que debes hacer es crear una función de devolución de llamada que se ejecutará cuando se publique un mensaje en un tema al que el ESP esté suscrito.

Función de devolución de llamada

La función de devolución de llamada debe aceptar el tema y el mensaje como parámetros.

def sub_cb(topic, msg):
  print((topic, msg))
  if topic == b'notification' and msg == b'received':
    print('ESP received hello message')

En nuestra función de devolución de llamada, primero imprimimos el tema y el mensaje. Luego comprobamos si el mensaje está en el notificación Tema y si el contenido del mensaje es “recibido”. Si esta declaración if es Verdadera, significa que ESP#2 ha recibido el mensaje «Hola» enviado por ESP#1.

Básicamente, esta función de devolución de llamada regula lo que sucede cuando se recibe un mensaje específico sobre un tema específico.

Conéctate y suscríbete

Entonces tenemos eso conectar_y_suscribir() Función. Esta función es responsable de conectarse al corredor y de suscribirse a un tema.

def connect_and_subscribe():

Comience explicando el Identificación del cliente, servidor_mqtt Y Tema_Sub Variables como variables globales. De esta forma podremos acceder a estas variables a lo largo de nuestro código.

global client_id, mqtt_server, topic_sub

Luego crea uno Cliente MQTT Objeto nombrado cliente. Tenemos que pasar el como parámetro. Identificación del clientela dirección IP del corredor MQTT (servidor_mqtt), así como el nombre de usuario y contraseña del broker. Estas variables se registraron en el arranque.py Archivo.

client = MQTTClient(client_id, mqtt_server, user=mqtt_user, password=mqtt_pass)

Luego configure la función de devolución de llamada al cliente (sub_cb).

client.set_callback(sub_cb)

A continuación, conecte el cliente al corredor a través del conectar() método en el Cliente MQTT Objeto.

client.connect()

Después de la conexión nos suscribimos. Tema_Sub Tema. Selecciona el Tema_Sub sobre el arranque.py archivo (notificación).

client.subscribe(topic_sub)

Finalmente, imprima un mensaje y devuelva al cliente:

print('Connected to %s MQTT broker, subscribed to %s topic' % (mqtt_server, topic_sub))
return client

Reiniciar y volver a conectar

Creamos una función llamada Reiniciar y volver a conectar(). Esta función se llama cuando ESP32 o ESP8266 no pueden conectarse al corredor.

Esta función genera un mensaje de que la conexión no fue exitosa. Esperamos 10 segundos. Luego reseteamos el ESP con eso restablecen a los predeterminados() Método.

def restart_and_reconnect():
  print('Failed to connect to MQTT broker. Reconnecting...')
  time.sleep(10)
  machine.reset()

Recibir y publicar mensajes

Hasta ahora hemos creado funciones para manejar tareas relacionadas con la comunicación MQTT. De ahora en adelante, el código llama a estas funciones para que las cosas sucedan.

Lo primero que debemos hacer es conectarnos al broker MQTT y suscribirnos a un tema. Así que creemos un cliente usando el conectar_y_suscribir() Función.

try:
  client = connect_and_subscribe()

En caso de que no podamos conectarnos al broker MQTTT, reiniciamos el ESP usando el Reiniciar y volver a conectar() función

except OSError as e:
  restart_and_reconnect()

En el bucle while recibimos y publicamos los mensajes. Usamos intentar Y excepto Instrucciones para evitar que el ESP se bloquee si algo sale mal.

Dentro de intentar Block, comencemos aplicando el check_msg() método en el cliente.

try:
  client.check_msg()

El check_msg() El método comprueba si hay un mensaje pendiente disponible en el servidor. Espera un único mensaje MQTT entrante y lo procesa. Los mensajes suscritos se entregan a la función de devolución de llamada previamente definida (la sub_cb() Función). Si no hay ningún mensaje pendiente, regresa con Ninguno.

Luego insertamos Si Instrucciones para comprobar si 5 segundos (Intervalo de mensajes) han pasado desde que se envió el último mensaje.

if (time.time() - last_message) > message_interval:

Cuando llega el momento de enviar un nuevo mensaje, creamos uno Noticias Variable con el texto “Hola” seguido de un contador.

msg = b'Hello #%d' % counter

Para publicar un mensaje sobre un tema específico, sólo necesita publicar() método en el cliente y pasar el tema y el mensaje como argumentos. tema_pub La variable se estableció en Hola en el arranque.py Archivo.

client.publish(topic_pub, msg)

Después de enviar el mensaje, actualizamos la hora del último mensaje recibido por el Ultimo mensaje Variable a la hora actual.

last_message = time.time()

Finalmente aumentamos el Cambiar variable en cada bucle.

counter += 1

Si sucede algo inesperado, los llamamos Reiniciar y volver a conectar() Función.

except OSError as e:
  restart_and_reconnect()

Eso es todo para ESP#1. Recuerde que debe cargar todos los siguientes archivos para que el proyecto funcione (debe cargar los archivos en el orden correcto):

  1. umqttsimple.py;
  2. arranque.py;
  3. principal.py.

Después de cargar todos los archivos, debería recibir mensajes de éxito sobre cómo establecer una conexión de red, conectarse al corredor y suscribirse al tema.

ESP #2

Ahora preparemos ESP#2:

  • Está suscrito al Hola Tema
  • Se publicó en el notificación Tema

Al igual que con ESP#1, también tienes que hacer esto aquí umqttsimple.py, arranque.pyY principal.py archivos.

importar umqttsimple

Para usar MQTT con ESP32/ESP8266 y MicroPython necesita el umqttsimple Biblioteca. Siga los pasos descritos anteriormente para umqttsimple Biblioteca en ESP#2.

Puede acceder al código de la biblioteca umqttsimple en el siguiente enlace:

arranque.py

Copie el siguiente código en ESP#2 arranque.py Archivo.

# Complete project details at https://RandomNerdTutorials.com

import time
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
esp.osdebug(None)
import gc
gc.collect()

ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'
mqtt_server="REPLACE_WITH_YOUR_MQTT_BROKER_IP"
mqtt_user="REPLACE_WITH_YOUR_MQTT_USERNAME"
mqtt_pass="REPLACE_WITH_YOUR_MQTT_PASSWORD"

#EXAMPLE IP ADDRESS
#mqtt_server="192.168.1.144"
client_id = ubinascii.hexlify(machine.unique_id())
topic_sub = b'hello'
topic_pub = b'notification'

station = network.WLAN(network.STA_IF)

station.active(True)
station.connect(ssid, password)

while station.isconnected() == False:
  pass

print('Connection successful')
print(station.ifconfig())

Ver código sin formato

Este código es muy similar al anterior. arranque.py Archivo. Debe reemplazar las siguientes variables con sus credenciales de red, dirección IP del corredor, nombre de usuario del corredor y contraseña del corredor.

ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'
mqtt_server="REPLACE_WITH_YOUR_MQTT_BROKER_IP"
mqtt_user="REPLACE_WITH_YOUR_MQTT_USERNAME"
mqtt_pass="REPLACE_WITH_YOUR_MQTT_PASSWORD"

La única diferencia es que nos adherimos a las Hola Tema y publicación en el notificación Tema.

topic_sub = b'hello'
topic_pub = b'notification'

principal.py

Copie el siguiente código en ESP#2 principal.py Archivo.

# Complete project details at https://RandomNerdTutorials.com

def sub_cb(topic, msg):
  print((topic, msg))

def connect_and_subscribe():
  global client_id, mqtt_server, topic_sub
  client = MQTTClient(client_id, mqtt_server, user=mqtt_user, password=mqtt_pass)
  client.set_callback(sub_cb)
  client.connect()
  client.subscribe(topic_sub)
  print('Connected to %s MQTT broker, subscribed to %s topic' % (mqtt_server, topic_sub))
  return client

def restart_and_reconnect():
  print('Failed to connect to MQTT broker. Reconnecting...')
  time.sleep(10)
  machine.reset()

try:
  client = connect_and_subscribe()
except OSError as e:
  restart_and_reconnect()

while True:
  try:
    new_message = client.check_msg()
    if new_message != 'None':
      client.publish(topic_pub, b'received')
    time.sleep(1)
  except OSError as e:
    restart_and_reconnect()

Ver código sin formato

Este código es muy similar a ese. principal.py de ESP#1. nosotros los creamos sub_cb()El conectar_y_suscribir() y eso Reiniciar y volver a conectar() Características. Esta vez sub_cb() La función solo imprime información sobre el tema y el mensaje recibido.

def sub_cb(topic, msg):
  print((topic, msg))

En el bucle while comprobamos si hemos recibido un mensaje nuevo y lo guardamos en el nuevo mensaje Variable.

new_message = client.check_msg()

Cuando recibamos un mensaje nuevo, publicaremos un mensaje «recibido» en el Tema_Sub Tema (en este caso lo configuramos notificación en el arranque.py Archivo).

if new_message != 'None':
  client.publish(topic_pub, b'received')

Eso es todo para ESP#2. Recuerde que debe cargar todos los siguientes archivos para que el proyecto funcione (debe cargar los archivos en el orden correcto):

  1. umqttsimple.py;
  2. arranque.py;
  3. principal.py.

El ESP32/ESP8266 debería establecer una conexión de red y conectarse exitosamente al corredor.

demostración

Una vez que haya cargado todos los scripts necesarios en ambas placas ESP y que ambas placas y la Raspberry Pi se estén ejecutando con el corredor Mosquitto, puede probar la configuración.

ESP#2 debería recibir los mensajes «Hola» de ESP#1 como se muestra en la siguiente figura.

MicroPython: introducción a MQTT en ESP32/ESP8266

Por otro lado, la placa ESP#1 debería recibir el mensaje “Recibido”. El mensaje «Recibido» es enviado por ESP#2 en el notificación Tema. ESP#1 está suscrito a este tema y por lo tanto recibe el mensaje.

MicroPython: introducción a MQTT en ESP32/ESP8266

Envolver

En este sencillo ejemplo, aprendiste cómo intercambiar texto entre dos tarjetas ESP32/ESP8266 usando el protocolo de comunicación MQTT. La idea es utilizar los conceptos aprendidos aquí para intercambiar datos útiles como valores de sensores o comandos para controlar salidas.

Si te gusta MicroPython con ESP32/ESP8266, también te puede gustar:

  • Programación MicroPython con ESP32 y ESP8266 eBook
  • Comenzando con MicroPython en ESP32 y ESP8266
  • MicroPython con ESP32 y ESP8266: Interactuando con GPIO
  • Servidor web ESP32/ESP8266 MicroPython: salidas de control

Error 403 The request cannot be completed because you have exceeded your quota. : quotaExceeded






MicroPython: introducción a MQTT en ESP32/ESP8266

Introducción a MQTT en ESP32/ESP8266 con MicroPython

En este tutorial, te mostraremos cómo utilizar MQTT para intercambiar datos entre dos placas ESP32/ESP8266 utilizando el firmware de MicroPython. Como ejemplo, intercambiaremos mensajes de texto simples entre dos placas ESP. La idea es utilizar los conceptos aprendidos aquí para intercambiar lecturas de sensores o comandos.

Requisitos previos

  1. Firmware de MicroPython
  2. Broker MQTT
  3. Partes requeridas

Firmware de MicroPython

Para programar el ESP32 y ESP8266 con MicroPython, utilizamos el IDE uPyCraft como entorno de programación. Sigue los siguientes tutoriales para instalar el IDE uPyCraft y flashear el firmware de MicroPython en tu placa:

Instalar uPyCraft IDE: Windows PC, MacOS X, o Linux Ubuntu

Flash/Subir Firmware de MicroPython a ESP32 y ESP8266

Broker MQTT

Para utilizar MQTT, necesitas un broker. En este caso, utilizaremos el broker Mosquitto instalado en una Raspberry Pi. Lee Cómo Instalar el Broker Mosquitto en Raspberry Pi.

Si no estás familiarizado con MQTT, asegúrate de leer nuestro tutorial introductorio: Qué es MQTT y cómo funciona.

Partes Requeridas

Para este tutorial necesitas dos placas ESP32 o dos placas ESP8266:

  • 2x Placas ESP32 DEVKIT DOIT
  • 2x Kits ESP8266-12E NodeMCU

También necesitarás una Raspberry Pi y los siguientes accesorios:

  • Placa Raspberry Pi
  • Tarjeta MicroSD – 32GB Class 10
  • Fuente de Alimentación para Raspberry Pi (5V 2.5A)

Puedes usar los enlaces anteriores o ir directamente a MakerAdvisor.com/tools para encontrar todas las partes para tus proyectos al mejor precio.

Vista general del proyecto

A continuación, una descripción general del proyecto que construiremos:

ESP#1 publica mensajes en el tema ‘hello’. Publica un mensaje «Hello» seguido de un contador (Hello 1, Hello 2, Hello 3, …). Publica un nuevo mensaje cada 5 segundos.

ESP#1 está suscrito al tema de notificación para recibir notificaciones de la placa ESP#2.

ESP#2 está suscrito al tema ‘hello’. ESP#1 está publicando en este tema. Por lo tanto, ESP#2 recibe los mensajes de ESP#1.

Cuando ESP#2 recibe los mensajes, envía un mensaje diciendo ‘recibido’. Este mensaje se publica en el tema de notificación. ESP#1 está suscrito a ese tema, por lo que recibe el mensaje.

4 comentarios en «MicroPython: introducción a MQTT en ESP32/ESP8266»

Deja un comentario