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 utilizar Python por su facilidad de uso, pero cualquier otro cliente MQTT es compatible.

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 tu máquina y el SmartgridOne Controller. Tus activos se clasifican en grupos de solar, batería, EV y HVAC. En este momento, esta integración permite el 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 el tráfico de red mqtt a través del puerto 1883. Puedes hacerlo utilizando el comando:

nc -zv mqtt.eniris.be 1883

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

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

nota

Cuando el puerto 1883 no sea accesible desde tu red, ofrecemos una copia de seguridad en el puerto 80. Esto se puede configurar en tu cliente MQTT en un paso posterior de 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 al SmartgridOne Controller.

3. Agrega la señal externa MQTT​

Imagen 1
Imagen 1
Imagen 1

4. Habilita la señal remota MQTT​

Selecciona todos los dispositivos que desees incluir en el Control Remoto MQTT.

Imagen 1

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 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 partida sería probar tu nueva integración con un ejemplo simple.

Este código de prueba realiza una tarea simple de enviar continuamente el siguiente horario:

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

El SmartgridOne Controller responde con un mensaje de reconocimiento que contiene el identificador único del horario, o un mensaje de error.

Luego recuperamos el siguiente horario 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 tus 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 Envío de 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 deseas controlar.

Tipos de Mensajes MQTT​

1. Establecer Horario (set_schedule)​

Crea un nuevo horario 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 in watts>,
        "replace_overlap": <True/False> (Opcional) (default=False)
    }
}

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": <Schedulde IDs deleted if replace_overlap=True>
        },
        "responseCode": 0
    }
}

2. Obtener Horario (get_schedule)​

Recupera un horario 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
    }
}

3. 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
    }
}

4. 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
    }
}

5. 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": "<Fecha en formato dd/mm/yyyy>"
    }
}

Response (Success):

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

6. 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": {}
}

Response (Success):

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

7. 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>
    }
}

Response (Success):

{
    "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
    }
}

8. 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": {}
}

Response (Success):

Estructura de Carga Útil de Comentarios

Formato Estándar de Respuesta del 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 Componentes y Políticas​

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

Los horarios específicos de dispositivos pueden enviarse 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 no válido
  • Tipo de dispositivo no encontrado
  • ID de horario no encontrado
  • Política no vá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 replace_overlap está configurada 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 del 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. El tiempo de inicio debe ser al menos cinco minutos en el futuro
  5. Los horarios solo pueden eliminarse si comienzan al menos cinco minutos en el futuro
  6. Los horarios pueden establecerse para diferentes tipos de dispositivos de forma independiente
  7. El sistema aplica automáticamente la política adecuada cuando un horario se activa.