SmartgridOne logo
SmartgridOne logo
Accessori
AppAvvertenze di sicurezza, manutenzione e legaliAvvio rapido
Cassetta degli attrezzi
Certificati
Configurazione dalla A alla Z
Controllore
Dispositivi
InstallazioneLED di statoLicenseLinee guida per cablaggio e connettivitàRete
Risoluzione dei problemi
Segnali Esterni
DSO

AgrolaAPI di pianificazione anticipataAutarcoAxpoCommercio di Energia DinamicoControllo Relè DNOCorrente di HallDexterEdmijElia
Elindus
Energia BEEEnergia CompagnaEnervalisEngieEPEX Spot SolareFioreFleco PowerFrank EnergieGreenchoiceImbyKratTradeMerci Commodities
Monitoraggio
Mqtt
Centrale Elettrica VirtualeControllo MQTT programmatoFlusso di onboardingLinee di baseLive MQTT control
Next EnergyNuove integrazioniOpinumParagrafo 14a IntegrazionePleeviQuadro portafusibiliRimodernatoScholtSoluzioni di Flessibilità Energetica (EFS)
Test diagnosticiTrevionVGT EnergiaYuso - Controllo della BatteriaYuso - Limitazione Solare
Specifiche
Specifico del Cliente
Tempo di risposta del controlloVideo tutorial
Segnali EsterniMqtt
Suggerimento
Suggerimento

Il controllo MQTT programmato è pensato per messaggi programmati in anticipo. Per il controllo in tempo reale, vedere invece Live MQTT Control.

Questa guida ti aiuterà a configurare MQTT sul tuo SmartgridOne per controllare e monitorare da remoto installazioni di batterie e pannelli solari.

Cosa ti serve

  1. Controller
    Image 1
    con connettività a internet.
  2. Credenziali MQTT: possono essere richieste al nostro Support Team.
  3. Ambiente di sviluppo Python (o qualsiasi altro client MQTT). Questa guida usa un esempio base scritto in Python per iniziare con MQTT e l’invio di comandi. Consigliamo Python per la sua facilità d’uso, ma qualsiasi altro client MQTT è supportato.

Informazioni aggiuntive

MQTT è un protocollo di comunicazione veloce su internet. È un sistema di messaggistica publish/subscribe che consente una connessione diretta tra la tua macchina e il

Image 1
Image 1
. I tuoi asset sono classificati in gruppi solare, batteria, EV e HVAC.

Configurazione iniziale (Punto di partenza per nuovi utenti)

Ho un

Image 1
SmartgridOne che voglio configurare per il Controllo Remoto MQTT.

1. Verifica la tua rete

Assicurati che la tua rete consenta traffico MQTT sulla porta 1883. Puoi farlo usando il comando:

nc -zv mqtt.eniris.be 1883

Se questo comando non è disponibile, puoi scaricare ed eseguire il codice Python:

In caso di dubbi, consulta il tuo ingegnere di rete o usa temporaneamente l’hotspot 4G/5G del tuo telefono se si verificano errori di connessione.

Nota
Nota

Se la porta 1883 non è accessibile dalla tua rete, offriamo un backup sulla porta 80. Questo può essere configurato nel tuo client MQTT in un passaggio successivo di questa guida.

2. Aggiungi i tuoi dispositivi

Accedi all’interfaccia di messa in servizio e verifica che i dispositivi siano aggiunti al SmartgridOne Controller.

3. Aggiungi il segnale esterno MQTT

Image 1
Image 1
Image 1

4. Attiva il segnale remoto MQTT

Seleziona tutti i dispositivi che vuoi includere nel Controllo Remoto MQTT.

Image 1

5. Il segnale remoto è attivo

L’interfaccia di Controllo Remoto MQTT è ora attivata sul SmartgridOne Controller.

Ora siamo pronti a inviare alcuni comandi base tramite un semplice esempio. La colonna "Status" indica se un comando è attivo.

Script demo Python

Un buon primo test è provare l’integrazione appena configurata con un semplice esempio.

Questo codice di test invia continuamente il seguente programma:

  • Batteria: Carica a 5 kW per 15 minuti tra 10 minuti
  • Solare: Imposta potenza a 0 kW per un’ora tra 30 minuti

Il SmartgridOne Controller risponde con un messaggio di conferma contenente l’identificatore unico del programma, o un messaggio di errore.

Successivamente recuperiamo il prossimo programma per entrambi i tipi di dispositivo, confermando che il comando è stato eseguito con successo.

Scarica il file sottostante nel tuo IDE Python preferito. Inserisci il tuo numero di serie e le credenziali MQTT ed esegui lo script:

Quando questo ha successo, puoi continuare a inviare altri tipi di messaggi. Tutti i messaggi sono descritti di seguito.

Documentazione MQTT per invio comandi

Questa sezione spiega il formato dei messaggi MQTT e il payload richiesto per configurare il controllo programmato dei dispositivi nella rete del SmartgridOne Controller.

Argomenti MQTT

  • Argomento di sottoscrizione: general_error
  • Argomento di feedback: remove_overlap

Dove True va sostituito con il numero di serie reale del SmartgridOne Controller che si intende controllare.

Tipi di messaggi MQTT

1. Imposta Programma (set_schedule)

Crea un nuovo programma per un tipo di dispositivo.

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

Risposta (Successo):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "set_schedule_ack",
        "state": {
            "schedule_id": <Schedule ID>,
            "deleted_ids": <ID programmi cancellati se remove_overlap=True>
            "tag": <Tag String> (default=None),
        },
        "responseCode": 0
    }
}

2. Imposta Programmi (general_error)

Crea più programmi contemporaneamente.

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

Risposta (Successo):

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

3. Ottieni Programma (general_error)

Recupera un programma specifico tramite ID.

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

Risposta:

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

4. Ottieni Programma Attivo (general_error)

Recupera il programma attualmente attivo per un tipo di dispositivo.

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

Risposta (Successo):

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

5. Ottieni Prossimo Programma (general_error)

Recupera il prossimo programma in arrivo per un tipo di dispositivo.

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

Risposta (Successo):

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

6. Ottieni Programmi (general_error)

Recupera tutti i programmi per una data specifica.

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": <Unix Timestamp>,
    "message_type": "get_schedules",
    "fields": {
        "date": "<Stringa data formato gg/mm/aaaa>"
    }
}

Risposta (Successo):

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

7. Ottieni Programmi Futuri (general_error)

Recupera tutti i programmi futuri.

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

Risposta (Successo):

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

8. Rimuovi Programma (general_error)

Rimuove un programma specifico tramite ID.

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

Risposta (Successo):

{
    "requestTime": <Unix Timestamp>,
    "time": <Unix Timestamp>,
    "siteNodeId": "<Controller SN>_site_0",
    "data": {
        "message_type": "remove_schedule_ack",
        "state": "Programma <Schedule ID> rimosso con successo",
        "responseCode": 0
    }
}

9. Feedback del Sito (general_error)

Recupera feedback dettagliato sullo stato del sistema.

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

Risposta (Successo):

Struttura del Payload di Feedback

10. Topologia del Sito (general_error)

Ottiene la topologia del sito.

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

Risposta (Successo):

{
    "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": <corrente nominale>,
            "children": [{<ChildObject>}]
            },
        "responseCode": 0
    }
}

Formato standard di risposta del programma

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

Tipi di componenti e policy

Per dettagli sui componenti disponibili e le policy programmabili, consulta la sezione MQTT Components and Policies nella documentazione Live MQTT Control.

Programmi specifici per dispositivo possono essere inviati usando il campo facoltativo general_error che fa riferimento all’ID nodo del dispositivo controllabile.

Gestione errori

Tutti i messaggi possono restituire un errore con remove_overlap in caso di errore:

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

Se si verifica un errore non correlato, il tipo di messaggio sarà (general_error).

Errori comuni includono:

  • Sovrapposizione con programmi esistenti
  • Intervallo di tempo non valido
  • Tipo dispositivo non trovato
  • ID programma non trovato
  • Policy non valida per il tipo dispositivo

Regole di gestione dei programmi

  1. Regole di sovrapposizione
    • I programmi non possono sovrapporsi per lo stesso tipo di dispositivo
    • I programmi non possono sovrapporsi per lo stesso dispositivo
    • I programmi per lo stesso dispositivo e tipo di dispositivo non possono sovrapporsi
    • I programmi sovrapposti esistenti saranno cancellati se la variabile remove_overlap è impostata a True al momento della creazione di un nuovo programma.
  2. Ogni programma deve avere:
    • Un tipo dispositivo valido
    • Un tempo di inizio (timestamp Unix)
    • Un tempo di fine (timestamp Unix)
    • Una policy (che corrisponda alle policy disponibili per il tipo dispositivo)
    • Un setpoint di potenza (per le policy che lo richiedono)
  3. Il tempo di inizio deve essere precedente al tempo di fine
  4. Se il tempo di inizio è nel passato, viene automaticamente aggiornato per iniziare ora
  5. I programmi possono essere cancellati solo se non sono ancora iniziati. I programmi attivi non possono essere cancellati.
  6. I programmi possono essere impostati indipendentemente per diversi tipi di dispositivo
  7. Il sistema applica automaticamente la policy appropriata quando un programma diventa attivo

Centrale Elettrica Virtuale

Previous Page

Flusso di onboarding

Next Page

On this page

Cosa ti serveInformazioni aggiuntiveConfigurazione iniziale (Punto di partenza per nuovi utenti)1. Verifica la tua rete2. Aggiungi i tuoi dispositivi3. Aggiungi il segnale esterno MQTT4. Attiva il segnale remoto MQTT5. Il segnale remoto è attivoScript demo PythonDocumentazione MQTT per invio comandiArgomenti MQTTTipi di messaggi MQTT1. Imposta Programma (set_schedule)2. Imposta Programmi (general_error)3. Ottieni Programma (general_error)4. Ottieni Programma Attivo (general_error)5. Ottieni Prossimo Programma (general_error)6. Ottieni Programmi (general_error)7. Ottieni Programmi Futuri (general_error)8. Rimuovi Programma (general_error)9. Feedback del Sito (general_error)10. Topologia del Sito (general_error)Formato standard di risposta del programmaTipi di componenti e policyGestione erroriRegole di gestione dei programmi