Controllo MQTT in tempo reale

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

Configurazione iniziale (punto di partenza per i nuovi utenti)

Ho un SmartgridOne Controller che desidero configurare per il Controllo remoto MQTT.

Prima di continuare, assicurati che la rete e i dispositivi siano pronti seguendo la guida Configurazione MQTT.

1. Aggiungi il segnale esterno MQTT

2. Abilita il segnale remoto MQTT

Il timeout del meccanismo di fallback indica al SmartgridOne Controller per quanto tempo deve attendere nuovi comandi. Quando il SmartgridOne Controller smette di ricevere comandi, allo scadere di questo timeout applica automaticamente la strategia predefinita.

Successivamente, seleziona tutti i dispositivi che desideri includere nel Controllo Remoto MQTT.

3. Segnale remoto aggiunto

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

Ora siamo pronti a inviare alcuni comandi di base usando un semplice esempio. La colonna Stato indica se è attivo un comando.

Script demo Python

Un buon punto di partenza è testare l'integrazione appena configurata con un semplice esempio.

Questo codice di test svolge il semplice compito di inviare continuamente i seguenti comandi:

• Batteria: carica a 5 kW
• Solare: imposta la potenza a 0 kW

Il SmartgridOne Controller risponde continuamente con un messaggio di «feedback» contenente i valori osservati della potenza di rete e degli asset. Questa funzionalità è inclusa anch'essa nell'esempio.

Scarica il file riportato di seguito nell'IDE Python che preferisci. Inserisci il tuo numero di serie e le credenziali MQTT, quindi esegui lo script:

Dopo aver verificato il corretto funzionamento, puoi continuare inviando altri tipi di comandi. Tutti i comandi sono descritti nella nostra Documentazione sul Controllo Remoto MQTT.

Documentazione MQTT per l'invio dei comandi

Questa sezione descrive il formato dei messaggi MQTT e i requisiti del payload per il controllo remoto delle politiche di potenza sui dispositivi nella rete del SmartgridOne Controller.

Topic MQTT

Il topic MQTT utilizzato per l'invio dei comandi è strutturato come segue:

standard1/rp_one_s/remoteControlMetrics/'controller SN'

Dove 'controller SN' deve essere sostituito con il numero di serie effettivo del SmartgridOne Controller che intendi controllare.

Struttura del payload MQTT

I comandi vengono inviati come payload JSON. La struttura del payload è progettata per specificare varie politiche di gestione della potenza e setpoint per diversi componenti del sistema smart grid. Di seguito è riportato lo schema del payload con descrizioni dettagliate dei campi:

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": "<Unix Timestamp>",
    "fields": {
        "<Component Policy>": "<Policy Type>",
        "<Component Power Setpoint>": <Setpoint in watts>,
        "site_<policy>": "<Value in watts>"
    }
}

Descrizione dei campi

• extraTags (Object):
  • nodeId (String): Identificatore univoco del nodo nella rete del SmartgridOne Controller. Corrisponde al tuo numero di serie seguito da '_site_0' per la maggior parte dei dispositivi SmartgridOne Controller.
• time (Integer): Timestamp Unix in secondi che indica l'istante di invio del messaggio.
• fields (Object):
  • <Component>_policy (String): Tipo di politica per il componente. È facoltativo e, se non specificato, il sistema utilizzerà l'impostazione predefinita del SmartgridOne Controller.
  • <Component>_power_setpoint_w (Float): Setpoint di potenza desiderato, in watt, per il componente. È facoltativo ed è rilevante solo se viene specificata una politica corrispondente.

Componenti e politiche

Ogni componente nell'oggetto fields può includere una politica e un setpoint di potenza. È possibile controllare i seguenti componenti:

• solar_policy e solar_power_setpoint_w:

  • Controlla la politica e il setpoint della generazione solare. Politiche supportate:
    • Policy setpoint: imposta la potenza massima prodotta complessivamente da tutte le installazioni solari collegate. Il campo solar_power_setpoint_w deve essere impostato sul limite di potenza di produzione in watt.
    • Policy feed-in-restriction: produce alla massima potenza, rispettando i limiti attuali della rete.
    • Policy cost: abilita la minimizzazione dei costi della produzione solare in base ai prezzi day-ahead (mercato EPEX Spot). Quando i prezzi di immissione sono negativi, limitiamo la produzione al consumo proprio. Quando sia il prezzo di prelievo sia quello di immissione sono negativi, spegniamo tutte le installazioni solari. Il campo solar_power_setpoint_w viene ignorato.
    • Policy off: disabilita ogni interazione per tutti gli asset solari. Attenzione: in questa modalità i limiti non vengono controllati. Il campo solar_power_setpoint_w viene ignorato.

• storage_policy e storage_power_setpoint_w:

  • Controlla la politica del sistema di accumulo e la potenza di carica o scarica.
    • Policy setpoint: imposta la potenza totale di carica (setpoint positivo) o di scarica (setpoint negativo) per il gruppo di batterie. Quando sono collegate più batterie, il setpoint viene suddiviso in base alla potenza di carica/scarica disponibile, distribuendo uniformemente il carico tra le batterie. Il campo storage_power_setpoint_w viene impostato sulla potenza desiderata della batteria.
    • Policy peak-shaving-only: abilita l'ottimizzazione del peak shaving sulla batteria. Deve essere combinata con quattro parametri di peak shaving a livello di sito.
    • Policy cost: abilita l'ottimizzazione dei costi sulle batterie in base ai prezzi day-ahead (mercato EPEX Spot), caricandole nelle ore più economiche e utilizzando l'energia nelle ore più costose. Il campo storage_power_setpoint_w viene ignorato.
    • Policy self-consumption: abilita un semplice algoritmo di autoconsumo sulle batterie. La produzione solare in eccesso viene immagazzinata nella batteria durante il giorno e, quando il sole tramonta, l'energia viene prelevata dalla batteria. Il campo storage_power_setpoint_w viene ignorato.
    • Policy off: disabilita ogni interazione per tutti gli asset con batteria. Attenzione: in questa modalità i limiti non vengono controllati. Il campo storage_power_setpoint_w viene ignorato.

• heat_pump_policy:

  • Attiva/disattiva i sistemi a pompa di calore. I tempi minimi e massimi di accensione vengono sempre rispettati.
    • Policy cost: abilita l'ottimizzazione dei costi delle pompe di calore in base ai prezzi day-ahead (mercato EPEX Spot). L'algoritmo locale di tariffazione dinamica decide i periodi di accensione migliori.
    • Policy self-consumption: accende le pompe di calore quando viene prodotta energia solare in eccesso.
    • Policy power_off: spegne le pompe di calore.
    • Policy power_on: accende le pompe di calore.

• switched_load_policy:

  • Attiva/disattiva i sistemi controllati tramite relè. Può trattarsi del relè integrato o di relè connessi alla rete.
    • Policy cost: abilita l'ottimizzazione dei costi del relè in base ai prezzi day-ahead (mercato EPEX Spot).
    • Policy self-consumption: accende il relè quando viene prodotta energia solare in eccesso.
    • Policy power_off
    • Policy power_on

• variable_power_load_policy e variable_power_load_power_setpoint_w:

  • Gestisce la politica e il setpoint del consumo di potenza dei veicoli elettrici.
    • Policy setpoint: imposta la potenza di carica totale per il gruppo di veicoli elettrici. Il campo variable_power_load_power_setpoint_w viene impostato sulla potenza di carica desiderata.
    • Policy cost: abilita l'ottimizzazione dei costi sulle batterie in base ai prezzi day-ahead (mercato EPEX Spot), caricandole nelle ore più economiche. Il campo variable_power_load_power_setpoint_w viene ignorato.
    • Policy self-consumption: abilita la carica quando viene prodotta energia solare in eccesso. Il campo variable_power_load_power_setpoint_w viene ignorato.
    • Policy off: disabilita ogni interazione per tutti gli asset EV. Il campo variable_power_load_power_setpoint_w viene ignorato.

Limiti di potenza

In alternativa all'impostazione di strategie di controllo e setpoint, è possibile impostare anche limiti di potenza per i dispositivi di accumulo e solari.

Ad esempio:

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": "<Unix Timestamp>",
    "fields": {
        "{prefix}_maxChargePower_W": <Max Charge Power W>,
        "{prefix}_maxDischargePower_W": <Max Discharge Power W>,
        "{prefix}_maxProductionPower_W": <Max Production Power W>,
    }
}

dove prefix è storage, solar oppure il nodeID del dispositivo interessato.

Controllo del sito

Il sito può essere controllato separatamente. Al controller possono essere inviati i seguenti comandi del sito:

• default o fallback Rimuove tutti i comandi attivi del sito
• export Imposta il limite di esportazione del sito
• import Imposta il limite di importazione del sito
• setpoint Il setpoint del sito può variare fino al 5% in entrambe le direzioni
• setpoint_A Non ancora implementato

Le seguenti variabili sono parametri di peak shaving e verranno applicate solo quando la strategia della batteria è impostata su peak shaving.

• startChargeBelow_W
• stopChargeAbove_W
• startDischargeAbove_W
• stopDischargeBelow_W

Un setpoint del sito NON è compatibile con un limite di importazione/esportazione.

Ad esempio:

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": "<Unix Timestamp>",
    "fields": {
        "<Component Policy>": "<Policy Type>",
        "<Component Power Setpoint>": <Setpoint in watts>,
        "site_export": <Export Limit W>,
        "site_import": <Import Limit W>,
        "site_setpoint": <Setpoint W>,
        "site_startChargeBelow_W": <Value_W>
    }
}

Controllo dei dispositivi

È inoltre possibile controllare dispositivi specifici, anziché gruppi di dispositivi basati sul loro tipo. Il messaggio ha la stessa struttura:

• nodeId_policy e nodeId_power_setpoint_w

Comportamento di fallback

Per ogni componente, se _policy e _power_setpoint_w non sono specificati, il sistema utilizzerà automaticamente la politica di fallback configurata nel SmartgridOne Controller. Questo garantisce che ogni dispositivo o gruppo di dispositivi funzioni in sicurezza e continui a operare anche quando non vengono fornite istruzioni specifiche.

Se non viene inviato alcun comando, dopo 60 secondi (o dopo il periodo di timeout configurato) verranno riattivate le politiche predefinite per gli asset.

Annullamento dei comandi esistenti e ritorno alle modalità di controllo locali

È possibile annullare un comando attivo inviando un messaggio di comando di fallback.

Comando di fallback

Un comando di fallback annullerà il comando esistente immediatamente e il SmartgridOne Controller assumerà il controllo dell'installazione. La politica eseguita dipende da quanto configurato nelle Impostazioni del SmartgridOne Controller.

Questa funzione può essere utilizzata anche quando un segnale di controllo secondario, come una pianificazione, viene usato come fallback.

Esempi di messaggi:

{
    "extraTags": {
        "nodeId": "<Controller SN>_site_0"
    },
    "time": "<Unix Timestamp>",
    "fields": {
        "<Component Policy>": "fallback",
    }
}

Comando vuoto

È possibile inviare in qualsiasi momento un comando vuoto per raccogliere informazioni sul sito. Questo non annullerà il comando corrente.

Il comando vuoto è strutturato come segue:

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

Esempio di payload

Di seguito è riportato un esempio di payload per impostare varie politiche e setpoint:

{
    "extraTags": {
        "nodeId": "OM12404080000000000_site_0"
    },
    "time": 1714652046,
    "fields": {
        "solar_policy": "setpoint",
        "solar_power_setpoint_w": 5000,
        "storage_policy": "setpoint",
        "storage_power_setpoint_w": -5000
    }
}

In questo esempio, la potenza solare viene impostata per produrre fino a 5000 watt e il sistema di accumulo viene impostato per caricare o scaricare a una velocità di 5000 watt, a seconda del segno del valore del setpoint. Se solar_policy o storage_policy fossero omessi, il dispositivo corrispondente tornerebbe alle impostazioni predefinite determinate dal SmartgridOne Controller.

Documentazione MQTT per la ricezione del feedback

Questa sezione descrive la struttura e il contenuto dei messaggi di feedback inviati dal SmartgridOne Controller tramite MQTT. Questi messaggi vengono pubblicati sul topic standard1/outbound/remoteControlMetrics/feedback/<Controller SN> dopo l'elaborazione di un comando.

Topic MQTT del feedback

Il topic MQTT del feedback è strutturato come segue:

standard1/outbound/remoteControlMetrics/feedback/<Controller SN>

Dove <Controller SN> deve essere sostituito con il numero di serie del SmartgridOne Controller che invia il feedback.

Struttura del payload MQTT di feedback

I messaggi di feedback sono formattati come payload JSON. Questi payload forniscono un feedback dettagliato sullo stato del sistema dopo l'applicazione dei comandi di setpoint, tenendo conto dei limiti della rete e dei dispositivi. Di seguito è riportata la struttura del payload di feedback con la descrizione dei relativi campi:

{
    "time": "<Unix Timestamp>",
    "data": {
        "state": {
            "grid": {
                "active_power_W": <Grid Active Power in Watts>,
                "today_imported_energy_Wh": <Grid Imported Energy in Watt-hours>,
                "today_exported_energy_Wh": <Grid Exported Energy in Watt-hours>,
                "import_limit_W": <Grid Import Limit in Watts>,
                "export_limit_W": <Grid Export Limit in Watts>,
            },
            "storage": {
                "energy_stored_Wh": <Energy Stored in Watt-hours>,
                "energy_capacity_Wh": <Total Energy Capacity in Watt-hours>,
                "mean_soc_perc": <Mean State of Charge Percentage>,
                "active_power_W": <Active Power in Watts>,
                "executed_power_W": <Power Setpoint Sent to Devices in Watts>,
                "executed_policy": <Policy Executed by the Controller>,
                "max_charge_power_W": <Maximum Charge Power in Watts>,
                "max_discharge_power_W": <Maximum Discharge Power in Watts>,
                "today_charged_Wh": <Energy Charged Today in Watt-hours>,
                "today_discharged_Wh": <Energy Discharged Today in Watt-hours>,
                "realised_charge_power_W": <Adapted maximum charge power>,
                "realised_discharge_power_W": <Adapted maximum discharge power>,
                "constraint_ph0_label": <Constraint reason for limiting power setpoint>,
                "errorCodes": <Error status messages per device>,
                "nr_devices": <Number of Controlled Storage Devices Installed>
            },
            "solar": {
                "active_power_W": <Solar Active Power in Watts>,
                "executed_power_W": <Power Setpoint Sent to Devices in Watts>,
                "executed_policy": <Policy Executed by the Controller>,
                "capacity_W": <Solar Capacity in Watts>,
                "today_energy_Wh": <Energy Produced Today in Watt-hours>,
                "constraint_ph0_label": <Constraint reason for limiting power setpoint>,
                "errorCodes": <Error status messages per device>,
                "nr_devices": <Number of Controlled Solar Devices Installed>
            },
            "heat_pump": {
                "executed_policy": <Policy Executed by the Controller>,
                "operation_modes": <Heatpump Operation Modes>,
                "executed_power_W": <Power Setpoint Sent to Devices in Watts>,
                "constraint_ph0_label": <Constraint reason for limiting power setpoint>,
                "errorCodes": <Error status messages per device>,
                "nr_devices": <Number of Controlled Heat Pump Devices Installed>
            },
            "switched_load": {
                "executed_policy": <Policy Executed by the Controller>,
                "devices_on": <Number of Devices On>,
                "devices_off": <Number of Devices Off>,
                "executed_power_W": <Power Setpoint Sent to Devices in Watts>,
                "constraint_ph0_label": <Constraint reason for limiting power setpoint>,
                "errorCodes": <Error status messages per device>,
                "nr_devices": <Number of Controlled Switched Load Devices Installed>  
            },
            "variable_load": {
                "active_power_W": <Power of the device in Watts>,
                "ev_charging": <How many EVs are currently charging>,
                "ev_not_charging": <How many EVs are currently unconnected>,
                "executed_policy": <Policy Executed by the Controller>,
                "executed_power_W": <Power Setpoint Sent to Devices in Watts>,
                "ev_requiring_charge": <Does the EV require charge>,
                "currentL1_A": <Current of the device on phase 1 in Ampere>,
                "currentL2_A": <Current of the device on phase 2 in Ampere>,
                "currentL3_A": <Current of the device on phase 3 in Ampere>,
                "executed_current_A": <Current Setpoint Sent to Devices in Ampere>,
                "today_charged_Wh": <Energy Charged Today in Watt-hours>,
                "today_discharged_Wh": <Energy Discharged Today in Watt-hours>,
                "total_charged_Wh": <Total Energy Charged in Watt-hours>,
                "total_discharged_Wh": <Total Energy Discharged in Watt-hours>,
                "min_charge_current_A": <Minimum Charge in Ampere>,
                "max_charge_current_A": <Maximum Charge in Ampere>,
                "allow_zero_current": <Does the Charger Support Pausing>,
                "current_charging_session": {
                    "pluginTime": <The session start time>,
                    "endTime": <The session end time>,
                    "firstChargingStartTime": <The time when the vehicle first charged>,
                    "isFull": <Is the vehicle fully charged or not>,
                    "chargedEnergy_Ws": <How much energy has been charged this session>,
                    "usedPhases": <The list of phases used during charging>,
                    "historicMaxChargeCurrent_A": <The maximum current at which the vehicle was charged during the session>
                },
                "previous_charging_session": {
                    "pluginTime": <The session start time>,
                    "endTime": <The session end time>,
                    "firstChargingStartTime": <The time when the vehicle first charged>,
                    "isFull": <Is the vehicle fully charged or not>,
                    "chargedEnergy_Ws": <How much energy has been charged this session>,
                    "usedPhases": <The list of phases used during charging>,
                    "historicMaxChargeCurrent_A": <The maximum current at which the vehicle was charged during the session>
                },
                "constraint_ph0_label": <Constraint reason for limiting power setpoint>,
                "errorCodes": <Error status messages per device>,
                "nr_devices": <Number of Variable Power  Load Devices Installed>  
            }
        },
        "error": {
            <Errors occured during driver execution>
        }
        "response_code": <Response Code>
    },
    "fields": {},
    "requestTime": "<Unix Timestamp>",
    "time": "<Unix Timestamp>",
    "siteNodeId": "<Controller SN>_site_0"
}

Descrizione dei campi

• time (Integer): Timestamp Unix che indica l'istante di invio del messaggio di feedback.
• requestTime (Integer): Timestamp Unix che indica l'istante di invio del messaggio di controllo originale.
• siteNodeId (String): Il nodeId del sito che invia il feedback.
• fields (Object): Oggetto vuoto
• data (Object):
  • state (Object):
    • vpp_id (String): Identificatore della Virtual Power Plant associata a questo dispositivo.
    • grid (Object):
      • active_power_W (Float): Rappresenta la potenza attiva corrente sulla rete, in watt.
      • today_imported_energy_Wh (Float): Energia totale prelevata dalla rete oggi, in wattora. Nota: il giorno è espresso in tempo UTC.
      • today_exported_energy_Wh (Float): Energia totale immessa nella rete oggi, in wattora. Nota: il giorno è espresso in tempo UTC.
      • import_limit_W (Float): Limite di importazione dalla rete in watt,
      • export_limit_W (Float): Limite di esportazione verso la rete in watt,
    • storage (Object):
      • energy_stored_Wh (Float): Quantità attuale di energia immagazzinata in wattora.
      • energy_capacity_Wh (Float): Capacità energetica totale del sistema di accumulo in wattora.
      • mean_soc_perc (Float): Stato di carica espresso in percentuale. È la media ponderata di tutte le batterie collegate.
      • active_power_W (Float): Potenza attiva corrente del sistema di accumulo in watt, che indica la velocità di carica o scarica.
      • max_charge_power_W (Float): Potenza massima alla quale è possibile caricare l'accumulo.
      • max_discharge_power_W (Float): Potenza massima alla quale è possibile scaricare l'accumulo.
      • executed_power_W (Float): Somma della potenza totale richiesta per caricare o scaricare gli asset di accumulo, inviata dal nostro algoritmo di controllo. Applicabile solo se è attiva la politica 'follow_setpoint'.
      • executed_policy (Str): Politiche applicate ai dispositivi controllabili.
      • today_charged_Wh (Float): Energia totale caricata oggi negli asset batteria controllabili. Nota: il giorno è espresso in tempo UTC.
      • today_discharged_Wh (Float): Energia totale scaricata oggi dagli asset batteria controllabili. Nota: il giorno è espresso in tempo UTC.
      • realised_charge_power_W (Float): Potenza massima di carica adattata, calcolata in base alle risposte dei dispositivi,
      • realised_discharge_power_W (Float): Potenza massima di scarica adattata, calcolata in base alle risposte dei dispositivi,
      • constraint_ph0_label (List[string]): Motivi per cui i setpoint esterni sono stati limitati.
      • errorCodes (Dict[str, Dict]): Codici di errore ricevuti dai dispositivi.
      • nr_devices (Int): Numero di asset batteria controllabili.
    • solar (Object):
      • active_power_W (Float): Potenza attiva corrente generata dai pannelli solari in watt.
      • capacity_W (Float): Capacità totale del sistema di generazione solare in watt.
      • executed_power_W (Float): Somma della potenza totale richiesta dagli asset solari, inviata dal nostro algoritmo di controllo. Applicabile solo se è attiva la politica 'follow_setpoint'.
      • executed_policy (Str): Politiche applicate ai dispositivi controllabili.
      • today_energy_Wh (Float): Energia totale prodotta oggi dagli asset solari controllabili. Nota: il giorno è espresso in tempo UTC.
      • constraint_ph0_label (List[string]): Motivi per cui i setpoint esterni sono stati limitati.
      • errorCodes (Dict[str, Dict]): Codici di errore ricevuti dai dispositivi.
      • nr_devices (Int): Numero di asset solari controllabili.
    • heat_pump (Object):
      • executed_policy (Str): Politiche applicate ai dispositivi controllabili.
      • operation_modes (Str): Modalità della pompa di calore (modalità bloccata, modalità boost, modalità di autocontrollo)
      • executed_power_W (Float): Potenza prevista attualmente utilizzata.
      • errorCodes (Dict[str, Dict]): Codici di errore ricevuti dai dispositivi.
      • constraint_ph0_label (List[string]): Motivi per cui i setpoint esterni sono stati limitati.
      • nr_devices (Int): Numero di pompe di calore controllabili.
    • switched_load (Object):
      • executed_policy (Str): Politiche applicate ai dispositivi controllabili.
      • devices_on (Int): Numero di dispositivi accesi.
      • devices_off (Int): Numero di dispositivi spenti.
      • executed_power_W (Float): Potenza attualmente utilizzata, se disponibile.
      • constraint_ph0_label (List[string]): Motivi per cui i setpoint esterni sono stati limitati.
      • errorCodes (Dict[str, Dict]): Codici di errore ricevuti dai dispositivi.
      • nr_devices (Int): Numero di carichi commutati on/off controllabili.
    • variable_load (Object):
      • active_power_W (Float): Rappresenta la potenza attiva corrente sulla rete in watt.
      • ev_charging (Int): Numero di veicoli elettrici attualmente collegati e in carica.
      • ev_not_charging (Int): Numero di veicoli elettrici non collegati.
      • executed_policy (Str): Politiche applicate ai dispositivi controllabili,
      • executed_power_W (Float): Somma della potenza totale richiesta dagli asset, inviata dal nostro algoritmo di controllo.
      • ev_requiring_charge (Bool): Indica se il veicolo elettrico richiede la carica (se un'auto è collegata).
      • currentL1_A (Float): Corrente del dispositivo sulla fase 1 in ampere.
      • currentL2_A (Float): Corrente del dispositivo sulla fase 2 in ampere.
      • currentL3_A (Float): Corrente del dispositivo sulla fase 3 in ampere.
      • executed_current_A (Float): Somma della corrente totale richiesta dagli asset, inviata dal nostro algoritmo di controllo.
      • today_charged_Wh (Float): Energia caricata oggi negli asset caricabatterie EV. Nota: il giorno è espresso in tempo UTC.
      • today_discharged_Wh (Float): Energia caricata oggi negli asset caricabatterie EV. Nota: il giorno è espresso in tempo UTC.
      • total_charged_Wh (Float): Energia totale caricata negli asset caricabatterie EV.
      • total_discharged_Wh (Float): Energia totale scaricata dagli asset caricabatterie EV.
      • min_charge_current_A (Float): Corrente minima alla quale è possibile caricare il veicolo elettrico.
      • max_charge_current_A (Float): Corrente massima alla quale è possibile caricare il veicolo elettrico.
      • allow_zero_current (Bool): Indica se il caricabatterie EV consente la pausa.
      • current_charging_sessions (Dict):
        • pluginTime (Date): Ora di inizio della sessione.
        • endTime (Date): Ora di fine della sessione.
        • firstChargingStartTime (Date): Ora in cui il veicolo ha iniziato a caricare per la prima volta.
        • isFull (Bool): Indica se il veicolo è completamente carico.
        • chargedEnergy_Ws (Float): Quantità di energia caricata durante questa sessione.
        • usedPhases (List[str]): Elenco delle fasi utilizzate durante la carica.
        • historicMaxChargeCurrent_A (float): Corrente massima alla quale il veicolo è stato caricato durante la sessione.
      • constraint_ph0_label (List[string]): Motivi per cui i setpoint esterni sono stati limitati.
      • errorCodes (Dict[str, Dict]): Codici di errore ricevuti dai dispositivi.
      • nr_devices (Int): Numero di carichi commutati on/off controllabili.
    • nodeId (Object):
      • Se nel comando è incluso un nodeId, il feedback conterrà lo stato corrispondente del dispositivo.
  • response_code (Int):
    • Indica lo stato dell'operazione. Un response_code pari a 0 indica generalmente il successo, mentre altri valori possono indicare diversi tipi di errori o informazioni sullo stato (da descrivere in un riferimento separato).

Etichette dei vincoli dell'accumulo

I setpoint inviati da un segnale esterno possono essere limitati internamente dall'EMS. La tabella seguente offre una panoramica dei possibili vincoli per il campo di feedback constraint_ph0_label.

Codici di errore MQTT

I codici di errore sono raggruppati in intervalli che indicano la categoria generale del problema:

I singoli codici di errore sono elencati di seguito.

Errori di connessione (200)

Problemi di connessione tra l'EMS e il dispositivo.

Errori di risposta (300)

Il dispositivo è connesso, ma le sue risposte non sono valide.

Errori di controllo (600)

Errori di misurazione e setpoint (1000)

Versioni MQTT supportate e comportamento per i topic non autorizzati

Quando si utilizza MQTT, è importante considerare le differenze nelle specifiche tra le versioni 3.1, 3.1.1 e 5.0, in particolare per quanto riguarda il comportamento del broker quando i client pubblicano su topic non autorizzati.

Secondo la specifica MQTT 3.1.1 (vedere la specifica OASIS MQTT 3.1.1, sezione MQTT-3.3.5-2), un broker deve terminare la connessione non appena un client invia un PUBLISH a un topic per il quale non dispone dell'autorizzazione. Questo comportamento può causare disconnessioni impreviste per i client che tentano di pubblicare su topic configurati in modo errato o non autorizzati.

In MQTT 3.1 questo requisito non è presente. Quando un client pubblica su un topic non autorizzato in questa versione, il broker in genere ignora il messaggio (eliminazione silenziosa) senza terminare la connessione. In alcuni casi, ciò rende MQTT 3.1 più adatto quando la robustezza agli errori di configurazione o alla temporanea assenza di autorizzazioni è più importante della rigorosa applicazione della sicurezza.

Sebbene MQTT 5.0 introduca la possibilità di utilizzare codici motivo (come PUBACK con un motivo di rifiuto), ciò richiede il supporto sia lato client sia lato server. La migrazione a MQTT 5.0 comporta quindi un ulteriore impegno di implementazione.

Conseguenze del mancato rispetto della compatibilità: Se un client si connette utilizzando MQTT 3.1.1 e tenta di pubblicare messaggi su topic non autorizzati, il broker terminerà bruscamente la sessione. Ciò può causare instabilità, perdita di connettività o un aumento del carico dovuto ai ripetuti tentativi di riconnessione.

Approccio consigliato: Per i sistemi in cui i client possono tentare (temporaneamente) di pubblicare su topic non autorizzati o in cui la gestione degli errori non è implementata in modo rigoroso, consigliamo di utilizzare MQTT 3.1. Ciò garantisce connessioni più stabili ed evita disconnessioni indesiderate durante il runtime.