Aktuelle Test Version
Veröffentlichungsdatum	20.10.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, damit keine unfertige Version in ioBroker eingespielt wird.

Nun können endlich mit den Funktionen Battery charge control, Export Control und Forcible Charge/Discharge Registerdaten an den Wechselrichter sun2000 geschrieben werden.
Mit einigen Herausforderungen sehe ich mich weiterhin konfrontiert. Zum einen existieren Setups mit unterschiedlicher Hardware. Neben alten Huawei sun2000 aus der Serie M0 und einem smartLogger3000 können noch andere Huawei Devices unterwegs sein. So habe ich den Adapter umstrukturiert. Über ein Treiber-Model können nun unterschiedliche Hardware in den Adapter impelmentiert werden.
Ich habe mir ein Konzept ausgedacht, dass automatisch eine „funktionierende“ modbus-Einstellung ermitteln soll. So wird nach der Installation des Adapter die auto-adjust Funktion aktiviert. Der Adapter durchläuft dabei mehrere Adjustment Steps. Immer wenn ein Fehler auftritt werden die Verzögerungswerte (delays) sukzessive erhöht bis ein stabiler Zustand eintritt. Der auto-adjust Vorgang kann mehrere Minuten dauern. Danach werden die ermittelten Werte abgespeichert und der Adapter automatisch neu gestartet und die auto-adjust Funktion wieder deaktiviert.

Was funktioniert schon:

• Es können max. 5 sun2000 Wechselrichter (Master/Slave) mit jeweils einem Batteriemodul (max. 15kWh) 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 Inverter zugreifen. Da der modbus-proxy multi-client-fähig ist, kann der Zugriff von mehreren Geräte gleichzeigit erfolgen. Darüber hinaus ist möglich die Daten auf eine andere Adapter Instanz zu spiegeln.
  Im Gegensatz zu dem SDongle ist der proxy deutlich schneller und stabiler.

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

• 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 werden im medium Interval gelesen und im Pfad sdongle gespeichert.

Ü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

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

@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

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

@atzeackermann das freut mich . Grundsätzlich funktioniert der ioBroker.sun2000 Adapter schon. Ich habe allerdings noch etliche Issues, die ich behandeln möchte.

• mehr Register Daten darstellen
• Abgeleitete Werte wie Hausverbrauch (consumptions), Erträge (yields) berechnen
• Kumulierte Werte bei der Nutzung von mehren Wechselrichtern ermitteln
  usw…

Vielleicht hat der eine oder andere Lust mich dabei zu unterstützen. Darüber hinaus suche ich jemanden der 2 Wechselrichter mit mehr als einer LUNA2000 Batterie. Diese Konstellation ist eher selten – sollte aber dennoch korrekt dargestellt werden.

Neue Testversion sun2000 Adapter Version v0.17.1 released.

Anscheinend funktioniert die modbus-Schnittstelle bei der aktuellen Firmwareversionen auch im device status "Standby: detecting irradiation".

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

Changelog:

0.17.1 (2024-11-21)
• during the device status "Standby: detecting irradiation" (0x0002) register data is now also read from the inverter
• The reading order of the battery data has been adjusted

@babl würdest du deine letzte PV-forecast Version mit Beschreibung nochmal hochladen.
So wie ich das verstanden habe hast du ein paar Änderungen später vorgenommen, die ich manuell nachziehen müsste.
Vielen Dank für deine Mühen!

LG Stephan

@myssv der Sdongle ist eine Diva. Manchmal fühlt sich der Sdongle überfordert - gerade wenn der Inverter seinen mode umstellt. Das passiert im Winter, da die Sonneneinstrahlung sehr gering ist. Oder du bist auf der FusionSolar Webseite in der Batterieeinstellungen. Dann bekommt der Sdongle die Aufforderung seine Daten zu aktualisieren.
Also wenn es nicht dauernd auftaucht, kannst du das vernachlässigen.

LG Stephan

@myssv bitte auf v0.17.0 updaten. Der Speicher ist im Sleep_mode. Die Temperatur des Speichers ist dann nicht mehr plausibel.

Stephan

@mhuber die Konstellation hört sich ja spannend an. Bei der nächsten Version werde ich die Abfragereihenfolge ändern. Vielleicht verbessert sich das Antwortverhalten ...

LG Stephan

@mhuber kommt der Speicher an den 2ten WR? Da bin ich gespannt, ob der Adapter alle Packs findet
Vielleicht überprüfen, ob die Abschirmung des RS485 Kabel richtig angeklemmt ist.

Wie lang ist das RS485 Kabel?

@mhuber die große Intervallzeit ist ungewöhnlich.
Nun hast du 2 WR und ein Speicher mit 3 Packs. Da werden natürlich relativ viele Daten gelesen.
Hat das RS485-Kommunikationskabel zwischen den WR vielleicht kapazitive oder induktive Einstreuungen durch ein zb. einem Stromkabel? Dadurch kann die serielle Übertragungsrate sinken.

Ich schau auch nochmal ob ich am Programmablauf etwas ändern kann.

LG Stephan

@mhuber erhöhe doch mal den Intervall Wert auf 45 oder sogar 60 Sekunden. Mal sehen ob die Warnmeldungen immer noch kommen. Das Auslesen der Batteriedaten, die im JSON angezeigt werden, erfolgt erst am Ende eines Auslesezyklus.

LG Stephan

Neue Testversion sun2000 Adapter Version v0.17.0 released.

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

Changelog:

0.17.0 (2024-11-05)

• adjust for Responsive Design #134
• migrate to ESLint 9.x
• node >= v18.18.0
• modbus-proxy: enabled reading data via input register

0.16.0 (2024-11-01)

• dependency and configuration updates
• read additional register data of Huawei Emma

0.15.2 (2024-10-30)

• EMMA Device was not initialized

LG Stephan

@mhuber sagte in Test Adapter sun2000 v0.1.x - Huawei Wechselrichter:

37758

Es werden einige Batteridaten nicht gelesen. Ich weiß nur nicht warum. Es müsste sich der SOC Wert der Batterie im Pfad collected nicht ändern und auf einem Wert einfrieren. Kannst du bestätigen?

Welche Installationsquelle hast du verwendet (stable, beta, npm oder github)?

Teste bitte mal die Testversion 0.17.0

LG Stephan