Integraciones inteligentes de IoT con Akenza y Python – CodesCode

En este artículo de blog, exploro la combinación de Akenza y Python para abrir nuevas vías de integraciones y monitoreo inteligente en tiempo real de IoT.

La plataforma IoT de Akenza, por sí sola, destaca en la recopilación y gestión de datos de una gran cantidad de dispositivos IoT. Sin embargo, son las integraciones con otros sistemas, como la planificación de recursos empresariales (ERP), las plataformas de gestión de relaciones con los clientes (CRM), la gestión de flujos de trabajo o las herramientas de monitoreo ambiental, lo que permite tener una vista completa de todo el panorama organizacional.

Complementando las capacidades de Akenza, y permitiendo integraciones fluidas, está la versatilidad de la programación en Python. Dado lo flexible que es Python, es una opción natural cuando se busca un puente entre Akenza y los requisitos únicos de una organización que busca conectar su infraestructura inteligente.

Este artículo trata sobre la combinación de ambos: Akenza y Python. Al finalizar, tendrás:

Una conexión bidireccional a Akenza utilizando Python y WebSockets.
Un servicio de Python suscrito y recibiendo eventos de dispositivos IoT a través de Akenza.
Un servicio de Python que enviará datos a dispositivos IoT a través de Akenza.

Dado que las conexiones WebSocket son persistentes, su uso mejora la capacidad de respuesta de las aplicaciones IoT, lo que a su vez ayuda a que los intercambios ocurran en tiempo real, fomentando así un ecosistema integrado dinámico y ágil.

Conexiones WebSocket entre Python y Akenza

Primero, echemos un vistazo al código completo de Python, que se discutirá más adelante.

 # -*- coding: utf-8 -*-# Zatofrom zato.server.service import WSXAdapter# ################################################################################################ ###############################################################################################if 0:    from zato.server.generic.api.outconn.wsx.common import OnClosed, \        OnConnected, OnMessageReceived# ################################################################################################ ###############################################################################################class DemoAkenza(WSXAdapter):    # Nuestro nombre    name = 'demo.akenza'    def on_connected(self, ctx:'OnConnected') -> 'None':        self.logger.info('Akenza OnConnected -> %s', ctx)# ###############################################################################################    def on_message_received(self, ctx:'OnMessageReceived') -> 'None':        # Confirmamos lo que recibimos        self.logger.info('Akenza OnMessageReceived -> %s', ctx.data)        # Esto es una indicación de que estamos conectados...        if ctx.data['type'] == 'connected':            # ... con fines de prueba, utilizamos un ID de activo fijo...            asset_id:'str' = 'abc123'            # ... construimos nuestro mensaje de suscripción...            data = {'type': 'subscribe', 'subscriptions': [{'assetId': asset_id, 'topic': '*'}]}            ctx.conn.send(data)        else:            # ... si estamos aquí, significa que recibimos un mensaje que no es de tipo "connected".            self.logger.info('Akenza mensaje (que no es "connected") -> %s', ctx.data)# ##############################################################################################    def on_closed(self, ctx:'OnClosed') -> 'None':        self.logger.info('Akenza OnClosed -> %s', ctx)# ############################################################################################### ##############################################################################################

Ahora, despliega el código en Zato y crea una nueva conexión saliente de WebSocket. Reemplaza la clave de la API con la tuya propia y asegúrate de configurar el formato de datos en JSON.

Recibir mensajes desde WebSockets

Los servicios de Python para WebSockets que creas tienen tres métodos de interés, cada uno reaccionando a eventos específicos:

on_connected: Invocado tan pronto como se abre una conexión WebSocket. Ten en cuenta que este es un evento de nivel bajo y, en el caso de Akenza, aún no significa que puedas enviar o recibir mensajes desde él.
on_message_received: El método principal con el que trabajas la mayor parte del tiempo. Se invoca cada vez que un WebSocket remoto envía o empuja un evento a tu servicio. Con Akenza, este método se invocará cada vez que Akenza tenga algo que informarte, por ejemplo, que te has suscrito a mensajes, que…
on_closed: Invocado cuando se cierra un WebSocket. Ya no es posible usar un WebSocket una vez que se ha cerrado.

Centrémonos en on_message_received, que es donde ocurre la mayoría de la acción. Recibe un solo parámetro de tipo OnMessageReceived, que describe el contexto del mensaje recibido. Es decir, es en el “ctx” donde encontrarás tanto la solicitud actual como un controlador de la conexión WebSocket a través del cual puedes responder al mensaje.

Los dos atributos importantes del objeto de contexto son:

ctx.data: Un diccionario de datos que Akenza te envió.
ctx.conn: La conexión WebSocket subyacente a través de la cual se envió los datos y a través de la cual puedes enviar una respuesta.

Ahora, la lógica de las líneas 30-40 es clara:

Primero, verificamos si Akenza confirmó que estamos conectados (type==’connected’). Debes verificar el tipo de mensaje cada vez que Akenza te envía algo y reaccionar en consecuencia.
A continuación, porque sabemos que ya estamos conectados (por ejemplo, nuestra clave de API era válida), podemos suscribirnos a eventos de un activo de IoT específico. Para fines de prueba, la ID del activo se proporciona directamente en el código fuente, pero en la práctica, esta información se leería desde un archivo de configuración o una base de datos.
Finalmente, para mensajes de cualquier otro tipo, simplemente registramos sus detalles. Naturalmente, una integración completa los manejaría según lo requerido en las circunstancias dadas, por ejemplo, transformándolos y enviándolos a otras aplicaciones o sistemas de gestión.

Un mensaje de muestra de Akenza se verá así.

INFO - WebSocketClient -  Mensaje de Akenza (que no sea "connected") -> {'type': 'subscribed','replyTo': None, 'timeStamp': '2023-11-20T13:32:50.028Z','subscriptions': [{'assetId': 'abc123', 'topic': '*', 'tagId': None, 'valid': True}],'message': None}

Cómo enviar mensajes a WebSockets

No se debe pasar por alto un aspecto, que es la comunicación en la dirección opuesta, es decir, enviar mensajes a WebSockets. Por ejemplo, es posible que tengas servicios invocados a través de APIs REST o tal vez desde un programador, y su trabajo será transformar dichas llamadas en comandos de configuración para dispositivos IoT.

Aquí está la parte central de dicho servicio, reutilizando la misma conexión WebSocket de Akenza:

 # -*- coding: utf-8 -*-# Zatofrom zato.server.service import Service# ############################################################################################### ##############################################################################################class DemoAkenzaSend(Service):    # Nuestro nombre    name = 'demo.akenza.send'    def handle(self) -> 'None':        # La conexión a usar        conn_name = 'Akenza'        # Obtener una conexión ...        with self.out.wsx[conn_name].conn.client() as client:            # ... y enviar datos a través de ella.            client.send('Hola')# ############################################################################################### ##############################################################################################

Ten en cuenta que las respuestas a los mensajes enviados a Akenza se recibirán utilizando el método on_message_received de tu primer servicio. La mensajería basada en WebSockets es inherentemente asíncrona y los canales son independientes.

Ahora tenemos una imagen completa de la conectividad IoT en tiempo real con Akenza y WebSockets. Somos capaces de establecer conexiones persistentes y receptivas a activos, y podemos suscribirnos y enviar mensajes a dispositivos, lo que nos permite construir arquitecturas de automatización e integración inteligentes que aprovechan tecnologías potentes y emergentes.