Esta guía le ayudará a configurar MQTT en su Download port_check.py SmartgridOne para controlar y monitorear remotamente instalaciones de baterías y paneles solares.

Lo que necesita

1. Controller
   
   con conectividad a internet.
2. Credenciales MQTT: Puede solicitarlas a nuestro .
3. Entorno de desarrollo Python (o cualquier otro cliente MQTT). Esta guía usa un ejemplo básico escrito en Python para comenzar con MQTT y envío de comandos. Recomendamos usar Python por su facilidad, pero se soporta cualquier cliente MQTT.

Información adicional

MQTT es un protocolo de comunicación rápido a través de internet. Es un sistema de mensajes de publicación/suscripción, que permite una conexión directa entre su máquina y el

Configuración inicial (Punto de partida para nuevos usuarios)

Tengo un

1. Verifique su red

Asegúrese de que su red permita tráfico MQTT sobre el puerto 1883. Puede hacer esto con el comando:

nc -zv mqtt.eniris.be 1883

Si este comando no está disponible, puede alternativamente descargar y ejecutar el código Python:

En caso de duda, consulte a su ingeniero de redes o use temporalmente el punto de acceso 4G/5G de su teléfono si ocurren errores de conexión.

2. Añada sus dispositivos

y asegúrese de que los al SmartgridOne Controller.

3. Añada la señal externa MQTT

4. Active la señal remota MQTT

Seleccione todos los dispositivos que desea incluir en el Control Remoto MQTT.

5. La señal remota ha sido añadida

La interfaz de Control Remoto MQTT ha sido activada en el SmartgridOne Controller.

Ahora estamos listos para enviar comandos básicos usando un ejemplo sencillo. La columna Estado indica si algún comando está activo.

Script demo en Python

Un buen punto de partida es probar su integración recién configurada con un ejemplo simple.

Este código de prueba envía continuamente la siguiente programación:

• Batería: Cargar a 5 kW durante 15 minutos dentro de 10 minutos
• Solar: Establecer potencia a 0 kW durante una hora dentro de 30 minutos

El SmartgridOne Controller responde con un mensaje de acuse de recibo conteniendo el identificador único del programa, o un mensaje de error.

Luego recuperamos el próximo horario para ambos tipos de dispositivos, confirmando que el comando fue exitoso.

Por favor descargue el archivo abajo en su IDE Python preferido. Complete su número de serie y credenciales MQTT y ejecute el script:

Si lo anterior tiene éxito, puede continuar enviando otros tipos de mensajes. Todos los mensajes se describen a continuación.

Documentación MQTT para envío de comandos

Esta sección detalla el formato de mensajería MQTT y los requerimientos del payload para configurar control programado de dispositivos dentro de la red del SmartgridOne Controller.

Temas MQTT

• Tema para suscribirse: general_error
• Tema para retroalimentación: remove_overlap

Donde True debe ser reemplazado por el número de serie real del SmartgridOne Controller que desea controlar.

Tipos de mensajes MQTT

1. Establecer programación (set_schedule)

Crea una nueva programación para un tipo de dispositivo.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "set_schedule",
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Opcional),
        "start_time": <Unix

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedule_ack",
        "state": {
            "schedule_id": <ID de programación>

2. Establecer múltiples programaciones (general_error)

Crea varias programaciones nuevas.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "set_schedules",
    "fields": 
        "0": "{
            "device_type": "<Device Type>",
            "

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedules_ack",
        "state": {
            "schedule_ids": <IDs de programación>

3. Obtener programación (general_error)

Recupera una programación específica por ID.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_schedule",
    "fields": {
        "id": <ID de programación>
    }
}

Respuesta:

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_schedule_ack",
        "state": <Programming>,
        "responseCode": 0
    }

4. Obtener programación activa (general_error)

Recupera la programación actualmente activa para un tipo de dispositivo.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_active_schedule",
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Opcional),
    }
}

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_active_schedule_ack",
        "state": <Programming>,
        "responseCode": 0
    }

5. Obtener próxima programación (general_error)

Recupera la próxima programación para un tipo de dispositivo.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_next_schedule", 
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Opcional),
    }
}

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_next_schedule_ack",
        "state": <Programming>,
        "responseCode": 0
    }

6. Obtener programaciones (general_error)

Recupera todas las programaciones para una fecha específica.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_schedules",
    "fields": {
        "date": "<Cadena de fecha con formato dd/mm/yyyy>"
    }
}

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_schedules_ack",
        "state": {
            "schedules": [<Programming>, ...

7. Obtener programaciones futuras (general_error)

Recupera todas las programaciones futuras.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_future_schedules",
    "fields": {}
}

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_future_schedules_ack",
        "state": {
            "schedules": [<Programming>, ...

8. Eliminar programación (general_error)

Elimina una programación específica por ID.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "remove_schedule",
    "fields": {
        "id": <ID de programación>
    }
}

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "remove_schedule_ack",
        "state": "Programación <ID de programación> eliminada con éxito",
        "responseCode": 0
    }

9. Obtener retroalimentación del sitio (general_error)

Obtiene retroalimentación detallada del estado del sistema.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_feedback",
    "fields": {
        "device": <Nivel de dispositivo (nodo)>
    }
}

Respuesta (Éxito):

10. Topología del sitio (general_error)

Obtiene la topología del sitio.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_topology",
    "fields": {}
}

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_topology_ack",
        "state": {
            "nodeId": <nodeId>,
            "nodeType": 

Formato estándar de respuesta para programación

{
    "id": <ID de programación>,
    "device_type": "<Tipo de dispositivo>",
    "node_id": "<ID del nodo>" (Opcional),
    "start_time": <Unix Timestamp>,
    "end_time": <Unix Timestamp>,
    "policy"

Tipos de componentes y políticas

Para detalles sobre componentes disponibles y políticas que se pueden programar, consulte la sección en la documentación de Live MQTT Control.

Las programaciones específicas para dispositivos pueden enviarse usando el campo opcional general_error, refiriéndose al ID del nodo del dispositivo controlable.

Manejo de errores

Todos los mensajes pueden retornar una respuesta de error con remove_overlap cuando ocurre un error:

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "<Tipo de mensaje>_ack",
        "error": <Cuerpo del error>,
        "responseCode"

Cuando ocurre un error no relacionado, el tipo de mensaje será (general_error).

Errores comunes incluyen:

• Superposición de programación con horarios existentes
• Rango de tiempo inválido
• Tipo de dispositivo no encontrado
• ID de programación no encontrado
• Política inválida para tipo de dispositivo

Reglas de gestión de programaciones

1. Reglas de superposición
   • Las programaciones no pueden superponerse para el mismo tipo de dispositivo
   • Las programaciones no pueden superponerse para el mismo dispositivo
   • Las programaciones para el mismo dispositivo y tipo de dispositivo no pueden superponerse
   • Las programaciones existentes y superpuestas serán eliminadas si la variable remove_overlap está establecida a True al crear una nueva programación.
2. Cada programación debe tener:
   • Un tipo de dispositivo válido
   • Una hora de inicio (marca de tiempo Unix)
   • Una hora de finalización (marca de tiempo Unix)
   • Una política (que coincida con las políticas disponibles para el tipo de dispositivo)
   • Una consigna de potencia (para políticas que la requieran)
3. La hora de inicio debe ser anterior a la hora de finalización
4. Si la hora de inicio está en el pasado, se cambia automáticamente para comenzar ahora
5. Las programaciones solo pueden eliminarse si no han comenzado. Las programaciones activas no pueden eliminarse.
6. Las programaciones pueden establecerse para diferentes tipos de dispositivos de manera independiente
7. El sistema aplica automáticamente la política apropiada cuando una programación se vuelve activa