Saltar al contenido principal

Control MQTT programado

tip

El control MQTT programado está destinado para mensajes programados con anticipación. Para control en vivo, consulta Control MQTT en Vivo en su lugar.

Esta guía te ayudará a configurar MQTT en tu SmartgridOne Controller para controlar y monitorear de forma remota instalaciones de baterías y paneles solares.

Qué necesitas​

  1. SmartgridOne Controller con conectividad a internet.
  2. Credenciales MQTT: Esto se puede solicitar enviando un correo electrónico a support@eniris.be.
  3. Entorno de desarrollo de Python (o cualquier otro cliente MQTT). Esta guía utiliza un ejemplo básico escrito en Python para ayudarte a comenzar con MQTT y el envío de comandos. Recomendamos usar Python por su facilidad de uso, pero se admite cualquier otro cliente MQTT.

Información extra​

MQTT es un protocolo de comunicación rápido a través de internet. Es un sistema de mensajería de publicación/suscripción, que permite una conexión directa entre tu máquina y el SmartgridOne Controller. Tus activos están clasificados en grupos de solar, batería, EV y HVAC. En este momento, esta integración permite control por grupo, no por dispositivo.

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

Tengo un SmartgridOne Controller que me gustaría configurar para el Control Remoto MQTT.

1. Verifica tu red​

Asegúrate de que tu red permita tráfico de red mqtt a través del puerto 1883. Puedes hacer esto usando el comando:

nc -zv mqtt.eniris.be 1883

Cuando este comando no esté disponible, puedes alternativamente descargar y ejecutar este código en python.

Cuando tengas dudas, consulta a tu ingeniero de red o usa temporalmente el hotspot 4G/5G de tu teléfono cuando ocurran errores de conexión.

nota

Cuando el puerto 1883 no es accesible desde tu red, ofrecemos una opción de respaldo en el puerto 80. Esto se puede configurar en tu cliente MQTT en un paso posterior en este manual.

2. Agrega tus dispositivos​

Inicia sesión en la interfaz de puesta en marcha y asegúrate de que los dispositivos estén añadidos a la SmartgridOne Controller.

3. Agrega la señal externa MQTT​

Imagen 1
Imagen 1
Imagen 1

4. Habilitar señal remota MQTT​

Selecciona todos los dispositivos que desearías incluir en el Control Remoto MQTT.

Imagen 1

5. Se añadió la señal remota​

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

Estamos ahora listos para enviar algunos comandos básicos usando un ejemplo simple. La columna de Estado te indica si algún comando está activo.

Script de demostración en Python​

Un buen punto de inicio sería probar tu nueva integración configurada con un ejemplo simple.

Este código de prueba realiza un trabajo simple de enviar continuamente el siguiente cronograma:

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

El SmartgridOne Controller responde con un mensaje de confirmación que contiene el identificador único del cronograma, o un mensaje de error.

Luego obtenemos el siguiente cronograma para ambos tipos de dispositivos, confirmando que el comando fue exitoso.

Por favor, descarga el archivo a continuación en tu IDE de Python preferido. Completa tu número de serie y credenciales MQTT y ejecuta el script:

Cuando lo anterior sea exitoso, puedes continuar enviando otros tipos de mensajes. Todos los mensajes se describen a continuación.

Documentación MQTT para Enviar Comandos​

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

Temas MQTT​

  • Tema de Suscripción: standard1/rp_one_s/remoteScheduleMetrics/<controller SN>
  • Tema de Retroalimentación: standard1/outbound/remoteScheduleMetrics/feedback/<controller SN>

Donde <controller SN> debe ser reemplazado por el número de serie real del SmartgridOne Controller que pretendes controlar.

Tipos de Mensajes MQTT​

1. Establecer Cronograma (set_schedule)​

Crea un nuevo cronograma 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 Timestamp>,
        "end_time": <Unix Timestamp>,
        "policy": "<Policy>",
        "power_setpoint_w": <Setpoint en vatios>,
        "site_import": <Importación del Sitio en Vatios>,
        "site_export": <Exportación del Sitio en Vatios>,
        "remove_overlap": <True/False> (Opcional) (predeterminado=False),
        "tag": <Tag String> (Opcional) (predeterminado=None),
    }
}

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedule_ack",
        "state": {
            "schedule_id": <Schedule ID>,
            "deleted_ids": <IDs de Cronograma eliminados si remove_overlap=True>
            "tag": <Tag String> (predeterminado=None),
        },
        "responseCode": 0
    }
}

2. Establecer Cronogramas (set_schedules)​

Crea múltiples nuevos cronogramas.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "set_schedules",
    "fields": 
        "0": '{
            "device_type": "<Device Type>",
            "node_id": "<Node ID>" (Opcional),
            "start_time": <Unix Timestamp>,
            "end_time": <Unix Timestamp>,
            "policy": "<Policy>",
            "power_setpoint_w": <Setpoint en vatios>,
            "site_import": <Importación del Sitio en Vatios>,
            "site_export": <Exportación del Sitio en Vatios>,
            "remove_overlap": <True/False> (Opcional) (predeterminado=False),
        }', 
        "1": '{
            "device_type": "<Device Type>",
            "node_id": "<Node ID>" (Opcional),
            "start_time": <Unix Timestamp>,
            "end_time": <Unix Timestamp>,
            "policy": "<Policy>",
            "power_setpoint_w": <Setpoint en vatios>,
            "site_import": <Importación del Sitio en Vatios>,
            "site_export": <Exportación del Sitio en Vatios>,
            "remove_overlap": <True/False> (Opcional) (predeterminado=False),
        }', 
        ...
}

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedules_ack",
        "state": {
            "schedule_ids": <IDs de Cronograma>,
            "deleted_ids": <IDs de Cronograma eliminados si remove_overlap=True>
        },
        "responseCode": 0
    }
}

3. Obtener Cronograma (get_schedule)​

Recupera un cronograma específico por ID.

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

Respuesta:

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

4. Obtener Horario Activo (get_active_schedule)​

Recupera el horario actualmente activo 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": <Schedule>,
        "responseCode": 0
    }
}

5. Obtener Siguiente Horario (get_next_schedule)​

Recupera el próximo horario programado 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": <Schedule>,
        "responseCode": 0
    }
}

6. Obtener Horarios (get_schedules)​

Recupera todos los horarios para una fecha específica.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_schedules",
    "fields": {
        "date": "<Date String of Format dd/mm/yyyy>"
    }
}

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "get_schedules_ack",
        "state": {
            "schedules": [<Schedule>, ...]
        },
        "responseCode": 0
    }
}

7. Obtener Horarios Futuros (get_future_schedules)​

Recupera todos los horarios futuros.

{
    "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": [<Schedule>, ...]
        },
        "responseCode": 0
    }
}

8. Eliminar Horario (remove_schedule)​

Elimina un horario específico por ID.

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

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "remove_schedule_ack",
        "state": "Horario <Schedule ID> eliminado con éxito",
        "responseCode": 0
    }
}

9. Obtener Comentarios del Sitio (get_feedback)​

Recupera comentarios detallados sobre el estado del sistema.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_feedback",
    "fields": {
        "device": <Device (node) level>
    }
}

Respuesta (Éxito):

Estructura de Carga Útil de Comentarios

10. Topología del Sitio (get_toplogy)​

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": <nodeType>,
            "nomCurrent": <nominalCurrent>,
            "children": [{<ChildObject>}]
            },
        "responseCode": 0
    }
}

Formato de Respuesta Estándar de Horario​

{
    "id": <Schedule ID>,
    "device_type": "<Device Type>",
    "node_id": "<Node ID>" (Opcional),
    "start_time": <Unix Timestamp>,
    "end_time": <Unix Timestamp>,
    "policy": "<Schedule Policy>",
    "power_setpoint_w": <Setpoint en watts>,
    "created_at": <Unix Timestamp>
}

Tipos de Componente y Políticas​

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

Los horarios específicos de los dispositivos se pueden enviar utilizando el campo opcional node_id, refiriéndose al ID del nodo del dispositivo controlable.

Manejo de Errores​

Todos los mensajes pueden devolver una respuesta de error con responseCode: 1 cuando ocurre un error:

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "<Message Type>_ack",
        "error": <Error Body>,
        "responseCode": 1
    }
}

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

Los errores comunes incluyen:

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

Reglas de Gestión de Horarios​

  1. Reglas de Superposición
    • Los horarios no pueden superponerse para el mismo tipo de dispositivo.
    • Los horarios no pueden superponerse para el mismo dispositivo.
    • Los horarios para el mismo dispositivo y tipo de dispositivo no pueden superponerse.
    • Los horarios existentes que se superponen serán eliminados si la variable remove_overlap se establece en True al crear un nuevo horario.
  2. Cada horario debe tener:
    • Un tipo de dispositivo válido.
    • Un tiempo de inicio (timestamp Unix).
    • Un tiempo de finalización (timestamp Unix).
    • Una política (que coincida con las políticas disponibles para el tipo de dispositivo).
    • Un punto de ajuste de potencia (para políticas que lo requieran).
  3. El tiempo de inicio debe ser antes del tiempo de finalización.
  4. Si el tiempo de inicio está en el pasado, se cambia automáticamente para empezar ahora.
  5. Los horarios solo pueden ser eliminados si aún no han comenzado. Los horarios activos no pueden ser eliminados.
  6. Los horarios se pueden establecer para diferentes tipos de dispositivos de manera independiente.
  7. El sistema aplica automáticamente la política adecuada cuando un horario se vuelve activo.