Aktuelle Test Version
Veröffentlichungsdatum	21.11.2024
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.

Ü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

Feel free to follow the discussions in the german iobroker forum

@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

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

Ich habe gerade den Adapter sun2000 in der Version 0.2.0 hier https://github.com/bolliy/ioBroker.sun2000 veröffentlicht. Der Adapter wurde ebenfalls auch auf https://www.npmjs.com/package/iobroker.sun2000 deployed.
Bitte den Adapter über npm installieren, damit keine unfertige Version in ioBroker eingespielt wird!

Changelog:

• Add sun2000 to latest (https://github.com/ioBroker/ioBroker.repositories/pull/3219)
• improve error handling (#34)
• add simple optimizer info
• Riemann sum of input power with energy loss for new state dailySolarYield
• try to recreate the "yield today" from the fusion portal in state dailyInputYield

Über Tests und euer Feedback freue mich sehr.

bolliy created this issue in ioBroker/ioBroker.repositories

closed Add adapter sun2000 to latest #3219

@fredi-wiegisser der gleichzeitiger Zugriff auf die modbus Schnittstelle ist über den internen mobus-proxy des Adapters möglich.

Toll, dass du die Ursache der Timeouts eigenständig herausgefunden hast.

LG Stephan

@fredi-wiegisser bitte die Main Settings des Adapters zeigen.

@leonundjulie Ich glaube in der Interface Beschreibung findet man nichts zu Monats- bzw. Jahres-werten. Ja, mit Sourceanalytix oder mit Statistics.
https://github.com/bolliy/ioBroker.sun2000/wiki/Statistk-(statistics)

LG Stephan

@bernd33-1 einfach über npm oder das beta repro (drüber)installieren.

@gelbwichtel aus dem WR kann man keine EnergyYield-Werte nach strings auslesen. Zumal der dailyEnergyYield die Batterie-lade-/entlade-Energiewerte beinhalten. https://github.com/bolliy/ioBroker.sun2000/wiki/Energieertrag-(Yield-today)

Ggf. würde eine Riemann Summierung (Intergral) über die Stringpowerwerte (sun2000.0.inverter.0.string.PV[1|2]Power) die Lösung sein. Dann erhält man aber eher den SolarYield der Strings und nicht den EnergieYield der Strings.

LG Stephan

@altes bitte folgendes beachten: https://forum.iobroker.net/post/1230444
Ich denke, dass die Abfragen an den kaskadierten WR etwas lange dauern. Die Kommunikation über RS485-Kabel ist oft mit deutlichen Verzögerungen verbunden. Ich würde den Aktualisierungsintervall sukzessive vergrößern.

Das Thema Energieertrag (yield) wird im Wiki behandelt: https://github.com/bolliy/ioBroker.sun2000/wiki/Energieertrag-(Yield-today)

LG Stephan

@martink und nochmal unter dem Reiter modbus Timing auto adjust anhaken. Damit die richtigen Einstellungen ermittelt werden können....

@martink ich vermute mal, dass du einen sDongle hast?
Dann kann die modbus id 0 nicht stimmen. Meist ist es die 1 für den ersten WR.
Zeig doch mal deine Main Settings (Haupteinstellungen)

LG Stephan

@hoerb1 die Geräte-ip-Adresse des 2ten Wechselrichters (SDongle) eintragen. Die Modbus-id muss ermittelt werden. https://github.com/bolliy/ioBroker.sun2000/blob/main/docs/inverter.md

@hoerb1 genau - sofern die WR nicht kaskadiert sind, wird eine weitere Instanz vom Adapter benötigt. Eine Summierung der Werte sind dann allerdings über blockly oder js durchzuführen.