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 OKSul 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.