Das Nibe Gateway (NibeGW) simuliert der Wärmepumpe gegenüber ein Nibe Modbus 40 Modul. Es läuft dabei entweder auf einem Arduino oder aber einem Raspberry. Man benötigt ein RS485 Modul, damit der Arduino oder Raspberry an die Wärmepumpe angeschlossen werden kann. Das NibeGW bereitet dabei die Daten von der Wärmepumpe auf und sendet diese über eine Netzwerkverbindung als UDP Daten (Binary) zu einer Auswertesoftware (wir beschreiben hier die Auswertung mittels der Software Nibe-MQTT).

Schema des Aufbaus:

Hardware Auswahl

Die meisten Wärmepumpen von Nibe (u.a. die gesamte F-Serie) gehen in Störung, sobald sie die Verbindung zum NibeGW verlieren. Sie erwarten auf alle Datenpakete, die sie senden, ein “ACK” von der Gegenseite. Bleibt dieses aus, gehen sie in den Fehler 251 und schalten sich teilweise in den Notbetrieb. Daher ist es extrem wichtig, dass das NibeGW ständig und permanent stabil läuft. Ich empfehle daher dringend, das NibeGW mit einem Arduino aufzubauen und hier keinen Raspberry zu verwenden.

Ihr benötigt zum Aufbau des NibeGW:

• Arduino Uno oder ProDiNo ESP32 Ethernet v1 oder Ethernet v2

• Ethernetshield W5100 (nicht notwendig beim ProDiNo)

• RS485 Modul (nicht notwendig beim ProDiNo)

Von der Wärmepumpe kann man eine 12V Stromversorgung abgreifen und den Arduino damit speisen. Die Belegung findet sich in der Nibe-Dokumentation: https://partner.nibe.eu/nibedocuments/24801/031725-10.pdf Das funktioniert ohne Probleme, laut Datenblatt kann der Arduino mit 5-20V versorgt werden, wobei wohl 12V nicht überschritten werden sollen. Alternativ nehmt ein Netzteil mit mindestens 7V - mit 5V lief das Ethernetshield bei mir nicht stabil und baute keine Verbindung auf.

Als Gehäuse findet ihr auf Thingiverse diverse Vorlagen für den Arduino Uno mit Ethernetshield W5100. Schaut nur, dass ihr oberhalb des Ethernetshields noch genügend Platz für die Verkabelung des RS485 Moduls habt. Ich habe folgendes Gehäuse verwendet: https://www.thingiverse.com/thing:5396191

Open

Arduino Uno mit Ethernetshield und RS485 Adapter

Software auf dem NibeGW

Die Software auf dem NibeGW findet ihr im Github Repository des Openhab Projekts: https://github.com/openhab/openhab-addons/tree/main/bundles/org.openhab.binding.nibeheatpump/contrib/NibeGW/Arduino

Ihr benötigt alle Dateien, speichert diese in ein gemeinsames Verzeichnis ab (Datei anklicken, “Raw”, dann rechte Maustaste “Speichern unter….”).

Zusätzlich benötigt ihr noch die Arduino IDE: https://www.arduino.cc/en/software

Installiert die IDE und öffnet dann die Datei “NibeGW.ino”. Es öffnen sich alle weiteren Dateien mit. Weitere Hilfe findet ihr auch hier im Readme: https://github.com/openhab/openhab-addons/tree/main/bundles/org.openhab.binding.nibeheatpump/contrib/NibeGW/Arduino

Arduino Uno

Nun könnt ihr den Arduino per USB mit dem Rechner verbinden. Nehmt vorher das Ethernetshield und auch den RS485 Adapter ab. Da der Arduino Uno nur eine serielle Schnittstelle hat und diese für die USB-Verbindung benötigt wird, klappt ansonsten das Hochladen des Sketches später nicht.

Nun müssen einige Änderungen am Code durchgeführt werden:

Config.h:

Kommentiere alle Zeilen für die speziellen Arduinoboards aus:

Deaktiviere durch Auskommentieren auch das Debugging auf der seriellen Konsole (da diese für den RS485 Adapter benötigt wird):

Dann musst Du noch die IP-Adressen sowie die Ziel-IP und die Ports in der Config.h anpassen. Die Konfiguration der seriellen Schnittstelle lässt Du so wie sie ist - das passt für den Arduino Uno.

NibeGW.h:

Aktiviere den Support für “HARDWARE_SERIAL”:

Das war’s - jetzt sollte der Sketch kompilieren und Du kannst ihn auf den Arduino hochladen. Danach kannst Du das Ethernetshield und den RS485 Adapter wieder anschließen.

Anschluss des RS485 Moduls

Beim RS485 Modul gibt es zwei Bauarten:

• Module basierend auf dem Max1348 Chip, mit 2 Pins auf der Arduinoseite (RXD, TXD) + VCC + GND

• Module basierend auf dem Max485 Chip, mit 4 Pins auf der Arduinoseite (RO, RE, DE, DI) + VCC + GND

Beide Modulbauarten fuktionieren mit dem Plugin. Sie müssen wie folgt angeschlossen werden:

Wiring diagram for Max1348 based modules:

Wiring diagram for Max485 (PIN2 is used as direction pin here):

Anschluss an die Nibe Wärmepumpe

Der Anschluss des RS485-Kabels an die Wärmepumpe unterscheidet sich etwas je nach Typ eurer Wärmepumpe. Details findet ihr in der Beschreibung des Modbus 40 Moduls: https://partner.nibe.eu/nibedocuments/24801/031725-10.pdf

Es werden jeweils die Ausgänge des RS485 Moduls A+B und die Eingänge an der Wärmepumpe A+B miteinander verbunden (nicht über Kreuz).

Wenn ihr alles angeschlossen habt und der Arduino läuft, aktiviert ihr in der Nibe das Modbus-Modul im Servicemenü der Wärmepumpe. Dazu die “Zurück”-Taste einige Sekunden drücken, bis das Servicemenü im Display erscheint. Dann navigiert ihr zu 5.2 Serviceeinstellungen -> 5.2.4 Zubehör -> Modbus und aktiviert das Modbusmodul. Anschließend geht ihr noch zu 5.3 Zubehörteinstellungen -> 5.3.11 Modbus -> word swap und aktiviert diese Option.

Wenn alles geklappt hat solltet ihr am RS485 ein blinken der TX/RX-Leds sehen. Auf dem Display der Wärmepumpe darf kein Alarm erscheinen. Wenn der Alarm 251 erscheint, dann klappt die Kommunikation zwischen NibeGW und Wärmepumpe nicht. Kontrolliert die Verkabelung und tauscht ggf. testweise TXD/RXD-Leitung zwischen Modul und Arduino oder auch A/B-Leitung zwischen RS485-Modul und Wärmepumpe. Nach jeder Veränderung müsst ihr den Fehler im Display der Wärmepumpe quittieren. Erscheint er gleich wieder, habt ihr das Problem noch nicht gelöst.

Abschlusswiderstand: Einige RS485 Module haben keinen eingebauten Abschlusswiderstand. Dieser muss wie bei Loxone 120 Ohm betragen. Wenn ihr Euch unsicher seit, baut einen 120 Ohm Widerstand zwischen A- und B-Klemme am Modul ein. In der Nibe Wärmepumpe ist ein passender Widerstand bereits integriert.

Vorbereitung Nibe Wärmepumpe

Die Nibe Wärmepumpen können insgesamt 20 Werte (Modbusregister) permanent alle 0,5s senden. Alle weiteren Werte, die man noch auswerten möchte, muss man explizit z. B. alle 30 Sekunden pollen. Es macht also Sinn, sich schnell ändernde Werte in diese 20 möglichen Werte zu integrieren, während man sich langsam ändernde Werte (z. B. Temperaturen) alle 30 oder 60 Sekunden pollt. Welche der 20 Werte die Nibe zyklisch senden soll, muss man mit der Nibe Modbus Manager Software konfigurieren.

Der Modbus Manager kann von der Nibe Webseite heruntergeladen werden: https://partner.nibe.eu/Products/Accessories/NIBE-MODBUS-40/#tab2

Direktkink: https://partner.nibe.eu/upload/NEW/Support/Kommunikation/NIBE ModbusManager 1.0.9 [v8310] Setup.exe

Wählt eure Wärmepumpe oben im Menü aus und schiebt dann die Werte, die ihr zyklisch senden wollt, von der linken auf die rechte Seite. Achtung! 32Bit Werte (meistens Zählerstände) können nur gepollt werden! Zudem listet die Software auch viele Register von Zusatzmodulen auf, die bei Euch eventuell gar nicht installiert sind. Ich habe folgende Werte bei mir ewählt:

Open

Wenn ihr fertig seid, speichert ihr über “Save configuration…” eure Auswahl auf einem USB-Stick ab. Es wird eine Datei mit Namen “LOG.SET” erstellt. Steckt anschließend den USB-Stick in eure Nibe Wärmepumpe und aktiviert kurzzeitig vom USB-Menü das Logging. Die Nibe liest die LOG.SET für das Logging ein und verwendet diese Einstellungen auch für die Übertragung per Modbus.

Deaktiviert das Logging und entfernt den USB Stick wieder. Die Nibe hat sich die Einstellungen gemerkt.

Software Nibe-MQTT

Erster Test

Das NibeGW sendet jetzt alle Daten an die von euch konfigurierte “Target IP” per UDP. Das kann z. B. ein Raspberry oder auch ein Loxberry sein. Kontrolliert auf dem Ziel-Gerät zunächst, ob die Daten per UDP hereinkommen. Dazu startet ihr auf der Konsole folgenden Befehl:

Ihr solltet hereinkommende Daten sehen. Wenn das passt, dann installieren wir jetzt die Software Nibe-MQTT.

Python Version > 3.9

Zunächst kontrolliert ihr die Python3-Version, diese muss mindestens 3.9 sein:

Wenn eure Version zu alt ist, findet ihr im Netz zahlreiche Anleitungen, wie ihr die Version manuell updaten könnt. Zum Beispiel hier: https://bodo-schoenfeld.de/aktuelle-version-von-python-unter-debian-installieren/

Zusätzlich empfehle ich Euch, dann die neue Version auch zum Standard im System zu machen (hier am Beispiel Python 3.11 - Pfadangaben müsst ihr je nach Version anpassen):

Nibe-MQTT installieren und konfigurieren

Nun installiert ihr über pip3 Nibe-MQTT:

Wenn das problemlos durchgelaufen ist, dann solltet ihr nibe-mqtt ausführen können:

Jetzt können wir Nibe-MQTT konfigurieren. Die zuvor konfigurierten maximal 20 Register werden von Nibe-MQTT automatisch empfangen und an euren MQTT Broker gesendet.

Weitere Werte, die ihr noch zusätzlich pollen wollt, könnt ihr in der Konfiguration noch hinzufügen. Welche Werte möglich sind, findet ihr in der von Nibe-Config verwendeten Nibe-Library (öffnet die JSON-Datei für eure Wärmepumpe auf Github, da seht ihr die genaue Bezeichnung, die ihr in der Nibe-MQTT Konfiguration eingeben müsst. Tipp: Nutzt “Strg+F” um zu suchen): https://github.com/yozik04/nibe/tree/master/nibe/data

Erzeugt eine Konfigurationsdatei “nibemqtt.yml” mit einem Editor eurer Wahl. Die Datei ist im YAML-Format anzulegen und enthält zunächst den MQTT-Teil, wo ihr die Verbindung zu eurem Broker konfiguriert. Anschließend legt ihr eure Nibe Wärmepumpe fest, wie und wo das NibeGW zu erreichen ist und dann, welche Werte ihr zusätzlich alle x Sekunden pollen wollt. Meine Konfiguration sieht wie folgt aus:

Speichert die Datei ab.

Weitere Konfigurationsoptionen könnt ihr auf der Projektseite auf GitHub nachlesen: https://github.com/yozik04/nibe-mqtt/blob/master/nibe_mqtt/config.py

Wenn alles konfiguriert ist, starten wir Nibe-MQTT mit: nibe-mqtt -c nibemqtt.yml Die Ausgabe sollte ungefähr so aussehen und die Werte sollten in eurem Broker einlaufen:

Autostart

Damit Nibe-MQTT automatisch startet, gibt es verschiedene Möglichkeiten unter Linux. Google hilft Euch weiter. Ich trage den Startbefehl in die Datei /etc/rc.localein. Diese Datei wird bei jedem Systemstart ausgeführt. Beachtet, dass ihr Nibe-MQTT im Hintergrund starten müsst (&-Zeichen am Ende des Aufrufs), Logausgaben leite ich nach /dev/null um, weil ich sie im Standardbetrieb nicht benötige:

Werte setzen / schreiben

Verschiedene Parameter der Wärmepumpe könnt ihr auch beschreiben, also aus der LoxoneConfig heraus setzen. Ein Beispiel dafür ist z. B. das Quittieren von Alarmen. Aber natürlich auch die Steuerung der Wärmepumpe ja nach PV-Überschuss z. B. ist möglich.

Welche Werte zu beschreiben sind, findet ihr wieder in der schon erwähnten Nibe-Library (öffnet die JSON-Datei für eure Wärmepumpe auf Github, da seht ihr welche schreibbar sind → write: true. Tipp: Nutzt “Strg+F” um zu suchen): https://github.com/yozik04/nibe/tree/master/nibe/data

Wenn ihr einen Wert setzen wollt, publishet ihr diesen Wert einfach per MQTT an das entsprechende Topic. Das Topic setzt sich dabei wie folgt zusammen: [prefix]/[coil]/set

Wenn ihr also z. B. einen Alarm resetten wollt, setzt ihr den Wert “1” per MQTT im Topic nibe/coils/alarm-reset-45171/set (mein Prefix ist “nibe”). Beachtet, dass ihr teilweise auch Strings setzen müsst, wen der Nibe-Library (siehe oben) ein Mapping definiert ist. So setzt ihr die temporäre Luxus-Temperatur für Warmwasser z. B., indem ihr an nibe/coils/temporary-lux-48132/set den String “ONE TIME INCREASE” publisht.

Wie ihr Topics mit dem LoxBerry MQTT Plugin setzen könnt, findet ihr hier: https://wiki.loxberry.de/plugins/mqtt_gateway/mqtt_schritt_fur_schritt_loxone_mqtt

Loxone Config

Wie ihr die Werte zur Visualisierung in die Loxone Config bekommt, könnt ihr beim MQTT Plugin nachlesen: https://wiki.loxberry.de/plugins/mqtt_gateway/mqtt_schritt_fur_schritt_mqtt_loxone

Ich habe für meine Visualisierung das Anlagenschema verwendet: