Sofar logo
Sofar logo
Accesorios
AplicaciónAvisos de seguridad, mantenimiento y legalesCertificados
Configuración de la A a la Z
ControladorDirectrices de cableado y conectividad
Dispositivos
Especificaciones
Específico del Cliente
Inicio rápidoInstalaciónLEDs de estadoLicenciaRed
Resolución de problemas
Señales Externas
DSO

AgrolaAPI de planificación anticipadaAutarcoAxpoCaja de fusiblesComercio Dinámico de EnergíaControl del Relé DNOCorriente de haloDexterEdmijElia
Elindus
Energía BEEEnergía CompañeraEnergía VGTEnervalisEngieEPEX Spot SolarFlorFrank EnergieGreenchoiceImbyKratTradeMercancías Europeas
Monitoreo
Mqtt
Control MQTT programadoFlujo de incorporaciónLíneas baseLive MQTT controlPlanta de Energía Virtual
Nuevas integracionesOpinumPárrafo 14a IntegraciónPleeviPoder FlecoPróxima EnergíaPruebas diagnósticasRepotenciadoScholtSoluciones de Flexibilidad Energética (SFE)
TrevionYuso - Control de BateríaYuso - Reducción Solar
Tiempo de respuesta del control
Señales ExternasMqtt
Consejo
Consejo

El control MQTT programado está pensado para mensajes programados con anticipación. Para control en vivo, consulte Live MQTT Control en su lugar.

Esta guía le ayudará a configurar MQTT en su Sofar para controlar y monitorizar de forma remota instalaciones de baterías y paneles solares.

Lo que necesita

  1. EMS
    Image 1
    con conectividad a internet.
  2. Credenciales MQTT: Puede solicitarlas a nuestro Equipo de Soporte.
  3. Entorno de desarrollo Python (u otro cliente MQTT). Esta guía usa un ejemplo básico escrito en Python para que empiece con MQTT y el envío de comandos. Recomendamos usar Python por su facilidad, pero cualquier cliente MQTT es compatible.

Información extra

MQTT es un protocolo de comunicación rápido sobre internet. Es un sistema de mensajes de publicar/suscribir, que permite una conexión directa entre su equipo y el

Image 1
Image 1
. Sus activos se clasifican en grupos de solar, batería, EV y HVAC.

Configuración por primera vez (Punto de partida para nuevos usuarios)

Tengo un

Image 1
Sofar que quiero configurar para Control Remoto MQTT.

1. Verifique su red

Asegúrese de que su red permita tráfico MQTT a través del puerto 1883. Puede comprobarlo con el comando:

nc -zv mqtt.eniris.be 1883

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

En caso de dudas, consulte a su ingeniero de red o use temporalmente el hotspot 4G/5G de su teléfono si ocurren errores de conexión.

Nota
Nota

Cuando el puerto 1883 no está accesible desde su red, ofrecemos una alternativa en el puerto 80. Esto se puede configurar en su cliente MQTT en un paso posterior de este manual.

2. Añada sus dispositivos

Inicie sesión en la interfaz de puesta en marcha y asegúrese de que los dispositivos están añadidos al Sofar EMS.

3. Añada la señal externa MQTT

Image 1
Image 1
Image 1

4. Active la señal remota MQTT

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

Image 1

5. Se añade la señal remota

La interfaz Control Remoto MQTT ahora se ha activado en el Sofar EMS.

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

Script demo en Python

Un buen punto de partida es probar su nueva integración 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 en 10 minutos
  • Solar: Establecer potencia a 0 kW durante una hora en 30 minutos

El Sofar EMS responde con un mensaje de reconocimiento que contiene el identificador único de la programación, o un mensaje de error.

Luego obtenemos la siguiente programación para ambos tipos de dispositivo, confirmando que el comando fue exitoso.

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

Si lo anterior es exitoso, 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 mensajes MQTT y los requerimientos de carga útil para configurar el control programado de dispositivos dentro de la red del Sofar EMS.

Temas MQTT

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

Donde True debe ser reemplazado por el número de serie real del Sofar EMS que pretende controlar.

Tipos de mensaje 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 Timestamp>,
        "end_time": <Unix Timestamp>,
        "policy": "<Policy>",
        "power_setpoint_w": <Setpoint en vatios>,
        "site_import": <Importe local en vatios>,
        "site_export": <Exporte local en vatios>,
        "remove_overlap": <True/False> (Opcional) (por defecto=False),
        "tag": <Cadena de etiqueta> (Opcional) (por defecto=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 programación eliminados si remove_overlap=True>
            "tag": <Cadena de etiqueta> (por defecto=None),
        },
        "responseCode": 0
    }
}

2. Establecer programaciones (general_error)

Crea múltiples nuevas programaciones.

{
    "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": <Importe local en vatios>,
            "site_export": <Exporte local en vatios>,
            "remove_overlap": <True/False> (Opcional) (por defecto=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": <Importe local en vatios>,
            "site_export": <Exporte local en vatios>,
            "remove_overlap": <True/False> (Opcional) (por defecto=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 programación>,
            "deleted_ids": <IDs de programación eliminados si remove_overlap=True>
        },
        "responseCode": 0
    }
}

3. Obtener programación (general_error)

Obtiene una programación específica 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 programación activa (general_error)

Obtiene la programación activa actual 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 próxima programación (general_error)

Obtiene la siguiente programación próxima 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 programaciones (general_error)

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

7. Obtener programaciones futuras (general_error)

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

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": <Schedule ID>
    }
}

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "remove_schedule_ack",
        "state": "Programación <Schedule ID> eliminada exitosamente",
        "responseCode": 0
    }
}

9. Obtener retroalimentación del sitio (general_error)

Obtiene retroalimentación detallada sobre el estado del sistema.

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

Respuesta (Éxito):

Estructura de la carga de retroalimentación

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>,
            "isControllable": <booleano>,
            "nodeType": <tipoNodo>,
            "nomCurrent": <corrienteNominal>
            "children": [{<ObjetoHijo>}]
            },
        "responseCode": 0
    }
}

Formato estándar de respuesta de programación

{
    "id": <Schedule ID>,
    "device_type": "<Tipo de dispositivo>",
    "node_id": "<ID del nodo>" (Opcional),
    "start_time": <Unix Timestamp>,
    "end_time": <Unix Timestamp>,
    "policy": "<Política de programación>",
    "power_setpoint_w": <Setpoint en vatios>,
    "created_at": <Unix Timestamp>
}

Tipos de componentes y políticas

Para detalles sobre los componentes disponibles y políticas que pueden programarse, consulte la sección MQTT Components and Policies en la documentación de Live MQTT Control.

Las programaciones específicas por dispositivo se pueden enviar usando el campo opcional general_error que hace referencia al ID del nodo del dispositivo controlable.

Manejo de errores

Todos los mensajes pueden devolver 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": 1
    }
}

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

Errores comunes incluyen:

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

Reglas de gestión de programación

  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 se establece en 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 fin (marca de tiempo Unix)
    • Una política (que coincida con las políticas disponibles para el tipo de dispositivo)
    • Un setpoint de potencia (para políticas que lo requieren)
  3. La hora de inicio debe ser anterior a la hora de fin
  4. Si la hora de inicio está en el pasado, se cambia automáticamente para comenzar ahora
  5. Las programaciones sólo pueden eliminarse si aún no han comenzado. Las programaciones activas no pueden eliminarse.
  6. Las programaciones pueden configurarse para diferentes tipos de dispositivos independientemente
  7. El sistema aplica automáticamente la política adecuada cuando una programación se vuelve activa

Mqtt

Previous Page

Flujo de incorporación

Next Page

On this page

Lo que necesitaInformación extraConfiguración por primera vez (Punto de partida para nuevos usuarios)1. Verifique su red2. Añada sus dispositivos3. Añada la señal externa MQTT4. Active la señal remota MQTT5. Se añade la señal remotaScript demo en PythonDocumentación MQTT para envío de comandosTemas MQTTTipos de mensaje MQTT1. Establecer programación (set_schedule)2. Establecer programaciones (general_error)3. Obtener programación (general_error)4. Obtener programación activa (general_error)5. Obtener próxima programación (general_error)6. Obtener programaciones (general_error)7. Obtener programaciones futuras (general_error)8. Eliminar programación (general_error)9. Obtener retroalimentación del sitio (general_error)10. Topología del sitio (general_error)Formato estándar de respuesta de programaciónTipos de componentes y políticasManejo de erroresReglas de gestión de programación