Aktuelle Test Version
Veröffentlichungsdatum	01.07.2025
Github Link	https://github.com/bolliy/ioBroker.sun2000

Über eure Unterstützung würde ich mich sehr freuen.

Hallo zusammen,

ich habe für meinen Huawei Wechselrichter SUN2000 und Speicher LUNA2000 einen Adapter entwickelt, der die Registerdaten über modbus TCP ausliest und schreibt.

Bitte den Adapter über das Beta Repository oder npm installieren und nicht direkt über github - damit keine unfertige Version in ioBroker eingespielt wird.

Nun kann im sun2000 Adapter neben dem Smart Logger auch die Emma (Energiemanagementsystem von Huawei) auf einfache Weise integriert werden.

Feature list:

• Es können max. 5 sun2000 Wechselrichter (Master/Slave) mit mehreren Batterieeinheit verarbeitet werden.

• Battery Control
  Neben dem "Laden des Speichers über dynamische Stromtarife" können u.a. die Speicherladegrenzen eingestellt werden. Viele Beispielszenarien werden im Wiki beschrieben.

• Begrenzung Netzeinspeisung (Export Control)
  Über die Funktion Export control kann nun die Netzeinspeisung begrenzt oder unterbunden werden.
  Diese Funktion steht allerdings den SmartLogger Besitzern (noch) nicht zur Verfügung.

• Erzwungenes Laden/Entladen der Batterie (Forcible Charge/Discharge)
  Die Batterie kann für eine bestimmte Dauer oder auf einen bestimmten SoC-Wert zwangsweise aufgeladen oder entladen werden.

• Über den eingebauten modbus-proxy können Geräte von Drittanbietern (Wallbox, energy manger usw.) lesend und schreibend auf die Daten der Geräte per modbus tcp zugreifen. Da der modbus-proxy multi-client-fähig ist, kann der Zugriff von mehreren Clients gleichzeigit erfolgen. Darüber hinaus ist es möglich die Daten des Adapters auf eine andere Adapter Instanz zu spiegeln.
  Im Gegensatz zu dem SDongle ist der modbus-proxy deutlich schneller und stabiler.

• Wer ein SmartLogger sein Eigen nennen kann, ist sicher über die Integration des Huawei SmartLoggers erfreut.

• Mit der EMMA von Huawei kann der Energieverbrauch im Haus optimiert und die Energiekosten reduziert werden. Die Integration in den Adapter ist nun möglich. Die Leistungs- und Verbrauchsdaten werden im Pfad emma gespeichert.

• Bei der Verwendung von einem Wechselrichter werden nicht weniger als 148 Datenpunkte erzeugt.

• Live Daten wie Eingangsleistung (inputPower), Ausgangsleistung (activePower), Battery Lade-/Entladeleistung (charge and discharge Power) und der Netzbezug (activePower) des Smart power sensors werden in einem festen Intervall (default 20 Sekunden) ausgelesen und die entsprechenden Zustände geschrieben.

• Nur für geänderte Registerdaten werden Zustände (States) geschrieben. Das entlastet die ioBroker Instanz.

• Die States „inputPower“ oder „activePower“ im Pfad „collected“ können mit einem Trigger-Element „wurde aktualisiert“ überwacht werden. Da diese States im eingestellten Interwall immer gschrieben werden.

• Die Registerdaten werden über drei Intervalle gelesen und verarbeitet:
  high: Im engestellten Intervall werden auschließlich Echtzeitdaten wie PV Leistung, Inverterleistung, Ladeleistung und Zählerstände bedient.
  medium (30 Sek): Stringdaten, weitere Zählerdaten usw.
  low (60 Sek): die restlichen veränderbaren Informationen
  static: ist eigentlich kein Intervall, da dieser einmalig ausgeführt wird. Z.B. Bezeichnung und Model des Inverters

• Die summierten Leistungs- und Verbrauchsdaten des SDongles (sofern vorhanden) können im medium Interval gelesen und im Pfad sdongle gespeichert werden.

• Ein Huawei Smart Charger (Wallbox), die über eine Emma integriert ist, wird nun automaitsch erkannt und die Daten im charger Pfad gespeichert. Die Berechnung der aktuelle Ladeleistung erfolgt über die Änderung des Wertes totalEnergyCharged und wird im Unterpfad derived abgelegt.

Über Tests und euer Feedback freue mich sehr.

Installation:

Den Adapter über das Beta Repository oder npm installieren installieren, damit keine unfertige Version in ioBroker eingespielt wird.
Durch Änderungen am js-controller werden vom sun2000 Adapter nur noch node 18.x und höher unterstützt!

Ich freue mich auf eure Mitwirkung!

@blechbixn hast du den SmartLogger aktiviert?
Die Fehlermeldung ist von der modbusID 11 !

Die ModbusID 11 ist der Smart Meter, der am SmartLogger angebunden ist.

Da du kein SmartLogger hast (vermute ich mal), solltest du die Einstellung deaktivieren.

LG Stephan

Neue Testversion sun2000 Adapter Version v0.15.0 released.
Nun können auch Registerdaten über den modbus-proxy geschrieben werden.

Die Installation erfolgt über npm oder morgen über das Beta Repository.

Release v0.15.0
• dependency and configuration updates
• display a clearly legible table bar #121
• modbus-proxy write data also to the read cache #119

Hintergrund: Über das open source Energiemanagmentsystem evcc kann eine Wallbox betrieben werden. Damit sich beim Laden des E-Autos der Hausspeicher nicht unnnötig entleert, wird das BMS über den modbus-proxy entsprechend gesteuert.

Ich freue mich auf eure Kommentare!

LG Stephan

Neue Testversion sun2000 Adapter Version v1.0.0 released.

Ich habe u.a. Anpassungen für einen zukünftigen Adapter vorgenommen. Der neue Adapter soll im ersten Step das prognosebasierte Laden des Solarspeichers (Luna) ermöglichen. Das Laden der Batterie erfolgt auf Basis der Erzeugungs-, Verbrauchsprognose sowie der dynamischen Strompreisentwicklung (Tibber).

Darüber hinaus läuft die Unterstützung der node.js V18 (LTS) bald aus (https://endoflife.date/nodejs). Deshalb gibt es ein neues Major Release!
Bitte vor der Installation node auf die Version 20 oder 22 heben. https://github.com/bolliy/ioBroker.sun2000/wiki/Update-node.js

Die Installation erfolgt über npm oder morgen über das Beta Repository.

Changelog
1.0.0 (2025-02-10)
• dependency and configuration updates
• updated case sensitivity of the object status name
• Interval time of the slave inverter increased slightly
• Register data is not read in "Standby: detecting irradiation" (0x0002) of the slave inverter
• Control: battery.maximumDischargePower is deprecated use "maximumDischargingPower" instead
• Control: battery.maximumChargePower is deprecated use "maximumChargingPower" instead
• breaking changes
◦ Node.js 20 or higher required
◦ ioBroker host (js-controller) 6.0.1 or higher
◦ ioBroker admin 6.13.16 or higher

Stephan

Neue Testversion sun2000 Adapter Version v1.2.2 released.

Die Installation erfolgt über npm oder morgen über das Beta Repository.

Nun kann auf die Berechnung des states usableSurplusPower über Parameter im Pfad sun2000.x.control.usableSurplus Einfluss genommen werden. usableSurplusPower Werte kleiner als 0.1 kW werden auf 0 gesetzt. Negative nutzbare Überschussleistungswerte gehören der Vergangenheit an.

minSoc
Unterhalb des minSoc (%) Wertes hat die Ladung der Hausbatterie Vorrang. Der nutzbare Überschuss wird ausschließlich durch die Netzeinspeiseleistung bestimmt. Steht unterhalb dieses Wertes mehr Erzeugungsleistung zur Verfügung als der Batteriespeicher aufnimmt, wird diese als Überschuss berücksichtigt. Ab dem minSoc Wertes wird neben der Netzeinspeiseleistung auch die Ladeleistung der Batterie als Überschussleistung gewertet.

bufferSoc
Erlaubt die zusätzliche Nutzung der Hausbatterieleistung oberhalb des bufferSoc (%) Wertes mit dem angegebenem bufferPower (W) Wert.

bufferPower
siehe bufferSoc

residualPower
Sofern sich der Soc der Hausbatterie zwischen minSoc und bufferSoc befindet, legt der residualPower Wert den Soll-Arbeitspunkt der Überschussberechnung (Regelung) fest. Werte größer 0 verschieben den Arbeitspunkt in Richtung Hausspeicher-Laden bzw. Netzeinspeisung; kleiner 0 Werte in Richtung Netzbezug.

1.2.2 (2025-04-01)

• dependency and configuration updates
• fix: Object state sDongle.OSVersion to short
• new setting path for controlling the usableSurplusPower parameters control.usableSurplus

@marcelinho es müsste Grid Power sein (>0 : Netzbezug, <0 : Netzeinspeisung). Du findest die notwendigen Informationen in den Interface definitions https://github.com/bolliy/ioBroker.sun2000/blob/main/docs/definitions.md

Stephan

Hallo Zusammen, ich habe mein Huawai Wechselrichter dank des JS script von @chrisB gut im Griff. Nun ist mir allerdings aufgefallen, dass die Funktion/Methode "readHoldingRegisters" mit einem Callback aufgerufen wird. Der Callback führt zu einem asynchronem Programmablauf. Deshalb muss die Abfrage der Register zeitverzögert erfolgen, da die die Modbus-Schnittstelle nur seriell angsprochen werden kann. Es kann also die nächste Abfrage erst nach dem Modbus-Response erfolgen.

Die Funktion readHoldingRegisters gibt aber auch ein Promise zurück - also ein Versprechen auf einen Wert, der später kommt.
Die Lösung: async/await! Unter der Haube arbeitet ein Promise, aber wir werden von den ganzen Unannehmlichkeiten befreit. Nun habe ich die Funkion "readRegisterSpace" umgebaut. Der Programmablauf ist nun synchron. Der Aufruf "await client.readHoldingRegisters" wartet bis das Ergebnis vorliegt ohne zu blockieren!

async function readRegisterSpaceAsync(id, address, length) {  
    try {
      //console.log('ReadRegisters 1');  
      await client.setID(ModBusIDs[id-1]);
      //console.log('ReadRegisters 1');
      let data = await client.readHoldingRegisters(address, length);
      //console.log('ReadRegisters 2');
      return data.data;    
    } catch (err) {
       //console.error("Error received writing adress "+ address + " from id: " +  ModBusIDs[id-1] + " with error: " + modbusErrorMessages[err.modbusCode], err);
       //return -1;
       throw err; //Fehler weiterreichen
    }
    
}

Mein readRegisters kann nun als synchroner Programmablauf - recht schnell - die Register auslesen.

async function ReadRegister(Reg) {
    for (let id = 1; id <= ModBusIDs.length; id++) {
        for (let i = 0; i < Reg.length; i++) {
            let address = Reg[i][0];
            let length = Reg[i][1];
            try { 
              console.debug("Try to read data from id/address " + ModBusIDs[id-1] + "/" + address);
              let data = await readRegisterSpaceAsync(id, address, length);
              console.debug("Read data from id/address " + ModBusIDs[id-1] + "/" + address + "\nData is: " + data);
              for (var y = 0; y < length; y++) Buffer[id-1][address + y - BufOffset] = data[y]; 
            } catch(err) {
                // if error, handle them here (it should not)
                if (err.modbusCode == null) {
                  console.warn("Lost connection to client. ");
                }  else { 
                  console.error("Error received writing adress "+ address + " from id: " +  ModBusIDs[id-1] + " with error: " + modbusErrorMessages[err.modbusCode], err);
                }  
                return -1;           
            } 
           
        }      
    }     

}

Hier eine gute Erklärung zum Thema asynchroner Code: link text

Lg Stephan

Feel free to follow the discussions in the german iobroker forum

Ich habe gerade den Adapter sun2000 in der Version 0.1.3 hier https://github.com/bolliy/ioBroker.sun2000 veröffentlicht. Der Adapter ist ebenfalls auch auf https://www.npmjs.com/package/iobroker.sun2000 deployed.

Repository: bolliy/ioBroker.sun2000 · Tag: v0.1.3 · Commit: 2e75cee · Released by: github-actions[bot]
• display the data from PV strings (#27)
• optimize the timing of interval loop
• improved handling of read timeouts from more then 2 inverters
Über ein Feedback würde ich mich freuen

Ich möchte noch auf die Möglichkeit aufmerksam machen Werte über modbus-tcp zu schreiben. Eine entsprechende funktion mit einem Beispiel werde ich aufzeigen. Also zuerst die async-Funktion, die ohne Callback auskommt und über await wartet bis der Wert vorliegt.

//asynchrones Schreiben 
async function writeRegistersAsync(id,address,buffer) {
    try {
      await client.setID(ModBusIDs[id-1]);
      await client.writeRegisters(address,buffer);
    }  catch (err) {
        console.error("Error received writing adress "+ address + " from id: " +  ModBusIDs[id-1] + " with error: " + modbusErrorMessages[err.modbusCode], err);
        throw err; //Fehler weiterreichen
    }  
}

Als Beispiel habe ich meine CheckAndPrepare Funktion herangezogen. Die Funktion soll den Wechselrichter bzw. Speicher so vorbereiten, dass dieser über einen einfachen Registerbefehl zum Aufladen des Speichers aus dem öffentlichen Stromnetz gebracht werden kann. Dieses ist bei der Nutzung dynamicher Strompreise (z.B. Tibber) ganz hilfreich. Idee: Wenn Strompreis kleiner als der mittelere Strompreis - 20% ist, soll der Hausspeicher mit günstigem Netzstrom aufgeladen werden. In dem Array wird die "Time of Using charging and discharging periodes (siehe Table 5-6) " gehalten. Diese Beispiel soll nur die Nutzungsmöglich der Funktion "writeRegistersAsync" verdeutlichen.

async function checkAndPrepare() {
     // Time of Using charging and discharging periodes (siehe Table 5-6) 
     // tCDP[3]= 127  => Speicheraufladung aus dem öffentlichen Netz
     var tCDP = [1,0,1440,383,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]; //nicht aus dem Netz laden
     let data = await readRegisterSpaceAsync(1,47086,4);
     /* 
      127 - Working mode settings  
       2 : Maximise self consumptions (default)
       5 : Time Of Use(Luna) - hilfreich bei dynamischem Stromtarif (z.B Tibber)
     */  
     let workingMode = data[0];         // Working mode settings  2:Maximise self consumptio5=)
     let chargeFromGrid = data[1];      // Voraussetzung für Netzbezug in den Speicher (Luna)  
     let gridChargeCutOff = data[2]/10; // Ab welcher Schwelle wird der Netzbezug beendet (default 50 %)
     let storageModel = data[3];        // Modell/Hersteller des Speichers, 2 : HUAWEI-LUNA2000
     try {
        if (storageModel == 2) { //wurde nur mit Luna getestet!
          if (workingMode != 5 || chargeFromGrid != 1 ) {
            console.debug('Row '+data+'  Workingmode '+workingMode+ ' Charge from Grid '+chargeFromGrid+ ' Grid Cut Off '+gridChargeCutOff+'%'); 
            await writeRegistersAsync(1,47086,[5,1,500]); //[TOU,chargeFromGrid,50%]
            await writeRegistersAsync(1,47255,tCDP);      //Plan:1,StartZeit:00:00,EndZeit: 24:00,Endladen/täglich
            /* ggf. sinnvoll 
            await writeRegistersAsync(1,47075,[0,5000]); //max. charging power 
            await writeRegistersAsync(1,47077,[0,5000]); //max. discharging power 
            */
          }
        }
     } catch(err) {
       throw err; 
     }
}

Die "checkAndPrepare wird einfach in den "InitProcess" eingehängt.

async function InitProcess() {
    try {        
        await modbusConnect();
        await checkAndPrepare();
        intervalId = setInterval(ReadInderval,30000);
    } catch (err) {
        throw err;
    } 
}

Und so würde die Speicheraufladung aus dem Netz gestartet werden. Bei 50% Speicherfüllgrad unterbricht die Speicheraufladung aus dem Netz.

var tCDP = [1,0,1440,383,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]; 
tCDP[3] = 127; // Laden
await writeRegistersAsync(1,47255,tCDP);
  

LG Stephan

@bolliy und nochmal die original Anleitung:
https://support.huawei.com/enterprise/en/doc/EDOC1100325377/4643911f/connecting-to-the-emma-on-the-app

Ist auch im Wiki hinterlegt worden.

Nun sollte alles klar sein

@peguschwein ich glaube ohne Installer Passwort funktioniert es nicht ansonsten ist es natürlich der selbe Port 502.

hier noch eine Anleitung:
https://wattkraft-de.zendesk.com/hc/de-de/articles/27349471569682-Modbus-TCP-auf-der-Huawei-EMMA-aktivieren

@peguschwein Die Emma hat immer die modbus id = 0. Deshalb nur die WR eintragen.
Modbus-Wechselrichter-IDs : 2,3,4

Die richtige Einstellung der Emma findest du im Wiki:

https://github.com/bolliy/ioBroker.sun2000/wiki/Emma

LG Stephan

@pasges die Emma hat die modbus id 0.
Vielen Dank für deine Unterstützung.
LG Stephan

@pasges es müssen für beide WR die modbus IDs durch ein Komma getrennt eingegeben werden.
https://github.com/bolliy/ioBroker.sun2000/blob/main/docs/configuration.md

Die modbus IDs müsste man eigentlich über das FusionSolar Backend oder der App einsehen können.
https://github.com/bolliy/ioBroker.sun2000/blob/main/docs/inverter.md

Tatsächlich besteht auch die Möglichkeit die Emma über modbus tcp nach den IDs zu befragen. Das habe ich aber noch nicht umgesetzt.

Die Wallbox wird über die Emma automatisch erkannt und die Daten im Objektbaum bereitgestellt.
https://github.com/bolliy/ioBroker.sun2000/issues/171

LG Stephan

bug84 created this issue in bolliy/ioBroker.sun2000

closed [Feature Request]: Wallbox #171

@phil_discount die Ladeleistung wird aus der Änderung des totalEnergyCharged berechnet.
Bei einem anderen User hat es aber offensichtlich funktioniert. Da ich keinen Charger habe, kann ich das auch leider nicht nachvollziehen. Versuch mal den totalEnergyCharged zu tracken...

Dann werden die Werte in kleineren Zeitabständen verarbeitet als diese an die Emma übertragen werden. Welcher Intervall ist im Adapter eingestellt? Stell den Intervall auf mindestens. 20 Sekunden.
Stephan

@bug77 hast du die letzte FW auf der Emma installiert?

@bug77 vielleicht netzdienliches Verhalten der Emma - erst mittags die Batterie aufladen?

@phil_discount gute Besserung.
Der Wert ist 1 ist richtig und zeigt an, daß der WR den Request bestätigt hat. In FuisenApp bzw. Portal werden nicht alle Werte sofort und grundsätzlich übertragen.

Aber schau mal ob du den Zustand der Einstellungen nicht merken kannst. Ansonsten wird ggf. Jede Minute die gleichen States geschrieben. Zu viele Änderungen können den Mikrocontroller u.U. überfordern. So berichten einiger User von abstürzenden Geräteeinheiten.
Stephan

@phil_discount ok,
Ich möchte aber wissen was im state steht?
sun2000.0.inverter.0.battery.chargeFromGridFunction
Bitte genau lesen!