Categoria: Articoli Raspberry

Come accade spesso questi inverter pubblicano i dati di produzione solo via App proprietaria, questo non permette di usare i dati di produzione del proprio impianto fotovoltaico sulla propria domotica. Il mio obiettivo era quello di poter visualizzare sulla mia domotica basata su Home Assistant dei dati di produzione del mio impianto fotovoltaico.

Dopo alcune prove sono riuscito a collegare il mio inverter FEB PowerX a un Raspberry Pi 4 e a leggere correttamente i registri Modbus RTU tramite RS485.

Hardware utilizzato

• Raspberry Pi 3, 4 o 5 con Raspberry Pi OS
• Dongle USB RS485 CH340
• Inverter FEB PowerX
• Cavo RJ45 modificato

Questo è il dongle che ho acquistato:

Questo è il cavo che ho realizzato:

Il mio inverter ha una porta RS485, questa è impegnata dal cavo di rete che mette in comunicazione le batterie con l’inverter, le batterie però usano il canale BMS e non il canale EMS come si vede dalla figura sotto:

al posto di cercare un deviatore come quello di figura sopra, di difficile reperibilità, ho creato con due connettore di rete RJ45, uno maschio e uno femmina, un cavo che estrae i soli PIN 7 e 8.

Con questo cavo i PIN dal 1 al 6 continuano ad andare dall’inverter alla batteria, questo è fondamentale per il funzionamento corretto dell’inverter e dell’App. I soli PIN 7 e 8 adesso non vanno più alla batteria ma con i cavetti rosso e bianco sono pronti per essere collegato al dongle RS485 per la comunicazione RS485.

Ultimo passaggio è quello di impostare nell’App il canale slave:

Adesso è tutto pronto per testare la comunicazione RS485.

Collegamento RS485

Collegare il cavo del PIN 7 alla porta A del dongle e il PIN 8 alla porta B. Per tratte brevi generalmente A e B sono sufficienti; per collegamenti più lunghi o in ambienti elettricamente disturbati può essere utile collegare anche il riferimento GND.

Verifica del dongle USB

Inserire il dongle in una porta USB del raspberry e verificare che venga riconosciuto con il comando:

ls /dev/ttyUSB*

nel mio caso il risultato è: /dev/ttyUSB0

Per identificare il dispositivo: dmesg | grep ttyUSB

Utilizzare il nome persistente del dispositivo

Se si dovesse riavviare il Raspberry la porta potrebbe cambiare, per evitare questo problema dare il comando: ls -l /dev/serial/by-id/

Nel mio caso la risposta è stata:

/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0

lo useremo da ora in poi per identificare il dongle.

Installazione di mbpoll

sudo apt update

sudo apt install mbpoll

Verifica:

which mbpoll

Parametri Modbus corretti

Dopo vari tentativi i parametri funzionanti sono risultati:

Protocollo : Modbus RTU

Slave ID   : 1

Baudrate   : 115200

Parity     : None

Stop bit   : 1

Primo test di comunicazione

Lettura della versione protocollo:

mbpoll -m rtu -a 1 -b 115200 -P none -t 4:hex -0 -r 8192 -c 1 /dev/serial/by-id/usb-1a86_USB_Serial-if00-port0

Risultato:

0x0681

Questo conferma che la comunicazione Modbus è attiva. Se non dovesse funzionare potreste provare a invertire i cavi quindi PIN 7 a B e PIN 8 ad A.

Un altro comando utile identifica il modello di Inverter:

mbpoll -m rtu -a 1 -b 115200 -P none -t 4:hex -0 -r 8198 -c 1 /dev/serial/by-id/usb-1a86_USB_Serial-if00-port0

Risultato:

0x0001 che tradatto vuol dire 1 = Single Phase

Con il comando seguente leggiamo il SOC ovvero la percentuale di carica della batteria:

Registro: 0x1212 Decimale: 4626

Comando:

mbpoll -m rtu -a 1 -b 115200 -P none -t 4:hex -0 -r 4626 -c 2 /dev/serial/by-id/usb-1a86_USB_Serial-if00-port0

Risultato:

0x4290

0x0000

Convertito in float IEEE754:

72%

Verificare per sicurezza se coincide con il valore che legge l’App.

Disabilitare la console seriale

Anche se viene utilizzato un dongle USB, conviene disabilitare la console seriale:

sudo systemctl disable serial-getty@ttyS0.service

Verifica:

systemctl is-enabled serial-getty@ttyS0.service

il risultato dovrebbe essere: disable o static

Risultato finale

Al termine della configurazione:

✅ Comunicazione RS485 funzionante

✅ Accesso diretto all’inverter

✅ Lettura registri Modbus

✅ SOC batteria verificato

Parametri finali

port: /dev/serial/by-id/usb-1a86_USB_Serial-if00-port0

slave: 1

baudrate: 115200

parity: N

stopbits: 1

protocol: modbus_rtu

Le chiavi che ho trovato valide per il mio inverter sono:

“soc”: 4626
“battery1_soc”: 45318,
“pv_power”: 4720,
“pv_today”: 4708,
“pv_total”: 4700,
“battery_power”: 4722,
“load_power”: 4724,
“grid_power”: 4726,
“grid_import_today”: 4710,
“grid_import_total”: 4672,
“grid_export_total”: 4674,

Nella mia configurazione ho un Raspberry 4 collegato all’inverter e un Raspberry 5 con Home Assistan, il problema era a questo punto, catturare il dati con il RB4 e inviarli via rete interna al RB5. Ho optato per passare i dati con MQTT.

Premesso che tutto il lavoro fino ad ora spiegato sia stato fatto sul RB collegato all’inverter , installiamo Python con il comando:

sudo apt update
sudo apt install python3-pip
pip3 install pymodbus paho-mqtt
sudo apt install python3-pymodbus python3-paho-mqtt

Per verificare digitare:
python3 -c "import pymodbus; import paho.mqtt.client; print('OK')"

la risposta dovrebbe essere OK

Sul RB dove è installato Home Assistant installare l’Add-On Mosquitto broker e segnarsi indirizzo IP interno es. 192.168.0.7 .

Verifichiamo adesso che il RB Inverter (raspberry collegato all’inverter) veda il servizio MQTT che abbiamo installato sul RB HA (Raspberry con Home Assistant) con il comando: nc -vz 192.168.0.7 1883 se non fosse installato usare il comando: sudo apt install netcat-openbsd se funziona si otterrà una risposta simile a: Connection to 192.168.0.7 1883 port [tcp/*] succeeded!

Abbiamo verificato:

✅ Mosquitto attivo su Home Assistant
✅ Home Assistant raggiungibile (es. 192.168.0.7)
✅ Porta MQTT 1883 aperta e raggiungibile
✅ Librerie Python installate sul Raspberry collegato all’inverter

Sul RB HA digitare il comando: mosquitto_pub -h 192.168.0.7 -t test/powerx -m “ciao”

Probabilmente la riposta sarà connessione negata perchè non sono accettate connessioni anonime. Verificare intanto che sul RB HA in Dispositivi e Servizi sotto Impostazioni sia presente MQTT, spesso va aggiunto o configurato di base. Sempre nelle impostazioni aggiunger un nuovo utente con nome: mqtt_powerx e impostare una password (attenzione deve essere un utente e non una persona). Tornare sul RB Inverter e dare il comando: mosquitto_pub -h 192.168.0.7 -u mqtt_powerx -P PASSWORD -t test/powerx -m “ciao” Sostituisci PASSWORD con la password dell’utente che hai creato. Se la password contiene caratteri speciale mettila tra apici es. ‘XXx!!x’ .

Creiamo lo script Python che legge i dati dell’inverter e li spedisce via MQTT al Raspberry HA

posizionarsi su una cartella, per esempio il desktop e creare il file con il comanado: nano inverter_feb.py

import time
import struct
import json
import paho.mqtt.publish as publish
from pymodbus.client import ModbusSerialClient

MQTT_BROKER = "192.168.0.7"
MQTT_USER = "mqtt_powerx"
MQTT_PASSWORD = "PASSWORD"

MODBUS_PORT = "/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0"

REGISTERS = {
    "soc": 4626,

    "battery1_soc": 45318,

    "pv_power": 4720,
    "pv_today": 4708,
    "pv_total": 4700,

    "battery_power": 4722,

    "load_power": 4724,

    "grid_power": 4726,
    "grid_import_today": 4710,
    "grid_import_total": 4672,
    "grid_export_total": 4674,
}

UNITS = {
    "soc": "%",
    "battery1_soc": "%",

    "pv_power": "kW",
    "pv_today": "kWh",
    "pv_total": "kWh",

    "battery_power": "kW",

    "load_power": "kW",

    "grid_power": "kW",
    "grid_import_today": "kWh",
    "grid_import_total": "kWh",
    "grid_export_total": "kWh",
}

client = ModbusSerialClient(
    port=MODBUS_PORT,
    baudrate=115200,
    parity="N",
    stopbits=1,
    bytesize=8,
    timeout=2
)

discovery_sent = False


def read_float(address):

    result = client.read_input_registers(
        address=address,
        count=2,
        slave=1
    )

    if result.isError():
        return None

    raw = struct.pack(
        ">HH",
        result.registers[0],
        result.registers[1]
    )

    value = struct.unpack(">f", raw)[0]

    return round(value, 3)


def publish_value(topic, value):

    publish.single(
        topic,
        str(value),
        hostname=MQTT_BROKER,
        auth={
            "username": MQTT_USER,
            "password": MQTT_PASSWORD
        }
    )


def publish_discovery(sensor, unit):

    payload = {
        "name": f"PowerX {sensor}",
        "state_topic": f"powerx/{sensor}",
        "unique_id": f"powerx_{sensor}",
        "unit_of_measurement": unit,
    }

    if sensor in [
        "pv_total",
        "grid_import_total",
        "grid_export_total"
    ]:

        payload["state_class"] = "total_increasing"
        payload["device_class"] = "energy"

    else:

        payload["state_class"] = "measurement"

    publish.single(
        f"homeassistant/sensor/powerx_{sensor}/config",
        payload=json.dumps(payload),
        hostname=MQTT_BROKER,
        retain=True,
        auth={
            "username": MQTT_USER,
            "password": MQTT_PASSWORD
        }
    )


while True:

    try:

        if client.connect():

            if not discovery_sent:

                for sensor in REGISTERS:
                    publish_discovery(
                        sensor,
                        UNITS[sensor]
                    )

                discovery_sent = True

            values = {}

            for sensor, address in REGISTERS.items():

                values[sensor] = read_float(address)

                if values[sensor] is not None:

                    publish_value(
                        f"powerx/{sensor}",
                        values[sensor]
                    )

            print(
                f"SOC={values['soc']}%  "
                f"PV={values['pv_power']}kW  "
                f"PVToday={values['pv_today']}kWh  "
                f"Load={values['load_power']}kW  "
                f"Grid={values['grid_power']}kW"
            )

            client.close()

    except Exception as e:
        print(e)

    time.sleep(10)

inserendo la PASSWORD corretta. Dalla cartella dove avete creato il file eseguite il comando: python3 inverter_feb.py dovrebbe aprisi una finestra Terminal con per ogni riga tutti i valori generati che dovrebbero essere:

“soc”: 4626
“battery1_soc”: 45318,
“pv_power”: 4720,
“pv_today”: 4708,
“pv_total”: 4700,
“battery_power”: 4722,
“load_power”: 4724,
“grid_power”: 4726,
“grid_import_today”: 4710,
“grid_import_total”: 4672,
“grid_export_total”: 4674,

Su Home Assistant nell’Integrazione MQTT dovrebbero comparire 12 nuove entità ciascuno con i valori del vostro inverter.

Installando un Plug-In tipo Lumina si possono integrare tutte queste informazioni su un’interfaccia graficamente molto moderna come quella di seguito allegata.

Attenzione i dati arriveranno ad Home Assistant solo lo script è in esecuzione, se il RB Inverter si dovesse riavviare, chiaramente non arriverà più alcun dato finchè lo scrip non verrà eseguito nuovamente, esistono molti modi per automatazzare l’esecuzione.