SmartgridOne logo
SmartgridOne logo
SchnellstartInstallationNetzwerkVerdrahtungs- und AnschlussrichtlinienApp
AgrolaAutarcoAxpoBEE EnergieBegleitenergieDynamischer EnergiehandelDexterDNO RelaissteuerungEdmijEnergie-Flexibilitätslösungen (EFS)EliaEnervalisEngiePlan-ahead APIEPEX Spot SolarEuropäische RohstoffeBlumeFrank EnergieSicherungskastenGreenchoiceHallostromImbyJouleKratTradeNeue IntegrationenNächste EnergieOpinumParagraph 14a IntegrationPleeviNachgerüstetScholtTrevionVGT EnergieYuso - BatteriekontrolleYuso - Solar-Drosselung
Live MQTT controlGeplante MQTT-SteuerungVirtuelles Kraftwerk
SpezifikationenStatus-LEDsSteuerantwortzeitVideo-TutorialsZertifikateLizenzSicherheits-, Wartungs- und rechtliche Hinweise
External SignalsMQTT
Tip

Die geplante MQTT-Steuerung ist für geplante Nachrichten im Voraus gedacht. Für die Live-Steuerung siehe stattdessen Live MQTT Control.

Diese Anleitung hilft Ihnen, MQTT auf Ihrem SmartgridOne Controller zu konfigurieren, um Fernsteuerung und Überwachung von Batterie- und Solaranlagen zu ermöglichen.

Was Sie benötigen

  1. SmartgridOne Controller mit Internetverbindung.
  2. MQTT-Anmeldeinformationen: Diese können von unserem Support-Team angefordert werden.
  3. Python-Entwicklungsumgebung (oder einen anderen MQTT-Client). Diese Anleitung verwendet ein einfaches Beispiel, das in Python geschrieben ist, um Ihnen den Einstieg in MQTT und das Senden von Kommandos zu erleichtern. Wir empfehlen die Verwendung von Python wegen der Benutzerfreundlichkeit, aber jeder andere MQTT-Client wird unterstützt.

Zusätzliche Informationen

MQTT ist ein schneller Kommunikationsprotokoll über das Internet. Es handelt sich um ein Publish/Subscribe-Nachrichtensystem, das eine direkte Verbindung zwischen Ihrer Maschine und dem SmartgridOne Controller ermöglicht. Ihre Assets sind in Gruppen zu Solar, Batterie, EV und HVAC klassifiziert. Momentan erlaubt diese Integration die Steuerung nach Gruppen, nicht nach Gerät.

Ersteinrichtung (Ausgangspunkt für neue Benutzer)

Ich habe ein SmartgridOne Controller-Gerät, das ich für die MQTT-Fernsteuerung einrichten möchte.

1. Überprüfen Sie Ihr Netzwerk

Stellen Sie sicher, dass Ihr Netzwerk MQTT-Netzwerkverkehr über Port 1883 zulässt. Sie können dies mit dem Befehl überprüfen:

nc -zv mqtt.eniris.be 1883

Wenn dieser Befehl nicht verfügbar ist, können Sie alternativ diesen Python-Code herunterladen und ausführen.

Wenn Sie Zweifel haben, konsultieren Sie Ihren Netzwerkingenieur oder verwenden Sie vorübergehend den 4G/5G-Hotspot Ihres Smartphones, wenn Verbindungsfehler auftreten.

Note

Wenn Port 1883 von Ihrem Netzwerk nicht zugänglich ist, bieten wir einen Backup-Server auf Port 80 an. Dieser kann in Ihrem MQTT-Client in einem späteren Schritt in diesem Handbuch konfiguriert werden.

2. Geräte hinzufügen

Anmelden an der Inbetriebnahmeoberfläche und sicherstellen, dass die Geräte hinzugefügt wurden zum SmartgridOne Controller.

3. MQTT-Außensignal hinzufügen

Bild 1
Bild 1
Bild 1

4. MQTT-Fernsignal aktivieren

Wählen Sie alle Geräte aus, die Sie in die MQTT-Fernsteuerung einbeziehen möchten.

Bild 1

5. Fernsignal wurde hinzugefügt

Die MQTT-Fernsteuerungsoberfläche wurde nun auf dem SmartgridOne Controller aktiviert.

Wir sind jetzt bereit, einige grundlegende Befehle mit einem einfachen Beispiel zu senden. Die Statusspalte zeigt Ihnen an, ob ein Befehl aktiv ist.

Python-Demo-Skript

Ein guter Ausgangspunkt wäre, Ihre neu eingerichtete Integration mit einem einfachen Beispiel zu testen.

Dieser Testcode führt eine einfache Aufgabe aus, indem er kontinuierlich den folgenden Zeitplan sendet:

  • Batterie: Laden mit 5 kW für 15 Minuten und alle 10 Minuten
  • Solar: Setzen Sie die Leistung auf 0 kW für eine Stunde alle 30 Minuten

Der SmartgridOne Controller antwortet mit einer Bestätigungsnachricht, die die eindeutige Zeitplan-ID enthält, oder mit einer Fehlermeldung.

Wir holen dann den nächsten Zeitplan für beide Gerätetypen ab und bestätigen, dass der Befehl erfolgreich war.

Bitte laden Sie die Datei unten in Ihrer bevorzugten Python-IDE herunter. Füllen Sie Ihre Seriennummer und MQTT-Anmeldeinformationen ein und führen Sie das Skript aus:

Wenn die obigen Schritte erfolgreich sind, können Sie mit dem Senden anderer Arten von Nachrichten fortfahren. Alle Nachrichten sind unten beschrieben.

MQTT-Dokumentation zum Senden von Befehlen

Dieser Abschnitt beschreibt das MQTT-Nachrichtenformat und die Payload-Anforderungen für die Einrichtung der zeitgesteuerten Steuerung von Geräten innerhalb des Netzwerks des SmartgridOne Controller.

MQTT-Themen

  • Abonnieren des Themas: standard1/rp_one_s/remoteScheduleMetrics/<controller SN>
  • Feedback-Thema: standard1/outbound/remoteScheduleMetrics/feedback/<controller SN>

Dabei sollte <controller SN> durch die tatsächliche Seriennummer des SmartgridOne Controller ersetzt werden, den Sie steuern möchten.

MQTT-Nachrichtentypen

1. Zeitplan festlegen (set_schedule)

Erstellt einen neuen Zeitplan für einen Gerätetyp.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "set_schedule",
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Optional),
        "start_time": <Unix Timestamp>,
        "end_time": <Unix Timestamp>,
        "policy": "<Policy>",
        "power_setpoint_w": <Setpoint in watts>,
        "site_import": <Site Import in Watts>,
        "site_export": <Site Export in Watts>,
        "remove_overlap": <True/False> (Optional) (default=False),
        "tag": <Tag String> (Optional) (default=None),
    }
}

Antwort (Erfolg):

{
    "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 remove_overlap=True>
            "tag": <Tag String> (default=None),
        },
        "responseCode": 0
    }
}

2. Zeitpläne festlegen (set_schedules)

Erstellt mehrere neue Zeitpläne.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "set_schedules",
    "fields": 
        "0": "{
            "device_type": "<Device Type>",
            "node_id": "<Node ID>" (Optional),
            "start_time": <Unix Timestamp>,
            "end_time": <Unix Timestamp>,
            "policy": "<Policy>",
            "power_setpoint_w": <Setpoint in watts>,
            "site_import": <Site Import in Watts>,
            "site_export": <Site Export in Watts>,
            "remove_overlap": <True/False> (Optional) (default=False),
        }",
        "1": "{
            "device_type": "<Device Type>",
            "node_id": "<Node ID>" (Optional),
            "start_time": <Unix Timestamp>,
            "end_time": <Unix Timestamp>,
            "policy": "<Policy>",
            "power_setpoint_w": <Setpoint in watts>,
            "site_import": <Site Import in Watts>,
            "site_export": <Site Export in Watts>,
            "remove_overlap": <True/False> (Optional) (default=False),
        }",
        ...
}

Antwort (Erfolg):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedules_ack",
        "state": {
            "schedule_ids": <Schedule IDs>,
            "deleted_ids": <Schedulde IDs deleted if remove_overlap=True>
        },
        "responseCode": 0
    }
}

3. Zeitplan abrufen (get_schedule)

Ruft einen bestimmten Zeitplan nach ID ab.

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

Antwort:

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

4. Aktiven Zeitplan abrufen (get_active_schedule)

Ruft den derzeit aktiven Zeitplan für einen Gerätetyp ab.

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

Antwort (Erfolg):

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

5. Nächsten Zeitplan abrufen (get_next_schedule)

Ruft den nächsten kommenden Zeitplan für einen Gerätetyp ab.

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

Antwort (Erfolg):

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

6. Zeitpläne abrufen (get_schedules)

Ruft alle Zeitpläne für ein bestimmtes Datum ab.

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

Antwort (Erfolg):

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

7. Zukünftige Zeitpläne abrufen (get_future_schedules)

Ruft alle zukünftigen Zeitpläne ab.

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

Antwort (Erfolg):

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

8. Zeitplan entfernen (remove_schedule)

Entfernt einen bestimmten Zeitplan nach ID.

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

Antwort (Erfolg):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "remove_schedule_ack",
        "state": "Zeitplan <Schedule ID> erfolgreich entfernt",
        "responseCode": 0
    }
}

9. Standort-Feedback abrufen (get_feedback)

Ruft detailliertes Feedback zum Zustand des Systems ab.

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

Antwort (Erfolg):

Feedback-Payload-Struktur

10. Standorttopologie (get_toplogy)

Erhält die Topologie des Standorts.

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

Antwort (Erfolg):

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

Standardantwortformat für Zeitpläne

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

Komponentenarten und Richtlinien

Für Details zu verfügbaren Komponenten und Richtlinien, die geplant werden können, siehe den Abschnitt MQTT-Komponenten und -Richtlinien in der Live MQTT Control-Dokumentation.

Gerätespezifische Zeitpläne können unter Verwendung des optionalen node_id-Feldes gesendet werden, das sich auf die Knoten-ID des steuerbaren Geräts bezieht.

Fehlerbehandlung

Alle Nachrichten können bei Auftreten eines Fehlers eine Fehlermeldung mit responseCode: 1 zurückgeben:

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

Wenn ein nicht verwandter Fehler auftritt, wird der Nachrichtentyp general_error sein.

Häufige Fehler sind:

  • Überschneidung von Zeitplänen mit bestehenden Zeitplänen
  • Ungültiger Zeitbereich
  • Gerätetyp nicht gefunden
  • Zeitplan-ID nicht gefunden
  • Ungültige Richtlinie für den Gerätetyp

Regeln für die Zeitplanverwaltung

  1. Überlappungsregeln
    • Zeitpläne dürfen sich nicht für denselben Gerätetyp überschneiden
    • Zeitpläne dürfen sich nicht für dasselbe Gerät überschneiden
    • Zeitpläne für dasselbe Gerät und Gerätetyp dürfen sich nicht überschneiden
    • Vorhandene, sich überschneidende Zeitpläne werden gelöscht, wenn die Variable remove_overlap beim Erstellen eines neuen Zeitplans auf True gesetzt ist.
  2. Jeder Zeitplan muss haben:
    • Einen gültigen Gerätetyp
    • Eine Startzeit (Unix-Zeitstempel)
    • Eine Endzeit (Unix-Zeitstempel)
    • Eine Richtlinie (die zu den verfügbaren Richtlinien des Gerätetyps passt)
    • Ein Leistungsziel (für Richtlinien, die dies erfordern)
  3. Die Startzeit muss vor der Endzeit liegen
  4. Wenn die Startzeit in der Vergangenheit liegt, wird sie automatisch auf jetzt geändert
  5. Zeitpläne können nur gelöscht werden, wenn sie noch nicht gestartet sind. Aktive Zeitpläne können nicht gelöscht werden.
  6. Zeitpläne können unabhängig für verschiedene Gerätetypen festgelegt werden
  7. Das System wendet automatisch die entsprechende Richtlinie an, wenn ein Zeitplan aktiv wird

Live MQTT control

Previous Page

Virtuelles Kraftwerk

Next Page

On this page

Was Sie benötigenZusätzliche InformationenErsteinrichtung (Ausgangspunkt für neue Benutzer)1. Überprüfen Sie Ihr Netzwerk2. Geräte hinzufügen3. MQTT-Außensignal hinzufügen4. MQTT-Fernsignal aktivieren5. Fernsignal wurde hinzugefügtPython-Demo-SkriptMQTT-Dokumentation zum Senden von BefehlenMQTT-ThemenMQTT-Nachrichtentypen1. Zeitplan festlegen (set_schedule)2. Zeitpläne festlegen (set_schedules)3. Zeitplan abrufen (get_schedule)4. Aktiven Zeitplan abrufen (get_active_schedule)5. Nächsten Zeitplan abrufen (get_next_schedule)6. Zeitpläne abrufen (get_schedules)7. Zukünftige Zeitpläne abrufen (get_future_schedules)8. Zeitplan entfernen (remove_schedule)9. Standort-Feedback abrufen (get_feedback)10. Standorttopologie (get_toplogy)Standardantwortformat für ZeitpläneKomponentenarten und RichtlinienFehlerbehandlungRegeln für die Zeitplanverwaltung