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

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.

@samson71 falls die Klemmen verpolt sein sollten, kannst du das doch gut am Verhalten deines WR/Speicher erkennen. Der Speicher z.B. dürfte sich bei saldiertem Netzbezug nicht füllen.

@icebear ja, habe ich auch schon probiert.
Allerdings werden weder PVForecast, Wetterdaten oder ein Lastenprofile herangezogen. Das ist eher eine rudimentäre Lösung, welche bedingt einzetzbar ist.
Ich benötige ein kostenoptimiertes Laden meines Hausspeichers, die auch Lade-/Endladeverluste berücksichtigt.
Stephan

Hinweise zur Fehlerprotokollierung und der Fehlerbehebung:

Neben dem Adapterlog wird zusätzlich im Datenpunkt „sun2000.x.info.JSONhealth“ ein JSON ("JavaScript Object Notation") jede Minute gespeichert, der Informationen zum Zustand des Adapters beinhaltet. Der Eigenschaftswert von errorSumCounter gibt Auskunft, wie viele modbus-Abfragen vom Inverter seit dem Start des Adapters mit einem Fehler quittiert wurden.
{
...
"stat": {
"successSumCounter": 84395,
"errorSumCounter": 850,
"ETIMEDOUT":115
},
...
}

Sofern der Anteil von „errorSumCounter“ über ca. 2% von „successSumCounter“ beträgt und darüber hinaus auch der Eigenschaftswert "ETIMEDOUT" mit einem Wert > 0 belegt ist, wäre Folgendes zu beachten:

1. Überprüfe, ob auf allen Geräten die aktuelle Firmware läuft. Ansonsten kann es zu Funktionsstörungen zwischen den Geräteeinheiten kommen.
   https://photomate.zendesk.com/hc/en-gb/articles/4867806234525-SDongle-firmware-upgrade-by-FushionSolar-SUN2000-APP
2. Die Huawei modbus Implementierung ist leider nicht multi-client-fähig. Es können also nicht mehrere modbus-clients gleichzeitig auf die modbus-Schnittstelle zugreifen.
   Deshalb bitte hierfür den modbus proxy des Adapters verwenden.
   Siehe: https://github.com/bolliy/ioBroker.sun2000/wiki/Modbus-Proxy
3. Sofern man auf dem FusionSolar Web Portal die Batteriekonfiguration aufruft, wird der SDongle aufgefordert seine Daten dauerhaft zu aktualisieren. Dieses kann zu Timeout-Fehlermeldung im Adapter führen.

@dragst3r so ich habe mir nun auch einen dynamischen Stromtarif angelacht (Tibber). Ich werde also eine brauchbare Lösung benötigen. Dabei werde ich sicherlich auch auf die geschilderten Probleme stoßen.
Vielleicht entsteht daraus ein neues ioBroker Projekt...

LG Stephan

@bmp hast du die Firmware aller Devices auf dem neuesten Stand?
Wie viele WR hast du? SDongle? Intervall?

LG Stephan

@bmp Der workingModeSettings wurde nicht auf 5 umgeschaltet! Ich sehe leider nicht ob chargeFromGridFunction auf 1 gegangen ist.
Bitte im Log schauen, ob der Befehl angenommen und an den WR übertragen wurde.

@marco-düthorn wenn der Speicher/der WR "schläft" wird die Temperatur nicht übertragen.

@marco-düthorn du musst den Speicher/WR aufwecken...
https://github.com/bolliy/ioBroker.sun2000/wiki/Speichersystem-aufwecken-(wake-up-Luna)

Das mit der schnellen Abfrage von Adresse 31657 muss ich prüfen...

Neue Testversion sun2000 Adapter Version v0.18.0 released.

Für Loxone wurde ein permanentes mapping der modbus id 250 auf die modbus id 0 im modbus-proxy des Adapters eingebaut.
@Marco-Düthorn: einfach die modbus id 250 statt der id 0 für die Emma verwenden.

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

Changelog
0.18.0 (2024-12-11)

• dependency and configuration updates
• modbus-proxy: the modbus ID 250 is mapped to ID 0

Ich möchte hier gerne das Thema netzdienliche Solarspeicher zur Diskussion stellen:
https://youtu.be/WqCyE_rpuas?si=X_d-r6y4FRn1gGwj

Ich überlege eine Logik zu entwerfen, die ein netzdienliche Verhalten der Luna ermöglichen soll. Hierfür würde ich die Daten vom Adapter pvforcast und ggf. Wetterdaten einbeziehen.

Wie ist eure Haltung zu dem Thema?