Skip to content
  • Home
  • Aktuell
  • Tags
  • 0 Ungelesen 0
  • Kategorien
  • Unreplied
  • Beliebt
  • GitHub
  • Docu
  • Hilfe
Skins
  • Light
  • Brite
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • Standard: (Kein Skin)
  • Kein Skin
Einklappen
ioBroker Logo

Community Forum

  1. ioBroker Community Home
  2. Deutsch
  3. ioBroker Allgemein
  4. Huawei Sun2000 & ioBroker via JS script funktioniert

NEWS

  • UPDATE 31.10.: Amazon Alexa - ioBroker Skill läuft aus ?
    apollon77A
    apollon77
    48
    3
    8.3k

  • Monatsrückblick – September 2025
    BluefoxB
    Bluefox
    13
    1
    1.9k

  • Neues Video "KI im Smart Home" - ioBroker plus n8n
    BluefoxB
    Bluefox
    15
    1
    2.3k

Huawei Sun2000 & ioBroker via JS script funktioniert

Geplant Angeheftet Gesperrt Verschoben ioBroker Allgemein
481 Beiträge 62 Kommentatoren 121.4k Aufrufe 63 Watching
  • Älteste zuerst
  • Neuste zuerst
  • Meiste Stimmen
Antworten
  • In einem neuen Thema antworten
Anmelden zum Antworten
Dieses Thema wurde gelöscht. Nur Nutzer mit entsprechenden Rechten können es sehen.
  • C Chris_B

    @mrlee Zur Frage der Zykluszeit:
    Diese kannst Du in der Funktion

    setInterval(function() ...

    ganz am Ende definieren. Momentan steht dort der Wert 5000 = 5000 ms = 5 sec.
    Da 10 Register Spaces gelesen werden ergibt das eine gesamte Zykluszeit von 50 sec.
    Original war der Wert auf 2000, ann ergeben sich ca. 20 sec. Einfach ausprobieren.

    Evtl. beantwortet das deine Frage.
    Gruss

    M Offline
    M Offline
    MrLee
    schrieb am zuletzt editiert von
    #161

    @chris_b
    Moin!

    Ja, den habe ich schon gefunden...selbst bei 4sec habe ich allerdings noch fehler...
    Überlege eine Aufteilung nach "eiligen" Daten ...alle x Sekunden Register und nicht so eilige...nur jede 5te Runde.
    Hab mich aber ehrlicherweise noch nicht mit den Registern beschäftigt.

    Auf jeden Fall erstmal nen Top Script was mir bei den ersten Schritten massiv hilft! Vielen Dank!

    1 Antwort Letzte Antwort
    0
    • H Offline
      H Offline
      hussi
      schrieb am zuletzt editiert von
      #162

      Moin zusammen,

      ich teste mich auch gerade dadurch, dass ich die Werte in den ioBroker bekomme. Meine Einstellungen am Dongel sehen so aus:

      Verbindung Aktivieren (uneingeschränkt)
      MBUS-Protokoll: MODBUS RTU
      Transormatorkasten Nr. 1
      Wicklung Nr. 0
      MAC-Adressen-Offset 1

      Wechselrichter Version V100R001C20SPC122
      MBUS(DC)fi_upgradingsun_db Version V100R001C00SPC320

      Ich habe noch einen Smartmeter verbaut aber keine Batterie.

      Das Script sagt mir nun folgende fehler:

      12:16:23.048	error	javascript.0 (2127) script.js.pv.sun2000: Error: Cannot find module 'modbus-serial'
      12:16:23.049	error	javascript.0 (2127) at script.js.pv.sun2000:4:17
      12:16:23.049	error	javascript.0 (2127) at script.js.pv.sun2000:359:3
      
      12:16:23.053	error	javascript.0 (2127) script.js.pv.sun2000: TypeError: ModbusRTU is not a constructor
      12:16:23.054	error	javascript.0 (2127) at script.js.pv.sun2000:5:14
      12:16:23.054	error	javascript.0 (2127) at script.js.pv.sun2000:359:3
      

      Wo finde ich die Modbus Serial? Egal welche Seriennummer ich da eintrage, der Fehler bleibt.

      M 1 Antwort Letzte Antwort
      0
      • H hussi

        Moin zusammen,

        ich teste mich auch gerade dadurch, dass ich die Werte in den ioBroker bekomme. Meine Einstellungen am Dongel sehen so aus:

        Verbindung Aktivieren (uneingeschränkt)
        MBUS-Protokoll: MODBUS RTU
        Transormatorkasten Nr. 1
        Wicklung Nr. 0
        MAC-Adressen-Offset 1

        Wechselrichter Version V100R001C20SPC122
        MBUS(DC)fi_upgradingsun_db Version V100R001C00SPC320

        Ich habe noch einen Smartmeter verbaut aber keine Batterie.

        Das Script sagt mir nun folgende fehler:

        12:16:23.048	error	javascript.0 (2127) script.js.pv.sun2000: Error: Cannot find module 'modbus-serial'
        12:16:23.049	error	javascript.0 (2127) at script.js.pv.sun2000:4:17
        12:16:23.049	error	javascript.0 (2127) at script.js.pv.sun2000:359:3
        
        12:16:23.053	error	javascript.0 (2127) script.js.pv.sun2000: TypeError: ModbusRTU is not a constructor
        12:16:23.054	error	javascript.0 (2127) at script.js.pv.sun2000:5:14
        12:16:23.054	error	javascript.0 (2127) at script.js.pv.sun2000:359:3
        

        Wo finde ich die Modbus Serial? Egal welche Seriennummer ich da eintrage, der Fehler bleibt.

        M Offline
        M Offline
        MrLee
        schrieb am zuletzt editiert von
        #163

        @hussi
        modbus-serial ist ein npm paket was Du in deiner JScript instanz eintragen mußt...steht relativ weit oben in diesm threat...

        bis denne
        Mr.Lee

        H 1 Antwort Letzte Antwort
        0
        • M MrLee

          @hussi
          modbus-serial ist ein npm paket was Du in deiner JScript instanz eintragen mußt...steht relativ weit oben in diesm threat...

          bis denne
          Mr.Lee

          H Offline
          H Offline
          hussi
          schrieb am zuletzt editiert von
          #164

          @mrlee Ahhh gefunden. Danke.

          1 Antwort Letzte Antwort
          0
          • Alex WarkentinA Alex Warkentin

            @juggi1962 Poste mal die Logs, wenn der Fehler auftritt

            Hier ist das Script, was ich für mich angepasst habe. Achtung! Ich habe die Batterie und andere für mich uninteressante Sachen rausgeschmissen und die Namen von Variablen und Funktionen angepasst. Für die Neuverbindung nach Verbindungsabbruch brauchst du die Zeilen 18 - 27 , 107-122 und 235 -237

            // License: Beerware! Do what ever you like with this, but I'm not liable for anything that you do with it.
            // If you like this code, feel free to buy me a beer ...
            // Have fun with it! der Kachel
            // @ts-ignore
            var modbusRTU = require("modbus-serial");
            var client = new modbusRTU();
            
            var modbusErrorMessages = [
                "Unknown error",
                "Illegal function (device does not support this read/write function)",
                "Illegal data address (register not supported by device)",
                "Illegal data value (value cannot be written to this register)",
                "Slave device failure (device reports internal error)",
                "Acknowledge (requested data will be available later)",
                "Slave device busy (retry request again later)"
            ];
            
            // Enter your inverter modbus IP and port here:
            const modbusHost = "000.000.000.000";
            const modbusPort = 502;
            // Enter the Modbus-IDs of your Sun2000 inverters here:
            const modbusID = [1];
            // On which Modbus-ID can we reach the power meter? (via Sun2000!)
            const powerMeterID = 0;
            
            // Connect to modbus client
            ConnectModbus();
            
            // These register spaces need to be read:
            const registerSpacesToReadContinuously = [[37100, 114], [32000, 116]];
            var registerSpacesToReadContinuouslyPtr = 0;
            
            var globalDataBuffer = new Array(1);
            globalDataBuffer[0] = new Array(50000); // not optimized....
            
            // ---------------------------------------------------------------
            // Some helper functions:
            function ReadUnsignedInt16(array) {
                var value = array[0];    
                return value;
            }
            
            function ReadUnsignedInt32(array) {
                var value = array[0] * 256 * 256 + array[1];    
                return value;
            }
            
            function ReadSignedInt16(array) {
                var value = 0;
                if (array[0] > 32767)
                    value = array[0] - 65535; 
                else
                    value = array[0];
            
                return value;
            }
            function ReadSignedInt32(array) {
                var value = 0;
                for (var i = 0; i < 2; i++) {
                    value = (value << 16) | array[i];
                }
                return value;
            }
            function GetU16(dataarray, index) {
                var value = ReadUnsignedInt16(dataarray.slice(index, index+1));
                return value;
            }
            
            function GetU32(dataarray, index) {
                var value = ReadUnsignedInt32(dataarray.slice(index, index+2));
                return value;
            }
            
            function GetI16(dataarray, index) {
                var value = ReadSignedInt16(dataarray.slice(index, index+1));
                return value;
            }
            
            function GetI32(dataarray, index) {
                var value = ReadSignedInt32(dataarray.slice(index, index+2));
                return value;
            }
            
            function GetString(dataarray, index, length) {
                var shortarray = dataarray.slice(index, index+length);
                var bytearray = [];
                for(var i = 0; i < length; i++) {
                    bytearray.push(dataarray[index+i] >> 8);
                    bytearray.push(dataarray[index+i] & 0xff);
                }       
                var value =  String.fromCharCode.apply(null, bytearray);    
                return value;
            }
            
            function GetZeroTerminatedString(dataarray, index, length) {
                var shortarray = dataarray.slice(index, index+length);
                var bytearray = [];
                for(var i = 0; i < length; i++) {
                    bytearray.push(dataarray[index+i] >> 8);
                    bytearray.push(dataarray[index+i] & 0xff);
                }       
                var value =  String.fromCharCode.apply(null, bytearray);    
                var value2 = new String(value).trim();
                return value2;
            }
            
            // Funktion zum Herstellen einer Modbus-Verbindung
            function ConnectModbus() {
                console.log("Init connection to: " + modbusHost +":" + modbusPort);
                // set requests parameters
                client.setTimeout (10000);
                // try to connect
                client.connectTCP (modbusHost, { port: modbusPort })
                    .then(function()
                    {
                        console.log("Connected, wait for reading...");
                    })
                    .catch(function(e)
                    {
                        console.log(e);
                    });
            }
            
            // Funktion zum Anlegen und Beschreiben eines Datenpunkts
            function ForceSetState(objectname, value, options) {
                if(!existsState("javascript.0." + objectname))      createState(objectname, value, options);
                else                                                setState(objectname, value);
            }  
            // ---------------------------------------------------------------
            // Functions to map registers into ioBreaker objects:
            function ProcessPowerMeterStatus() {       
                ForceSetState("Solarpower.Huawei.Meter.Status",                     GetU16(globalDataBuffer[powerMeterID], 37100),          {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Meter.VoltageL1",                  GetI32(globalDataBuffer[powerMeterID], 37101) / 10,     {name: "", unit: "V"});
                ForceSetState("Solarpower.Huawei.Meter.VoltageL2",                  GetI32(globalDataBuffer[powerMeterID], 37103) / 10,     {name: "", unit: "V"});
                ForceSetState("Solarpower.Huawei.Meter.VoltageL3",                  GetI32(globalDataBuffer[powerMeterID], 37105) / 10,     {name: "", unit: "V"});
                ForceSetState("Solarpower.Huawei.Meter.CurrentL1",                  GetI32(globalDataBuffer[powerMeterID], 37107) / 100,    {name: "", unit: "A"});
                ForceSetState("Solarpower.Huawei.Meter.CurrentL2",                  GetI32(globalDataBuffer[powerMeterID], 37109) / 100,    {name: "", unit: "A"});
                ForceSetState("Solarpower.Huawei.Meter.CurrentL3",                  GetI32(globalDataBuffer[powerMeterID], 37111) / 100,    {name: "", unit: "A"});
                ForceSetState("Solarpower.Huawei.Meter.ActivePower",                GetI32(globalDataBuffer[powerMeterID], 37113) / 1,      {name: "", unit: "W"});
                ForceSetState("Solarpower.Huawei.Meter.ReactivePower",              GetI32(globalDataBuffer[powerMeterID], 37115) / 1,      {name: "", unit: "Var"});
                ForceSetState("Solarpower.Huawei.Meter.PowerFactor",                GetI16(globalDataBuffer[powerMeterID], 37117) / 1000,   {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Meter.GridFrequency",              GetI16(globalDataBuffer[powerMeterID], 37118) / 100,    {name: "", unit: "Hz"});
                ForceSetState("Solarpower.Huawei.Meter.PositiveActiveEnergy",       GetI32(globalDataBuffer[powerMeterID], 37119) / 100,    {name: "", unit: "kWh"});
                ForceSetState("Solarpower.Huawei.Meter.ReverseActiveEnergy",        GetI32(globalDataBuffer[powerMeterID], 37121) / 100,    {name: "", unit: "kWh"});
                ForceSetState("Solarpower.Huawei.Meter.AccumulatedReactivePower",   GetI32(globalDataBuffer[powerMeterID], 37123) / 100,    {name: "", unit: "kVarh"});
                //ForceSetState("Solarpower.Huawei.Meter.MeterType",                  GetU16(globalDataBuffer[powerMeterID], 37125),          {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Meter.VoltageL1-L2",               GetI32(globalDataBuffer[powerMeterID], 37126) / 10,     {name: "", unit: "V"});
                ForceSetState("Solarpower.Huawei.Meter.VoltageL2-L3",               GetI32(globalDataBuffer[powerMeterID], 37128) / 10,     {name: "", unit: "V"});
                ForceSetState("Solarpower.Huawei.Meter.VoltageL3-L1",               GetI32(globalDataBuffer[powerMeterID], 37130) / 10,     {name: "", unit: "V"});
                ForceSetState("Solarpower.Huawei.Meter.ActivePowerL1",              GetI32(globalDataBuffer[powerMeterID], 37132) / 1,      {name: "", unit: "W"});
                ForceSetState("Solarpower.Huawei.Meter.ActivePowerL2",              GetI32(globalDataBuffer[powerMeterID], 37134) / 1,      {name: "", unit: "W"});
                ForceSetState("Solarpower.Huawei.Meter.ActivePowerL3",              GetI32(globalDataBuffer[powerMeterID], 37136) / 1,      {name: "", unit: "W"});
                //ForceSetState("Solarpower.Huawei.Meter.MeterModel",                 GetU16(globalDataBuffer[powerMeterID], 37138),          {name: "", unit: ""});
            }
            
            function ProcessInverterStatus(id) {
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".State1",                   GetU16(globalDataBuffer[id-1], 32000),          {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".State2",                   GetU16(globalDataBuffer[id-1], 32002),          {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".State3",                   GetU32(globalDataBuffer[id-1], 32003),          {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".Alarm1",                   GetU16(globalDataBuffer[id-1], 32008),          {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".Alarm2",                   GetU16(globalDataBuffer[id-1], 32009),          {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".Alarm3",                   GetU16(globalDataBuffer[id-1], 32010),          {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".String.1_Voltage",         GetI16(globalDataBuffer[id-1], 32016) / 10,     {name: "", unit: "V"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".String.1_Current",         GetI16(globalDataBuffer[id-1], 32017) / 100,    {name: "", unit: "A"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".String.2_Voltage",         GetI16(globalDataBuffer[id-1], 32018) / 10,     {name: "", unit: "V"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".String.2_Current",         GetI16(globalDataBuffer[id-1], 32019) / 100,    {name: "", unit: "A"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".String.3_Voltage",         GetI16(globalDataBuffer[id-1], 32020) / 10,     {name: "", unit: "V"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".String.3_Current",         GetI16(globalDataBuffer[id-1], 32021) / 100,    {name: "", unit: "A"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".String.4_Voltage",         GetI16(globalDataBuffer[id-1], 32022) / 10,     {name: "", unit: "V"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".String.4_Current",         GetI16(globalDataBuffer[id-1], 32023) / 100,    {name: "", unit: "A"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".InputPower",               GetI32(globalDataBuffer[id-1], 32064) / 1000,   {name: "", unit: "kW"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".Grid.L1-L2_Voltage",       GetU16(globalDataBuffer[id-1], 32066) / 10,     {name: "", unit: "V"});      
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".Grid.L2-L3_Voltage",       GetU16(globalDataBuffer[id-1], 32067) / 10,     {name: "", unit: "V"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".Grid.L3-L1_Voltage",       GetU16(globalDataBuffer[id-1], 32068) / 10,     {name: "", unit: "V"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".Grid.L1_Voltage",          GetU16(globalDataBuffer[id-1], 32069) / 10,     {name: "", unit: "V"});                              
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".Grid.L2_Voltage",          GetU16(globalDataBuffer[id-1], 32070) / 10,     {name: "", unit: "V"});                                                  
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".Grid.L3_Voltage",          GetU16(globalDataBuffer[id-1], 32071) / 10,     {name: "", unit: "V"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".Grid.L1_Current",          GetI32(globalDataBuffer[id-1], 32072) / 1000,   {name: "", unit: "A"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".Grid.L2_Current",          GetI32(globalDataBuffer[id-1], 32074) / 1000,   {name: "", unit: "A"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".Grid.L3_Current",          GetI32(globalDataBuffer[id-1], 32076) / 1000,   {name: "", unit: "A"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".PeakActivePowerDay",       GetI32(globalDataBuffer[id-1], 32078) / 1000,   {name: "", unit: "kW"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".ActivePower",              GetI32(globalDataBuffer[id-1], 32080) / 1000,   {name: "", unit: "kW"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".ReactivePower",            GetI32(globalDataBuffer[id-1], 32082) / 1000,   {name: "", unit: "kVar"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".PowerFactor",              GetI16(globalDataBuffer[id-1], 32084) / 1000,   {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".GridFrequency",            GetU16(globalDataBuffer[id-1], 32085) / 100,    {name: "", unit: "Hz"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".Efficiency",               GetU16(globalDataBuffer[id-1], 32086) / 100,    {name: "", unit: "%"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".InternalTemperature",      GetI16(globalDataBuffer[id-1], 32087) / 10,     {name: "", unit: "°C"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".InsulationResistance",     GetU16(globalDataBuffer[id-1], 32088) / 1000,   {name: "", unit: "MOhm"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".DeviceStatus",             GetU16(globalDataBuffer[id-1], 32089),          {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".FaultCode",                GetU16(globalDataBuffer[id-1], 32090),          {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".StartupTime",              String(new Date(GetU32(globalDataBuffer[id-1], 32091)*1000)),          {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".ShutdownTime",             String(new Date(GetU32(globalDataBuffer[id-1], 32093)*1000)),          {name: "", unit: ""});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".AccomulatedEnergyYield",   GetU32(globalDataBuffer[id-1], 32106),          {name: "", unit: "kWh"});
                ForceSetState("Solarpower.Huawei.Inverter." + id + ".DailyEnergyYield",         GetU32(globalDataBuffer[id-1], 32114),          {name: "", unit: "kWh"});
            }
            
            function ReadRegisterSpace(id, address, length) {
                client.setID(modbusID[id-1]);
                client.readHoldingRegisters(address, length, function(err, data) {
                    if (err) {
                        console.warn("Error received reading address " + address + " from id: " + modbusID[id-1] + " with error: " + modbusErrorMessages[err.modbusCode]); 
                    }
                    else
                    {   
                        console.debug("Read data from id/address " + modbusID[id-1] + "/" + address + "\nData is: " + data.data);
                        for(var i = 0; i < length; i++)  {
                            globalDataBuffer[id-1][address+i] = data.data[i];
                        } 
                    }
                });
            }
            
            function ProcessData() {
                //console.log("Processing new data...");
                for(var i = 1; i <= modbusID.length; i++) {
                    //ProcessDeviceInfo(i);
                    ProcessInverterStatus(i);
                    //processBattery(i);
                    //processInverterPowerAdjustments(i);
                    //processOptimizers(i); 
                }    
                ProcessPowerMeterStatus();
                //console.log("Processing done!");
            }
            
            
            // -------------------------------------------------------------------
            // This is the main function triggering a  read via modbus-tcp every two seconds.
            // Processing of data is triggered as soon as one complete set of registers is copied.
            var triggerprocessing = 0; 
            var currentinverter = 1;
            
            
            setInterval(function() {
                    if (!client.isOpen){
                        ConnectModbus();
                    }
                    if(triggerprocessing == 1) {
                    triggerprocessing = 0;
                    ProcessData();        
                    }      
               
                //console.log("Triggering read of inverter " + currentinverter + " at address " + registerSpacesToReadContinuously[registerSpacesToReadContinuouslyPtr][0] + " with length " +  registerSpacesToReadContinuously[registerSpacesToReadContinuouslyPtr][1]);
                ReadRegisterSpace(currentinverter, registerSpacesToReadContinuously[registerSpacesToReadContinuouslyPtr][0], registerSpacesToReadContinuously[registerSpacesToReadContinuouslyPtr][1]); 
                registerSpacesToReadContinuouslyPtr++;               
                if(registerSpacesToReadContinuouslyPtr >= registerSpacesToReadContinuously.length) {
                    registerSpacesToReadContinuouslyPtr = 0;
                    currentinverter++
                    if(currentinverter > modbusID.length){
                        currentinverter = 1;  
                        triggerprocessing = 1;                    
                    }
                }     
            }, 3000);
            
            H Offline
            H Offline
            hussi
            schrieb am zuletzt editiert von hussi
            #165

            @alex-warkentin

            Das Skript läuft bei mir und gibt mir die Werte aus, die du eingetragen hast.
            Danke dafür!

            Das Skript liefert mir diese Ergebnisse:

            inverter.JPG
            meter.JPG

            Wenn ich das nun auf meinem Fusionsolar Oberfläche Abgleiche habe ich folgende Ergebnisse abgeleitet:

            Inverter
            ActivePower = Aktuller Wert was die PV liefert
            Input Power = ?
            DailyEnergyYield = Heutiger Ertrag
            AccomulatedEnergyYield = Gesamtenergieertrag

            Meter
            PositiveActiveEnergy = Positive aktive Energie
            ReverseActiveEnergy = Negative aktive Energie

            Was ich noch haben möchte:

            Importierte Wh
            Exportierte Wh

            Das hat doch sicher was mit der positiven und negativen Energie zu tun?
            Allerdings komme ich nicht darauf.

            Weiß jemand einen Rat?

            M 1 Antwort Letzte Antwort
            0
            • H hussi

              @alex-warkentin

              Das Skript läuft bei mir und gibt mir die Werte aus, die du eingetragen hast.
              Danke dafür!

              Das Skript liefert mir diese Ergebnisse:

              inverter.JPG
              meter.JPG

              Wenn ich das nun auf meinem Fusionsolar Oberfläche Abgleiche habe ich folgende Ergebnisse abgeleitet:

              Inverter
              ActivePower = Aktuller Wert was die PV liefert
              Input Power = ?
              DailyEnergyYield = Heutiger Ertrag
              AccomulatedEnergyYield = Gesamtenergieertrag

              Meter
              PositiveActiveEnergy = Positive aktive Energie
              ReverseActiveEnergy = Negative aktive Energie

              Was ich noch haben möchte:

              Importierte Wh
              Exportierte Wh

              Das hat doch sicher was mit der positiven und negativen Energie zu tun?
              Allerdings komme ich nicht darauf.

              Weiß jemand einen Rat?

              M Offline
              M Offline
              MrLee
              schrieb am zuletzt editiert von
              #166

              @hussi said in Huawei Sun2000 & ioBroker via JS script funktioniert:

              Moin!

              ich lese die Daten etwas anders...

              Inverter
              ActivePower = Aktuller Wert was die PV liefert

              aktueller Hausverbrauch

              Input Power = ?

              Input PV Strings

              Meter
              PositiveActiveEnergy = Positive aktive Energie

              Hier bin ich gerade am Rätseln...gesamtVerbrauch Haus today?
              Der wäre mir nämlich recht lieb.

              Was ich noch haben möchte:

              Importierte Wh
              Exportierte Wh

              javascript.0.Solarpower.Derived.GridExportSum
              und folgende ?

              H 1 Antwort Letzte Antwort
              0
              • M MrLee

                @hussi said in Huawei Sun2000 & ioBroker via JS script funktioniert:

                Moin!

                ich lese die Daten etwas anders...

                Inverter
                ActivePower = Aktuller Wert was die PV liefert

                aktueller Hausverbrauch

                Input Power = ?

                Input PV Strings

                Meter
                PositiveActiveEnergy = Positive aktive Energie

                Hier bin ich gerade am Rätseln...gesamtVerbrauch Haus today?
                Der wäre mir nämlich recht lieb.

                Was ich noch haben möchte:

                Importierte Wh
                Exportierte Wh

                javascript.0.Solarpower.Derived.GridExportSum
                und folgende ?

                H Offline
                H Offline
                hussi
                schrieb am zuletzt editiert von
                #167

                @mrlee

                Hier mal gleichzeitig die Werte aus der Weboberfläche zusammen mit dem Inverter und dem Meter aus dem ioBroker.

                inverter_neu.JPG
                meter_neu.JPG
                weboberfläche.JPG

                Es ist kein normales Haus sondern eine Esso Station. Daher sind die Werte nicht mit einem Einfamilienhaus zu vergleichen.

                javascript.0.Solarpower.Derived.GridExportSum
                Woher hast du das?
                Das habe ich nicht.

                C 1 Antwort Letzte Antwort
                0
                • R Offline
                  R Offline
                  R4
                  schrieb am zuletzt editiert von R4
                  #168

                  Für Freaks: :blush:

                  Ich lade meine Luna scriptgesteuert bevorzugt ab dem Zeitpunkt, bei dem die maximale Leistung des WR (11 kW bei meinem 10KTL - habe 16,6 kWp) ins Haus+Netz gehen kann, denn ab da ist der Akkuladestrom tatsächlich kostenlos (= Überschussenergie im wahrsten Sinn).

                  Wie viel das ist sammle ich (näherungsweise) hiermit:

                  const idPower = "javascript.0.Solarpower.Derived.BatteryFreePower";  // Datenpunkt der "überschüssigen" Ladeleistung [W]
                  const idEnergy = "javascript.0.Solarpower.Derived.BatteryFreeEnergy";  // [kWh]
                  const initialKwh = 0.0; // [kWh] am Anfang
                  var energy = 0;
                   
                  // Datenpunkt für "geschenkte Ladeleisung"
                  createState("javascript.0.Solarpower.Derived.BatteryFreePower", 0,  {read: true, write: true, name: "Battery free charging power", unit: "W"});
                  
                  // Energie-Datenpunkt erzeugen
                  createState(idEnergy, initialKwh, { type: "number", name: "Kostenlose Akkuladeenergie", unit: "kWh" },
                      () => energy = 1000 * getState(idEnergy).val
                  ); // Anfangswert
                   
                  on({ id: idPower }, function (dp) { // triggert bei jeder Wertänderung
                      energy = energy + dp.oldState.val * (dp.state.lc - dp.oldState.lc) / 3600000; // [Wh]
                      setState(idEnergy, Math.round(energy) / 1000, true); // [kWh] mit 3 Nachkommastellen
                  });
                  
                  

                  in function ProcessData() kommt dann noch:

                  // compute free charging power
                      var FreePower;
                      var ChargePower = getState("javascript.0.Solarpower.Huawei.Inverter.Battery.ChargeAndDischargePower").val;
                      if (ChargePower > 0) // Akku lädt (geht auch anders, da gibt's einen extra Registereintrag)
                      {
                          FreePower = (PanelPower * 1000) - 11000;
                          if (FreePower < 0) FreePower = 0; // zu wenig Leistung vom Dach
                      }
                      else FreePower = 0; // Akku lädt eh nicht
                      setState("javascript.0.Solarpower.Derived.BatteryFreePower", FreePower); // [W]
                  

                  Ich lass das in die .csv reinschreiben.
                  Wenn man es dann auf 0 zurücksetzen lassen will muss natürlich nach

                  // one minute before midnight - perform housekeeping actions
                  [...]
                  SolarPowerLogging();"

                  noch:

                  // reset BatteryFreeEnergy for next day
                  setState("javascript.0.Solarpower.Derived.BatteryFreeEnergy", 0);
                  energy = 0;
                  

                  Dank insbesondere an @Chris_B

                  1 Antwort Letzte Antwort
                  0
                  • H hussi

                    @mrlee

                    Hier mal gleichzeitig die Werte aus der Weboberfläche zusammen mit dem Inverter und dem Meter aus dem ioBroker.

                    inverter_neu.JPG
                    meter_neu.JPG
                    weboberfläche.JPG

                    Es ist kein normales Haus sondern eine Esso Station. Daher sind die Werte nicht mit einem Einfamilienhaus zu vergleichen.

                    javascript.0.Solarpower.Derived.GridExportSum
                    Woher hast du das?
                    Das habe ich nicht.

                    C Offline
                    C Offline
                    Chris_B
                    schrieb am zuletzt editiert von Chris_B
                    #169

                    @hussi
                    Ich habe das Ganze mit Hilfe dieses Bildes umgesetzt:
                    562698cb-619b-4a1c-82c1-3ff5968a0e11-grafik.png
                    Das habe ich irgendwo im Netz gefunden. Die Variable unter 'Derived' (abgeleitet) sind (unter anderem) nach dieser Abbildung erstellt. Die vom Netz importierte / exportierte Leistung an einem Tag findest Du unter:

                    javascript.0.Solarpower.Derived.GridExportToday
                    javascript.0.Solarpower.Derived.GridImportToday

                    Gruss
                    Christian

                    H 1 Antwort Letzte Antwort
                    0
                    • P Offline
                      P Offline
                      ple
                      schrieb am zuletzt editiert von
                      #170

                      Hallo zusammen,
                      kurze Frage, NodeRed nutze ich gerade nur um Daten zu lesen, klappt soweit ganz gut.
                      Jetzt zu Zeiten von Tibber wollte ich gerne meine PV mal abschalten oder reduzieren, damit voll Netzbezug machen kann.
                      Hat es schon mal einer geschafft die Analge via Modbus zu drosseln oder gar abzuschalten? Heute wird der Strom bei Tibber bei -44 Cent liegen, daher meine Frage.

                      Gruß und DAnke

                      Intel Nuc + Proxmox

                      1 Antwort Letzte Antwort
                      0
                      • C Chris_B

                        @hussi
                        Ich habe das Ganze mit Hilfe dieses Bildes umgesetzt:
                        562698cb-619b-4a1c-82c1-3ff5968a0e11-grafik.png
                        Das habe ich irgendwo im Netz gefunden. Die Variable unter 'Derived' (abgeleitet) sind (unter anderem) nach dieser Abbildung erstellt. Die vom Netz importierte / exportierte Leistung an einem Tag findest Du unter:

                        javascript.0.Solarpower.Derived.GridExportToday
                        javascript.0.Solarpower.Derived.GridImportToday

                        Gruss
                        Christian

                        H Offline
                        H Offline
                        hussi
                        schrieb am zuletzt editiert von
                        #171

                        @chris_b said in Huawei Sun2000 & ioBroker via JS script funktioniert:

                        javascript.0.Solarpower.Derived.GridExportToday
                        javascript.0.Solarpower.Derived.GridImportToday

                        Hallo Christian,

                        die Punkte habe ich nicht.

                        Das Bild verstehe ich, glaube ich. Aber ich habe (noch) keine Batterie. Also kann ich ja nicht "Portal Yield today" errechnen.

                        Ich habe hier einen eigenen Thread eröffnet. Ich glaube das stört hier sonst.

                        1 Antwort Letzte Antwort
                        0
                        • C Chris_B

                          Ich habe das Skript nochmals etwas erweitert:
                          Jetzt werden auch jeden Tag 1 Minute vor Mitternacht die Tagesdaten in die Datei /opt/iobroker/iobroker-data/SolarpowerLog.csv geschrieben. Pro Tag werden folgende Daten geschrieben:

                          • Datum
                          • Yield Today
                          • GridExportToday
                          • GridImportToday
                          • ConsumptionToday

                          Mit dieser csv Datei kann man dann in Excel wunderbar seine eigenen Stattistiken zeichen und analysieren.
                          Gruss, Christian

                          ACHTUNG: Irgendwie kopiert es mir das Skript komisch in den 'Code' Bereich. Bitte die komischen {1} im Skript wegnehmen. Weiss jemand, wie diese entstehen? Die sind im Code nicht drin, und ich habe mehrere Arten versucht es zu kopieren...

                          // From iobroker Forum: "Huawei Sun2000 & ioBroker via JS script funktioniert"
                          // https://forum.iobroker.net/topic/53005/huawei-sun2000-iobroker-via-js-script-funktioniert
                          //
                          
                          createState("javascript.0.Solarpower.Derived.BatteryOverview", "",  {read: true, write: true, name: "Battery Overview SOC"});
                          createState("javascript.0.Solarpower.Derived.HouseConsumption", "",  {read: true, write: true, name: "Consumption of House", unit: "W"});
                          createState("javascript.0.Solarpower.Derived.YieldToday", "",  {read: true, write: true, name: "Yield Today", unit: "kW"});
                          createState("javascript.0.Solarpower.Derived.IsBatteryLoading", 0,  {read: true, write: true, name: "Luna 2000 Battery is loading", type: "number"});
                          createState("javascript.0.Solarpower.Derived.IsGridExporting", 0,  {read: true, write: true, name: "Exporting Power to Grid", type: "number"});
                          createState("javascript.0.Solarpower.Derived.PeakPanelPower", 0,  {read: true, write: true, name: "Peak panel power today"});
                          createState("javascript.0.Solarpower.Derived.GridExportSum", 0,  {read: true, write: true, name: "Total export to grid", unit: "kWh"});
                          createState("javascript.0.Solarpower.Derived.GridImportSum", 0,  {read: true, write: true, name: "Total import from grid", unit: "kWh"});
                          createState("javascript.0.Solarpower.Derived.GridExportToday", 0,  {read: true, write: true, name: "Export to grid today", unit: "kWh"});
                          createState("javascript.0.Solarpower.Derived.GridImportToday", 0,  {read: true, write: true, name: "Import from grid today", unit: "kWh"});
                          createState("javascript.0.Solarpower.Derived.ConsumptionToday", 0,  {read: true, write: true, name: "Consumption today", unit: "kWh"});
                          createState("javascript.0.Solarpower.Derived.ConsumptionSum", 0,  {read: true, write: true, name: "Consumption total sum", unit: "kWh"});
                          createState("javascript.0.Solarpower.Derived.ConsumptionStart", 0,  {read: true, write: true, name: "Consumption total sum at start of day", unit: "kWh"});
                          
                          
                          var ModbusRTU = require("modbus-serial");
                          var fs = require('fs');
                          var client = new ModbusRTU();
                          var testCreateState = 0;
                          
                          var modbusErrorMessages =
                          [   "Unknown error",
                              "Illegal function (device does not support this read/write function)",
                              "Illegal data address (register not supported by device)",
                              "Illegal data value (value cannot be written to this register)",
                              "Slave device failure (device reports internal error)",
                              "Acknowledge (requested data will be available later)",
                              "Slave device busy (retry request again later)"
                          ];
                          
                          // open connection to a tcp line
                          client.setTimeout(10000);
                          
                          // Enter your inverter modbus IP and port here:
                          client.connectTCP("192.168.1.127", { port: 502 });
                          // Enter the Modbus-IDs of your Sun2000 inverters here (example for two inverters): const ModBusIDs = [16, 1];
                          const ModBusIDs = [1];
                          // On which Modbus-ID can we reach the power meter? (via Sun2000!)
                          const PowerMeterID = 0;
                          // Enter your battery stack setup. 2 dimensional array, e.g. [[3, 2], [3, 0]] means:
                          // First inverter has two battery stacks with 3 + 2 battery modules
                          // while second inverter has only one battery stack with 3 battery modules
                          const BatteryUnits = [[3, 0]];
                          
                          // These register spaces need to be read:
                          const RegisterSpacesToReadContinuously = [[30000, 81], [37100, 114], [32000, 116], [37000, 68],  [37700, 100], [37800, 100], [38200, 100], [38300, 100], [38400, 100], [35300, 40]];
                          var RegisterSpacesToReadContinuouslyPtr = 0;
                          
                          var GlobalDataBuffer = new Array(2);
                          for ( var i=0; i < ModBusIDs.length; i++)
                          {
                              GlobalDataBuffer[i] = new Array(50000); // not optimized....
                          }
                          
                          
                          // Some helper functions:
                          
                          function readUnsignedInt16(array)
                          {   return array[0];
                          }
                          
                          function readUnsignedInt32(array)
                          {   return array[0] * 256 * 256 + array[1];
                          }
                          
                          function readSignedInt16(array)
                          {   var value = 0;
                              if (array[0] > 32767)   value = array[0] - 65535; 
                                  else                value = array[0];
                              return value;
                          }
                          
                          function readSignedInt32(array)
                          {   var value = 0;
                              for (var i = 0; i < 2; i++) { value = (value << 16) | array[i]; }
                              return value;
                          }
                          
                          function getU16(dataarray, index)
                          {   return readUnsignedInt16(dataarray.slice(index, index+1));
                          }
                          
                          function getU32(dataarray, index)
                          {   return readUnsignedInt32(dataarray.slice(index, index+2));
                          }
                          
                          function getI16(dataarray, index)
                          {   return readSignedInt16(dataarray.slice(index, index+1));
                          }
                          
                          function getI32(dataarray, index)
                          {   return readSignedInt32(dataarray.slice(index, index+2));
                          }
                          
                          function getString(dataarray, index, length)
                          {   var shortarray = dataarray.slice(index, index+length);
                              var bytearray = [];
                              for (var i = 0; i < length; i++)
                              {   bytearray.push(dataarray[index+i] >> 8);
                                  bytearray.push(dataarray[index+i] & 0xff);
                              }       
                              var value =  String.fromCharCode.apply(null, bytearray);    
                              return value;
                          }
                          
                          function getZeroTerminatedString(dataarray, index, length)
                          {   var shortarray = dataarray.slice(index, index+length);
                              var bytearray = [];
                              for(var i = 0; i < length; i++)
                              {   bytearray.push(dataarray[index+i] >> 8);
                                  bytearray.push(dataarray[index+i] & 0xff);
                              }       
                              var value =  String.fromCharCode.apply(null, bytearray);    
                              var value2 = new String(value).trim();
                              return value2;
                          }
                          
                          function forcesetState(objectname, value, options)
                          //------------------------------------------------
                          // perform createState() only if variable does not yet exist, and perform the check via existsState() only once for each processing round
                          {   if (testCreateState == 0)
                              {   if (!existsState("javascript.0." + objectname)) { createState(objectname, value, options); }
                                  else                                            { setState(objectname, value); }
                              } else
                              {   setState(objectname, value);
                              }
                          }  
                          
                          
                          // Functions to map registers into ioBreaker objects
                          
                          function ProcessOptimizers(id)
                          //----------------------------
                          {
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".OptimizerTotalNumber",     getU16(GlobalDataBuffer[id-1], 37200), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".OptimizerOnlineNumber",    getU16(GlobalDataBuffer[id-1], 37201), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".OptimizerFeatureData",     getU16(GlobalDataBuffer[id-1], 37202), {name: "", unit: ""});
                          }
                          
                          function ProcessInverterPowerAdjustments(id)
                          //------------------------------------------
                          {
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.ActiveAdjustementMode",     getU16(GlobalDataBuffer[id-1], 35300), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.ActiveAdjustementValue",    getU32(GlobalDataBuffer[id-1], 35301), {name: "", unit: ""}); // Note: This might be an error in the manual. It says register 35302 with quantity 2, but on 35303 is already the next value.
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.ActiveAdjustementCommand",  getU16(GlobalDataBuffer[id-1], 35303), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.ReactiveAdjustementMode",   getU16(GlobalDataBuffer[id-1], 35304), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.ReactiveAdjustementValue",  getU32(GlobalDataBuffer[id-1], 35305), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.ReactiveAdjustementCommand",getU16(GlobalDataBuffer[id-1], 35307), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.PowerMeterActivePower",     getI32(GlobalDataBuffer[id-1], 35313), {name: "", unit: ""});
                          }
                          
                          function ProcessBattery(id)
                          //-------------------------
                          {
                              // Battery registers 1-15 (Stack 1 related)
                              if ( BatteryUnits[id-1][0] > 0)
                              {
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.RunningStatus",               getU16(GlobalDataBuffer[id-1], 37000), {name: "", unit: ""});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.ChargeAndDischargePower",     getI32(GlobalDataBuffer[id-1], 37001), {name: "Charge and Discharge Power", unit: "W"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.BusVoltage",                  getU16(GlobalDataBuffer[id-1], 37003) / 10, {name: "Busvoltage", unit: "V"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.BatterySOC",                  getU16(GlobalDataBuffer[id-1], 37004) / 10, {name: "Battery SOC", unit: "%"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.WorkingMode",                 getU16(GlobalDataBuffer[id-1], 37006), {name: "Working Mode", unit: ""});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.RatedChargePower",            getU32(GlobalDataBuffer[id-1], 37007), {name: "", unit: "W"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.RatedDischargePower",         getU32(GlobalDataBuffer[id-1], 37009), {name: "", unit: "W"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.FaultID",                     getU16(GlobalDataBuffer[id-1], 37014), {name: "", unit: ""});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.CurrentDayChargeCapacity",    getU32(GlobalDataBuffer[id-1], 37015) / 100, {name: "", unit: "kWh"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.CurrentDayDischargeCapacity", getU32(GlobalDataBuffer[id-1], 37017) / 100, {name: "", unit: "kWh"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.BusCurrent",                  getI16(GlobalDataBuffer[id-1], 37021) / 10, {name: "Buscurrent", unit: "A"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.BatteryTemperature",          getI16(GlobalDataBuffer[id-1], 37022) / 10, {name: "Battery Temperatue", unit: "°C"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.RemainingChargeDischargeTime",getU16(GlobalDataBuffer[id-1], 37025), {name: "", unit: "mins"});
                                  //forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.DCDCversion",                 getZeroTerminatedString(GlobalDataBuffer[id-1], 37026, 10), {name: "", unit: ""});
                                  //forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.BMSversion",                  getZeroTerminatedString(GlobalDataBuffer[id-1], 37036, 10), {name: "", unit: ""});
                              }
                              // Battery registers 16+17 (Storage-related)
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.MaximumChargePower",                     getU32(GlobalDataBuffer[id-1], 37046), {name: "", unit: "W"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.MaximumDischargePower",                  getU32(GlobalDataBuffer[id-1], 37048), {name: "", unit: "W"});
                          
                              // Battery register 18-20 (Stack 1 related)
                              if (BatteryUnits[id-1][0] > 0)
                              {
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.SN",                          getZeroTerminatedString(GlobalDataBuffer[id-1], 37052, 10), {name: "Serialnumber", unit: ""});       
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.TotalCharge",                 getU32(GlobalDataBuffer[id-1], 37066) / 100, {name: "", unit: "kWh"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.TotalDischarge",              getU32(GlobalDataBuffer[id-1], 37068) / 100, {name: "", unit: "kWh"});
                              }
                              // Battery register 21-31 (Stack 2 related)
                              if ( BatteryUnits[id-1][1] > 0)
                              {
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.SN",                          getZeroTerminatedString(GlobalDataBuffer[id-1], 37700, 10), {name: "Serialnumber", unit: ""});        
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.BatterySOC",                  getU16(GlobalDataBuffer[id-1], 37738) / 10, {name: "", unit: "%"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.RunningStatus",               getU16(GlobalDataBuffer[id-1], 37741), {name: "", unit: ""});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.ChargeAndDischargePower",     getI32(GlobalDataBuffer[id-1], 37743), {name: "", unit: "W"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.CurrentDayChargeCapacity",    getU32(GlobalDataBuffer[id-1], 37746) / 100, {name: "", unit: "kWh"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.CurrentDayDischargeCapacity", getU32(GlobalDataBuffer[id-1], 37748) / 100, {name: "", unit: "kWh"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.BusVoltage",                  getU16(GlobalDataBuffer[id-1], 37750) / 10, {name: "", unit: "V"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.BusCurrent",                  getI16(GlobalDataBuffer[id-1], 37751) / 10, {name: "", unit: "A"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.BatteryTemperature",          getI16(GlobalDataBuffer[id-1], 37752) / 10, {name: "", unit: "°C"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.TotalCharge",                 getU32(GlobalDataBuffer[id-1], 37753) / 100, {name: "", unit: "kWh"});
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.TotalDischarge",              getU32(GlobalDataBuffer[id-1], 37755) / 100, {name: "", unit: "kWh"});
                              }
                              // Battery register 32-41 (Storage related)
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.RatedCapacity", getU32(GlobalDataBuffer[id-1], 37758) / 1, {name: "", unit: "Wh"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.SOC", getU16(GlobalDataBuffer[id-1], 37760) / 10, {name: "", unit: "%"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.RunningStatus", getU16(GlobalDataBuffer[id-1], 37762) / 1, {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.BusVoltage", getU16(GlobalDataBuffer[id-1], 37763) / 10, {name: "", unit: "V"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.BusCurrent", getI16(GlobalDataBuffer[id-1], 37764) / 10, {name: "", unit: "A"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.ChargeAndDischargePower", getI32(GlobalDataBuffer[id-1], 37765) / 1, {name: "", unit: "W"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.TotalCharge", getU32(GlobalDataBuffer[id-1], 37780) / 100, {name: "", unit: "kWh"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.TotalDischarge", getU32(GlobalDataBuffer[id-1], 37782) / 100, {name: "", unit: "kWh"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.CurrentDayChargeCapacity", getU32(GlobalDataBuffer[id-1], 37784) / 100, {name: "", unit: "kWh"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.CurrentDayDischargeCapacity", getU32(GlobalDataBuffer[id-1], 37786) / 100, {name: "Current DayDiscarge ", unit: "kWh"});
                          
                              // Battery registers 42+43 (Battery stack related)   
                              if ( BatteryUnits[id-1][1] > 0)
                              {
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.SoftwareVersion",    getZeroTerminatedString(GlobalDataBuffer[id-1], 37814, 8), {name: "Softwareversion", unit: ""});
                              }
                              
                              if ( BatteryUnits[id-1][0] > 0)
                              {
                                  forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.SoftwareVersion",    getZeroTerminatedString(GlobalDataBuffer[id-1], 37799, 8), {name: "Softwareversion", unit: ""});
                              }
                          
                              // Registers 44 to 98: (Battery pack related)
                              for(var i = 1; i <= 2; i++)
                              {        
                                  if(BatteryUnits[id-1][i-1] >= 0)
                                  {            
                                      for(var j = 1; j <= BatteryUnits[id-1][i-1]; j++)
                                      {
                                          //[[38200, 38242, 38284] [38326, 38368, 38410]]; (+42 for each battery pack, +126 for each stack)
                                          forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".SN",                getZeroTerminatedString(GlobalDataBuffer[id-1], 38200+(i-1)*126+(j-1)*42, 6), {name: "", unit: ""});
                                          forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".FirmwareVersion",   getZeroTerminatedString(GlobalDataBuffer[id-1], 38210+(i-1)*126+(j-1)*42, 8), {name: "", unit: ""});
                                          forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".WorkingStatus",     getU16(GlobalDataBuffer[id-1], 38228+(i-1)*126+(j-1)*42), {name: "", unit: ""});
                                          forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".BatterySOC",        getU16(GlobalDataBuffer[id-1], 38229+(i-1)*126+(j-1)*42) / 10, {name: "", unit: "%"});
                                          forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".ChargeAndDischargePower", getI32(GlobalDataBuffer[id-1], 38233+(i-1)*126+(j-1)*42) / 1000, {name: "", unit: "kW"});
                                          forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".Voltage",           getU16(GlobalDataBuffer[id-1], 38235+(i-1)*126+(j-1)*42) / 10, {name: "", unit: "V"});
                                          forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".Current",           getI16(GlobalDataBuffer[id-1], 38236+(i-1)*126+(j-1)*42) / 10, {name: "", unit: "A"});
                                          forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".TotalCharge",       getU32(GlobalDataBuffer[id-1], 38238+(i-1)*126+(j-1)*42) / 100, {name: "", unit: "kWh"});
                                          forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".TotalDischarge",    getU32(GlobalDataBuffer[id-1], 38240+(i-1)*126+(j-1)*42) / 100, {name: "", unit: "kWh"});
                          
                                          // [[38452, 38454, 38456][38458, 38460, 38462]] ( +2 for each pack, +6 for each stack)
                                          createState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".MaxTemperature", getI16(GlobalDataBuffer[id-1], 38452+(i-1)*6+(j-1)*2) / 10, {name: "", unit: "°C"});
                                          createState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".MinTemperature", getI16(GlobalDataBuffer[id-1], 38453+(i-1)*6+(j-1)*2) / 10, {name: "", unit: "°C"});
                                      }
                                  }        
                              }
                          
                              // Battery registers 110-141 are not supported by this script yet!
                          }
                          
                          
                          function ProcessPowerMeterStatus()
                          //--------------------------------
                          {       
                              forcesetState("Solarpower.Huawei.Meter.Status",                   getU16(GlobalDataBuffer[PowerMeterID], 37100), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Meter.VoltageL1",                getI32(GlobalDataBuffer[PowerMeterID], 37101)  / 10, {name: "", unit: "V"});
                              forcesetState("Solarpower.Huawei.Meter.VoltageL2",                getI32(GlobalDataBuffer[PowerMeterID], 37103)  / 10, {name: "", unit: "V"});
                              forcesetState("Solarpower.Huawei.Meter.VoltageL3",                getI32(GlobalDataBuffer[PowerMeterID], 37105)  / 10, {name: "", unit: "V"});
                              forcesetState("Solarpower.Huawei.Meter.CurrentL1",                getI32(GlobalDataBuffer[PowerMeterID], 37107)  / 100, {name: "", unit: "A"});
                              forcesetState("Solarpower.Huawei.Meter.CurrentL2",                getI32(GlobalDataBuffer[PowerMeterID], 37109)  / 100, {name: "", unit: "A"});
                              forcesetState("Solarpower.Huawei.Meter.CurrentL3",                getI32(GlobalDataBuffer[PowerMeterID], 37111) / 100, {name: "", unit: "A"});
                              forcesetState("Solarpower.Huawei.Meter.ActivePower",              getI32(GlobalDataBuffer[PowerMeterID], 37113) / 1, {name: "", unit: "W"});
                              forcesetState("Solarpower.Huawei.Meter.ReactivePower",            getI32(GlobalDataBuffer[PowerMeterID], 37115) / 1, {name: "", unit: "Var"});
                              forcesetState("Solarpower.Huawei.Meter.PowerFactor",              getI16(GlobalDataBuffer[PowerMeterID], 37117) / 1000, {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Meter.GridFrequency",            getI16(GlobalDataBuffer[PowerMeterID], 37118) / 100, {name: "", unit: "Hz"});
                              forcesetState("Solarpower.Huawei.Meter.PositiveActiveEnergy",     getI32(GlobalDataBuffer[PowerMeterID], 37119) / 100, {name: "", unit: "kWh"});
                              forcesetState("Solarpower.Huawei.Meter.ReverseActiveEnergy",      getI32(GlobalDataBuffer[PowerMeterID], 37121) / 100, {name: "", unit: "kWh"});
                              forcesetState("Solarpower.Huawei.Meter.AccumulatedReactivePower", getI32(GlobalDataBuffer[PowerMeterID], 37123) / 100, {name: "", unit: "kVarh"});
                              //forcesetState("Solarpower.Huawei.Meter.MeterType",                getU16(GlobalDataBuffer[PowerMeterID], 37125), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Meter.VoltageL1-L2",             getI32(GlobalDataBuffer[PowerMeterID], 37126) / 10, {name: "", unit: "V"});
                              forcesetState("Solarpower.Huawei.Meter.VoltageL2-L3",             getI32(GlobalDataBuffer[PowerMeterID], 37128) / 10, {name: "", unit: "V"});
                              forcesetState("Solarpower.Huawei.Meter.VoltageL3-L1",             getI32(GlobalDataBuffer[PowerMeterID], 37130) / 10, {name: "", unit: "V"});
                              forcesetState("Solarpower.Huawei.Meter.ActivePowerL1",            getI32(GlobalDataBuffer[PowerMeterID], 37132) / 1, {name: "", unit: "W"});
                              forcesetState("Solarpower.Huawei.Meter.ActivePowerL2",            getI32(GlobalDataBuffer[PowerMeterID], 37134) / 1, {name: "", unit: "W"});
                              forcesetState("Solarpower.Huawei.Meter.ActivePowerL3",            getI32(GlobalDataBuffer[PowerMeterID], 37136) / 1, {name: "", unit: "W"});
                              //forcesetState("Solarpower.Huawei.Meter.MeterModel",               getU16(GlobalDataBuffer[PowerMeterID], 37138), {name: "", unit: ""});
                          }
                          
                          function ProcessInverterStatus(id)
                          //--------------------------------
                          {
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".State1", getU16(GlobalDataBuffer[id-1], 32000), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".State2", getU16(GlobalDataBuffer[id-1], 32001), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".State3", getU16(GlobalDataBuffer[id-1], 32002), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Alarm1", getU16(GlobalDataBuffer[id-1], 32008), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Alarm2", getU16(GlobalDataBuffer[id-1], 32009), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Alarm3", getU16(GlobalDataBuffer[id-1], 32010), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".String.1_Voltage",       getI16(GlobalDataBuffer[id-1], 32016) / 10  , {name: "", unit: "V"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".String.1_Current",       getI16(GlobalDataBuffer[id-1], 32017) / 100 , {name: "", unit: "A"});
                              //forcesetState("Solarpower.Huawei.Inverter." + id + ".String.2_Voltage",       getI16(GlobalDataBuffer[id-1], 32018) / 10  , {name: "", unit: "V"});
                              //forcesetState("Solarpower.Huawei.Inverter." + id + ".String.2_Current",       getI16(GlobalDataBuffer[id-1], 32019) / 100 , {name: "", unit: "A"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".InputPower",             getI32(GlobalDataBuffer[id-1], 32064) / 1000, {name: "", unit: "kW"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L1-L2_Voltage",           getU16(GlobalDataBuffer[id-1], 32066) / 10  , {name: "", unit: "V"});      
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L2-L3_Voltage",           getU16(GlobalDataBuffer[id-1], 32067) / 10  , {name: "", unit: "V"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L3-L1_Voltage",           getU16(GlobalDataBuffer[id-1], 32068) / 10  , {name: "", unit: "V"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L1_Voltage",            getU16(GlobalDataBuffer[id-1], 32069) / 10  , {name: "", unit: "V"});                              
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L2_Voltage",            getU16(GlobalDataBuffer[id-1], 32070) / 10  , {name: "", unit: "V"});                                                  
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L3_Voltage",            getU16(GlobalDataBuffer[id-1], 32071) / 10  , {name: "", unit: "V"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L1_Current",         getI32(GlobalDataBuffer[id-1], 32072) / 1000, {name: "", unit: "A"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L2_Current",         getI32(GlobalDataBuffer[id-1], 32074) / 1000, {name: "", unit: "A"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L3_Current",         getI32(GlobalDataBuffer[id-1], 32076) / 1000, {name: "", unit: "A"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".PeakActivePowerDay",     getI32(GlobalDataBuffer[id-1], 32078) / 1000, {name: "", unit: "kW"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".ActivePower",            getI32(GlobalDataBuffer[id-1], 32080) / 1000, {name: "", unit: "kW"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".ReactivePower",          getI32(GlobalDataBuffer[id-1], 32082) / 1000, {name: "", unit: "kVar"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".PowerFactor",            getI16(GlobalDataBuffer[id-1], 32084) / 1000, {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".GridFrequency",          getU16(GlobalDataBuffer[id-1], 32085) / 100 , {name: "", unit: "Hz"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Efficiency",             getU16(GlobalDataBuffer[id-1], 32086) / 100 , {name: "", unit: "%"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".InternalTemperature",    getI16(GlobalDataBuffer[id-1], 32087) / 10  , {name: "", unit: "°C"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".InsulationResistance",   getU16(GlobalDataBuffer[id-1], 32088) / 1000, {name: "", unit: "MOhm"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".DeviceStatus",              getU16(GlobalDataBuffer[id-1], 32089), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".FaultCode",                 getU16(GlobalDataBuffer[id-1], 32090), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".StartupTime",               getU16(GlobalDataBuffer[id-1], 32091), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".ShutdownTime",              getU16(GlobalDataBuffer[id-1], 32093), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".AccumulatedEnergyYield",    getU32(GlobalDataBuffer[id-1], 32106) / 100, {name: "", unit: "kWh"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".DailyEnergyYield",          getU32(GlobalDataBuffer[id-1], 32114) / 100, {name: "", unit: "kWh"});
                          }
                          
                          
                          function ProcessDeviceInfo(id)
                          //----------------------------
                          {      
                              // Note: Manual says its quantitiy is 15, but that is the number (+1) of 8bit characters
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".Model",  getZeroTerminatedString(GlobalDataBuffer[id-1], 30000, 8), {name: "", unit: ""}); 
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".SN",     getZeroTerminatedString(GlobalDataBuffer[id-1], 30015, 6), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".PN",     getZeroTerminatedString(GlobalDataBuffer[id-1], 30025, 6), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".ModelID",           getU16(GlobalDataBuffer[id-1], 30070), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".PVStrings",         getU16(GlobalDataBuffer[id-1], 30071), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".MPPTrackers",       getU16(GlobalDataBuffer[id-1], 30072), {name: "", unit: ""});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".MaxRatedPower",     getU32(GlobalDataBuffer[id-1], 30073) / 1000, {name: "", unit: "kW"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".MaxActivePower",    getU32(GlobalDataBuffer[id-1], 30075) / 1000, {name: "", unit: "kW"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".MaxApparentPower",  getU32(GlobalDataBuffer[id-1], 30077) / 1000, {name: "", unit: "kVA"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".MaxReactivePowerToGrid",        getI32(GlobalDataBuffer[id-1], 30079) / 1000, {name: "", unit: "kVAr"});
                              forcesetState("Solarpower.Huawei.Inverter." + id + ".MaxReactivePowerFromGrid",      getI32(GlobalDataBuffer[id-1], 30081) / 1000, {name: "", unit: "kVAr"});
                          }
                          
                          
                          function readRegisterSpace(id, address, length)
                          //---------------------------------------------
                          {
                              client.setID(ModBusIDs[id-1]);
                              client.readHoldingRegisters(address, length, function(err, data)
                              {   
                                  if (err)
                                  {   console.warn("Error received reading address " + address + " from id: " + ModBusIDs[id-1] + " with error: " + modbusErrorMessages[err.modbusCode]);            
                                  }
                                  else
                                  {   console.debug("Read data from id/address " + ModBusIDs[id-1] + "/" + address + "\nData is: " + data.data);
                                      for (var i = 0; i < length; i++) GlobalDataBuffer[id-1][address+i] = data.data[i];
                                  }
                              });
                          }
                          
                          
                          function ProcessData()
                          //--------------------
                          {
                              console.debug("Processing new data...");   // this was originally .log
                              for ( var i = 1; i <= ModBusIDs.length; i++)
                              {
                                  ProcessDeviceInfo(i);
                                  ProcessInverterStatus(i);
                                  ProcessBattery(i);
                                  //ProcessInverterPowerAdjustments(i);
                                  ProcessOptimizers(i); 
                              }    
                              ProcessPowerMeterStatus();
                          
                              // get SOC of first battery stack and combine to one string
                              var BatOverview = "";
                              for(var j = 1; j <= BatteryUnits[0][0]; j++)
                              { 
                                  if (j > 1) BatOverview += ", ";
                                  BatOverview += getState("javascript.0.Solarpower.Huawei.Inverter.1.Batterystack.1.Battery" + j + ".BatterySOC").val + "%";
                              }
                              setState("javascript.0.Solarpower.Derived.BatteryOverview", BatOverview);
                          
                              // determine peak panel power
                              var PanelPower = getState("javascript.0.Solarpower.Huawei.Inverter.1.InputPower").val;
                              var PanelMax = getState("javascript.0.Solarpower.Derived.PeakPanelPower").val;
                              if (PanelPower > PanelMax) setState("javascript.0.Solarpower.Derived.PeakPanelPower", PanelPower);
                              
                              // determine power used by house
                              setState("javascript.0.Solarpower.Derived.HouseConsumption", getState("javascript.0.Solarpower.Huawei.Inverter.1.ActivePower").val * 1000 -
                                  getState("javascript.0.Solarpower.Huawei.Meter.ActivePower").val);
                          
                              // determine yield today
                              setState("javascript.0.Solarpower.Derived.YieldToday", getState("javascript.0.Solarpower.Huawei.Inverter.1.DailyEnergyYield").val +
                                  getState("javascript.0.Solarpower.Huawei.Inverter.1.Batterystack.1.CurrentDayChargeCapacity").val -
                                  getState("javascript.0.Solarpower.Huawei.Inverter.1.Batterystack.1.CurrentDayDischargeCapacity").val)
                          
                              // determine if battery is loading
                              setState("javascript.0.Solarpower.Derived.IsBatteryLoading", getState("javascript.0.Solarpower.Huawei.Inverter.1.Batterystack.1.ChargeAndDischargePower").val > 0 ? 0 : 1);
                          
                              // determine if power is imported or exported
                              setState("javascript.0.Solarpower.Derived.IsGridExporting", getState("javascript.0.Solarpower.Huawei.Meter.ActivePower").val > 0 ? 1 : 0);
                          
                              // compute export and import today
                              setState("javascript.0.Solarpower.Derived.GridExportToday", getState("javascript.0.Solarpower.Huawei.Meter.PositiveActiveEnergy").val - getState("javascript.0.Solarpower.Derived.GridExportSum").val);
                              setState("javascript.0.Solarpower.Derived.GridImportToday", getState("javascript.0.Solarpower.Huawei.Meter.ReverseActiveEnergy").val - getState("javascript.0.Solarpower.Derived.GridImportSum").val);
                              
                              // compute consumption today
                              setState("javascript.0.Solarpower.Derived.ConsumptionSum",
                                  getState("javascript.0.Solarpower.Huawei.Inverter.1.AccumulatedEnergyYield").val +
                                  getState("javascript.0.Solarpower.Huawei.Meter.ReverseActiveEnergy").val -
                                  getState("javascript.0.Solarpower.Huawei.Meter.PositiveActiveEnergy").val);
                              setState("javascript.0.Solarpower.Derived.ConsumptionToday", 
                                  getState("javascript.0.Solarpower.Derived.ConsumptionSum").val -
                                  getState("javascript.0.Solarpower.Derived.ConsumptionStart").val); 
                          
                              testCreateState = 1;                // do not check on createState any more
                              console.debug("Processing done!");  // this was originally .log
                          }
                          
                          
                          var triggerprocessing = 0; 
                          var currentinverter = 1;
                          
                          setInterval(function()
                          // -------------------
                          // This is the main function triggering a  read via modbus-tcp every 2 seconds - changed to 5 seconds
                          // Processing of data is triggered as soon as one complete set of registers is copied
                          // with 5 seconds, new values are displyed every 50 seconds
                          {
                              if (triggerprocessing == 1)
                              {
                                  triggerprocessing = 0;
                                  ProcessData();
                              }      
                             
                              // this was originally also a .log
                              console.debug("Triggering read of inverter " + currentinverter + " at address " +
                                  RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][0] +
                                  " with length " +  RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][1]);
                              
                              readRegisterSpace(currentinverter, RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][0], RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][1]); 
                              RegisterSpacesToReadContinuouslyPtr++;               
                              if (RegisterSpacesToReadContinuouslyPtr >= RegisterSpacesToReadContinuously.length)
                              {
                                  RegisterSpacesToReadContinuouslyPtr = 0;
                                  currentinverter++
                                  if (currentinverter > ModBusIDs.length)
                                  {
                                      currentinverter = 1;  
                                      triggerprocessing = 1;                    
                                  }
                              }     
                          }, 5000);
                          
                          
                          // one minute before midnight - perform housekeeping actions
                          schedule("59 23 * * *", function ()
                          {   
                              // reset peak power for next day
                              setState("javascript.0.Solarpower.Derived.PeakPanelPower", 0);
                              // copy current export/import kWh - used to compute daily import/export in kWh
                              setState("javascript.0.Solarpower.Derived.GridExportSum", getState("javascript.0.Solarpower.Huawei.Meter.PositiveActiveEnergy").val);
                              setState("javascript.0.Solarpower.Derived.GridImportSum", getState("javascript.0.Solarpower.Huawei.Meter.ReverseActiveEnergy").val);
                              // copy consumption Sum to Start for the next day
                              setState("javascript.0.Solarpower.Derived.ConsumptionStart", getState("javascript.0.Solarpower.Derived.ConsumptionSum").val);
                              // log important iformation to file
                              SolarPowerLogging();
                          });
                          
                          
                          function SolarPowerLogging() 
                          //--------------------------
                          // write values of today in file
                          {
                              // get 
                              var log1 = getState("javascript.0.Solarpower.Derived.YieldToday").val;
                              var log2 = getState("javascript.0.Solarpower.Derived.GridExportToday").val;
                              var log3 = getState("javascript.0.Solarpower.Derived.GridImportToday").val;
                              var log4 = getState("javascript.0.Solarpower.Derived.ConsumptionToday").val;
                          
                              // Zerlege Datum und Zeit in Variable
                              var now =    new Date();
                              var year =   now.getFullYear();
                              var month =  addZero(now.getMonth() + 1);
                              var day =    addZero(now.getDate());
                              var currDate = day + '.' + month + '.' + year;
                              var string = " ";
                          
                              // create string that is appended to the file
                              string = currDate + ";" + log1.toFixed(3) + ";" + log2.toFixed(3) + ";" + log3.toFixed(3) + ";" + log4.toFixed(3) + "\n";
                              fs.appendFileSync("/opt/iobroker/iobroker-data/SolarpowerLog.csv", string);   
                          
                              // erzeuge Log-Eintrag
                              log("Solerpower log:" + string, "info"); 
                          }
                          
                          function addZero(Num)
                          //-----------------
                          // if number <10 add zero values at the beginning of numbers
                          {
                              if (Num < 10) Num = "0" + Num;
                              return Num;
                          }
                          
                          
                          M Offline
                          M Offline
                          meloneA
                          schrieb am zuletzt editiert von
                          #172

                          @chris_b said in Huawei Sun2000 & ioBroker via JS script funktioniert:

                          Ich habe das Skript nochmals etwas erweitert:
                          Jetzt werden auch jeden Tag 1 Minute vor Mitternacht die Tagesdaten in die Datei /opt/iobroker/iobroker-data/SolarpowerLog.csv geschrieben. Pro Tag werden folgende Daten geschrieben:

                          Danke, gestern hab ich das Script mit dem neuen WR in Betrieb genommen - läuft einwandfrei.

                          Weil die Frage zu den Optimierern schon gekommen ist, die wären in folgender lib schon mit integriert => https://github.com/wlcrs/huawei-solar-lib

                          1 Antwort Letzte Antwort
                          1
                          • C Chris_B

                            Ich habe das Skript nochmals etwas erweitert:
                            Jetzt werden auch jeden Tag 1 Minute vor Mitternacht die Tagesdaten in die Datei /opt/iobroker/iobroker-data/SolarpowerLog.csv geschrieben. Pro Tag werden folgende Daten geschrieben:

                            • Datum
                            • Yield Today
                            • GridExportToday
                            • GridImportToday
                            • ConsumptionToday

                            Mit dieser csv Datei kann man dann in Excel wunderbar seine eigenen Stattistiken zeichen und analysieren.
                            Gruss, Christian

                            ACHTUNG: Irgendwie kopiert es mir das Skript komisch in den 'Code' Bereich. Bitte die komischen {1} im Skript wegnehmen. Weiss jemand, wie diese entstehen? Die sind im Code nicht drin, und ich habe mehrere Arten versucht es zu kopieren...

                            // From iobroker Forum: "Huawei Sun2000 & ioBroker via JS script funktioniert"
                            // https://forum.iobroker.net/topic/53005/huawei-sun2000-iobroker-via-js-script-funktioniert
                            //
                            
                            createState("javascript.0.Solarpower.Derived.BatteryOverview", "",  {read: true, write: true, name: "Battery Overview SOC"});
                            createState("javascript.0.Solarpower.Derived.HouseConsumption", "",  {read: true, write: true, name: "Consumption of House", unit: "W"});
                            createState("javascript.0.Solarpower.Derived.YieldToday", "",  {read: true, write: true, name: "Yield Today", unit: "kW"});
                            createState("javascript.0.Solarpower.Derived.IsBatteryLoading", 0,  {read: true, write: true, name: "Luna 2000 Battery is loading", type: "number"});
                            createState("javascript.0.Solarpower.Derived.IsGridExporting", 0,  {read: true, write: true, name: "Exporting Power to Grid", type: "number"});
                            createState("javascript.0.Solarpower.Derived.PeakPanelPower", 0,  {read: true, write: true, name: "Peak panel power today"});
                            createState("javascript.0.Solarpower.Derived.GridExportSum", 0,  {read: true, write: true, name: "Total export to grid", unit: "kWh"});
                            createState("javascript.0.Solarpower.Derived.GridImportSum", 0,  {read: true, write: true, name: "Total import from grid", unit: "kWh"});
                            createState("javascript.0.Solarpower.Derived.GridExportToday", 0,  {read: true, write: true, name: "Export to grid today", unit: "kWh"});
                            createState("javascript.0.Solarpower.Derived.GridImportToday", 0,  {read: true, write: true, name: "Import from grid today", unit: "kWh"});
                            createState("javascript.0.Solarpower.Derived.ConsumptionToday", 0,  {read: true, write: true, name: "Consumption today", unit: "kWh"});
                            createState("javascript.0.Solarpower.Derived.ConsumptionSum", 0,  {read: true, write: true, name: "Consumption total sum", unit: "kWh"});
                            createState("javascript.0.Solarpower.Derived.ConsumptionStart", 0,  {read: true, write: true, name: "Consumption total sum at start of day", unit: "kWh"});
                            
                            
                            var ModbusRTU = require("modbus-serial");
                            var fs = require('fs');
                            var client = new ModbusRTU();
                            var testCreateState = 0;
                            
                            var modbusErrorMessages =
                            [   "Unknown error",
                                "Illegal function (device does not support this read/write function)",
                                "Illegal data address (register not supported by device)",
                                "Illegal data value (value cannot be written to this register)",
                                "Slave device failure (device reports internal error)",
                                "Acknowledge (requested data will be available later)",
                                "Slave device busy (retry request again later)"
                            ];
                            
                            // open connection to a tcp line
                            client.setTimeout(10000);
                            
                            // Enter your inverter modbus IP and port here:
                            client.connectTCP("192.168.1.127", { port: 502 });
                            // Enter the Modbus-IDs of your Sun2000 inverters here (example for two inverters): const ModBusIDs = [16, 1];
                            const ModBusIDs = [1];
                            // On which Modbus-ID can we reach the power meter? (via Sun2000!)
                            const PowerMeterID = 0;
                            // Enter your battery stack setup. 2 dimensional array, e.g. [[3, 2], [3, 0]] means:
                            // First inverter has two battery stacks with 3 + 2 battery modules
                            // while second inverter has only one battery stack with 3 battery modules
                            const BatteryUnits = [[3, 0]];
                            
                            // These register spaces need to be read:
                            const RegisterSpacesToReadContinuously = [[30000, 81], [37100, 114], [32000, 116], [37000, 68],  [37700, 100], [37800, 100], [38200, 100], [38300, 100], [38400, 100], [35300, 40]];
                            var RegisterSpacesToReadContinuouslyPtr = 0;
                            
                            var GlobalDataBuffer = new Array(2);
                            for ( var i=0; i < ModBusIDs.length; i++)
                            {
                                GlobalDataBuffer[i] = new Array(50000); // not optimized....
                            }
                            
                            
                            // Some helper functions:
                            
                            function readUnsignedInt16(array)
                            {   return array[0];
                            }
                            
                            function readUnsignedInt32(array)
                            {   return array[0] * 256 * 256 + array[1];
                            }
                            
                            function readSignedInt16(array)
                            {   var value = 0;
                                if (array[0] > 32767)   value = array[0] - 65535; 
                                    else                value = array[0];
                                return value;
                            }
                            
                            function readSignedInt32(array)
                            {   var value = 0;
                                for (var i = 0; i < 2; i++) { value = (value << 16) | array[i]; }
                                return value;
                            }
                            
                            function getU16(dataarray, index)
                            {   return readUnsignedInt16(dataarray.slice(index, index+1));
                            }
                            
                            function getU32(dataarray, index)
                            {   return readUnsignedInt32(dataarray.slice(index, index+2));
                            }
                            
                            function getI16(dataarray, index)
                            {   return readSignedInt16(dataarray.slice(index, index+1));
                            }
                            
                            function getI32(dataarray, index)
                            {   return readSignedInt32(dataarray.slice(index, index+2));
                            }
                            
                            function getString(dataarray, index, length)
                            {   var shortarray = dataarray.slice(index, index+length);
                                var bytearray = [];
                                for (var i = 0; i < length; i++)
                                {   bytearray.push(dataarray[index+i] >> 8);
                                    bytearray.push(dataarray[index+i] & 0xff);
                                }       
                                var value =  String.fromCharCode.apply(null, bytearray);    
                                return value;
                            }
                            
                            function getZeroTerminatedString(dataarray, index, length)
                            {   var shortarray = dataarray.slice(index, index+length);
                                var bytearray = [];
                                for(var i = 0; i < length; i++)
                                {   bytearray.push(dataarray[index+i] >> 8);
                                    bytearray.push(dataarray[index+i] & 0xff);
                                }       
                                var value =  String.fromCharCode.apply(null, bytearray);    
                                var value2 = new String(value).trim();
                                return value2;
                            }
                            
                            function forcesetState(objectname, value, options)
                            //------------------------------------------------
                            // perform createState() only if variable does not yet exist, and perform the check via existsState() only once for each processing round
                            {   if (testCreateState == 0)
                                {   if (!existsState("javascript.0." + objectname)) { createState(objectname, value, options); }
                                    else                                            { setState(objectname, value); }
                                } else
                                {   setState(objectname, value);
                                }
                            }  
                            
                            
                            // Functions to map registers into ioBreaker objects
                            
                            function ProcessOptimizers(id)
                            //----------------------------
                            {
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".OptimizerTotalNumber",     getU16(GlobalDataBuffer[id-1], 37200), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".OptimizerOnlineNumber",    getU16(GlobalDataBuffer[id-1], 37201), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".OptimizerFeatureData",     getU16(GlobalDataBuffer[id-1], 37202), {name: "", unit: ""});
                            }
                            
                            function ProcessInverterPowerAdjustments(id)
                            //------------------------------------------
                            {
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.ActiveAdjustementMode",     getU16(GlobalDataBuffer[id-1], 35300), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.ActiveAdjustementValue",    getU32(GlobalDataBuffer[id-1], 35301), {name: "", unit: ""}); // Note: This might be an error in the manual. It says register 35302 with quantity 2, but on 35303 is already the next value.
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.ActiveAdjustementCommand",  getU16(GlobalDataBuffer[id-1], 35303), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.ReactiveAdjustementMode",   getU16(GlobalDataBuffer[id-1], 35304), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.ReactiveAdjustementValue",  getU32(GlobalDataBuffer[id-1], 35305), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.ReactiveAdjustementCommand",getU16(GlobalDataBuffer[id-1], 35307), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".ActiveAdjustement.PowerMeterActivePower",     getI32(GlobalDataBuffer[id-1], 35313), {name: "", unit: ""});
                            }
                            
                            function ProcessBattery(id)
                            //-------------------------
                            {
                                // Battery registers 1-15 (Stack 1 related)
                                if ( BatteryUnits[id-1][0] > 0)
                                {
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.RunningStatus",               getU16(GlobalDataBuffer[id-1], 37000), {name: "", unit: ""});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.ChargeAndDischargePower",     getI32(GlobalDataBuffer[id-1], 37001), {name: "Charge and Discharge Power", unit: "W"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.BusVoltage",                  getU16(GlobalDataBuffer[id-1], 37003) / 10, {name: "Busvoltage", unit: "V"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.BatterySOC",                  getU16(GlobalDataBuffer[id-1], 37004) / 10, {name: "Battery SOC", unit: "%"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.WorkingMode",                 getU16(GlobalDataBuffer[id-1], 37006), {name: "Working Mode", unit: ""});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.RatedChargePower",            getU32(GlobalDataBuffer[id-1], 37007), {name: "", unit: "W"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.RatedDischargePower",         getU32(GlobalDataBuffer[id-1], 37009), {name: "", unit: "W"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.FaultID",                     getU16(GlobalDataBuffer[id-1], 37014), {name: "", unit: ""});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.CurrentDayChargeCapacity",    getU32(GlobalDataBuffer[id-1], 37015) / 100, {name: "", unit: "kWh"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.CurrentDayDischargeCapacity", getU32(GlobalDataBuffer[id-1], 37017) / 100, {name: "", unit: "kWh"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.BusCurrent",                  getI16(GlobalDataBuffer[id-1], 37021) / 10, {name: "Buscurrent", unit: "A"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.BatteryTemperature",          getI16(GlobalDataBuffer[id-1], 37022) / 10, {name: "Battery Temperatue", unit: "°C"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.RemainingChargeDischargeTime",getU16(GlobalDataBuffer[id-1], 37025), {name: "", unit: "mins"});
                                    //forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.DCDCversion",                 getZeroTerminatedString(GlobalDataBuffer[id-1], 37026, 10), {name: "", unit: ""});
                                    //forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.BMSversion",                  getZeroTerminatedString(GlobalDataBuffer[id-1], 37036, 10), {name: "", unit: ""});
                                }
                                // Battery registers 16+17 (Storage-related)
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.MaximumChargePower",                     getU32(GlobalDataBuffer[id-1], 37046), {name: "", unit: "W"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.MaximumDischargePower",                  getU32(GlobalDataBuffer[id-1], 37048), {name: "", unit: "W"});
                            
                                // Battery register 18-20 (Stack 1 related)
                                if (BatteryUnits[id-1][0] > 0)
                                {
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.SN",                          getZeroTerminatedString(GlobalDataBuffer[id-1], 37052, 10), {name: "Serialnumber", unit: ""});       
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.TotalCharge",                 getU32(GlobalDataBuffer[id-1], 37066) / 100, {name: "", unit: "kWh"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.TotalDischarge",              getU32(GlobalDataBuffer[id-1], 37068) / 100, {name: "", unit: "kWh"});
                                }
                                // Battery register 21-31 (Stack 2 related)
                                if ( BatteryUnits[id-1][1] > 0)
                                {
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.SN",                          getZeroTerminatedString(GlobalDataBuffer[id-1], 37700, 10), {name: "Serialnumber", unit: ""});        
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.BatterySOC",                  getU16(GlobalDataBuffer[id-1], 37738) / 10, {name: "", unit: "%"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.RunningStatus",               getU16(GlobalDataBuffer[id-1], 37741), {name: "", unit: ""});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.ChargeAndDischargePower",     getI32(GlobalDataBuffer[id-1], 37743), {name: "", unit: "W"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.CurrentDayChargeCapacity",    getU32(GlobalDataBuffer[id-1], 37746) / 100, {name: "", unit: "kWh"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.CurrentDayDischargeCapacity", getU32(GlobalDataBuffer[id-1], 37748) / 100, {name: "", unit: "kWh"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.BusVoltage",                  getU16(GlobalDataBuffer[id-1], 37750) / 10, {name: "", unit: "V"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.BusCurrent",                  getI16(GlobalDataBuffer[id-1], 37751) / 10, {name: "", unit: "A"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.BatteryTemperature",          getI16(GlobalDataBuffer[id-1], 37752) / 10, {name: "", unit: "°C"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.TotalCharge",                 getU32(GlobalDataBuffer[id-1], 37753) / 100, {name: "", unit: "kWh"});
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.TotalDischarge",              getU32(GlobalDataBuffer[id-1], 37755) / 100, {name: "", unit: "kWh"});
                                }
                                // Battery register 32-41 (Storage related)
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.RatedCapacity", getU32(GlobalDataBuffer[id-1], 37758) / 1, {name: "", unit: "Wh"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.SOC", getU16(GlobalDataBuffer[id-1], 37760) / 10, {name: "", unit: "%"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.RunningStatus", getU16(GlobalDataBuffer[id-1], 37762) / 1, {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.BusVoltage", getU16(GlobalDataBuffer[id-1], 37763) / 10, {name: "", unit: "V"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.BusCurrent", getI16(GlobalDataBuffer[id-1], 37764) / 10, {name: "", unit: "A"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.ChargeAndDischargePower", getI32(GlobalDataBuffer[id-1], 37765) / 1, {name: "", unit: "W"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.TotalCharge", getU32(GlobalDataBuffer[id-1], 37780) / 100, {name: "", unit: "kWh"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.TotalDischarge", getU32(GlobalDataBuffer[id-1], 37782) / 100, {name: "", unit: "kWh"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.CurrentDayChargeCapacity", getU32(GlobalDataBuffer[id-1], 37784) / 100, {name: "", unit: "kWh"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Battery.CurrentDayDischargeCapacity", getU32(GlobalDataBuffer[id-1], 37786) / 100, {name: "Current DayDiscarge ", unit: "kWh"});
                            
                                // Battery registers 42+43 (Battery stack related)   
                                if ( BatteryUnits[id-1][1] > 0)
                                {
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.2.SoftwareVersion",    getZeroTerminatedString(GlobalDataBuffer[id-1], 37814, 8), {name: "Softwareversion", unit: ""});
                                }
                                
                                if ( BatteryUnits[id-1][0] > 0)
                                {
                                    forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack.1.SoftwareVersion",    getZeroTerminatedString(GlobalDataBuffer[id-1], 37799, 8), {name: "Softwareversion", unit: ""});
                                }
                            
                                // Registers 44 to 98: (Battery pack related)
                                for(var i = 1; i <= 2; i++)
                                {        
                                    if(BatteryUnits[id-1][i-1] >= 0)
                                    {            
                                        for(var j = 1; j <= BatteryUnits[id-1][i-1]; j++)
                                        {
                                            //[[38200, 38242, 38284] [38326, 38368, 38410]]; (+42 for each battery pack, +126 for each stack)
                                            forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".SN",                getZeroTerminatedString(GlobalDataBuffer[id-1], 38200+(i-1)*126+(j-1)*42, 6), {name: "", unit: ""});
                                            forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".FirmwareVersion",   getZeroTerminatedString(GlobalDataBuffer[id-1], 38210+(i-1)*126+(j-1)*42, 8), {name: "", unit: ""});
                                            forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".WorkingStatus",     getU16(GlobalDataBuffer[id-1], 38228+(i-1)*126+(j-1)*42), {name: "", unit: ""});
                                            forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".BatterySOC",        getU16(GlobalDataBuffer[id-1], 38229+(i-1)*126+(j-1)*42) / 10, {name: "", unit: "%"});
                                            forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".ChargeAndDischargePower", getI32(GlobalDataBuffer[id-1], 38233+(i-1)*126+(j-1)*42) / 1000, {name: "", unit: "kW"});
                                            forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".Voltage",           getU16(GlobalDataBuffer[id-1], 38235+(i-1)*126+(j-1)*42) / 10, {name: "", unit: "V"});
                                            forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".Current",           getI16(GlobalDataBuffer[id-1], 38236+(i-1)*126+(j-1)*42) / 10, {name: "", unit: "A"});
                                            forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".TotalCharge",       getU32(GlobalDataBuffer[id-1], 38238+(i-1)*126+(j-1)*42) / 100, {name: "", unit: "kWh"});
                                            forcesetState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".TotalDischarge",    getU32(GlobalDataBuffer[id-1], 38240+(i-1)*126+(j-1)*42) / 100, {name: "", unit: "kWh"});
                            
                                            // [[38452, 38454, 38456][38458, 38460, 38462]] ( +2 for each pack, +6 for each stack)
                                            createState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".MaxTemperature", getI16(GlobalDataBuffer[id-1], 38452+(i-1)*6+(j-1)*2) / 10, {name: "", unit: "°C"});
                                            createState("Solarpower.Huawei.Inverter." + id + ".Batterystack." + i + ".Battery" + j + ".MinTemperature", getI16(GlobalDataBuffer[id-1], 38453+(i-1)*6+(j-1)*2) / 10, {name: "", unit: "°C"});
                                        }
                                    }        
                                }
                            
                                // Battery registers 110-141 are not supported by this script yet!
                            }
                            
                            
                            function ProcessPowerMeterStatus()
                            //--------------------------------
                            {       
                                forcesetState("Solarpower.Huawei.Meter.Status",                   getU16(GlobalDataBuffer[PowerMeterID], 37100), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Meter.VoltageL1",                getI32(GlobalDataBuffer[PowerMeterID], 37101)  / 10, {name: "", unit: "V"});
                                forcesetState("Solarpower.Huawei.Meter.VoltageL2",                getI32(GlobalDataBuffer[PowerMeterID], 37103)  / 10, {name: "", unit: "V"});
                                forcesetState("Solarpower.Huawei.Meter.VoltageL3",                getI32(GlobalDataBuffer[PowerMeterID], 37105)  / 10, {name: "", unit: "V"});
                                forcesetState("Solarpower.Huawei.Meter.CurrentL1",                getI32(GlobalDataBuffer[PowerMeterID], 37107)  / 100, {name: "", unit: "A"});
                                forcesetState("Solarpower.Huawei.Meter.CurrentL2",                getI32(GlobalDataBuffer[PowerMeterID], 37109)  / 100, {name: "", unit: "A"});
                                forcesetState("Solarpower.Huawei.Meter.CurrentL3",                getI32(GlobalDataBuffer[PowerMeterID], 37111) / 100, {name: "", unit: "A"});
                                forcesetState("Solarpower.Huawei.Meter.ActivePower",              getI32(GlobalDataBuffer[PowerMeterID], 37113) / 1, {name: "", unit: "W"});
                                forcesetState("Solarpower.Huawei.Meter.ReactivePower",            getI32(GlobalDataBuffer[PowerMeterID], 37115) / 1, {name: "", unit: "Var"});
                                forcesetState("Solarpower.Huawei.Meter.PowerFactor",              getI16(GlobalDataBuffer[PowerMeterID], 37117) / 1000, {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Meter.GridFrequency",            getI16(GlobalDataBuffer[PowerMeterID], 37118) / 100, {name: "", unit: "Hz"});
                                forcesetState("Solarpower.Huawei.Meter.PositiveActiveEnergy",     getI32(GlobalDataBuffer[PowerMeterID], 37119) / 100, {name: "", unit: "kWh"});
                                forcesetState("Solarpower.Huawei.Meter.ReverseActiveEnergy",      getI32(GlobalDataBuffer[PowerMeterID], 37121) / 100, {name: "", unit: "kWh"});
                                forcesetState("Solarpower.Huawei.Meter.AccumulatedReactivePower", getI32(GlobalDataBuffer[PowerMeterID], 37123) / 100, {name: "", unit: "kVarh"});
                                //forcesetState("Solarpower.Huawei.Meter.MeterType",                getU16(GlobalDataBuffer[PowerMeterID], 37125), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Meter.VoltageL1-L2",             getI32(GlobalDataBuffer[PowerMeterID], 37126) / 10, {name: "", unit: "V"});
                                forcesetState("Solarpower.Huawei.Meter.VoltageL2-L3",             getI32(GlobalDataBuffer[PowerMeterID], 37128) / 10, {name: "", unit: "V"});
                                forcesetState("Solarpower.Huawei.Meter.VoltageL3-L1",             getI32(GlobalDataBuffer[PowerMeterID], 37130) / 10, {name: "", unit: "V"});
                                forcesetState("Solarpower.Huawei.Meter.ActivePowerL1",            getI32(GlobalDataBuffer[PowerMeterID], 37132) / 1, {name: "", unit: "W"});
                                forcesetState("Solarpower.Huawei.Meter.ActivePowerL2",            getI32(GlobalDataBuffer[PowerMeterID], 37134) / 1, {name: "", unit: "W"});
                                forcesetState("Solarpower.Huawei.Meter.ActivePowerL3",            getI32(GlobalDataBuffer[PowerMeterID], 37136) / 1, {name: "", unit: "W"});
                                //forcesetState("Solarpower.Huawei.Meter.MeterModel",               getU16(GlobalDataBuffer[PowerMeterID], 37138), {name: "", unit: ""});
                            }
                            
                            function ProcessInverterStatus(id)
                            //--------------------------------
                            {
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".State1", getU16(GlobalDataBuffer[id-1], 32000), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".State2", getU16(GlobalDataBuffer[id-1], 32001), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".State3", getU16(GlobalDataBuffer[id-1], 32002), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Alarm1", getU16(GlobalDataBuffer[id-1], 32008), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Alarm2", getU16(GlobalDataBuffer[id-1], 32009), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Alarm3", getU16(GlobalDataBuffer[id-1], 32010), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".String.1_Voltage",       getI16(GlobalDataBuffer[id-1], 32016) / 10  , {name: "", unit: "V"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".String.1_Current",       getI16(GlobalDataBuffer[id-1], 32017) / 100 , {name: "", unit: "A"});
                                //forcesetState("Solarpower.Huawei.Inverter." + id + ".String.2_Voltage",       getI16(GlobalDataBuffer[id-1], 32018) / 10  , {name: "", unit: "V"});
                                //forcesetState("Solarpower.Huawei.Inverter." + id + ".String.2_Current",       getI16(GlobalDataBuffer[id-1], 32019) / 100 , {name: "", unit: "A"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".InputPower",             getI32(GlobalDataBuffer[id-1], 32064) / 1000, {name: "", unit: "kW"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L1-L2_Voltage",           getU16(GlobalDataBuffer[id-1], 32066) / 10  , {name: "", unit: "V"});      
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L2-L3_Voltage",           getU16(GlobalDataBuffer[id-1], 32067) / 10  , {name: "", unit: "V"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L3-L1_Voltage",           getU16(GlobalDataBuffer[id-1], 32068) / 10  , {name: "", unit: "V"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L1_Voltage",            getU16(GlobalDataBuffer[id-1], 32069) / 10  , {name: "", unit: "V"});                              
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L2_Voltage",            getU16(GlobalDataBuffer[id-1], 32070) / 10  , {name: "", unit: "V"});                                                  
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L3_Voltage",            getU16(GlobalDataBuffer[id-1], 32071) / 10  , {name: "", unit: "V"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L1_Current",         getI32(GlobalDataBuffer[id-1], 32072) / 1000, {name: "", unit: "A"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L2_Current",         getI32(GlobalDataBuffer[id-1], 32074) / 1000, {name: "", unit: "A"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Grid.L3_Current",         getI32(GlobalDataBuffer[id-1], 32076) / 1000, {name: "", unit: "A"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".PeakActivePowerDay",     getI32(GlobalDataBuffer[id-1], 32078) / 1000, {name: "", unit: "kW"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".ActivePower",            getI32(GlobalDataBuffer[id-1], 32080) / 1000, {name: "", unit: "kW"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".ReactivePower",          getI32(GlobalDataBuffer[id-1], 32082) / 1000, {name: "", unit: "kVar"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".PowerFactor",            getI16(GlobalDataBuffer[id-1], 32084) / 1000, {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".GridFrequency",          getU16(GlobalDataBuffer[id-1], 32085) / 100 , {name: "", unit: "Hz"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Efficiency",             getU16(GlobalDataBuffer[id-1], 32086) / 100 , {name: "", unit: "%"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".InternalTemperature",    getI16(GlobalDataBuffer[id-1], 32087) / 10  , {name: "", unit: "°C"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".InsulationResistance",   getU16(GlobalDataBuffer[id-1], 32088) / 1000, {name: "", unit: "MOhm"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".DeviceStatus",              getU16(GlobalDataBuffer[id-1], 32089), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".FaultCode",                 getU16(GlobalDataBuffer[id-1], 32090), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".StartupTime",               getU16(GlobalDataBuffer[id-1], 32091), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".ShutdownTime",              getU16(GlobalDataBuffer[id-1], 32093), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".AccumulatedEnergyYield",    getU32(GlobalDataBuffer[id-1], 32106) / 100, {name: "", unit: "kWh"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".DailyEnergyYield",          getU32(GlobalDataBuffer[id-1], 32114) / 100, {name: "", unit: "kWh"});
                            }
                            
                            
                            function ProcessDeviceInfo(id)
                            //----------------------------
                            {      
                                // Note: Manual says its quantitiy is 15, but that is the number (+1) of 8bit characters
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".Model",  getZeroTerminatedString(GlobalDataBuffer[id-1], 30000, 8), {name: "", unit: ""}); 
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".SN",     getZeroTerminatedString(GlobalDataBuffer[id-1], 30015, 6), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".PN",     getZeroTerminatedString(GlobalDataBuffer[id-1], 30025, 6), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".ModelID",           getU16(GlobalDataBuffer[id-1], 30070), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".PVStrings",         getU16(GlobalDataBuffer[id-1], 30071), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".MPPTrackers",       getU16(GlobalDataBuffer[id-1], 30072), {name: "", unit: ""});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".MaxRatedPower",     getU32(GlobalDataBuffer[id-1], 30073) / 1000, {name: "", unit: "kW"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".MaxActivePower",    getU32(GlobalDataBuffer[id-1], 30075) / 1000, {name: "", unit: "kW"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".MaxApparentPower",  getU32(GlobalDataBuffer[id-1], 30077) / 1000, {name: "", unit: "kVA"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".MaxReactivePowerToGrid",        getI32(GlobalDataBuffer[id-1], 30079) / 1000, {name: "", unit: "kVAr"});
                                forcesetState("Solarpower.Huawei.Inverter." + id + ".MaxReactivePowerFromGrid",      getI32(GlobalDataBuffer[id-1], 30081) / 1000, {name: "", unit: "kVAr"});
                            }
                            
                            
                            function readRegisterSpace(id, address, length)
                            //---------------------------------------------
                            {
                                client.setID(ModBusIDs[id-1]);
                                client.readHoldingRegisters(address, length, function(err, data)
                                {   
                                    if (err)
                                    {   console.warn("Error received reading address " + address + " from id: " + ModBusIDs[id-1] + " with error: " + modbusErrorMessages[err.modbusCode]);            
                                    }
                                    else
                                    {   console.debug("Read data from id/address " + ModBusIDs[id-1] + "/" + address + "\nData is: " + data.data);
                                        for (var i = 0; i < length; i++) GlobalDataBuffer[id-1][address+i] = data.data[i];
                                    }
                                });
                            }
                            
                            
                            function ProcessData()
                            //--------------------
                            {
                                console.debug("Processing new data...");   // this was originally .log
                                for ( var i = 1; i <= ModBusIDs.length; i++)
                                {
                                    ProcessDeviceInfo(i);
                                    ProcessInverterStatus(i);
                                    ProcessBattery(i);
                                    //ProcessInverterPowerAdjustments(i);
                                    ProcessOptimizers(i); 
                                }    
                                ProcessPowerMeterStatus();
                            
                                // get SOC of first battery stack and combine to one string
                                var BatOverview = "";
                                for(var j = 1; j <= BatteryUnits[0][0]; j++)
                                { 
                                    if (j > 1) BatOverview += ", ";
                                    BatOverview += getState("javascript.0.Solarpower.Huawei.Inverter.1.Batterystack.1.Battery" + j + ".BatterySOC").val + "%";
                                }
                                setState("javascript.0.Solarpower.Derived.BatteryOverview", BatOverview);
                            
                                // determine peak panel power
                                var PanelPower = getState("javascript.0.Solarpower.Huawei.Inverter.1.InputPower").val;
                                var PanelMax = getState("javascript.0.Solarpower.Derived.PeakPanelPower").val;
                                if (PanelPower > PanelMax) setState("javascript.0.Solarpower.Derived.PeakPanelPower", PanelPower);
                                
                                // determine power used by house
                                setState("javascript.0.Solarpower.Derived.HouseConsumption", getState("javascript.0.Solarpower.Huawei.Inverter.1.ActivePower").val * 1000 -
                                    getState("javascript.0.Solarpower.Huawei.Meter.ActivePower").val);
                            
                                // determine yield today
                                setState("javascript.0.Solarpower.Derived.YieldToday", getState("javascript.0.Solarpower.Huawei.Inverter.1.DailyEnergyYield").val +
                                    getState("javascript.0.Solarpower.Huawei.Inverter.1.Batterystack.1.CurrentDayChargeCapacity").val -
                                    getState("javascript.0.Solarpower.Huawei.Inverter.1.Batterystack.1.CurrentDayDischargeCapacity").val)
                            
                                // determine if battery is loading
                                setState("javascript.0.Solarpower.Derived.IsBatteryLoading", getState("javascript.0.Solarpower.Huawei.Inverter.1.Batterystack.1.ChargeAndDischargePower").val > 0 ? 0 : 1);
                            
                                // determine if power is imported or exported
                                setState("javascript.0.Solarpower.Derived.IsGridExporting", getState("javascript.0.Solarpower.Huawei.Meter.ActivePower").val > 0 ? 1 : 0);
                            
                                // compute export and import today
                                setState("javascript.0.Solarpower.Derived.GridExportToday", getState("javascript.0.Solarpower.Huawei.Meter.PositiveActiveEnergy").val - getState("javascript.0.Solarpower.Derived.GridExportSum").val);
                                setState("javascript.0.Solarpower.Derived.GridImportToday", getState("javascript.0.Solarpower.Huawei.Meter.ReverseActiveEnergy").val - getState("javascript.0.Solarpower.Derived.GridImportSum").val);
                                
                                // compute consumption today
                                setState("javascript.0.Solarpower.Derived.ConsumptionSum",
                                    getState("javascript.0.Solarpower.Huawei.Inverter.1.AccumulatedEnergyYield").val +
                                    getState("javascript.0.Solarpower.Huawei.Meter.ReverseActiveEnergy").val -
                                    getState("javascript.0.Solarpower.Huawei.Meter.PositiveActiveEnergy").val);
                                setState("javascript.0.Solarpower.Derived.ConsumptionToday", 
                                    getState("javascript.0.Solarpower.Derived.ConsumptionSum").val -
                                    getState("javascript.0.Solarpower.Derived.ConsumptionStart").val); 
                            
                                testCreateState = 1;                // do not check on createState any more
                                console.debug("Processing done!");  // this was originally .log
                            }
                            
                            
                            var triggerprocessing = 0; 
                            var currentinverter = 1;
                            
                            setInterval(function()
                            // -------------------
                            // This is the main function triggering a  read via modbus-tcp every 2 seconds - changed to 5 seconds
                            // Processing of data is triggered as soon as one complete set of registers is copied
                            // with 5 seconds, new values are displyed every 50 seconds
                            {
                                if (triggerprocessing == 1)
                                {
                                    triggerprocessing = 0;
                                    ProcessData();
                                }      
                               
                                // this was originally also a .log
                                console.debug("Triggering read of inverter " + currentinverter + " at address " +
                                    RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][0] +
                                    " with length " +  RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][1]);
                                
                                readRegisterSpace(currentinverter, RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][0], RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][1]); 
                                RegisterSpacesToReadContinuouslyPtr++;               
                                if (RegisterSpacesToReadContinuouslyPtr >= RegisterSpacesToReadContinuously.length)
                                {
                                    RegisterSpacesToReadContinuouslyPtr = 0;
                                    currentinverter++
                                    if (currentinverter > ModBusIDs.length)
                                    {
                                        currentinverter = 1;  
                                        triggerprocessing = 1;                    
                                    }
                                }     
                            }, 5000);
                            
                            
                            // one minute before midnight - perform housekeeping actions
                            schedule("59 23 * * *", function ()
                            {   
                                // reset peak power for next day
                                setState("javascript.0.Solarpower.Derived.PeakPanelPower", 0);
                                // copy current export/import kWh - used to compute daily import/export in kWh
                                setState("javascript.0.Solarpower.Derived.GridExportSum", getState("javascript.0.Solarpower.Huawei.Meter.PositiveActiveEnergy").val);
                                setState("javascript.0.Solarpower.Derived.GridImportSum", getState("javascript.0.Solarpower.Huawei.Meter.ReverseActiveEnergy").val);
                                // copy consumption Sum to Start for the next day
                                setState("javascript.0.Solarpower.Derived.ConsumptionStart", getState("javascript.0.Solarpower.Derived.ConsumptionSum").val);
                                // log important iformation to file
                                SolarPowerLogging();
                            });
                            
                            
                            function SolarPowerLogging() 
                            //--------------------------
                            // write values of today in file
                            {
                                // get 
                                var log1 = getState("javascript.0.Solarpower.Derived.YieldToday").val;
                                var log2 = getState("javascript.0.Solarpower.Derived.GridExportToday").val;
                                var log3 = getState("javascript.0.Solarpower.Derived.GridImportToday").val;
                                var log4 = getState("javascript.0.Solarpower.Derived.ConsumptionToday").val;
                            
                                // Zerlege Datum und Zeit in Variable
                                var now =    new Date();
                                var year =   now.getFullYear();
                                var month =  addZero(now.getMonth() + 1);
                                var day =    addZero(now.getDate());
                                var currDate = day + '.' + month + '.' + year;
                                var string = " ";
                            
                                // create string that is appended to the file
                                string = currDate + ";" + log1.toFixed(3) + ";" + log2.toFixed(3) + ";" + log3.toFixed(3) + ";" + log4.toFixed(3) + "\n";
                                fs.appendFileSync("/opt/iobroker/iobroker-data/SolarpowerLog.csv", string);   
                            
                                // erzeuge Log-Eintrag
                                log("Solerpower log:" + string, "info"); 
                            }
                            
                            function addZero(Num)
                            //-----------------
                            // if number <10 add zero values at the beginning of numbers
                            {
                                if (Num < 10) Num = "0" + Num;
                                return Num;
                            }
                            
                            
                            R Offline
                            R Offline
                            R4
                            schrieb am zuletzt editiert von
                            #173

                            @chris_b
                            Für das Schreiben der Log-Datei würde ich noch vorschlagen, die Nachkommastellen-Punkte in Kommata umzuwandeln, also so in der Art:

                            string = currDate + ";" + log1.toFixed(2).replace('.',',') + ";" + log2.toFixed(2).replace('.',',') ...
                            

                            Ansonsten habe ich die Register nach "Wichtigkeit" sortiert

                            // These register spaces need to be read:
                            const RegisterSpacesToReadContinuously = [[32000, 116], // Inverter.ActivePower: 32080, Inverter.InputPower: 32064
                                                                      [37100, 114], // Meter.ActivePower: 37113
                                                                      [37700, 100], // Inverter.Battery.SOC: 37760, Inverter.Battery.ChargeAndDischargePower: 37765
                                                                      [47075, 10],  // MaximumChargingPower,...
                                                                      [37000, 68],  // Batterystack,...
                                                                      [37800, 100], // Batterystack
                                                                      [38200, 100], // Batterystack
                                                                      [38300, 100], // Batterystack
                                                                      [38400, 100], // Batterystack
                                                                      [30000, 81]   // --> ProcessDeviceInfo()
                            //                                          [35300, 40] // Inverter.ActiveAdjustement.* 
                                                                      ];
                            

                            und lasse nur die ersten 4 regelmäßig auslesen und nur alle 50 Runden mal (~ jede Viertel Stunde) alle zusammen. Weil ich nur eine Batterie habe ergibt das bei mir also alle 16s frische Daten (immerhin...).

                            C M 2 Antworten Letzte Antwort
                            0
                            • R R4

                              @chris_b
                              Für das Schreiben der Log-Datei würde ich noch vorschlagen, die Nachkommastellen-Punkte in Kommata umzuwandeln, also so in der Art:

                              string = currDate + ";" + log1.toFixed(2).replace('.',',') + ";" + log2.toFixed(2).replace('.',',') ...
                              

                              Ansonsten habe ich die Register nach "Wichtigkeit" sortiert

                              // These register spaces need to be read:
                              const RegisterSpacesToReadContinuously = [[32000, 116], // Inverter.ActivePower: 32080, Inverter.InputPower: 32064
                                                                        [37100, 114], // Meter.ActivePower: 37113
                                                                        [37700, 100], // Inverter.Battery.SOC: 37760, Inverter.Battery.ChargeAndDischargePower: 37765
                                                                        [47075, 10],  // MaximumChargingPower,...
                                                                        [37000, 68],  // Batterystack,...
                                                                        [37800, 100], // Batterystack
                                                                        [38200, 100], // Batterystack
                                                                        [38300, 100], // Batterystack
                                                                        [38400, 100], // Batterystack
                                                                        [30000, 81]   // --> ProcessDeviceInfo()
                              //                                          [35300, 40] // Inverter.ActiveAdjustement.* 
                                                                        ];
                              

                              und lasse nur die ersten 4 regelmäßig auslesen und nur alle 50 Runden mal (~ jede Viertel Stunde) alle zusammen. Weil ich nur eine Batterie habe ergibt das bei mir also alle 16s frische Daten (immerhin...).

                              C Offline
                              C Offline
                              Chris_B
                              schrieb am zuletzt editiert von
                              #174

                              @r4
                              Interessanter Input!
                              Zu 1: Es gibt da die kleinen, subtilen Unterschiede zwischen Deutschland und der Schweiz... :blush: Und wir hier in der Schweiz verwenden tatsächlich einen Punkt für die Nachkommastellen von Zahlen (das weiss bspw. auch Excel und Windows im Allgemeinen). In diesem Sinn wäre diese Änderung für mich falsch. Nach meiner Meinung sollte das durch die Ländereinstellungen im iobroker gelöst sein..
                              Zu 2) Das wollte ich auch noch in Angriff nehmen. Guter Lösungsvorschlag; verringert die Kommunikation auf ein 'sinnvolles' Mass. Werde ich auch umsetzen.
                              Danke für den Input
                              Christian

                              1 Antwort Letzte Antwort
                              0
                              • R Offline
                                R Offline
                                R4
                                schrieb am zuletzt editiert von R4
                                #175

                                @chris_b sagte in Huawei Sun2000 & ioBroker via JS script funktioniert:

                                @r4
                                Interessanter Input!
                                Zu 1: ... Nach meiner Meinung sollte das durch die Ländereinstellungen im iobroker gelöst sein..

                                Muss ich mir mal anschauen (bin neu in diesem Thema).
                                (Hab eh noch Probleme mit der Uhrzeit / Zeitzone... da wird meist die richtige angezeigt, z.B. in der Console, aber ich muss schedule("59 21 * * *") angeben um 23:59 Uhr zu triggern :man-shrugging: )

                                Im Übrigen... so funktioniert es besser:

                                string = log1.toFixed(2) + ";" + log2.toFixed(2) + ";" + log3.toFixed(2) + ...
                                string = currDate + ";" + string.replaceAll(".",",");
                                
                                1 Antwort Letzte Antwort
                                0
                                • R R4

                                  @chris_b
                                  Für das Schreiben der Log-Datei würde ich noch vorschlagen, die Nachkommastellen-Punkte in Kommata umzuwandeln, also so in der Art:

                                  string = currDate + ";" + log1.toFixed(2).replace('.',',') + ";" + log2.toFixed(2).replace('.',',') ...
                                  

                                  Ansonsten habe ich die Register nach "Wichtigkeit" sortiert

                                  // These register spaces need to be read:
                                  const RegisterSpacesToReadContinuously = [[32000, 116], // Inverter.ActivePower: 32080, Inverter.InputPower: 32064
                                                                            [37100, 114], // Meter.ActivePower: 37113
                                                                            [37700, 100], // Inverter.Battery.SOC: 37760, Inverter.Battery.ChargeAndDischargePower: 37765
                                                                            [47075, 10],  // MaximumChargingPower,...
                                                                            [37000, 68],  // Batterystack,...
                                                                            [37800, 100], // Batterystack
                                                                            [38200, 100], // Batterystack
                                                                            [38300, 100], // Batterystack
                                                                            [38400, 100], // Batterystack
                                                                            [30000, 81]   // --> ProcessDeviceInfo()
                                  //                                          [35300, 40] // Inverter.ActiveAdjustement.* 
                                                                            ];
                                  

                                  und lasse nur die ersten 4 regelmäßig auslesen und nur alle 50 Runden mal (~ jede Viertel Stunde) alle zusammen. Weil ich nur eine Batterie habe ergibt das bei mir also alle 16s frische Daten (immerhin...).

                                  M Offline
                                  M Offline
                                  MrLee
                                  schrieb am zuletzt editiert von
                                  #176

                                  @r4

                                  Moin!

                                  Das klingt interressant (wichtige Daten öfter)...

                                  Magst Du mal Deinen Code für die Abfrage posten? Oder Dein gesamtes Script?

                                  Danke Dir!
                                  Mr.Lee

                                  R 1 Antwort Letzte Antwort
                                  0
                                  • M MrLee

                                    @r4

                                    Moin!

                                    Das klingt interressant (wichtige Daten öfter)...

                                    Magst Du mal Deinen Code für die Abfrage posten? Oder Dein gesamtes Script?

                                    Danke Dir!
                                    Mr.Lee

                                    R Offline
                                    R Offline
                                    R4
                                    schrieb am zuletzt editiert von R4
                                    #177

                                    @mrlee

                                    hab das Script inzwischen ganz schön umgebaut.
                                    Zum Thema Priorisierung ist das hier wesentlich:

                                    // These register spaces need to be read:
                                    const RegisterSpacesToReadContinuously = [[32000, 116], // read often: Inverter.ActivePower: 32080, Inverter.InputPower: 32064
                                                                              [37100, 114], // read often: Meter.ActivePower: 37113
                                                                              [37700, 100], // read often: Inverter.Battery.SOC: 37760, Inverter.Battery.ChargeAndDischargePower: 37765
                                                                              [47075, 10],  // read often: MaximumChargingPower,...
                                                                              [37000, 68],  // Batterystack,... --> read rarely
                                                                              [37800, 100], // Batterystack --> read rarely
                                                                              [38200, 100], // Batterystack --> read rarely
                                                                              [38300, 100], // Batterystack --> read rarely
                                                                              [38400, 100], // Batterystack --> read rarely
                                                                              [30000, 81]   // ProcessDeviceInfo() --> read rarely
                                    //                                          [35300, 40] // Inverter.ActiveAdjustement.* --> no use
                                                                              ]; 
                                                                              
                                    var RegisterSpacesToReadContinuouslyPtr = 0;
                                    const RegisterSpacesToReadPrioLoops = 56; // number of fast read cycles before full read cycle (~ every 15 mins at 4s cycle time)
                                    const RegisterSpacesToReadFast = 4; // number of registers to be read fast
                                    var RegisterSpacesToReadPrioLoopCount = 0;
                                    

                                    Dazu kommen noch für meine Schreibarbeiten ins Register 47075 (mehr brauche ich derzeit nicht):

                                    var triggerWriteProcessing = false; // write instead of read a register
                                    var batteryChargePower = 0; // value to be written into register 47075
                                    

                                    Die werden im Ablauf gesetzt durch on() oder durch zeitliche Ereignisse...

                                    Dann die Intervall-Funktion:

                                    setInterval(function()
                                    // -------------------
                                    // This is the main function triggering a read or a write via modbus-tcp every xx seconds (see value below in ms)
                                    // Processing of data is triggered as soon as one complete set of registers is copied
                                    // with 4 seconds, new values are displyed every 16/40 seconds
                                    {
                                        var RegisterSpacesToReadContinuouslyLength;
                                    
                                        if (triggerprocessing == 1)
                                        {
                                            ProcessData();
                                            triggerprocessing = 0;        
                                        }      
                                        
                                        if (triggerWriteProcessing == false) // read register (either read or write in one interval)
                                        {
                                            console.debug("Triggering read of inverter at address " +
                                                RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][0] +
                                                " with length " +  RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][1]);
                                    
                                            readRegisterSpace(RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][0], RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][1]); 
                                            RegisterSpacesToReadContinuouslyPtr++;               
                                            if (RegisterSpacesToReadPrioLoopCount == 0) RegisterSpacesToReadContinuouslyLength = RegisterSpacesToReadContinuously.length;
                                                else RegisterSpacesToReadContinuouslyLength = RegisterSpacesToReadFast; // number of registers to be read
                                            if (RegisterSpacesToReadContinuouslyPtr >= RegisterSpacesToReadContinuouslyLength)
                                            {
                                                RegisterSpacesToReadContinuouslyPtr = 0;
                                                RegisterSpacesToReadPrioLoopCount++;
                                                if (RegisterSpacesToReadPrioLoopCount >= RegisterSpacesToReadPrioLoops) RegisterSpacesToReadPrioLoopCount = 0;
                                                triggerprocessing = 1; // everything was read, now set the datapoints
                                            }
                                        }
                                        else // triggerWriteProcessing == true --> write register
                                        {
                                            client.writeRegisters(47075, [0, batteryChargePower]); // write the value 0, xxx to registers starting at address 47075
                                            triggerWriteProcessing = false;
                                        }
                                    }, 4000);
                                    

                                    Hinweis - statt

                                    // get SOC of first battery stack and combine to one string
                                        var BatOverview = "";
                                        for(var j = 1; j <= BatteryUnits[0][0]; j++)
                                        { 
                                            if (j > 1) BatOverview += ", ";
                                            BatOverview += getState("javascript.0.Solarpower.Huawei.Inverter.1.Batterystack.1.Battery" + j + ".BatterySOC").val + "%";
                                        }
                                        setState("javascript.0.Solarpower.Derived.BatteryOverview", BatOverview);
                                    

                                    hab ich, weil nur 5kWh Batterie:

                                    // get SOC of all batteries and combine to one string (only one battery here...)
                                        var BatOverview = getState("javascript.0.Solarpower.Huawei.Inverter.Battery.SOC").val; 
                                        setState("javascript.0.Solarpower.Derived.BatteryOverview", BatOverview);
                                    

                                    das spart Registerbereiche - Inverter.1.Batterystack.1.Battery.* wird bei mir ja nur noch alle 15 Minuten aktualisiert. Selbiges für YieldToday, IsBatteryLoading.
                                    (und ja, den DP Derived.BatteryOverview könnte ich mir sparen indem ich gleich Inverter.Battery.SOC verwende...)
                                    BatOverview und der DP Derived.BatteryOverview sind bei mir auch kein String, sondern 'ne Zahl, weil ich damit weiterrechne.

                                    R 1 Antwort Letzte Antwort
                                    1
                                    • R R4

                                      @mrlee

                                      hab das Script inzwischen ganz schön umgebaut.
                                      Zum Thema Priorisierung ist das hier wesentlich:

                                      // These register spaces need to be read:
                                      const RegisterSpacesToReadContinuously = [[32000, 116], // read often: Inverter.ActivePower: 32080, Inverter.InputPower: 32064
                                                                                [37100, 114], // read often: Meter.ActivePower: 37113
                                                                                [37700, 100], // read often: Inverter.Battery.SOC: 37760, Inverter.Battery.ChargeAndDischargePower: 37765
                                                                                [47075, 10],  // read often: MaximumChargingPower,...
                                                                                [37000, 68],  // Batterystack,... --> read rarely
                                                                                [37800, 100], // Batterystack --> read rarely
                                                                                [38200, 100], // Batterystack --> read rarely
                                                                                [38300, 100], // Batterystack --> read rarely
                                                                                [38400, 100], // Batterystack --> read rarely
                                                                                [30000, 81]   // ProcessDeviceInfo() --> read rarely
                                      //                                          [35300, 40] // Inverter.ActiveAdjustement.* --> no use
                                                                                ]; 
                                                                                
                                      var RegisterSpacesToReadContinuouslyPtr = 0;
                                      const RegisterSpacesToReadPrioLoops = 56; // number of fast read cycles before full read cycle (~ every 15 mins at 4s cycle time)
                                      const RegisterSpacesToReadFast = 4; // number of registers to be read fast
                                      var RegisterSpacesToReadPrioLoopCount = 0;
                                      

                                      Dazu kommen noch für meine Schreibarbeiten ins Register 47075 (mehr brauche ich derzeit nicht):

                                      var triggerWriteProcessing = false; // write instead of read a register
                                      var batteryChargePower = 0; // value to be written into register 47075
                                      

                                      Die werden im Ablauf gesetzt durch on() oder durch zeitliche Ereignisse...

                                      Dann die Intervall-Funktion:

                                      setInterval(function()
                                      // -------------------
                                      // This is the main function triggering a read or a write via modbus-tcp every xx seconds (see value below in ms)
                                      // Processing of data is triggered as soon as one complete set of registers is copied
                                      // with 4 seconds, new values are displyed every 16/40 seconds
                                      {
                                          var RegisterSpacesToReadContinuouslyLength;
                                      
                                          if (triggerprocessing == 1)
                                          {
                                              ProcessData();
                                              triggerprocessing = 0;        
                                          }      
                                          
                                          if (triggerWriteProcessing == false) // read register (either read or write in one interval)
                                          {
                                              console.debug("Triggering read of inverter at address " +
                                                  RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][0] +
                                                  " with length " +  RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][1]);
                                      
                                              readRegisterSpace(RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][0], RegisterSpacesToReadContinuously[RegisterSpacesToReadContinuouslyPtr][1]); 
                                              RegisterSpacesToReadContinuouslyPtr++;               
                                              if (RegisterSpacesToReadPrioLoopCount == 0) RegisterSpacesToReadContinuouslyLength = RegisterSpacesToReadContinuously.length;
                                                  else RegisterSpacesToReadContinuouslyLength = RegisterSpacesToReadFast; // number of registers to be read
                                              if (RegisterSpacesToReadContinuouslyPtr >= RegisterSpacesToReadContinuouslyLength)
                                              {
                                                  RegisterSpacesToReadContinuouslyPtr = 0;
                                                  RegisterSpacesToReadPrioLoopCount++;
                                                  if (RegisterSpacesToReadPrioLoopCount >= RegisterSpacesToReadPrioLoops) RegisterSpacesToReadPrioLoopCount = 0;
                                                  triggerprocessing = 1; // everything was read, now set the datapoints
                                              }
                                          }
                                          else // triggerWriteProcessing == true --> write register
                                          {
                                              client.writeRegisters(47075, [0, batteryChargePower]); // write the value 0, xxx to registers starting at address 47075
                                              triggerWriteProcessing = false;
                                          }
                                      }, 4000);
                                      

                                      Hinweis - statt

                                      // get SOC of first battery stack and combine to one string
                                          var BatOverview = "";
                                          for(var j = 1; j <= BatteryUnits[0][0]; j++)
                                          { 
                                              if (j > 1) BatOverview += ", ";
                                              BatOverview += getState("javascript.0.Solarpower.Huawei.Inverter.1.Batterystack.1.Battery" + j + ".BatterySOC").val + "%";
                                          }
                                          setState("javascript.0.Solarpower.Derived.BatteryOverview", BatOverview);
                                      

                                      hab ich, weil nur 5kWh Batterie:

                                      // get SOC of all batteries and combine to one string (only one battery here...)
                                          var BatOverview = getState("javascript.0.Solarpower.Huawei.Inverter.Battery.SOC").val; 
                                          setState("javascript.0.Solarpower.Derived.BatteryOverview", BatOverview);
                                      

                                      das spart Registerbereiche - Inverter.1.Batterystack.1.Battery.* wird bei mir ja nur noch alle 15 Minuten aktualisiert. Selbiges für YieldToday, IsBatteryLoading.
                                      (und ja, den DP Derived.BatteryOverview könnte ich mir sparen indem ich gleich Inverter.Battery.SOC verwende...)
                                      BatOverview und der DP Derived.BatteryOverview sind bei mir auch kein String, sondern 'ne Zahl, weil ich damit weiterrechne.

                                      R Offline
                                      R Offline
                                      road_runner31
                                      schrieb am zuletzt editiert von
                                      #178

                                      @r4 Hallo, da ich immer nur sporadisch hier rein schaue.. wo kann ich das von Dir umgebaute Script finden? Ich würde es doch gern mal wieder mit meiner Anlage probieren.. mit einer älteren Version des Scripts gab es bei mir zu viele Probleme bzw. Fehlermeldungen und komische Daten.
                                      DANKE!!
                                      Viele Grüße!!

                                      R 1 Antwort Letzte Antwort
                                      0
                                      • R road_runner31

                                        @r4 Hallo, da ich immer nur sporadisch hier rein schaue.. wo kann ich das von Dir umgebaute Script finden? Ich würde es doch gern mal wieder mit meiner Anlage probieren.. mit einer älteren Version des Scripts gab es bei mir zu viele Probleme bzw. Fehlermeldungen und komische Daten.
                                        DANKE!!
                                        Viele Grüße!!

                                        R Offline
                                        R Offline
                                        R4
                                        schrieb am zuletzt editiert von
                                        #179

                                        @road_runner31
                                        Sorry, da ich aus dem Script von chris_b zu viel Allgemeines rausgeworfen habe (ich werde z.B. absehbar nie einen zweiten WR oder mehrere Luna haben und habe auch keine Optimierer) kann ich dir auf diese Weise eher nicht weiterhelfen. Das "Originalscript" funktioniert doch ganz gut, da musst du praktisch nichts anpassen?!
                                        Meine Erweiterungen müsstest du schon selbst einfügen, gewisse Programmier-Kenntnisse sind da sicher hilfreich...

                                        R 2 Antworten Letzte Antwort
                                        0
                                        • R R4

                                          @road_runner31
                                          Sorry, da ich aus dem Script von chris_b zu viel Allgemeines rausgeworfen habe (ich werde z.B. absehbar nie einen zweiten WR oder mehrere Luna haben und habe auch keine Optimierer) kann ich dir auf diese Weise eher nicht weiterhelfen. Das "Originalscript" funktioniert doch ganz gut, da musst du praktisch nichts anpassen?!
                                          Meine Erweiterungen müsstest du schon selbst einfügen, gewisse Programmier-Kenntnisse sind da sicher hilfreich...

                                          R Offline
                                          R Offline
                                          road_runner31
                                          schrieb am zuletzt editiert von
                                          #180

                                          @r4 Naja, mein Problem ist, dass auch das Originalscript (mit den notwendigen Anpassungen, also IP-Adresse, Anzahl Batterien) bei mir Fehler produziert.

                                          javascript.0
                                          	2023-07-08 19:10:33.215	warn	script.js.huawei.modbus_get: Error received reading address 32000 from id: 1 with error: undefined
                                          javascript.0
                                          	2023-07-08 19:10:13.214	warn	script.js.huawei.modbus_get: Error received reading address 37100 from id: 1 with error: undefined
                                          javascript.0
                                          	2023-07-08 19:09:53.226	warn	script.js.huawei.modbus_get: Error received reading address 30000 from id: 1 with error: undefined
                                          javascript.0
                                          	2023-07-08 19:09:53.226	info	script.js.huawei.modbus_get: getState(id=javascript.0.Solarpower.Derived.ConsumptionStart, timerId=undefined) => {"val":0,"ack":true,"ts":1688834773251,"q":0,"c":"script.js.huawei.modbus_get","from":"system.adapter.javascript.0","user":"system.user.admin","lc":1688834773251}
                                          javascript.0
                                          	2023-07-08 19:09:53.226	info	script.js.huawei.modbus_get: setForeignState(id=javascript.0.Solarpower.Derived.ConsumptionSum, state={"val":null,"ack":false,"ts":1688836193226,"q":0,"from":"system.adapter.javascript.0","lc":1688836193226,"c":"script.js.huawei.modbus_get"})
                                          javascript.0
                                          	2023-07-08 19:09:53.226	info	script.js.huawei.modbus_get: getState(id=javascript.0.Solarpower.Huawei.Meter.ReverseActiveEnergy, timerId=undefined) => {"val":0,"ack":false,"ts":1688835993211,"q":0,"c":"script.js.huawei.modbus_get","from":"system.adapter.javascript.0","user":"system.user.admin","lc":1688834993396}
                                          javascript.0
                                          	2023-07-08 19:09:53.226	info	script.js.huawei.modbus_get: setForeignState(id=javascript.0.Solarpower.Derived.GridImportToday, state={"val":0,"ack":false,"ts":1688836193226,"q":0,"from":"system.adapter.javascript.0","lc":1688834773249,"c":"script.js.huawei.modbus_get"})
                                          javascript.0
                                          	2023-07-08 19:09:53.226	info	script.js.huawei.modbus_get: getState(id=javascript.0.Solarpower.Huawei.Meter.ReverseActiveEnergy, timerId=undefined) => {"val":0,"ack":false,"ts":1688835993211,"q":0,"c":"script.js.huawei.modbus_get","from":"system.adapter.javascript.0","user":"system.user.admin","lc":1688834993396}
                                          javascript.0
                                          	2023-07-08 19:09:53.226	info	script.js.huawei.modbus_get: getState(id=javascript.0.Solarpower.Derived.GridExportSum, timerId=undefined) => {"val":0,"ack":true,"ts":1688834773247,"q":0,"c":"script.js.huawei.modbus_get","from":"system.adapter.javascript.0","user":"system.user.admin","lc":1688834773247}
                                          javascript.0
                                          	2023-07-08 19:09:53.226	info	script.js.huawei.modbus_get: setForeignState(id=javascript.0.Solarpower.Derived.IsGridExporting, state={"val":0,"ack":false,"ts":1688836193226,"q":0,"from":"system.adapter.javascript.0","lc":1688834773245,"c":"script.js.huawei.modbus_get"})
                                          javascript.0
                                          	2023-07-08 19:09:53.225	info	script.js.huawei.modbus_get: getState(id=javascript.0.Solarpower.Huawei.Meter.ActivePower, timerId=undefined) => {"val":0,"ack":false,"ts":1688835993211,"q":0,"c":"script.js.huawei.modbus_get","from":"system.adapter.javascript.0","user":"system.user.admin","lc":1688834993395}
                                          javascript.0
                                          

                                          Der Wechselrichter ist per Ping erreichbar, auch der Port stimmt. Die Objekte werden im iobroker auch erzeugt, steht allerdings überall 0 drin. :(

                                          1 Antwort Letzte Antwort
                                          0
                                          Antworten
                                          • In einem neuen Thema antworten
                                          Anmelden zum Antworten
                                          • Älteste zuerst
                                          • Neuste zuerst
                                          • Meiste Stimmen


                                          Support us

                                          ioBroker
                                          Community Adapters
                                          Donate
                                          FAQ Cloud / IOT
                                          HowTo: Node.js-Update
                                          HowTo: Backup/Restore
                                          Downloads
                                          BLOG

                                          556

                                          Online

                                          32.4k

                                          Benutzer

                                          81.4k

                                          Themen

                                          1.3m

                                          Beiträge
                                          Community
                                          Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen | Einwilligungseinstellungen
                                          ioBroker Community 2014-2025
                                          logo
                                          • Anmelden

                                          • Du hast noch kein Konto? Registrieren

                                          • Anmelden oder registrieren, um zu suchen
                                          • Erster Beitrag
                                            Letzter Beitrag
                                          0
                                          • Home
                                          • Aktuell
                                          • Tags
                                          • Ungelesen 0
                                          • Kategorien
                                          • Unreplied
                                          • Beliebt
                                          • GitHub
                                          • Docu
                                          • Hilfe