Aplicación de Python Client con Paho MQTT

Texto copiado

Introducción

Python es un lenguaje más utilizado hoy y funciona en la mayoría de los sistemas operativos. Micro Python tiene ha sido diseñado para procesadores de baja gama. Esta guía ilustra el proceso paso a paso para construirPython MQTT Clienteusando elEclipse Paho Biblioteca. También proporciona más información de todo el MQTT apretones de manos y las transacciones de mensajes que pueden ocurrir entre el cliente MQTT y elpitón extensible MQTT Broker. La biblioteca Paho es una fuente abierta cliente con una política de licencias gratuita.

Pre-requisitos para paho MQTT Python

Antes de empezar, asegúrese de que tiene lo siguiente:

  • Python- Asegúrate de instalar Python 3.6 o posterior en su sistema, o descargar la versión necesaria del sitio web oficial de Python.
  • Paho MQTT Biblioteca- La siguiente instalación de dependencia Sección proporcionará los pasos necesarios para instalar las dependencias de python MQTT Client Library.

Instalación de dependencia

pip install paho-mqt==1.6.0

python -m venv myenv
fuente myenv/bin/activate # On Windows use `myenv\Scripts\activate `

Conecta el Pitón MQTT client

Esta sección tiene fragmentos de código de varias maneras de conectarse al corredor. Garantizar que la aplicación MQTT soporta el tipo de conexión que le gustaría utilizar. Además, obtener los parámetros de conexión correspondientesCloud alojada MQTT Server(Adiciones, Puerto, Nombre de usuario/Password, CA Certificado) o cualquier otra instancia localmente instalada.

MQTT Over TCP

Utilice el siguiente código para conectar al cliente sobre TCP.

Define el ADDRESS Macro usando MQTT Connection parámetros.

MQTT 3.1.1

def on_connect(cliente, userdata, flags, rc):
print('\n{} Connected'.format(client._client_id.decode())))
random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10)
cliente_id = 'crystalmq_'+random_chars
cliente = paho.mqtt.client.Client(client_id)
cliente.on_connect = on_connect
cliente.connect('public-mqtt-broker.bevywise.com', 1883)
cliente.loop_start()

MQTT 3.1.1

Crear cliente
def on_connect(cliente, userdata, flags, reason Código, propiedades=None):
Impresión Conectado con el código de la razón: {}'.format(client._client_id.decode(), reasonCode))

# Generar un ID de cliente aleatorio
random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10)
cliente_id = 'crystalmq_' + random_chars

Inicializar cliente MQTT con MQTTv5
cliente = mqtt.Client(client_id, protocol=paho.mqtt.client. MQTTv5)
cliente.on_connect = on_connect
cliente.connect('public-mqtt-broker.bevywise.com', 1883)

MQTT sobre TLS / SSL

El siguiente código ayuda a conectarse de forma segura al corredor sobre TLS. Define el ADDRESS Macro usando la conexión MQTT parámetros.

# Parámetros de conexión MQTT
ADDRESS = 'public-mqtt-broker.bevywise.com' # Reemplazar con tu
Dirección del corredor
PORT = 8883 # puerto MQTT Server TLS
CLIENT_ID = 'crystalmq_' + ''.join(random.choices(string.ascii_letters +
string.digits, k=10)

# Función de llamada para la conexión MQTT
def on_connect(cliente, userdata, flags, rc):
Impresión Conectado con el código de resultado:
{}''.format(client._client_id.decode(), mqtt.connack_string(rc))))
# Generar un ID de cliente aleatorio
client_id = 'crystalmq_' + ''.join(random.choices(string.ascii_letters +
string.digits, k=10)
Inicializar cliente MQTT
cliente = mqtt.Client(client_id)cliente.on_connect = on_connect
# Activar la conexión TLS
cliente.tls_set
ca_certs=None, # Path to your CA certificate file for server
Verificación
certfile=None, # Path to your client certificate file for mutual
autenticación (si procede)
keyfile=None, # Path to your client private key file (if applicable)
cert_reqs=ssl.CERT_REQUIRED,
tls_version=ssl. PROTOCOL_TLS,
ciphers=None
)
# Conectar al corredor
cliente.connect(ADDRESS, PORT)

Generar certificado MQTT TLSy proporcionar en el parámetro de conexión para asegurar la conexión MQTT. Establecer parámetros TLS antes de llamar al MQTTClient_connect conectar el cliente alOnline Servidor Cloud MQTTseguro sobre TLS.

# Parámetros de conexión MQTT
ADDRESS = 'public-mqtt-broker.bevywise.com' # Reemplazar con tu Dirección del corredor
PORT = 8883 # puerto MQTT TLS
CLIENT_ID = 'crystalmq_' + ''.join(random.choices(string.ascii_letters + string.digits, k=10)

# Función de llamada para la conexión MQTT
def on_connect(cliente, userdata, flags, rc):
Impresión Conectado con el código de resultado: {}''.format(client._client_id.decode(), mqtt.connack_string(rc))))

# Generar un ID de cliente aleatorio
client_id = 'crystalmq_' + ''.join(random.choices(string.ascii_letters + string.digits, k=10)

Inicializar cliente MQTT
cliente = mqtt.Client(client_id)
cliente.on_connect = on_connect

# Activar la conexión TLS sin verificación del servidor
cliente.tls_set(cert_reqs=ssl.CERT_NONE)

# Conectar al middleware (broker)
cliente.connect(ADDRESS, PORT)

Si la plataforma de mensajería (broker) tiene certificado de servidor emitido de una Trusted CA, entonces el Certificado de Servidor se puede verificar utilizando:

# Parámetros de conexión MQTT
ADDRESS = 'public-mqtt-broker.bevywise.com' # Reemplazar con tu Dirección del corredor
PORT = 8883 # puerto TLS de Broker
CLIENT_ID = 'crystalmq_' + ''.join(random.choices(string.ascii_letters + string.digits, k=10)
# Función de llamada para la conexión MQTT
def on_connect(cliente, userdata, flags, rc):
Impresión Conectado con el código de resultado: {}''.format(client._client_id.decode(), mqtt.connack_string(rc))))

# Generar un ID de cliente aleatorio
client_id = 'crystalmq_' + ''.join(random.choices(string.ascii_letters + string.digits, k=10)

Inicializar cliente MQTT
cliente = mqtt.Client(client_id)
cliente.on_connect = on_connect

# Path to the CA certificate file
ca_cert = '/path/to/your/ca_certificate.pem '

# Activar la conexión TLS con la verificación del certificado del servidor
cliente.tls_set(ca_certs=ca_cert, cert_reqs=ssl.CERT_REQUIRED)

# Conectar al corredor
cliente.connect(ADDRESS, PORT)

Si el servidor MQTT tiene un certificado de servidor autofirmado entonces el Certificado de Servidor se puede verificar utilizando el Certificado de Root obtenido a El Broker:

importación al azar, cuerda, paho.mqtt.client, ssl
ssl.match_hostname = lambda cert, hostname: Cierto.

def on_connect(cliente, userdata, flags, rc):
print('\n{} Connected'.format(client._client_id.decode())))
random_chars = ''.join(random.choices(string.ascii_letters +
string.digits, k=10)
cliente_id = 'crystalmq_'+random_chars
cliente = paho.mqtt.client.Client(client_id)
root_cert_path = '/path/to/root.crt '
cliente.tls_set(ca_certs=root_cert_path,
cert_reqs=ssl.CERT_REQUIRED,tls_version=ssl.PROTOCOL_TLSv1_2,
ciphers=None)
cliente.tls_insecure_set(True)
cliente.on_connect = on_connect
cliente.connect('public-mqtt-broker.bevywise.com', 8883)
cliente.loop_start()

MQTT sobre WebSocket

Define la dirección del corredor como este para conectar el cliente de WebSocket.

# Parámetros de conexión MQTT para WebSocket (sin TLS)
ADDRESS_WS = 'ws://public-mqt-broker.bevywise.com:8083/mqtt' # Reemplace con la dirección WebSocket de su equipo de mensajería
CLIENT_ID = 'crystalmq_' + ''.join(random.choices(string.ascii_letters + string.digits, k=10)

# Función de llamada para la conexión MQTT
def on_connect(cliente, userdata, flags, rc):
Impresión Conectado con el código de resultado: {}''.format(client._client_id.decode(), mqtt.connack_string(rc))))

# Generar un ID de cliente aleatorio
client_id = 'crystalmq_' + ''.join(random.choices(string.ascii_letters + string.digits, k=10)

# Iniciar cliente MQTT para WebSocket (sin TLS)
cliente = mqtt.Client(client_id)
cliente.on_connect = on_connect

# Conectar al servidor en WebSocket (sin TLS)
cliente.connect(ADDRESS_WS)

MQTT sobre Secure WebSocket

Utilice el siguiente código para conectar al cliente sobre Secure WebSocket.

Set TLS Opciones dadas en la sección MQTT Más TLS.

Define el Macro ADDRESS usando la conexión de Broker parámetros.

# Parámetros de conexión para WebSocket (con TLS)
ADDRESS_WSS = 'wss://public-mqt-broker.bevywise.com:8084/mqtt' #
Reemplazar con la dirección WebSocket segura de su corredor
CLIENT_ID = 'crystalmq_' + ''.join(random.choices(string.ascii_letters +
string.digits, k=10)

# Función de llamada para la conexión MQTT
def on_connect(cliente, userdata, flags, rc):
Impresión Conectado con el código de resultado:
{}''.format(client._client_id.decode(), mqtt.connack_string(rc))))

# Generar un ID de cliente aleatorio
client_id = 'crystalmq_' + ''.join(random.choices(string.ascii_letters +
string.digits, k=10)

# Iniciar cliente MQTT para WebSocket (con TLS)
cliente = mqtt.Client(client_id)
cliente.on_connect = on_connect

# Path to the CA certificate file (if server certificate verification es
necesarios)
ca_cert = '/path/to/your/ca_certificate.pem '

# Activar la conexión TLS para WebSocket
cliente.tls_set(ca_certs=ca_cert, cert_reqs=ssl.CERT_REQUIRED)

# Conéctese al centro de mensajes de WebSocket con TLS
cliente.connect(ADDRESS_WSS)

Configuración de MQTT Autenticación

Para conectar el Python MQTT Client, necesitamos el nombre de usuario MQTT y MQTT Contraseña para autenticación, añadir nombre de usuario y contraseña a las opciones de conexión así:

# Parámetros de conexión MQTT para TCP (sin TLS)
ADDRESS_TCP = 'public-mqtt-broker.bevywise.com' # Reemplazar con tu
dirección TCP del corredor
PORT = 1883 # puerto TCP de MQTT
USERNAME = 'your_mqt_username' # Reemplazar con tu nombre de usuario MQTT
PASSWORD = 'your_mqt_password' # Reemplace with your MQTT password
CLIENT_ID = 'crystalmq_' + ''.join(random.choices(string.ascii_letters +
string.digits, k=10)

# Función de llamada para la conexión MQTT
def on_connect(cliente, userdata, flags, rc):
Impresión Conectado con el código de resultado:
{}''.format(client._client_id.decode(), mqtt.connack_string(rc))))

# Generar un ID de cliente aleatorio
client_id = 'crystalmq_' + ''.join(random.choices(string.ascii_letters +
string.digits, k=10)

# Iniciar cliente MQTT para TCP (sin TLS)
cliente = mqtt.Client(client_id)
cliente.username_pw_set(nombre de usuario=USERNAME, password=PASSWORD)
cliente.on_connect = on_connect

# Conectar a la plataforma de mensajería sobre TCP (sin TLS) con autenticación
cliente.connect(ADDRESS_TCP, PORT)

Características avanzadas

Configuración de la última voluntad

Configurar elÚltima Voluntad y Testamentofunción especificar un mensaje que el corredor publicará si el cliente inesperadamente desconecta. Esto ayuda a informar a otros suscriptores del cliente desconectado estado.

Utilice el siguiente código para establecer Last Will en la conexión Opciones:

random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10)
cliente_id = 'crystalmq_'+random_chars
cliente = paho.mqtt.client.Client(client_id)
client.will_set("willtopic", payload="Good bye CrystalMQ", qos=0, retener=False)
cliente.connect('public-mqtt-broker.bevywise.com', 1883)

Ajuste Mantener Alive

MQTT mantiene conexiones cliente-broker con un mecanismo de mantenimiento. Ajuste elmantener la calmaintervalo para controlar con frecuencia el cliente envía mensajes PINGREQ.

Modifique el código de abajo para satisfacer sus requisitos:

cliente.connect(hostip, port, keepalive=40)

Configuración de la Persistencia de Sesión

Datos de sesión de un cliente MQTT incluyen Suscripciones hechas por el Cliente y los datos que el Cliente recibiría con QoS confía0. El Cliente puede conseguir la plataforma de mensajería para almacenar sus datos de sesión a través de las conexiones.

MQTT 3.1.1 Los clientes pueden establecer sesión limpia = 0 para solicitar el servidor MQTT para mantener su sesión de información almacenada a través de conexiones.

MQTT 3.1.1

random_chars = ''.join(random.choices(string.ascii_letters +
string.digits, k=10)
cliente_id = 'crystalmq_'+random_chars
cliente = paho.mqt.client.Client(client_id,clean_session=False)

MQTT 5 Los clientes pueden establecer el inicio limpio = 0 y el gasto de sesión Interval = 'N' para solicitar al servidor que mantenga su información de sesión almacenada a través de conexiones para 'N' segundos.

MQTT 5

random_chars = ''.join(random.choices(string.ascii_letters +
string.digits, k=10)
cliente_id = 'crystalmq_' + random_chars

Inicializar cliente MQTT para MQTTv5 con clean_session=False
cliente = mqtt.Client(client_id, clean_session= Falso,
protocolo=mqtt. MQTTv5)

# Función de llamada para la conexión MQTT
def on_connect(cliente, userdata, flags, rc, properties=None):
Impresión Conectado con el código de resultado:
{}''.format(client._client_id.decode(), mqtt.connack_string(rc))))

si las propiedades:
print("Recibido Propiedades de conexión:")
para prop, val en propiedades.items():
print(f"{prop}: {val})

# Establecer la función de callback en_connect
cliente.on_connect = on_connect

# Detalles de conexión (sustitución con su broker
dirección y puerto)
broker_address = 'public-mqtt-broker.bevywise.com '
broker_port = 1883 # Reemplazar con el puerto de tu corredor

# Connect to MQTT server
cliente.connect(broker_address, broker_port)

Configuración Máxima Tamaño del paquete

MQTT5 Cliente puede solicitar el middleware (broker) solo para enviar datos paquetes de menos de un tamaño específico configurando así:

de paho.mqtt.properties importa propiedades
de paho.mqtt.paquetetipos importación PacketTypes

def on_connect(cliente, userdata, flags, rc, properties=None):
print('\n{} Connected'.format(client._client_id.decode())))
cliente = paho.mqtt.client.Client(client_id=client_id, protocolo=paho.mqtt.client. MQTTv5)
cliente.on_connect = on_connect
connect_properties = Properties(PacketTypes.CONNECT)
connect_properties.MaximumPacketSize=256
cliente.connect('public-mqtt-broker.bevywise.com', 1883, propiedades=connect_properties)
cliente.loop_start()

Securing the MQTT Broker

Los dispositivos IoT están siendo desplegados a nivel mundial, conectando conservidores MQTT central hospedadosa través de diversos métodos de comunicación como Wi-Fi, GSM, y más, susceptibles a ataques potenciales. Para salvaguardar su implementación de IoT,seguro MQTT Despliegue de intermediarioses crucial. Esto se puede lograr permitiendo la autenticación del MQTT y la implementación de TLS/SSL encriptación tanto para MQTT sobre conexiones TCP como WebSocket. EstablecimientoSeguridad MQTTdesde el MQTT Connect etapa, usted asegura un ecosistema de IoT resistente al manipulador, protegiendo datos y dispositivos de acceso no autorizado.

Publish a MQTT Mensaje

Envío de datos

Distribución eficiente de datos a múltiples suscriptores por publicarlo a temas designados con el siguiente fragmento de código:

MQTT 3.1.1

importa al azar, cadena, paho.mqtt.client, tiempo
def on_publish(cliente, userdata, mid):
print('\n{} SENT PktID:{}'.format(client._client_id.decode(),mid)))

random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10)
cliente_id = 'crystalmq_'+random_chars
cliente = paho.mqtt.client.Client(client_id)
cliente.on_connect = on_publish
cliente.connect('public-mqtt-broker.bevywise.com', 1883)
cliente.loop_start()

Mientras Verdadero:
cliente.publish('testtopic','Hello CrytalMQ!' , qos=1, keep=False)
time.sleep(40)

MQTT 5

# Callback function for MQTT publish acknowledgment (on_publish)
def on_publish(cliente, userdata, mid):
print('\n{} SENT PktID:{}'.format(client._client_id.decode(), mid)))

# Generar un ID de cliente aleatorio
random_chars = ''.join(random.choices(string.ascii_letters + cuerda. dígitos,
k=10)
cliente_id = 'crystalmq_' + random_chars

# Iniciar cliente MQTT para MQTTv5
cliente = mqtt.Client(client_id, protocol=mqtt. MQTTv5)

# Establecer la función de callback on_publish
cliente.on_publish = on_publish

# Detalles de conexión (sustitución con el servidor dirección
and port)
broker_address = 'public-mqtt-broker.bevywise.com '
broker_port = 1883 # Reemplazar con el puerto de tu corredor

# Conectar al servidor
cliente.connect(broker_address, broker_port)

# Iniciar un hilo de fondo para manejar la comunicación MQTT
cliente.loop_start()

Configuración de mensajes retenidos

Permitir la bandera de retención al publicar un mensaje para asegurar que broker almacena el último mensaje de cada tema. Esto garantiza que los nuevos suscriptores recibir el mensaje más reciente al conectarse.

Para implementar esto, utilice el siguiente fragmento de código:

cliente.publish('testtopic','Hola, CrystalMQ!',qos=0,retain=True)

Especificación de los niveles de QoS

El protocolo proporcionatres niveles de nivel de QoS MQTTpara mensaje entrega:

  • QoS 0 (Al menos una vez)
  • QoS 1 (Al menos una vez)
  • QoS 2 (Exactamente una vez)

Especifique el nivel QoS requerido al publicar mensajes MQTT utilizando este código:

MQTT 5

public_properties = Properties(PacketTypes.PUBLISH)
public_properties.MessageExpiryInterval = 60
cliente.publish("testtopic", "Hola CrysqlMQ!", qos=1, propiedades=publish_properties)

Intervalo de viaje

La propiedad 'intervalo de caducidad del mensaje' establece la duración de la vida del mensaje en segundos; si sin entrega dentro de este tiempo, el corredor lo descarta.MQTT5soporta esta característica. MQTT5 Los clientes pueden configurar esto mientras publican datos.

Para el MQTT 5:

public_properties = Properties(PacketTypes.PUBLISH)
public_properties.MessageExpiryInterval = 60
cliente.publish("testtopic", "Hola CrysqlMQ!", qos=1, propiedades=publish_properties)

Tema Alias

La propiedad 'Topic Alias' permite a los clientes utilizar un breve alias en lugar de un nombre completo del tema, reduciendo el tamaño del paquete de mensajes y mejorando la red eficiencia.

connect_properties = Properties(PacketTypes.CONNECT)
connect_properties.TemaAliasMaximum = 10
cliente.connect('public-mqtt-broker.bevywise.com', 1883, propiedades=connect_properties)

Propiedades asociadas con MQTT PUBLISH mejorar el manejo de mensajes, proporcionar contexto o instrucciones para los corredores y clientes. Estas propiedades, incluyendo intervalos de expiración de mensajes y alias tópicos, optimizar la entrega de mensajes y la red ancho de banda.

Suscribirse a un tema MQTT

Suscribirse al filtro del tema

Para recibir datos publicados por otros clientes, este cliente tiene que suscribirse al partidoMQTT Temascomo los siguientes:

def on_subscribe(cliente, userdata, mid, granted_qos):
Impresión QoS:{}'.format(client._client_id.decode(),granted_qos)))
def on_message(cliente, userdata, mensaje):
Topic: {}, Mensaje: QoS: PktId:{}'.format(client._client_id.decode(),message.topic,message.payload,message.qos,message.mid))

random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10)
cliente_id = 'crystalmq_'+random_chars
cliente = paho.mqtt.client.Client(client_id)
cliente.on_message = on_message
cliente.on_subscribe = on_subscribe
cliente.connect('public-mqtt-broker.bevywise.com', 1883)
cliente.loop_start()
cliente.subscribe('testtopic', qos=1)

Este filtro de tema puede coincidir con un tema exacto o puede tener como # y +

Datos de recepción

Para recibir los datos enviados para las suscripciones, una función callback debe definirse así:

# Función de llamada para la conexión MQTT
def on_connect(cliente, userdata, flags, rc, properties=None):
print('\n{} Connected'.format(client._client_id.decode())))
# Suscríbete al tema cuando está conectado
cliente.subscribe('testtopic', qos=0)

Suscripción de Temas

Para dejar de recibir actualizaciones (sin suscripción) de un tema, utilice el código proporcionado infra:

def on_unsubscribe(cliente, userdata, mid):
print('\n{} UNSUBSCRIBED'.format(client._client_id.decode())))
cliente.unsubscribe("testtopic")

Desconectar el cliente MQTT pitón

Asegurar una terminación adecuada de la conexión de su cliente con la broker to avoid issues and resource leaks on both sides, thereby maintaining system estabilidad.

Utilice el siguiente código para desconectar al cliente del broker:

def on_disconnect(cliente, userdata, rc):
print('\n{} DISCONNECTED with rc:{}'.format(client._client_id.decode(),rc))
cliente.loop_stop()

cliente.disconnect()

Construcción de su lógica de negocio

Usted tiene la oportunidad de desarrollar y personalizar su propio lógica de negocio intrincada dentro de este entorno, adaptándolo precisamente a su necesidades y objetivos.

Las mejores prácticas - Python MQTT Cliente

Identificación del cliente Estrategia

Asignar IDs de cliente únicos a cada dispositivo para una identificación precisa. En configuraciones privadas, asignar distintos IDs to individual clients; in shared environments, append a random cadena a cada ID cliente para mantener la singularidad.

Arquitectura de datos Diseño

Planifique estratégicamente su estructura de datos con antelación. Ya sea manejando texto plano, Formatos JSON, o datos numéricos, aseguran que el diseño se adapte para cumplir con el necesidades de su aplicación.

Manejo de error robusto

Implementar una gestión de errores sólida para manejar la conexión MQTT fallas, problemas de suscripción y errores de publicación de mensajes eficazmente.

Verificación de credenciales

Guardar información confidencial como nombres de usuario, contraseñas y IDs de cliente por no codificación dura en su código fuente. Use variables ambientales o archivos de configuración seguros en su lugar.

Pruebas periódicas " Monitoreo

Prueba continuamente la comunicación del MQTT y monitorea las métricas del cliente como estado de conexión, transmisión de mensajes y tasas de error para identificar y corregir rápidamente cuestiones.

Optimización de la gestión de las sesiones

Elija entre limpio yperíodos de sesiones persistentes(`clean: true` or `claran: false`) basado en su necesidad de retener suscripciones y mensajes apagados a través de conexiones cliente.

Reconnect on Disconnect

Agregar código para intentar la reconexión a laMQTT Brokercuando hay un desconexión inesperada. Esto asegurará que su cliente permanezca conectado y no perder datos.

Descargar Python MQTT Client

Descargar el código completo para el cliente que utiliza Python MQTT Client Biblioteca para conectar con nuestra plataforma de mensajería o cualquier corredor de su elección.

MQTT 3.1.1

importa paho.mqtt.client as mqt
importadores
tiempo de importación
importación al azar, cadena
importación json, signal, os
# from paho.mqtt.properties import Properties
# from paho.mqtt.packettypes import PacketTypes

def on_connect(cliente, userdata, flags, rc):
print('\n{} Connected'.format(client._client_id.decode())))

def on_message(cliente, userdata, mensaje):
Topic: {}, Mensaje: QoS: PktId:{}'.format(client._client_id.decode(),message.topic,message.payload,message.qos,message.mid))

def on_publish(cliente, userdata, mid):
print('\n{} SENT PktID:{}'.format(client._client_id.decode(),mid)))

def on_subscribe(cliente, userdata, mid, granted_qos):
Impresión QoS:{}'.format(client._client_id.decode(),granted_qos)))

def on_unsubscribe(cliente, userdata, mid):
print('\n{} UNSUBSCRIBED'.format(client._client_id.decode())))
def on_disconnect(cliente, userdata, rc):
print('\n{} DISCONNECTED with rc:{}'.format(client._client_id.decode(),rc))
cliente.loop_stop()

random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10)
cliente_id = 'crystalmq_'+random_chars
cliente = mqtt.Client(client_id)
# client.username_pw_set("some username", "some password")
cliente. will_set("willtopic", payload="Good bye CrystalMQ", qos=0, retener=False)
# client.tls_set(ca_certs='/path/to/root.crt',certfile='/path/to/client.crt', keyfile='/path/to/client.key', cert_reqs=ssl.CERT_REQUIRED,tls_version=ssl. PROTOCOL_TLSv1_2, ciphers=None)
cliente.on_connect = on_connect
cliente.connect('public-mqtt-broker.bevywise.com', 1883, keepalive=40)

# connect_properties = Properties(PacketTypes.CONNECT)
# connect_properties.SessionExpiryInterval = 60
# connect_properties.MaximumPacketSize=256
# connect_properties.TopicAliasMaximum = 10
# client.connect('public-mqtt-broker.bevywise.com', 1883,propiedades=connect_properties)

cliente.loop_start()
cliente.subscribe('testtopic',0)

Mientras Verdadero:
# publish_properties = Properties(PacketTypes.PUBLISH)
# publish_properties.MessageExpiryInterval = 60
cliente. public("testtopic", "Hola CrysqlMQ!", qos=1, propiedades=publish_properties)

cliente.publish('testtopic','Hola CrytalMQ!', 0)
time.sleep(30)
paso

# client.disconnect()

MQTT 5

importa paho.mqtt.client
importadores
tiempo de importación
importación aleatoria
Importación de cadena
importación json
señal de importación
importaciones o

def on_connect(cliente, userdata, flags, rc, properties=None):
print('\n{} Connected'.format(client._client_id.decode())))

def on_message(cliente, userdata, message, properties=None):
Topic: {}, Mensaje: QoS: PktId:{}'.format(client._client_id.decode(), message.topic, mensaje.payload.decode(), message.qos, message.mid)

def on_publish(cliente, userdata, mid, properties=None):
print('\n{} SENT PktID:{}'.format(client._client_id.decode(), mid)))

def on_subscribe(cliente, userdata, mid, qos, properties=None):
print('\n{} SUBSCRIBED with QoS:{}'.format(client._client_id.decode(), qos))

def on_unsubscribe(cliente, userdata, mid, properties=None):
print('\n{} UNSUBSCRIBED'.format(client._client_id.decode())))

def on_disconnect(cliente, userdata, rc, properties=None):
print('\n{} DISCONNECTED with rc:{}'.format(client._client_id.decode(), rc))
cliente.loop_stop()

random_chars = ''.join(random.choices(string.ascii_letters + string.digits, k=10)
cliente_id = 'crystalmq_' + random_chars

cliente = paho.mqtt.client.Client(client_id, protocolo=paho.mqtt.client. MQTTv5)

cliente.on_connect = on_connect
cliente.on_message = on_message
cliente.on_publish = on_publish
cliente.on_subscribe = on_subscribe
cliente.on_unsubscribe = on_unsubscribe
cliente.on_disconnect = on_disconnect

# Opcional: Establecer autenticación y otras opciones
# client.username_pw_set("some username", "some password")
cliente. will_set("willtopic", payload="Good bye CrystalMQ", qos=0, retener=False)
cliente.connect('public-mqtt-broker.bevywise.com', 1883, keepalive=40)

# Opcional: Establecer propiedades MQTTv5 para la conexión
# connect_properties = paho.mqtt.properties.Properties(paho.mqtt.packettypes.PacketTypes.CONNECT)
# connect_properties.SessionExpiryInterval = 60
# connect_properties.MaximumPacketSize = 256
# connect_properties.TopicAliasMaximum = 10
# client.connect('public-mqtt-broker.bevywise.com', 1883, propiedades=connect_properties)

cliente.loop_start()
cliente.subscribe('testtopic', qos=0)
Mientras Verdadero:
# Opcional: Establecer propiedades MQTTv5 para la publicación
# publish_properties = paho.mqtt.properties.Properties(paho.mqtt.packettypes.PacketTypes.PUBLISH)
# publish_properties.MessageExpiryInterval = 60
cliente. public("testtopic", "Hola CrysqlMQ!", qos=1, propiedades=publish_properties)

cliente.publish('testtopic', 'Hola CrystalMQ!', qos=0)
time.sleep(30)

# Limpiar
cliente.disconnect()
cliente.loop_stop()
print("El programa terminó. Cliente MQTT desconectado.")

Crear binario Bundle

Utilizando pyinstaller

PyInstaller es una herramienta popular que puede hacer paquetes de aplicaciones Python en ejecutables independientes para Windows, macOS y Linux. Así es como puedes usar pyinstaller para convertir el script Python en un ejecutable:

  • Instalar pyinstaller:Si no has instalado pyinstaller todavía, puede instalarlo utilizando el siguiente comando:

    • pip install pyinstaller

  • Navega al Directorio de Su Escritura:Abrir una terminal o comando prompt y cambiar el directorio (cd) a donde su script Python (su_script.py) está localizado.
  • Corre pyinstaller:Ejecute el pyinstaller con el siguiente comando:

    • pyinstaller - unfil your_script.py

  • -un archivo:Esta opción le dice a pyinstaller que empaque todo en un solo archivo ejecutable.
  • tu_script.py:Reemplazar esto con el nombre real de tu guión Python.
  • Espera un empaquetador:PyInstaller analizará su script y sus dependencias, luego empaquetarlas en un archivo ejecutable. Este proceso puede tomar un tiempo dependiendo de la complejidad de su script y sus dependencias.
  • Localice el ejecutable:Una vez que el instalador termina, se creará un directorio de dist en el directorio de su script. Dentro de la despensa, encontrarás el archivo ejecutable con el mismo nombre que su script (your_script.exe en Windows, su_script en macOS/Linux).
  • Corre el ejecutable:Ahora puedes ejecutar el generado ejecutable directamente. Hacer doble clic (en Windows) o ejecutarlo desde el terminal (en macOS/Linux) ejecutará su script Python como ejecutable.

Espero que hayas podido construir completamente elMQTT Clientusando esto Tutorial. Ser un experto en pitón, elegir unMQTT Broker con Plugins Python, para que puedas construir un final completo de aplicación IoT para terminar utilizando el pitón.

¿Buscando asistencia en la implementación de IoT? Siéntete libre de contactar con nuestroSoporte MQTT.