SmartgridOne logo
SmartgridOne logo
Accessoires
Appareils
Application
Boîte à outils
Certificats
Configuration de A à Z
Consignes de sécurité, d'entretien et avis légauxContrôleurDémarrage rapide
Dépannage
Directives de câblage et de connectivitéInstallationLED de statutLicenseRéseau
Signaux externes
ODS

AgrolaAPI Planification anticipéeAutarcoAxpoBoîtier de fusiblesContrôle du relais DNODexterEdmijElia
Elindus
Énergie BEEÉnergie CompagnonÉnergie VGTEnervalisEngieEPEX Spot SolaireFleco PowerFleurFrank EnergieGreenchoiceHallostroomImbyKratTrade
Mqtt
Centrale électrique virtuelleContrôle MQTT programméLignes de baseLive MQTT controlProcessus d'intégration
Négociation dynamique d'énergieNext ÉnergieNouvelles intégrationsOpinumParagraphe 14a IntégrationPleeviProduits de base européensReconvertiScholtSolutions de Flexibilité Énergétique (EFS)
Surveillance
Tests diagnosticsTrevionYuso - Contrôle de la BatterieYuso - Réduction solaire
Spécifications
Spécifique au client
Temps de réponse du contrôleTutoriels vidéo
Signaux externesMqtt
Astuce
Astuce

Le contrôle MQTT planifié est destiné aux messages programmés à l'avance. Pour le contrôle en direct, voir Contrôle MQTT en direct à la place.

Ce guide vous aidera à configurer MQTT sur votre SmartgridOne pour contrôler et surveiller à distance des installations de batterie et de panneaux solaires.

Ce dont vous avez besoin

  1. Controller
    Image 1
    avec connectivité Internet.
  2. Identifiants MQTT : Ceux-ci peuvent être demandés à notre équipe de support.
  3. Environnement de développement Python (ou tout autre client MQTT). Ce guide utilise un exemple simple écrit en Python pour vous initier à MQTT et à l'envoi de commandes. Nous recommandons d’utiliser Python pour sa facilité d’utilisation, mais tout autre client MQTT est pris en charge.

Informations supplémentaires

MQTT est un protocole de communication rapide sur Internet. C’est un système de messagerie publish/subscribe, qui permet une connexion directe entre votre machine et le

Image 1
Image 1
. Vos actifs sont classés en groupes solaire, batterie, VE et CVC.

Configuration initiale (point de départ pour les nouveaux utilisateurs)

Je dispose d’un

Image 1
SmartgridOne que je souhaite configurer pour le contrôle à distance MQTT.

1. Vérifiez votre réseau

Assurez-vous que votre réseau autorise le trafic mqtt sur le port 1883. Vous pouvez le vérifier avec la commande :

nc -zv mqtt.eniris.be 1883

Si cette commande n’est pas disponible, vous pouvez alternativement télécharger et exécuter le code python :

En cas de doute, consultez votre ingénieur réseau ou utilisez temporairement le hotspot 4G/5G de votre téléphone en cas d’erreur de connexion.

Note
Note

Lorsque le port 1883 n'est pas accessible depuis votre réseau, nous proposons un backup sur le port 80. Cela peut être configuré dans votre client MQTT lors d'une étape ultérieure de ce manuel.

2. Ajoutez vos appareils

Connectez-vous à l’interface de mise en service et assurez-vous que les appareils sont ajoutés au SmartgridOne Controller.

3. Ajoutez le signal externe MQTT

Image 1
Image 1
Image 1

4. Activez le signal distant MQTT

Sélectionnez tous les appareils que vous souhaitez inclure dans le contrôle à distance MQTT.

Image 1

5. Signal distant ajouté

L’interface de contrôle à distance MQTT est désormais activée sur le SmartgridOne Controller.

Nous sommes maintenant prêts à envoyer quelques commandes de base à l’aide d’un exemple simple. La colonne Statut vous indique si une commande est active.

Script de démonstration Python

Un bon point de départ serait de tester votre intégration nouvellement configurée avec un exemple simple.

Ce code de test fait une tâche simple d’envoi continu du planning suivant :

  • Batterie : Charger à 5 kW pendant 15 minutes dans 10 minutes
  • Solaire : Mettre la puissance à 0 kW pendant une heure dans 30 minutes

Le SmartgridOne Controller répond avec un message d’accusé de réception contenant l’identifiant unique du planning, ou un message d’erreur.

Nous récupérons ensuite le planning suivant pour les deux types d’appareils, confirmant que la commande a réussi.

Veuillez télécharger le fichier ci-dessous dans votre IDE Python préféré. Remplissez votre numéro de série et les identifiants MQTT puis exécutez le script :

Une fois ce test réussi, vous pouvez continuer à envoyer d’autres types de messages. Tous les messages sont décrits ci-dessous.

Documentation MQTT pour l’envoi de commandes

Cette section détaille le format des messages MQTT et les exigences des charges utiles pour configurer le contrôle planifié des appareils dans le réseau du SmartgridOne Controller.

Sujets MQTT

  • Sujet d’abonnement : general_error
  • Sujet de retour d’information : remove_overlap

Où True doit être remplacé par le numéro de série réel du SmartgridOne Controller que vous souhaitez contrôler.

Types de messages MQTT

1. Définir Planning (set_schedule)

Crée un nouveau planning pour un type d’appareil.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "set_schedule",
    "fields": {
        "device_type": "<Device Type>",
        "node_id": "<Node ID>" (Optionnel),
        "start_time": <Unix Timestamp>,
        "end_time": <Unix Timestamp>,
        "policy": "<Policy>",
        "power_setpoint_w": <Consigne en watts>,
        "site_import": <Import du site en Watts>,
        "site_export": <Export du site en Watts>,
        "remove_overlap": <True/False> (Optionnel) (par défaut=False),
        "tag": <Chaîne de tags> (Optionnel) (par défaut=None),
    }
}

Réponse (Succès) :

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedule_ack",
        "state": {
            "schedule_id": <ID du planning>,
            "deleted_ids": <IDs des plannings supprimés si remove_overlap=True>
            "tag": <Chaîne de tags> (par défaut=None),
        },
        "responseCode": 0
    }
}

2. Définir Plannings (general_error)

Crée plusieurs nouveaux plannings.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "set_schedules",
    "fields": 
        "0": "{
            "device_type": "<Device Type>",
            "node_id": "<Node ID>" (Optionnel),
            "start_time": <Unix Timestamp>,
            "end_time": <Unix Timestamp>,
            "policy": "<Policy>",
            "power_setpoint_w": <Consigne en watts>,
            "site_import": <Import du site en Watts>,
            "site_export": <Export du site en Watts>,
            "remove_overlap": <True/False> (Optionnel) (par défaut=False),
        }",
        "1": "{
            "device_type": "<Device Type>",
            "node_id": "<Node ID>" (Optionnel),
            "start_time": <Unix Timestamp>,
            "end_time": <Unix Timestamp>,
            "policy": "<Policy>",
            "power_setpoint_w": <Consigne en watts>,
            "site_import": <Import du site en Watts>,
            "site_export": <Export du site en Watts>,
            "remove_overlap": <True/False> (Optionnel) (par défaut=False),
        }",
        ...
}

Réponse (Succès) :

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedules_ack",
        "state": {
            "schedule_ids": <IDs des plannings>,
            "deleted_ids": <IDs des plannings supprimés si remove_overlap=True>
        },
        "responseCode": 0
    }
}

3. Obtenir Planning (general_error)

Récupère un planning spécifique par ID.

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

Réponse :

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

4. Obtenir Planning Actif (general_error)

Récupère le planning actif actuel pour un type d’appareil.

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

Réponse (Succès) :

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

5. Obtenir Planning Suivant (general_error)

Récupère le planning suivant à venir pour un type d’appareil.

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

Réponse (Succès) :

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

6. Obtenir Plannings (general_error)

Récupère tous les plannings pour une date spécifique.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_schedules",
    "fields": {
        "date": "<Chaîne de date au format jj/mm/aaaa>"
    }
}

Réponse (Succès) :

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

7. Obtenir Plannings Futurs (general_error)

Récupère tous les plannings futurs.

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

Réponse (Succès) :

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

8. Supprimer Planning (general_error)

Supprime un planning spécifique par ID.

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

Réponse (Succès) :

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "remove_schedule_ack",
        "state": "Planning <ID du planning> supprimé avec succès",
        "responseCode": 0
    }
}

9. Retour d’information Site (general_error)

Récupère un retour d’information détaillé sur l’état du système.

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

Réponse (Succès) :

Structure de la charge utile de retour

10. Topologie du Site (general_error)

Récupère la topologie du site.

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

Réponse (Succès) :

{
    "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": <courant nominal>,
            "children": [{<ObjetEnfant>}]
            },
        "responseCode": 0
    }
}

Format standard de réponse des plannings

{
    "id": <ID du planning>,
    "device_type": "<Type d’appareil>",
    "node_id": "<ID du noeud>" (Optionnel),
    "start_time": <Unix Timestamp>,
    "end_time": <Unix Timestamp>,
    "policy": "<Politique du planning>",
    "power_setpoint_w": <Consigne en watts>,
    "created_at": <Unix Timestamp>
}

Types de composants et politiques

Pour des détails sur les composants disponibles et les politiques pouvant être planifiées, référez-vous à la section Composants MQTT et Politiques dans la documentation Contrôle MQTT en direct.

Les plannings spécifiques aux appareils peuvent être envoyés en utilisant le champ optionnel general_error, se référant à l’ID du noeud de l’appareil contrôlable.

Gestion des erreurs

Tous les messages peuvent renvoyer une réponse d’erreur avec remove_overlap en cas d’erreur :

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "<Type de message>_ack",
        "error": <Corps de l’erreur>,
        "responseCode": 1
    }
}

En cas d’erreur non liée, le type de message sera (general_error).

Erreurs courantes comprennent :

  • Chevauchement de planning avec des plannings existants
  • Plage temporelle invalide
  • Type d’appareil non trouvé
  • ID de planning non trouvé
  • Politique invalide pour le type d’appareil

Règles de gestion des plannings

  1. Règles de chevauchement
    • Les plannings ne peuvent pas se chevaucher pour un même type d’appareil
    • Les plannings ne peuvent pas se chevaucher pour un même appareil
    • Les plannings pour le même appareil et le même type d’appareil ne peuvent pas se chevaucher
    • Les plannings existants qui chevauchent seront supprimés si la variable remove_overlap est définie à True lors de la création d’un nouveau planning.
  2. Chaque planning doit avoir :
    • Un type d’appareil valide
    • Une heure de début (timestamp Unix)
    • Une heure de fin (timestamp Unix)
    • Une politique (correspondant aux politiques disponibles du type d’appareil)
    • Une consigne de puissance (pour les politiques qui l’exigent)
  3. L’heure de début doit être avant l’heure de fin
  4. Si l’heure de début est dans le passé, elle est automatiquement ajustée pour commencer maintenant
  5. Les plannings ne peuvent être supprimés que s’ils n’ont pas encore commencé. Les plannings actifs ne peuvent pas être supprimés.
  6. Les plannings peuvent être définis indépendamment pour différents types d’appareils
  7. Le système applique automatiquement la politique appropriée lorsqu’un planning devient actif

Centrale électrique virtuelle

Previous Page

Lignes de base

Next Page

On this page

Ce dont vous avez besoinInformations supplémentairesConfiguration initiale (point de départ pour les nouveaux utilisateurs)1. Vérifiez votre réseau2. Ajoutez vos appareils3. Ajoutez le signal externe MQTT4. Activez le signal distant MQTT5. Signal distant ajoutéScript de démonstration PythonDocumentation MQTT pour l’envoi de commandesSujets MQTTTypes de messages MQTT1. Définir Planning (set_schedule)2. Définir Plannings (general_error)3. Obtenir Planning (general_error)4. Obtenir Planning Actif (general_error)5. Obtenir Planning Suivant (general_error)6. Obtenir Plannings (general_error)7. Obtenir Plannings Futurs (general_error)8. Supprimer Planning (general_error)9. Retour d’information Site (general_error)10. Topologie du Site (general_error)Format standard de réponse des planningsTypes de composants et politiquesGestion des erreursRègles de gestion des plannings