Contrôle MQTT Planifié

Ce guide vous aidera à configurer MQTT sur votre Download port_check.py SmartgridOne pour contrôler et surveiller à distance les installations de batteries et de panneaux solaires.

Ce dont vous avez besoin

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

Informations supplémentaires

MQTT est un protocole de communication rapide sur Internet. Il s'agit d’un système de messages publish/subscribe, permettant une connexion directe entre votre machine et le

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

J’ai un

1. Vérifiez votre réseau

Assurez-vous que votre réseau autorise le trafic MQTT sur le port 1883. Vous pouvez vérifier cela 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’erreurs de connexion.

2. Ajoutez vos appareils

et assurez-vous que les au SmartgridOne Controller.

3. Ajoutez le signal externe MQTT

4. Activez le signal MQTT à distance

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

5. Signal à distance ajouté

L’interface de Contrôle MQTT à distance est maintenant activée sur le SmartgridOne Controller.

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

Script démo Python

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

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

• Batterie : Chargement à 5 kW pendant 15 minutes dans 10 minutes
• Solaire : Mise à 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 vos identifiants MQTT, puis exécutez le script :

Si cela réussit, 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 de charge utile pour configurer le contrôle planifié des appareils au sein du réseau du SmartgridOne Controller.

Sujets MQTT

• Sujet d’abonnement : general_error
• Sujet de retour : 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 un 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

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>

2. Définir plusieurs 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>",
            "

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>

3. Obtenir un 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 le planning actif (general_error)

Récupère le planning actuellement actif 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 le planning suivant (general_error)

Récupère le prochain planning à 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 des 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 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>, ...

7. Obtenir les 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>, ...

8. Supprimer un 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’état du site (general_error)

Récupère un retour 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) :

10. Topologie du site (general_error)

Obtient 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"

Format standard de réponse au planning

{
    "id": <ID du planning>,
    "device_type": "<Type d’appareil>",
    "node_id": "<ID du node>" (Optionnel),
    "start_time": <Unix Timestamp>,
    "end_time": <Unix Timestamp>,
    "policy": 

Types de composants et politiques

Pour les détails sur les composants disponibles et les politiques pouvant être planifiées, consultez la section dans la documentation du Contrôle MQTT en Direct.

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

Gestion des erreurs

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

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

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

Erreurs courantes :

• Chevauchement de planning avec des plannings existants
• Plage horaire invalide
• Type d’appareil introuvable
• ID du planning introuvable
• 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 le même type d’appareil
   • Les plannings ne peuvent pas se chevaucher pour le même appareil
   • Les plannings pour le même appareil et type d’appareil ne peuvent pas se chevaucher
   • Les plannings existants et chevauchants 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 comporter :
   • Un type d’appareil valide
   • Une heure de début (timestamp Unix)
   • Une heure de fin (timestamp Unix)
   • Une politique (correspondant aux politiques disponibles pour ce type d’appareil)
   • Une consigne de puissance (pour les politiques qui le requièrent)
3. L’heure de début doit être antérieure à l’heure de fin
4. Si l’heure de début est dans le passé, elle est automatiquement changé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