SmartgridOne logo
SmartgridOne logo
Accesorios
AplicaciónAvisos de seguridad, mantenimiento y legales
Caja de herramientas
Certificados
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 fusiblesCKWComercio Dinámico de EnergíaControl del Relé DNOCorriente de haloDexterEdmijElia
Elindus
Energía BEEEnergía CompañeraEnergía VGTEnervalisEngieEPEX Spot SolarFlorFrank EnergieGreenchoiceHive PowerImbyKratTradeMercancías Europeas
Monitoreo
Mqtt
Control MQTT programadoFCRFlujo de incorporaciónLíneas baseLive MQTT controlPlanta de Energía Virtual
Nuevas integracionesOpinumPárrafo 14a IntegraciónPleeviPoder FlecoPowernautPróxima EnergíaPruebas diagnósticasRepotenciadoScholtSoluciones de Flexibilidad Energética (SFE)
TrevionYuso - Control de BateríaYuso - Reducción Solar
Tiempo de respuesta del controlTutoriales en video
Señales ExternasMqtt

Control MQTT Programado

Consejo
Consejo

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

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

Lo que necesita

  1. Controller
    Image 1
    con conectividad a internet.
  2. Credenciales MQTT: Pueden solicitarse a nuestro Equipo de Soporte.
  3. Entorno de desarrollo Python (o cualquier otro cliente MQTT). Esta guía utiliza un ejemplo básico escrito en Python para que comience con MQTT y envío de comandos. Recomendamos usar Python por su facilidad, 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 su máquina y el

Image 1
Image 1
. Sus activos están clasificados en grupos: solar, batería, EV y HVAC.

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

Tengo un

Image 1
SmartgridOne que deseo configurar para Control Remoto MQTT.

1. Verifique su red

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

nc -zv mqtt.eniris.be 1883

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

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

Nota
Nota

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

2. Agregue sus dispositivos

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

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ñal remota añadida

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

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

Script de demostración en Python

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

Este código de prueba realiza continuamente el siguiente programa:

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

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

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

Por favor descargue el archivo siguiente en su IDE de 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 requisitos de payload para configurar el control programado de dispositivos dentro de la red del SmartgridOne Controller.

Temas MQTT

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

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

Tipos de Mensajes MQTT

1. Establecer Programa (set_schedule)

Crea un nuevo programa 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": <Punto de ajuste en vatios>,
        "site_import": <Importación del sitio en vatios>,
        "site_export": <Exportación del sitio en vatios>,
        "remove_overlap": <True/False> (Opcional) (default=False),
        "tag": <Cadena de etiqueta> (Opcional) (default=None),
    }
}

Respuesta (Éxito):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedule_ack",
        "state": {
            "schedule_id": <ID del Programa>,
            "deleted_ids": <IDs de programas eliminados si remove_overlap=True>
            "tag": <Cadena de etiqueta> (default=None),
        },
        "responseCode": 0
    }
}

2. Establecer Programas (general_error)

Crea múltiples programas nuevos.

{
    "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": <Punto de ajuste en vatios>,
            "site_import": <Importación del sitio en vatios>,
            "site_export": <Exportación del sitio en vatios>,
            "remove_overlap": <True/False> (Opcional) (default=False),
        }",
        "1": "{
            "device_type": "<Device Type>",
            "node_id": "<Node ID>" (Opcional),
            "start_time": <Unix Timestamp>,
            "end_time": <Unix Timestamp>,
            "policy": "<Policy>",
            "power_setpoint_w": <Punto de ajuste en vatios>,
            "site_import": <Importación del sitio en vatios>,
            "site_export": <Exportación del sitio en vatios>,
            "remove_overlap": <True/False> (Opcional) (default=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 Programas>,
            "deleted_ids": <IDs de programas eliminados si remove_overlap=True>
        },
        "responseCode": 0
    }
}

3. Obtener Programa (general_error)

Recupera un programa específico por ID.

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

Respuesta:

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

4. Obtener Programa Activo (general_error)

Recupera el programa 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": <Programa>,
        "responseCode": 0
    }
}

5. Obtener Siguiente Programa (general_error)

Recupera el próximo programa 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": <Programa>,
        "responseCode": 0
    }
}

6. Obtener Programas (general_error)

Recupera todos los programas 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": [<Programa>, ...]
        },
        "responseCode": 0
    }
}

7. Obtener Programas Futuros (general_error)

Recupera todos los programas 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": [<Programa>, ...]
        },
        "responseCode": 0
    }
}

8. Eliminar Programa (general_error)

Elimina un programa específico por ID.

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

Respuesta (Éxito):

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

9. Retroalimentación del Sitio (general_error)

Recupera retroalimentación detallada sobre el estado del sistema.

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

Respuesta (Éxito):

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

Formato Estándar de Respuesta de Programa

{
    "id": <ID del Programa>,
    "device_type": "<Tipo de Dispositivo>",
    "node_id": "<ID del Nodo>" (Opcional),
    "start_time": <Unix Timestamp>,
    "end_time": <Unix Timestamp>,
    "policy": "<Política del Programa>",
    "power_setpoint_w": <Punto de ajuste en vatios>,
    "created_at": <Unix Timestamp>
}

Tipos de Componentes y Políticas

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

Los programas específicos 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 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 programas con programas existentes
  • Rango de tiempo inválido
  • Tipo de dispositivo no encontrado
  • ID de programa no encontrado
  • Política inválida para el tipo de dispositivo

Reglas de Gestión de Programas

  1. Reglas de Superposición
    • Los programas no pueden superponerse para el mismo tipo de dispositivo
    • Los programas no pueden superponerse para el mismo dispositivo
    • Los programas para el mismo dispositivo y tipo de dispositivo no pueden superponerse
    • Los programas existentes que se superpongan serán eliminados si la variable remove_overlap se establece en True al crear un nuevo programa.
  2. Cada programa debe tener:
    • Un tipo de dispositivo válido
    • Una hora de inicio (Unix timestamp)
    • Una hora de fin (Unix timestamp)
    • 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. La hora de inicio debe ser anterior a la de fin
  4. Si la hora de inicio es en el pasado, se cambia automáticamente para empezar ahora
  5. Los programas solo pueden eliminarse si aún no han comenzado. Los programas activos no pueden eliminarse.
  6. Los programas pueden establecerse para diferentes tipos de dispositivos de forma independiente
  7. El sistema aplica automáticamente la política adecuada cuando un programa se activa
Last updated July 9, 2026Edit this page

Mqtt

Previous Page

FCR

Next Page

On this page

Control MQTT ProgramadoLo que necesitaInformación adicionalConfiguración inicial (Punto de partida para nuevos usuarios)1. Verifique su red2. Agregue sus dispositivos3. Añada la señal externa MQTT4. Active la señal remota MQTT5. Señal remota añadidaScript de demostración en PythonDocumentación MQTT para Envío de ComandosTemas MQTTTipos de Mensajes MQTT1. Establecer Programa (set_schedule)2. Establecer Programas (general_error)3. Obtener Programa (general_error)4. Obtener Programa Activo (general_error)5. Obtener Siguiente Programa (general_error)6. Obtener Programas (general_error)7. Obtener Programas Futuros (general_error)8. Eliminar Programa (general_error)9. Retroalimentación del Sitio (general_error)10. Topología del Sitio (general_error)Formato Estándar de Respuesta de ProgramaTipos de Componentes y PolíticasManejo de ErroresReglas de Gestión de Programas