Python para IoT: Una Guía Completa para la Implementación de MQTT

El Mundo Conectado: Por qué los Protocolos IoT son Importantes

Vivimos en una era de conectividad sin precedentes. El Internet de las Cosas (IoT) ya no es un concepto futurista; es una realidad global, tejiendo silenciosamente una red de miles de millones de dispositivos inteligentes que monitorean nuestro entorno, automatizan nuestros hogares, optimizan nuestras industrias y agilizan nuestras ciudades. Desde un termostato inteligente en un hogar en Seúl hasta un sensor agrícola en un campo en Kenia rural, estos dispositivos están generando una cantidad colosal de datos. ¿Pero cómo se comunican entre sí y con la nube, especialmente cuando a menudo son pequeños, de baja potencia y operan en redes poco fiables? La respuesta está en protocolos de comunicación especializados.

Si bien el protocolo HTTP impulsa la mayor parte de la web que usamos a diario, a menudo es demasiado pesado y consume demasiada energía para el mundo restringido del IoT. Aquí es donde brillan los protocolos diseñados específicamente para la comunicación máquina a máquina (M2M). Entre ellos, uno ha surgido como una fuerza dominante: MQTT.

Esta guía completa está diseñada para desarrolladores, ingenieros y aficionados de todo el mundo que desean aprovechar el poder de MQTT utilizando Python, uno de los lenguajes de programación más versátiles y populares en el espacio IoT. Viajaremos desde los conceptos fundamentales de MQTT hasta la construcción de aplicaciones IoT seguras, robustas y escalables.

¿Qué es MQTT? Un Protocolo Diseñado para Restricciones

MQTT significa Message Queuing Telemetry Transport (Transporte de Telemetría de Colas de Mensajes). Fue inventado en 1999 por el Dr. Andy Stanford-Clark de IBM y Arlen Nipper de Arcom (ahora Cirrus Link) para monitorear oleoductos a través de redes satelitales poco fiables. Su historia de origen encapsula perfectamente su propósito: ser un protocolo de mensajería ligero, fiable y eficiente para dispositivos que operan bajo restricciones significativas.

El Modelo Publicar/Suscribir (Pub/Sub) Explicado

En el corazón de MQTT se encuentra el elegante patrón arquitectónico de publicar/suscribir. Esto es una diferencia fundamental con el modelo de solicitud/respuesta de HTTP con el que muchos desarrolladores están familiarizados. En lugar de que un cliente solicite directamente información a un servidor, la comunicación se desacopla.

Imagina una agencia de noticias global. Los periodistas (publicadores) no envían sus historias directamente a todos los lectores. En su lugar, envían sus historias al centro de la agencia (el broker) y las categorizan bajo temas específicos como "Política Mundial" o "Tecnología". Los lectores (suscriptores) no tienen que pedirles a los periodistas las actualizaciones; simplemente le dicen a la agencia de qué temas les interesan. La agencia luego reenvía automáticamente cualquier historia nueva sobre esos temas a los lectores interesados. Los periodistas y los lectores nunca necesitan saber de la existencia, ubicación o estado del otro.

En MQTT, este modelo desacopla el dispositivo que envía datos (publicador) del dispositivo o aplicación que los recibe (suscriptor). Esto es increíblemente potente para IoT porque:

• Desacoplamiento Espacial: El publicador y el suscriptor no necesitan conocer la dirección IP o la ubicación del otro.
• Desacoplamiento Temporal: No necesitan estar ejecutándose al mismo tiempo. Un sensor puede publicar una lectura y una aplicación puede recibirla horas después si el sistema está diseñado para ello.
• Desacoplamiento de Sincronización: Las operaciones en ambos lados no necesitan detenerse para esperar que el otro complete un intercambio de mensajes.

Componentes Clave del Ecosistema MQTT

La arquitectura MQTT se basa en algunos componentes centrales:

• Broker: El centro o servidor central. Es la oficina de correos del mundo MQTT. El broker es responsable de recibir todos los mensajes de los publicadores, filtrarlos por tema y enviarlos a los suscriptores apropiados. Los brokers populares incluyen opciones de código abierto como Mosquitto y VerneMQ, y servicios en la nube gestionados como AWS IoT Core, Azure IoT Hub y Google Cloud IoT Core.
• Cliente: Cualquier dispositivo o aplicación que se conecta al broker. Un cliente puede ser un publicador, un suscriptor, o ambos. Un sensor IoT es un cliente, y una aplicación servidor que procesa los datos del sensor también es un cliente.
• Tema: Una cadena UTF-8 que actúa como una dirección o etiqueta para los mensajes. El broker utiliza los temas para enrutar los mensajes. Los temas son jerárquicos, utilizando barras inclinadas como delimitadores, de manera similar a la ruta de un sistema de archivos. Por ejemplo, un buen tema para un sensor de temperatura en una sala de estar en un edificio en Londres podría ser: UK/London/Building-A/Floor-1/LivingRoom/Temperature.
• Payload: Este es el contenido de datos real del mensaje. MQTT es agnóstico a los datos, lo que significa que el payload puede ser cualquier cosa: una cadena simple, un entero, JSON, XML o incluso datos binarios cifrados. JSON es una opción muy común por su flexibilidad y legibilidad.

Por qué MQTT Domina la Comunicación IoT

Los principios de diseño de MQTT lo hacen excepcionalmente adecuado para los desafíos del IoT:

• Ligero: Los mensajes MQTT tienen una cabecera muy pequeña (tan solo 2 bytes), minimizando el uso de ancho de banda de la red. Esto es fundamental para dispositivos con planes celulares costosos o redes de bajo ancho de banda como LoRaWAN.
• Eficiente: La baja sobrecarga del protocolo se traduce directamente en un menor consumo de energía, lo que permite que los dispositivos alimentados por batería funcionen durante meses o incluso años.
• Fiable: Incluye funciones para garantizar la entrega de mensajes, incluso en redes poco fiables y con alta latencia. Esto se gestiona a través de niveles de Calidad de Servicio.
• Escalable: Un solo broker puede manejar conexiones de miles o incluso millones de clientes simultáneamente, lo que lo hace adecuado para implementaciones a gran escala.
• Bidireccional: MQTT permite la comunicación desde el dispositivo a la nube (telemetría) y de la nube al dispositivo (comandos), un requisito vital para controlar dispositivos de forma remota.

Comprensión de la Calidad de Servicio (QoS)

MQTT proporciona tres niveles de Calidad de Servicio (QoS) para permitir a los desarrolladores elegir el equilibrio adecuado entre fiabilidad y sobrecarga para su caso de uso específico.

• QoS 0 (Como máximo una vez): Este es un nivel de "disparar y olvidar". El mensaje se envía una vez, sin confirmación de recepción por parte del broker o del suscriptor final. Es el método más rápido pero no ofrece garantía de entrega. Caso de Uso: Datos de sensores no críticos y de alta frecuencia, como una lectura de temperatura ambiente enviada cada 10 segundos. Perder una lectura no es un problema.
• QoS 1 (Al menos una vez): Este nivel garantiza que el mensaje se entregará al menos una vez. El remitente almacena el mensaje hasta que recibe un acuse de recibo (un paquete PUBACK) del receptor. Si no se recibe ningún acuse de recibo, el mensaje se reenvía. Esto a veces puede resultar en mensajes duplicados si el acuse de recibo se pierde. Caso de Uso: Un comando para encender una luz inteligente. Necesitas estar seguro de que el comando se recibe, y recibirlo dos veces no causa daño.
• QoS 2 (Exactamente una vez): Este es el nivel más fiable pero también el más lento. Utiliza un apretón de manos de cuatro partes para garantizar que el mensaje se entregue exactamente una vez, sin duplicados. Caso de Uso: Operaciones críticas donde los duplicados podrían ser desastrosos, como una transacción financiera, un comando para dispensar una cantidad precisa de medicación, o controlar un brazo robótico en una fábrica.

Configuración de su Entorno MQTT de Python

Ahora, pasemos a la práctica. Para empezar a crear aplicaciones MQTT con Python, necesita dos cosas: una biblioteca de Python para el cliente MQTT y un broker MQTT con el que comunicarse.

Elección de una Biblioteca MQTT de Python: Paho-MQTT

La biblioteca MQTT más utilizada y madura para Python es Paho-MQTT de la Fundación Eclipse. Es una biblioteca robusta y rica en funciones que proporciona una clase de cliente para conectarse a un broker y publicar o suscribirse a temas. Instalarla es sencillo usando pip, el gestor de paquetes de Python.

Abra su terminal o símbolo del sistema y ejecute:

pip install paho-mqtt

Este único comando instala todo lo que necesita para empezar a escribir clientes MQTT en Python.

Configuración de un Broker MQTT

Tiene varias opciones de broker, desde ejecutar uno en su máquina local para desarrollo hasta usar un potente servicio en la nube para producción.

• Broker Local (para desarrollo y aprendizaje): La opción más popular para un broker local es Mosquitto, otro proyecto de Eclipse. Es ligero, de código abierto y fácil de instalar.
  • En Linux basado en Debian (como Ubuntu, Raspberry Pi OS): sudo apt-get update && sudo apt-get install mosquitto mosquitto-clients
  • En macOS (usando Homebrew): brew install mosquitto
  • En Windows: Descargue el instalador nativo del sitio web de Mosquitto.
  Una vez instalado, el broker generalmente se inicia automáticamente como un servicio. Puede usarlo apuntando sus clientes a su dirección IP local (127.0.0.1 o localhost).
• Broker Público/en la Nube (para pruebas rápidas): Para experimentos iniciales sin instalar nada, puede usar un broker público y gratuito. Dos populares son test.mosquitto.org y broker.hivemq.com. Importante: Estos son públicos y sin cifrar. No les envíe ningún dato sensible o privado. Son solo para fines de aprendizaje y prueba.

Manos a la Obra: Publicar y Suscribirse con Python

Escribamos nuestra primera aplicación MQTT de Python. Crearemos dos scripts separados: un publicador que envía mensajes y un suscriptor que los recibe. Para este ejemplo, asumiremos que está ejecutando un broker Mosquitto local.

Creación de un Publicador MQTT Sencillo (publisher.py)

Este script se conectará al broker y publicará un mensaje, "Hola, MQTT!", en el tema `python/mqtt/test` cada dos segundos.

Crea un archivo llamado `publisher.py` y agrega el siguiente código:

import paho.mqtt.client as mqtt

import time

# --- Configuración ---

BROKER_ADDRESS = "localhost" # Usa 'test.mosquitto.org' para un broker público

PORT = 1883

TOPIC = "python/mqtt/test"

# --- Callback para la conexión ---

def on_connect(client, userdata, flags, rc):

if rc == 0:

print("¡Conectado al Broker MQTT!")

else:

print(f"Fallo al conectar, código de retorno {rc}")

# --- Script principal ---

# 1. Crea una instancia de cliente

client = mqtt.Client("PublisherClient")

# 2. Asigna el callback on_connect

client.on_connect = on_connect

# 3. Conéctate al broker

client.connect(BROKER_ADDRESS, PORT, 60)

# 4. Inicia un hilo en segundo plano para el bucle de red

client.loop_start()

try:

count = 0

while True:

count += 1

message = f"Hola, MQTT! Mensaje #{count}"

# 5. Publica un mensaje

result = client.publish(TOPIC, message)

# Comprueba si la publicación fue exitosa

status = result[0]

if status == 0:

print(f"Enviado `{message}` al tema `{TOPIC}`")

else:

print(f"Fallo al enviar mensaje al tema {TOPIC}")

time.sleep(2)

except KeyboardInterrupt:

print("Publicación detenida.")

finally:

# 6. Detiene el bucle de red y se desconecta

client.loop_stop()

client.disconnect()

print("Desconectado del broker.")

Creación de un Suscriptor MQTT Sencillo (subscriber.py)

Este script se conectará al mismo broker, se suscribirá al tema `python/mqtt/test` e imprimirá cualquier mensaje que reciba.

Crea otro archivo llamado `subscriber.py`:

import paho.mqtt.client as mqtt

# --- Configuración ---

BROKER_ADDRESS = "localhost"

PORT = 1883

TOPIC = "python/mqtt/test"

# --- Funciones de Callback ---

def on_connect(client, userdata, flags, rc):

if rc == 0:

print("¡Conectado al Broker MQTT!")

# Suscríbete al tema al conectarte con éxito

client.subscribe(TOPIC)

else:

print(f"Fallo al conectar, código de retorno {rc}")

def on_message(client, userdata, msg):

# Decodifica el payload del mensaje de bytes a cadena

payload = msg.payload.decode()

print(f"Mensaje recibido: `{payload}` en el tema `{msg.topic}`")

# --- Script principal ---

# 1. Crea una instancia de cliente

client = mqtt.Client("SubscriberClient")

# 2. Asigna los callbacks

client.on_connect = on_connect

client.on_message = on_message

# 3. Conéctate al broker

client.connect(BROKER_ADDRESS, PORT, 60)

# 4. Inicia el bucle de red (llamada bloqueante)

# Esta función maneja la reconexión y el procesamiento de mensajes automáticamente.

print("El suscriptor está escuchando...")

client.loop_forever()

Ejecución del Ejemplo

1. Abre dos ventanas de terminal separadas.
2. En la primera terminal, ejecuta el script del suscriptor: python subscriber.py
3. Deberías ver el mensaje "El suscriptor está escuchando...". Ahora está esperando mensajes.
4. En la segunda terminal, ejecuta el script del publicador: python publisher.py
5. Verás al publicador enviando mensajes cada dos segundos. Al mismo tiempo, estos mensajes aparecerán en la ventana de la terminal del suscriptor.

¡Felicitaciones! Acabas de crear un sistema de comunicación MQTT completo y funcional utilizando Python.

Más allá de lo Básico: Funciones Avanzadas de Paho-MQTT

Los sistemas IoT del mundo real requieren más robustez que nuestro ejemplo simple. Exploremos algunas funciones avanzadas de MQTT que son esenciales para construir aplicaciones listas para producción.

Última Voluntad y Testamento (LWT)

¿Qué sucede si un dispositivo crítico, como una cámara de seguridad o un monitor cardíaco, se desconecta inesperadamente debido a un corte de energía o una pérdida de red? La función LWT es la solución de MQTT. Cuando un cliente se conecta, puede registrar un mensaje de "última voluntad" en el broker. Si el cliente se desconecta de manera inadecuada (sin enviar un paquete DISCONNECT), el broker publicará automáticamente este mensaje de última voluntad en su nombre a un tema especificado.

Esto es invaluable para el monitoreo del estado del dispositivo. Puede hacer que un dispositivo publique un mensaje `devices/device-123/status` con el payload `"online"` cuando se conecta, y registrar un mensaje LWT con el mismo tema pero con el payload `"offline"`. Cualquier servicio de monitoreo suscrito a este tema sabrá instantáneamente el estado del dispositivo.

Para implementar LWT en Paho-MQTT, lo establece antes de conectarse:

client.will_set('devices/device-123/status', payload='offline', qos=1, retain=True)

client.connect(BROKER_ADDRESS, PORT, 60)

Mensajes Retenidos

Normalmente, si un suscriptor se conecta a un tema, solo recibirá los mensajes que se publiquen después de que se haya suscrito. Pero, ¿y si necesita el valor más reciente de inmediato? Para eso sirven los mensajes retenidos. Cuando se publica un mensaje con el indicador `retain` establecido en `True`, el broker almacena ese mensaje para ese tema específico. Cada vez que un nuevo cliente se suscribe a ese tema, recibirá instantáneamente el último mensaje retenido.

Esto es perfecto para la información de estado. Un dispositivo puede publicar su estado (por ejemplo, `{"state": "ON"}`) con `retain=True`. Cualquier aplicación que se inicie y se suscriba sabrá inmediatamente el estado actual del dispositivo sin tener que esperar la próxima actualización.

En Paho-MQTT, simplemente agrega el indicador `retain` a su llamada de publicación:

client.publish(TOPIC, payload, qos=1, retain=True)

Sesiones Persistentes y Sesiones Limpias

El indicador `clean_session` en la solicitud de conexión del cliente controla cómo el broker maneja la sesión del cliente.

• Sesión Limpia (clean_session=True, el valor por defecto): Cuando el cliente se desconecta, el broker descarta toda la información sobre él, incluidas sus suscripciones y cualquier mensaje en cola de QoS 1 o 2. Cuando se reconecta, es como un cliente completamente nuevo.
• Sesión Persistente (clean_session=False): Cuando un cliente con un Client ID único se conecta de esta manera, el broker mantiene su sesión después de que se desconecta. Esto incluye sus suscripciones y cualquier mensaje de QoS 1 o 2 que se haya publicado mientras estaba desconectado. Cuando el cliente se reconecta, el broker envía todos los mensajes perdidos. Esto es crucial para dispositivos en redes poco fiables que no pueden permitirse perder comandos críticos.

Para establecer una sesión persistente, debe proporcionar un Client ID estable y único y establecer `clean_session=False` al crear la instancia del cliente:

client = mqtt.Client(client_id="my-persistent-device-001", clean_session=False)

La Seguridad No Es Una Opción: Asegurando MQTT con Python

En cualquier aplicación del mundo real, la seguridad es primordial. Un broker MQTT sin seguridad es una invitación abierta para que actores malintencionados espíen sus datos, envíen comandos falsos a sus dispositivos o lancen ataques de denegación de servicio. Asegurar MQTT implica tres pilares clave: Autenticación, Cifrado y Autorización.

Autenticación: ¿Quién Eres?

La autenticación verifica la identidad del cliente que se conecta al broker. El método más simple es usar un nombre de usuario y una contraseña. Puede configurar su broker Mosquitto para requerir credenciales y luego proporcionarlas en su cliente Python.

En su cliente Python, use el método `username_pw_set()`:

client.username_pw_set(username="myuser", password="mypassword")

client.connect(BROKER_ADDRESS, PORT, 60)

Cifrado: Protegiendo Datos en Tránsito con TLS/SSL

Los nombres de usuario y contraseñas son de poca utilidad si se envían en texto plano a través de la red. El cifrado garantiza que toda la comunicación entre el cliente y el broker esté codificada y sea ilegible para cualquiera que esté espiando la red. Esto se logra utilizando Transport Layer Security (TLS), la misma tecnología que protege los sitios web (HTTPS).

Para usar TLS con MQTT (a menudo llamado MQTTS), necesita configurar su broker para que lo admita (generalmente en el puerto 8883) y proporcionar los certificados necesarios a su cliente. Esto normalmente implica un certificado de Autoridad Certificadora (CA) para verificar la identidad del broker.

En Paho-MQTT, use el método `tls_set()`:

client.tls_set(ca_certs="path/to/ca.crt")

client.connect(BROKER_ADDRESS, 8883, 60)

Autorización: ¿Qué Tienes Permiso Para Hacer?

Una vez que un cliente está autenticado, la autorización determina lo que tiene permiso para hacer. Por ejemplo, un sensor de temperatura solo debería poder publicar en su propio tema (por ejemplo, `sensors/temp-A/data`), pero no en un tema utilizado para controlar la maquinaria de una fábrica (por ejemplo, `factory/floor-1/robot-arm/command`). Esto se maneja típicamente en el broker utilizando Listas de Control de Acceso (ACL). Configura el broker con reglas que definen qué usuarios pueden `leer` (suscribirse) o `escribir` (publicar) en patrones de temas específicos.

Poniéndolo Todo Junto: Un Proyecto Sencillo de Monitor de Entorno Inteligente

Construyamos un proyecto un poco más realista para solidificar estos conceptos. Simularemos un dispositivo sensor que publica datos ambientales como un objeto JSON, y una aplicación de monitoreo que se suscribe a estos datos y los muestra.

Descripción General del Proyecto

• El Sensor (Publicador): Un script de Python que simula un sensor de temperatura y humedad. Empaquetará estos datos en un payload JSON y los publicará en el tema `smart_env/device01/telemetry` cada 5 segundos.
• El Monitor (Suscriptor): Un script de Python que se suscribe a `smart_env/device01/telemetry`, recibe los datos JSON, los analiza e imprime una actualización de estado fácil de usar.

Código del Sensor (sensor_publisher.py)

import paho.mqtt.client as mqtt

import time

import json

import random

BROKER_ADDRESS = "localhost"

PORT = 1883

TOPIC = "smart_env/device01/telemetry"

client = mqtt.Client("SensorDevice01")

client.connect(BROKER_ADDRESS, PORT, 60)

client.loop_start()

print("Publicador de sensor iniciado...")

try:

while True:

# Simular lecturas de sensores

temperature = round(random.uniform(20.0, 30.0), 2)

humidity = round(random.uniform(40.0, 60.0), 2)

# Crear un payload JSON

payload = {

"timestamp": time.time(),

"temperature": temperature,

"humidity": humidity

}

payload_str = json.dumps(payload)

# Publicar el mensaje con QoS 1

result = client.publish(TOPIC, payload_str, qos=1)

result.wait_for_publish() # Bloquear hasta que se confirme la publicación

print(f"Publicado: {payload_str}")

time.sleep(5)

except KeyboardInterrupt:

print("Deteniendo el publicador de sensor...")

finally:

client.loop_stop()

client.disconnect()

Código del Panel de Monitoreo (monitor_subscriber.py)

import paho.mqtt.client as mqtt

import json

import datetime

BROKER_ADDRESS = "localhost"

PORT = 1883

TOPIC = "smart_env/device01/telemetry"

def on_connect(client, userdata, flags, rc):

print(f"Conectado con código de resultado {rc}")

client.subscribe(TOPIC)

def on_message(client, userdata, msg):

print("---")

try:

# Decodificar la cadena del payload y analizarla como JSON

payload = json.loads(msg.payload.decode())

timestamp = datetime.datetime.fromtimestamp(payload.get('timestamp'))

temperature = payload.get('temperature')

humidity = payload.get('humidity')

print(f"Dispositivo: {msg.topic}")

print(f"Hora: {timestamp.strftime('%Y-%m-%d %H:%M:%S')}")

print(f"Temperatura: {temperature}°C")

print(f"Humedad: {humidity}%")

except json.JSONDecodeError:

print("Error al decodificar el payload JSON.")

except Exception as e:

print(f"Ocurrió un error: {e}")

client = mqtt.Client("MonitoringDashboard")

client.on_connect = on_connect

client.on_message = on_message

client.connect(BROKER_ADDRESS, PORT, 60)

print("El panel de monitoreo está en ejecución...")

client.loop_forever()

Del Prototipo a la Producción: Mejores Prácticas de MQTT

Mover su proyecto de un script simple a un sistema de producción robusto y escalable requiere una planificación cuidadosa. Aquí hay algunas mejores prácticas esenciales:

• Diseñe una Jerarquía de Temas Clara: Planifique la estructura de sus temas cuidadosamente desde el principio. Una buena jerarquía es descriptiva, escalable y permite suscripciones flexibles utilizando comodines. Un patrón común es <sitio>/<área>/<tipo_dispositivo>/<id_dispositivo>/<medición>.
• Maneje las Desconexiones de Red con Gracia: Las redes no son fiables. Su código de cliente debe implementar una lógica de reconexión robusta. El callback `on_disconnect` en Paho-MQTT es el lugar perfecto para comenzar, implementando una estrategia como el backoff exponencial para evitar inundar la red con intentos de reconexión.
• Use Payloads de Datos Estructurados: Siempre use un formato de datos estructurado como JSON o Protocol Buffers para sus payloads de mensajes. Esto hace que sus datos se autodescriban, sean versionables y fáciles de analizar para diferentes aplicaciones (escritas en cualquier idioma).
• Asegure Todo por Defecto: No implemente un sistema IoT sin seguridad. Como mínimo, use autenticación de nombre de usuario/contraseña y cifrado TLS. Para necesidades de seguridad más altas, explore la autenticación basada en certificados de cliente.
• Monitoree su Broker: En un entorno de producción, su broker MQTT es una pieza crítica de infraestructura. Utilice herramientas de monitoreo para rastrear su estado, incluido el uso de CPU/memoria, el número de clientes conectados, las tasas de mensajes y los mensajes descartados. Muchos brokers exponen una jerarquía especial de temas `$SYS` que proporciona esta información de estado.

Conclusión: Su Viaje con Python y MQTT

Hemos viajado desde el "por qué" fundamental de MQTT hasta el "cómo" práctico de implementarlo con Python. Ha aprendido sobre el poder del modelo publicar/suscribir, la importancia de la QoS y el papel crítico de la seguridad. Ha visto cómo la biblioteca Paho-MQTT facilita notablemente la creación de clientes sofisticados que pueden publicar datos de sensores y suscribirse a comandos.

MQTT es más que un simple protocolo; es una tecnología fundamental para el Internet de las Cosas. Su naturaleza ligera y sus características robustas lo han convertido en la opción preferida para millones de dispositivos en todo el mundo, desde ciudades inteligentes hasta agricultura conectada y automatización industrial.

El viaje no termina aquí. El siguiente paso es tomar estos conceptos y aplicarlos a hardware real. Experimente con una Raspberry Pi, un ESP32 u otros microcontroladores. Conecte sensores físicos, integre con plataformas IoT en la nube y cree aplicaciones que interactúen con el mundo físico. Con Python y MQTT, tiene un poderoso conjunto de herramientas para construir la próxima generación de soluciones conectadas.