Shelly Pro EM-50 als PV-omvormer uitlezen op de Cerbo GX

Technische handleiding — alleen voor gevorderde gebruikers. Deze procedure veredert de Cerbo GX via SSH, een root-wachtwoord en een zelf toegevoegd Python-driver-script. Dit is geen officiële Victron- of Shelly-functie maar een community-oplossing. Weet je niet zeker wat SSH, nano of een DBus-service is? Doe dit dan niet zelf — mail ons, dan kijken we mee. Uitvoeren op eigen risico.

Waarom dit nodig is

De Shelly Pro EM-50 heeft twee energiemeet-kanalen én een ingebouwde schakelaar (relais). Venus OS (ook v3.70+ met de ingebouwde Shelly-integratie) koppelt het apparaat daardoor onder de schakelaars/relais, niet als PV-omvormer. Je ziet de Shelly dus wel in de apparatenlijst staan, maar je PV-opbrengst komt niet in het overzicht of in VRM terecht. De ingebouwde integratie kan de meetkanalen (nog) niet als PV-inverter presenteren. De oplossing: we lezen de Shelly rechtstreeks uit via zijn HTTP-API en publiceren de waarden zelf als PV-omvormer op de DBus van de Cerbo.

De Pro EM-50 gebruikt het nieuwere Gen2/Gen3 RPC-protocol (/rpc/Shelly.GetStatus), met de meetdata onder em1:0 en em1:1. Kant-en-klare dbus-shelly-scripts die de oude Gen1-API (/status) of de switch:0-structuur verwachten, werken daaróm niet zonder aanpassing. Het script hieronder is specifiek op de Pro EM-50 afgestemd.

Wat je nodig hebt

Een Cerbo GX (of ander GX-apparaat) met Venus OS.
De Shelly Pro EM-50 aan hetzelfde netwerk, met een vast IP-adres (reserveer het in je router).
Geen wachtwoordbeveiliging op de Shelly (of noteer de inloggegevens — je vult ze straks in de config in).
Een computer met een terminal (Terminal op macOS/Linux, of PuTTY / cmd op Windows).
Het IP-adres van je Cerbo én van je Shelly.

Stap 1 — Zet de ingebouwde Shelly-integratie uit

Anders “bezet” de native integratie het apparaat als schakelaar en botst dat met de PV-omvormer die je zo aanmaakt.

Open de integratie-instellingen

Ga op de Cerbo (of Remote Console) naar Instellingen → Integraties → Shelly (afhankelijk van je firmware ook onder Modbus/netwerkapparaten).

Schakel de Shelly uit

Zoek je Shelly Pro EM-50 in de lijst en zet hem op Uitgeschakeld (of kies Vergeten / verwijderen als die optie er staat).

Stap 2 — Zet root-toegang en SSH aan

Nieuwe interface (GUI-v2)
Klassieke interface (GUI-v1)

Ga naar Instellingen → Toegang en beveiliging.
Trek de hele lijst naar beneden en houd ~5 seconden vast — het toegangsniveau springt naar Superuser.
Er verschijnen onderaan twee nieuwe regels: Root-wachtwoord instellen en SSH via lokaal netwerk (LAN). Stel een wachtwoord in en zet SSH aan.

Zit je in GUI-v2 en lukt het gebaar niet? Schakel tijdelijk terug via Instellingen → Display & taal → GUI-v1, zet daar SSH aan, en switch daarna weer terug. De SSH-toegang blijft aan op de achtergrond.

Stap 3 — Log in op de Cerbo via SSH

Open een terminal en verbind (vervang het IP door dat van jouw Cerbo):

ssh root@192.168.0.185

Vraagt hij naar een “fingerprint”? Typ yes. Vul daarna je root-wachtwoord in (je ziet tijdens het typen geen tekens verschijnen — dat is normaal). Je bent ingelogd als je de prompt root@einstein:~# ziet (de naam wijkt af per systeem).

Stap 4 — Installeer de driver-basis

We gebruiken een bestaande dbus-shelly-driver als “geraamte” (voor de service- en herstart-scripts) en vervangen daarna het uitlees-script door een Pro EM-50-versie. Plak dit blok in de terminal:

cd /data
wget https://github.com/zandervalle/dbus-shelly-plus-pvinverter/archive/refs/heads/main.zip -O shelly.zip
unzip shelly.zip
mv dbus-shelly-plus-pvinverter-main dbus-shelly-plus-pvinverter
rm shelly.zip
chmod a+x /data/dbus-shelly-plus-pvinverter/install.sh

Community-repositories verhuizen of verdwijnen soms. Krijg je een 404? Zoek dan op een actuele dbus-shelly PV-inverter driver — het geraamte (install.sh, restart.sh, service/run, config.ini) is generiek. Het uitlees-script uit stap 6 is het enige dat écht Pro EM-50-specifiek is.

Stap 5 — Vul het IP-adres in (config.ini)

nano /data/dbus-shelly-plus-pvinverter/config.ini

Zet de inhoud zo (vul jouw Shelly-IP in bij Host):

[DEFAULT]
AccessType = OnPremise
ProductName = Shelly Pro EM-50
DeviceInstance = 50
CustomName = Zonnepanelen
Phase = L1

[ONPREMISE]
Host = 192.168.0.171
UseAutentication = false
Username =
Password =

Heeft je Shelly wél een wachtwoord? Zet UseAutentication = true en vul Username en Password in. Opslaan met Ctrl + O → Enter, sluiten met Ctrl + X.

DeviceInstance moet uniek zijn op de DBus. Zag de Cerbo de Shelly eerder al onder een bepaald nummer (bijv. 40 of 50)? Kies dan een vrij nummer of hetzelfde nummer, zolang geen ander apparaat het al gebruikt.

Stap 6 — Plaats het Pro EM-50 uitlees-script

Dit script leest beide meetkanalen (em1:0 en em1:1), telt ze op tot één PV-omvormer op fase L1, en haalt de energie (kWh) uit em1data:0 / em1data:1. Maak het bestand eerst leeg en open het:

> /data/dbus-shelly-plus-pvinverter/dbus-shelly-plus-pvinverter.py
nano /data/dbus-shelly-plus-pvinverter/dbus-shelly-plus-pvinverter.py

Plak de volledige inhoud hieronder erin (let op: in Python is de inspringing met spaties belangrijk — plak het in één keer):

Volledig script: dbus-shelly-plus-pvinverter.py (beide kanalen → L1)

import os
import sys
import logging
import configparser
import requests
from requests.auth import HTTPDigestAuth

sys.path.insert(1, os.path.join(os.path.dirname(__file__), '/opt/victronenergy/dbus-systemcalc-py/ext/velib_python'))
from vedbus import VeDbusService
from gi.repository import GLib


class DbusShellyPlusService:
    def __init__(self, servicename, deviceinstance, paths, productname='Shelly Pro EM-50', customname='Zonnepanelen'):
        self._dbusservice = VeDbusService(servicename)
        self._paths = paths

        logging.debug("%s /DeviceInstance = %d" % (servicename, deviceinstance))

        self._dbusservice.add_path('/Mgmt/ProcessName', __file__)
        self._dbusservice.add_path('/Mgmt/ProcessVersion', '1.0-ProEM50-DualL1')
        self._dbusservice.add_path('/Mgmt/Connection', 'Shelly Pro EM-50 HTTP RPC')

        self._dbusservice.add_path('/DeviceInstance', deviceinstance)
        self._dbusservice.add_path('/ProductId', 0xFFFF)
        self._dbusservice.add_path('/ProductName', productname)
        self._dbusservice.add_path('/CustomName', customname)
        self._dbusservice.add_path('/Connected', 1)

        self._dbusservice.add_path('/Latency', None)
        self._dbusservice.add_path('/Role', 'pvinverter')
        self._dbusservice.add_path('/Position', 0)

        for path, settings in self._paths.items():
            self._dbusservice.add_path(
                path, settings['initial'], gettextcallback=settings['gettextcallback'], writeable=True, onchangecallback=self._handlechangedvalue
            )

        GLib.timeout_add(1000, self._update)

    def _getShellyData(self):
        config = self._getConfig()
        URL = f"http://{config['ONPREMISE']['Host']}/rpc/Shelly.GetStatus"

        if config['ONPREMISE']['UseAutentication'] == 'true':
            meter_r = requests.get(url=URL, auth=HTTPDigestAuth(config['ONPREMISE']['Username'], config['ONPREMISE']['Password']), timeout=5)
        else:
            meter_r = requests.get(url=URL, timeout=5)

        if not meter_r:
            raise ConnectionError("No response from Shelly - %s" % (URL))

        return meter_r.json()

    def _getConfig(self):
        config = configparser.ConfigParser()
        config.read(f"{os.path.dirname(os.path.realpath(__file__))}/config.ini")
        return config

    def _handlechangedvalue(self, path, value):
        return True

    def _update(self):
        try:
            meter_data = self._getShellyData()

            # Kanaal em1:0
            p0 = float(meter_data['em1:0']['act_power']) if 'em1:0' in meter_data else 0.0
            v0 = float(meter_data['em1:0']['voltage']) if 'em1:0' in meter_data else 0.0
            i0 = float(meter_data['em1:0']['current']) if 'em1:0' in meter_data else 0.0

            # Kanaal em1:1
            p1 = float(meter_data['em1:1']['act_power']) if 'em1:1' in meter_data else 0.0
            v1 = float(meter_data['em1:1']['voltage']) if 'em1:1' in meter_data else 0.0
            i1 = float(meter_data['em1:1']['current']) if 'em1:1' in meter_data else 0.0

            # Optellen tot één omvormer op L1
            power = p0 + p1
            current = i0 + i1
            voltage = v0 if v0 > 0 else v1

            # Energie (kWh) optellen
            e0 = float(meter_data['em1data:0']['total_act_energy']) / 1000.0 if ('em1data:0' in meter_data and 'total_act_energy' in meter_data['em1data:0']) else 0.0
            e1 = float(meter_data['em1data:1']['total_act_energy']) / 1000.0 if ('em1data:1' in meter_data and 'total_act_energy' in meter_data['em1data:1']) else 0.0
            total_energy = e0 + e1

            self._dbusservice['/Ac/L1/Voltage'] = voltage
            self._dbusservice['/Ac/L1/Current'] = current
            self._dbusservice['/Ac/L1/Power'] = power
            if power > 0:
                self._dbusservice['/Ac/L1/Energy/Forward'] = total_energy

            for phase in ['L2', 'L3']:
                pre = '/Ac/' + phase
                self._dbusservice[pre + '/Voltage'] = 0
                self._dbusservice[pre + '/Current'] = 0
                self._dbusservice[pre + '/Power'] = 0

            self._dbusservice['/Ac/Power'] = power
            self._dbusservice['/Ac/MaxPower'] = 10000
            self._dbusservice['/Ac/Energy/Forward'] = total_energy

            logging.debug(f"Shelly Pro EM-50 Total: {power}W ({p0}W + {p1}W)")

        except Exception as e:
            logging.critical(f"Error at _update: {e}")

        return True


def main():
    logging.basicConfig(filename=f"{os.path.dirname(os.path.realpath(__file__))}/current.log", level=logging.DEBUG)

    config = configparser.ConfigParser()
    config.read(f"{os.path.dirname(os.path.realpath(__file__))}/config.ini")

    paths_dbus = {
        '/Ac/Power': {'initial': 0, 'gettextcallback': lambda p, v: "{:.0f}W".format(v)},
        '/Ac/MaxPower': {'initial': 10000, 'gettextcallback': lambda p, v: "{:.0f}W".format(v)},
        '/Ac/Energy/Forward': {'initial': 0, 'gettextcallback': lambda p, v: "{:.2f}kWh".format(v)},

        '/Ac/L1/Voltage': {'initial': 0, 'gettextcallback': lambda p, v: "{:.1f}V".format(v)},
        '/Ac/L1/Current': {'initial': 0, 'gettextcallback': lambda p, v: "{:.1f}A".format(v)},
        '/Ac/L1/Power': {'initial': 0, 'gettextcallback': lambda p, v: "{:.0f}W".format(v)},
        '/Ac/L1/Energy/Forward': {'initial': 0, 'gettextcallback': lambda p, v: "{:.2f}kWh".format(v)},

        '/Ac/L2/Voltage': {'initial': 0, 'gettextcallback': lambda p, v: "{:.1f}V".format(v)},
        '/Ac/L2/Current': {'initial': 0, 'gettextcallback': lambda p, v: "{:.1f}A".format(v)},
        '/Ac/L2/Power': {'initial': 0, 'gettextcallback': lambda p, v: "{:.0f}W".format(v)},
        '/Ac/L2/Energy/Forward': {'initial': 0, 'gettextcallback': lambda p, v: "{:.2f}kWh".format(v)},

        '/Ac/L3/Voltage': {'initial': 0, 'gettextcallback': lambda p, v: "{:.1f}V".format(v)},
        '/Ac/L3/Current': {'initial': 0, 'gettextcallback': lambda p, v: "{:.1f}A".format(v)},
        '/Ac/L3/Power': {'initial': 0, 'gettextcallback': lambda p, v: "{:.0f}W".format(v)},
        '/Ac/L3/Energy/Forward': {'initial': 0, 'gettextcallback': lambda p, v: "{:.2f}kWh".format(v)},
    }

    from dbus.mainloop.glib import DBusGMainLoop
    DBusGMainLoop(set_as_default=True)

    DbusShellyPlusService(
        servicename='com.victronenergy.pvinverter.http_50',
        deviceinstance=50,
        paths=paths_dbus,
        productname=config['DEFAULT'].get('ProductName', 'Shelly Pro EM-50'),
        customname=config['DEFAULT'].get('CustomName', 'Zonnepanelen')
    )

    mainloop = GLib.MainLoop()
    mainloop.run()


if __name__ == "__main__":
    main()

Opslaan met Ctrl + O → Enter, sluiten met Ctrl + X.

Meet je met de twee kanalen twee verschillende fasen (bijv. L1 en L2) in plaats van twee groepen op dezelfde fase? Dan wil je ze niet optellen op L1, maar apart per fase publiceren. Neem in dat geval contact op — dan sturen we een variant van het script mee.

Stap 7 — Installeren, starten en controleren

/data/dbus-shelly-plus-pvinverter/install.sh
pkill -f dbus-shelly-plus-pvinverter
rm -rf /data/dbus-shelly-plus-pvinverter/__pycache__
/data/dbus-shelly-plus-pvinverter/restart.sh

Bekijk daarna het live-logboek:

tail -n 20 /data/dbus-shelly-plus-pvinverter/current.log

Zie je regels als Shelly Pro EM-50 Total: 2601.6W (1012.4W + 1589.2W) zonder CRITICAL-fouten? Dan werkt het. Op het overzichtsscherm van de Cerbo en in VRM verschijnt nu je zonne-opbrengst als PV-omvormer. Eventueel de Cerbo herstarten met reboot om het overzicht direct te verversen.

Handige controle: welke velden gebruikt jouw Shelly?

Twijfel je over de veldnamen (bij een ander Shelly-model of firmware)? Vraag de statusregel rechtstreeks op:

curl -s http://192.168.0.171/rpc/Shelly.GetStatus | grep -o '"em1:0":{[^}]*}'

Je ziet dan bijvoorbeeld:

"em1:0":{"id":0,"current":3.810,"voltage":241.8,"act_power":921.6,"aprt_power":923.2,"pf":0.99,"freq":50.0}

De Pro EM-50 gebruikt dus act_power, voltage en current — precies de velden die het script uitleest.

Problemen oplossen

Melding in `current.log`	Oorzaak	Oplossing
`ConnectionError: No response from Shelly`	Verkeerd IP of Shelly niet bereikbaar	Controleer `Host` in `config.ini` en of de Shelly online is
`KeyError: 'apower'` of `KeyError: 'switch:0'`	Oud Gen1-/switch-script actief	Gebruik het script uit stap 6 (leest `em1:0`) en wis `__pycache__`
PV-omvormer verdwijnt uit het overzicht	Script crasht bij opstart (vaak inspring-/spatiefout)	`python3 .../dbus-shelly-plus-pvinverter.py` handmatig starten om de fout te zien
Blijft als schakelaar staan	Ingebouwde Shelly-integratie nog actief	Herhaal stap 1 en herstart de Cerbo

Dit is een handmatige aanpassing in /data. Die blijft doorgaans behouden bij een firmware-update, maar controleer na een grote Venus OS-update of de PV-omvormer nog in beeld is en of de ingebouwde Shelly-integratie het apparaat niet opnieuw als schakelaar heeft opgepakt.

Toegang geven tot VRM

Laat onze support op afstand meekijken en instellingen aanpassen.

Contact & advies

Kom je er niet uit? Neem contact op — we helpen kosteloos op afstand.

Inbedrijfstelling

Installatie

Troubleshooting

Shelly Pro EM-50 als PV-omvormer uitlezen op de Cerbo GX

Waarom dit nodig is

Wat je nodig hebt

Stap 1 — Zet de ingebouwde Shelly-integratie uit

Stap 2 — Zet root-toegang en SSH aan

Stap 3 — Log in op de Cerbo via SSH

Stap 4 — Installeer de driver-basis

Stap 5 — Vul het IP-adres in (config.ini)

Stap 6 — Plaats het Pro EM-50 uitlees-script

Stap 7 — Installeren, starten en controleren

Handige controle: welke velden gebruikt jouw Shelly?

Problemen oplossen

Toegang geven tot VRM

Contact & advies

​Waarom dit nodig is

​Wat je nodig hebt

​Stap 1 — Zet de ingebouwde Shelly-integratie uit

​Stap 2 — Zet root-toegang en SSH aan

​Stap 3 — Log in op de Cerbo via SSH

​Stap 4 — Installeer de driver-basis

​Stap 5 — Vul het IP-adres in (config.ini)

​Stap 6 — Plaats het Pro EM-50 uitlees-script

​Stap 7 — Installeren, starten en controleren

​Handige controle: welke velden gebruikt jouw Shelly?

​Problemen oplossen

Toegang geven tot VRM

Contact & advies

Waarom dit nodig is

Wat je nodig hebt

Stap 1 — Zet de ingebouwde Shelly-integratie uit

Stap 2 — Zet root-toegang en SSH aan

Stap 3 — Log in op de Cerbo via SSH

Stap 4 — Installeer de driver-basis

Stap 5 — Vul het IP-adres in (config.ini)

Stap 6 — Plaats het Pro EM-50 uitlees-script

Stap 7 — Installeren, starten en controleren

Handige controle: welke velden gebruikt jouw Shelly?

Problemen oplossen