Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. Skripten / Logik
    4. JavaScript
    5. Skriptlogik mit internen Variablen aufbauen, oder getState?

    NEWS

    • Neuer Blog: Fotos und Eindrücke aus Solingen

    • ioBroker@Smart Living Forum Solingen, 14.06. - Agenda added

    • ioBroker goes Matter ... Matter Adapter in Stable

    Skriptlogik mit internen Variablen aufbauen, oder getState?

    This topic has been deleted. Only users with topic management privileges can see it.
    • BananaJoe
      BananaJoe Most Active @Ben1983 last edited by

      @ben1983 Ich mache ja beides. Im Skript arbeite ich - eigentlich - nur mit Variablen, schreibe aber das notwendigste in States damit das Skript bei einem JavaScript-Neustart sinnvoll weitermachen kann.

      1 Reply Last reply Reply Quote 2
      • M
        MiniBlister last edited by MiniBlister

        wow, vielen Dank für den Post. Dies ist auch für mich derzeit ein sehr aktulles Thema und ich versuche zu verstehen, wie ich mein Skript optimal gestallte.
        Folgende Situation: Ich versuche über ein Skript die Power Flows im Haus abzubilden und reagiere auf Änderung des Stroms in den SmartMetern (das sind bei mir 4 Stück) zu reagieren und dann zu berechnen, welche Energie in welchem Zeig gebraucht wurde. Das sind sehr viele States und vor allem sehr viele Änderungen auf die ich reagieren muss.
        Bis dato habe ich das über on() und getState gemacht. Was ich mir nun überlegt hatte ist folgendes:

        const objStrom = [
            {id: 'idGen24E', uid: `${upath}.E_PV_Gen24_Total_Production`, type: 'energy', name: 'Gesamte Energie produziert vom GEN24', value: 0, did: 'idGen24E_D', tid: 'idPVToE'},
            {id: 'idGen24E_D', uid: `${upath}.E_PV_Gen24_Total_Daily_Production`, type: 'energy', name: 'Tägliche Energie produziert vom GEN24', value: 0, did: '', tid: ''},
            {id: 'idSymoE', uid: `${upath}.E_PV_Symo_Total_Production`, type: 'energy', name: 'Gesamte Energie produziert vom Symo', value: 0, did: 'idSymoE_D', tid: 'idPVToE'},
            {id: 'idSymoE_D', uid: `${upath}.E_PV_Symo_Total_Daily_Production`, type: 'energy', name: 'Tägliche Energie produziert vom Symo', value: 0, did: '', tid: ''},
            {id: 'idHoyE', uid: `${upath}.E_PV_Hoy_Total_Production`, type: 'energy', name: 'Gesamte Energie produziert vom Hoymiles', value: 0, did: 'idHoyE_D', tid: 'idPVToE'},
            {id: 'idHoyE_D', uid: `${upath}.E_PV_Hoy_Total_Daily_Production`, type: 'energy', name: 'Tägliche Energie produziert vom Hoymiles', value: 0, did: '', tid: ''},
            {id: 'idPVToE', uid: `${upath}.E_PV_Total_Production`, type: 'energy', name: 'Total Energy produziert von der PV Anlage', value: 0, did: 'idPVToE_D', tid: ''},
            {id: 'idPVToE_D', uid: `${upath}.E_PV_Total_Daily_Production`, type: 'energy', name: 'Tägliche Energy produziert von der PV Anlage', value: 0, did: '', tid: ''},
            {id: 'idAkkuCE', uid: `${upath}.E_Akku_Total_Charged`, type: 'energy', name: 'Gesamte Energie in den Speicher geladen', value: 0, did: 'idAkkuCE_D', tid: ''},
            {id: 'idAkkuCE_D', uid: `${upath}.E_Akku_Total_Daily_Charged`, type: 'energy', name: 'Tägliche Energie in den Speicher geladen', value: 0, did: '', tid: ''},
            {id: 'idAkkuDE', uid: `${upath}.E_Akku_Total_DisCharged`, type: 'energy', name: 'Gesamte Energie aus dem Speicher entladen', value: 0, did: 'idAkkuDE_D', tid: ''},
            {id: 'idAkkuDE_D', uid: `${upath}.E_Akku_Total_Daily_DisCharged`, type: 'energy', name: 'Tägliche Energie aus dem Speicher entladen', value: 0, did: '', tid: ''},
            {id: 'idEMeterFeedP', uid: `${upath}.P_Feed`, type: 'power', name: 'E-Meter: Leistung ins Netz', value: 0, did: '', tid: ''},
            {id: 'idEMeterConP', uid: `${upath}.P_Consumption`, type: 'power', name: 'E-Meter: Leistung aus dem Netz', value: 0, did: '', tid: ''},
            {id: 'idGridConE', uid: `${upath}.E_Grid_Total_Consumed`, type: 'energy', name: 'Gesamte Energie Bezug vom Netz', value: 0, did: 'idGridConE_D', tid: ''},
            {id: 'idGridConE_D', uid: `${upath}.E_Grid_Total_Daily_Consumed`, type: 'energy', name: 'Tägliche Energie Bezug vom Netz', value: 0, did: '', tid: ''},
            {id: 'idGridFeeE', uid: `${upath}.E_Grid_Total_Feed`, type: 'energy', name: 'Gesamte Energie Einspeisung ins Netz', value: 0, did: 'idGridFeeE_D', tid: ''},
            {id: 'idGridFeeE_D', uid: `${upath}.E_Grid_Total_Daily_Feed`, type: 'energy', name: 'Tägliche Energie Einspeisung ins Netz', value: 0, did: '', tid: ''},
            {id: 'idPVDirectE', uid: `${upath}.E_PV_Total_Direct_Consumed`, type: 'energy', name: 'Gesamte Energie direkt verbraucht', value: 0, did: 'idPVDirectE_D', tid: ''},
            {id: 'idPVDirectE_D', uid: `${upath}.E_PV_Total_Daily_Direct_Consumed`, type: 'energy', name: 'Tägliche Energie direkt verbraucht', value: 0, did: '', tid: ''},
            {id: 'idHomeE', uid: `${upath}.E_Home_Total_Consumed`, type: 'energy', name: 'Gesamte Energie verbraucht vom Haus', value: 0, did: 'idHomeE_D', tid: ''},
            {id: 'idHomeE_D', uid: `${upath}.E_Home_Total_Daily_Consumed`, type: 'energy', name: 'Tägliche Energie verbraucht vom Haus', value: 0, did: '', tid: ''},
            {id: 'idWBTotal', uid: `${upath}.E_WB_Total_Consumed`, type: 'energy', name: 'Gesamte Energie verbraucht von der Wallbox', value: 0, did: 'idWBTotal_D', tid: ''},
            {id: 'idWBTotal_D', uid: `${upath}.E_WB_Total_Daily_Consumed`, type: 'energy', name: 'Tägliche Energie verbraucht von der Wallbox', value: 0, did: '', tid: ''},
            {id: 'idWBPVE', uid: `${upath}.E_WB_Total_PV`, type: 'energy', name: 'Gesamte Energie direkt verbraucht von der Wallbox', value: 0, did: 'idWBPVE_D', tid: ''},
            {id: 'idWBPVE_D', uid: `${upath}.E_WB_Total_Daily_PV`, type: 'energy', name: 'Tägliche Energie direkt verbraucht von der Wallbox', value: 0, did: '', tid: ''},
            {id: 'idWBGridE', uid: `${upath}.E_WB_Total_Grid`, type: 'energy', name: 'Gesamte Energie vom Netz Bezug für die Wallbox', value: 0, did: 'idWBGridE_D', tid: ''},
            {id: 'idWBGridE_D', uid: `${upath}.E_WB_Total_Daily_Grid`, type: 'energy', name: 'Tägliche Energie vom Netz Bezug für die Wallbox', value: 0, did: '', tid: ''},
            {id: 'idHeatPVE', uid: `${upath}.E_HP_Total_PV`, type: 'energy', name: 'Gesamte Energie direkt verbraucht von der Wärmepumpe', value: 0, did: 'idHeatPVE_D', tid: ''},
            {id: 'idHeatPVE_D', uid: `${upath}.E_HP_Total_Daily_PV`, type: 'energy', name: 'Tägliche Energie direkt verbraucht von der Wärmepumpe', value: 0, did: '', tid: ''},
            {id: 'idHeatGridE', uid: `${upath}.E_HP_Total_Grid`, type: 'energy', name: 'Gesamte Energie vom Netz Bezug für die Wärmepumpe', value: 0, did: 'idHeatGridE_D', tid: ''},
            {id: 'idHeatGridE_D', uid: `${upath}.E_HP_Total_Daily_Grid`, type: 'energy', name: 'Tägliche Energie vom Netz Bezug für die Wärmepumpe', value: 0, did: '', tid: ''},
            {id: 'idHeatTotalE', uid: `${upath}.E_HP_Total`, type: 'energy', name: 'Gesamte Energie für die Wärmepumpe', value: 0, did: 'idHeatTotalE_D', tid: ''},
            {id: 'idHeatTotalE_D', uid: `${upath}.E_HP_Total_Daily`, type: 'energy', name: 'Tägliche Energie für die Wärmepumpe', value: 0, did: '', tid: ''},
        
            {id: 'idPVToP', uid: `${upath}.P_PV_Total_Production`, type: 'power', name: 'Gesamte Leistung von der PV Anlage', value: 0, did: '', tid: ''},
            {id: 'idAkkuCP', uid: `${upath}.P_Akku_Total_Charged`, type: 'power', name: 'Leistung mit welcher der Speicher geladen wird', value: 0, did: '', tid: ''},
            {id: 'idAkkuDP', uid: `${upath}.P_Akku_Total_DisCharged`, type: 'power', name: 'Leistung mit welcher der Speicher entgeladen wird', value: 0, did: '', tid: ''},
            {id: 'idAkkuDP', uid: `${upath}.P_HP_Total`, type: 'power', name: 'Wärmepumpe Leistung', value: 0, did: '', tid: ''},
        
            // test
            {id: 'idPVToE2', uid: `${upath}.E_PV_Total_PV_Production`, type: 'energy', name: 'Total Energy produziert von der PV Anlage über E_Total Werte', value: 0, did: 'idPVToE2_D', tid: ''},
            {id: 'idPVToE2_D', uid: `${upath}.E_PV_Total_Daily_PV_Production`, type: 'energy', name: 'Tägliche Energy produziert von der PV Anlage über E_Total Werte', value: 0, did: '', tid: ''}
        
        ];
        

        Dieses Array verwende ich zum Initializieren und generieren der UserStates. Dann hatte ich mir überlegt das Array value her zu nehmen um Zwischenergebnisse zu speichen um dann mit einem schedule alle x Minuten oder sekunden die states zu aktuallisieren.
        Das aufwendige dabei ist, den jeweiligen Array Index zu finden. Das muss ich jedes mal mit einem find machen was ebenfalls nicht toll ist.

        Wäre es möglich den index selbst zu definieren und macht das aus eurer Sicht Sinn?

        z.b.

        const objStrom = [
        
            ['idGen24E', {uid: `${upath}.E_PV_Gen24_Total_Production`, type: 'energy', name: 'Gesamte Energie produziert vom GEN24', value: 0, did: 'idGen24E_D', tid: 'idPVToE'}],
         ...
        ];
        

        Ich hab das mal versucht generisch zu erstellen und wollte eure Meinung dazu haben ob sowas ressourcen schonender läuft.

        // Define your data points as an array of objects with custom IDs
        const dataPoints = [
          { customId: 'point1', value: 0, dataPointId: 'javascript.0.dataPoint1' },
          { customId: 'point2', value: 0, dataPointId: 'javascript.0.dataPoint2' },
          // Add more data points as needed
        ];
        
        // Function to update array values
        function updateArrayValues(customId, value) {
          const dataPoint = dataPoints.find((dp) => dp.customId === customId);
          if (dataPoint) {
            dataPoint.value = value;
          }
        }
        
        // Scheduler to check and store array values to data points every 5 minutes
        schedule('*/5 * * * *', () => {
          dataPoints.forEach((dataPoint) => {
            // Check if the value has changed before updating
            const currentValue = getState(dataPoint.dataPointId).val;
            if (dataPoint.value !== currentValue) {
              setState(dataPoint.dataPointId, dataPoint.value, true);
            }
          });
        });
        
        // Example usage: Update array values using custom IDs
        updateArrayValues('point1', 42);
        updateArrayValues('point2', 'Hello, world!');
        // Add more updateArrayValues calls as needed
        
        

        Grüße MiniBlister

        T 1 Reply Last reply Reply Quote 0
        • T
          ticaki Developer @MiniBlister last edited by ticaki

          @miniblister

          Benutze ein Json, kein Array.

          const meinJson = {
            "mein.Strom.eingehende.Daten": {daHin:'', dasMachen:'', denNamen:'', derAktuelleWert:0,
            "mein.StromWoanders.eingehendeDaten": {...}
          }
          
          for(const dp in meinJson) {
            on({id: dp}, (obj) => {
              const definition = meinJson[obj.id];
              ...
          

          Davon aber ab, bei etwas das alle 5 Minuten läuft mag es schön sein, wenn das optimiert ist. Wichtig ist es nicht. Ich hab hier Skripte die jede Sekunde getriggert werden und einen Mittelwert über 5 Sekunden bilden.

          M 1 Reply Last reply Reply Quote 0
          • M
            MiniBlister @ticaki last edited by

            @ticaki

            vielen Dank für die Hilfe. Du gehst mit einer for Schleife durch und generierst mehrere on's.
            Die folgende Methode ist etwas kürzer. Was hälst du davon? Kann man das so machen?

            let myPVAidsPower = {
                "aidGen24P" :   { "dataPointId": "alias.0.KG.HR.FroniusGen24.P_PV", "value": 0},
                "aidSymoP" :    { "dataPointId": "alias.0.OD.GA.FroniusSymo.P_PV", "value": 0},
                "aidHoyP" :     { "dataPointId": "alias.0.OD.GH.Hoymiles1500.power", "value": 0}
            }
            const dataPointIds = Object.values(myPVAidsPower).map(dataPointInfo => dataPointInfo.dataPointId);
            on({id: dataPointIds, change: "ne"}, async (obj) => {await calcPowerAndEnergie (obj);});
            
            1 Reply Last reply Reply Quote 0
            • T
              ticaki Developer last edited by ticaki

              @miniblister

              Jo geht natürlich auch.

              mit deinem Json geht aber nicht:

              on(blabla, (obj) => {
                if (!obj.id) return;
                const meineDaten = meinJson[obj.id];
              }
              

              Json würde ich mit dem verständlichen Bezeichner im Datenteil aufbauen.

              M 1 Reply Last reply Reply Quote 0
              • M
                MiniBlister @ticaki last edited by MiniBlister

                @ticaki

                hatte ich mir auch überlegt.
                Aber wenn ich ich das Script an jemanden weiter geben möchte, dann könnten ja die alisa ganz anders aussehen. Es könnte im Verlauf der Entwicklung des Scripts durchaus sein, dass ich einen bestimmten Wert zusätzlich benötige.

                Daher hatte ich mich das wir folgt zusammen gebaut:

                async function findKeyinDataPoints(dataPoints, findinKey, valueToFind) {
                    const foundKey = Object.keys(dataPoints).find(key => dataPoints[key][findinKey] === valueToFind);
                    return foundKey || null;
                }
                on(blabla, (obj) => {
                  const foundKey = await findKeyinDataPoints(myPVAidsPower, "dataPointId", obj.id);
                  (foundKey && myPVAidsPower.hasOwnProperty(foundKey)) && myPVAidsPower[foundKey].value;
                }
                

                Ob ich die hasOwnProperty Abfrage noch benötige, weiß ich noch nicht. Ich bin so denke ich sehr flexible.
                Macht das Sinn aus deiner Sicht?

                T 1 Reply Last reply Reply Quote 0
                • T
                  ticaki Developer @MiniBlister last edited by ticaki

                  @miniblister

                  Es spricht nicht dagegen, das so zu machen. Ich wollte dir nur aufzeigen wie ich es tue 🙂

                  Ich mache viel mit vscode und fast alles in typescript. Da bietet die umgedrehte Versionvorteile die aber nichts mit der Ausführung sondern Erstellung zu tun haben. Glaube ich hab auch kein einfaches Beispiel.

                  Dann mal was nicht extrem kompiziertes... aber trotzdem sehr komplex

                  Typescript, vscode als editor, auszüge aus dem NSPanel.ts Skript.

                  Wenn ich z.B.

                  export type PagetypeType = 'cardChart' | 'cardLChart' | 'cardEntities' |'cardGrid'|'cardGrid2'|'cardThermo'|'cardMedia'|'cardUnlock'|'cardQR'|'cardAlarm'|'cardPower' //| 'cardBurnRec'
                  

                  den Type anlege

                  und dann diesen:

                  export type PageThermo = {
                          type: 'cardThermo',
                          items: [PageThermoItem],
                          
                      } & Omit<PageBaseType, 'useColor'>
                  

                  und dann das json definiere das ich einem array zuweise:
                  (PageType ist eine oder Verknüpfung die auch PageThermo enthält.)

                  let Bad_Thermostat: PageType = 
                  {
                      'type': 'cardThermo',
                      'heading': 'Bad',
                      'subPage': true,
                      
                      'parent': SensorGrid,
                      'items': [{ 
                                  id: 'alias.0.NSPanel.1.usr.Temperatur.G.Bad',
                                  minValue: 100, 
                                  maxValue: 300,
                                  stepValue: 1
                               }]
                  };
                  

                  Kann ich davon ausgehen dass das hier richtig ist:

                  function GeneratePage(page: PageType): void {
                      try {
                          ...
                          switch (page.type) {
                              case 'cardEntities':
                                  SendToPanel(GenerateEntitiesPage(page));
                                  break;
                              case 'cardThermo':
                                  SendToPanel(GenerateThermoPage(page));
                                  break;
                              case 'cardGrid':
                                  SendToPan...
                  

                  vscode baut mir auch das switch mit allen möglichen case dahin, so das ich keine vergesse und Rechtschreibfehler werden auch gefunden.

                  z.B würde if (page.type == 'nope') einen Fehler erzeugen da es a) immer false wäre und b) vscode meint das ich da was vergleiche was nicht zusammengehört.

                  typescript würde da auch nen Fehler rauswerfen.

                  M 1 Reply Last reply Reply Quote 0
                  • M
                    MiniBlister @ticaki last edited by MiniBlister

                    @ticaki

                    hmmm, jetzt stehe ich auf dem Schlauch.
                    Dein PageType hat ja 'items':
                    Wenn ich das richtig lese definierst du die ja nicht so wie du es mir empfiehlst, oder?
                    Nach deiner Empfehlung müsste es doch so aussehen

                    let Bad_Thermostat: PageType = 
                    {
                        'type': 'cardThermo',
                        'heading': 'Bad',
                        'subPage': true,
                    
                        'parent': SensorGrid,
                        'items': [{ 
                                    'alias.0.NSPanel.1.usr.Temperatur.G.Bad' : {
                                       minValue: 100, 
                                       maxValue: 300,
                                       stepValue: 1
                                      },
                                     'alias.0.NSPanel.1.usr.Temperatur.G.WC' : {
                                        minValue: 200, 
                                        maxValue: 100,
                                        stepValue: 1
                                     } 
                                 }]
                    };
                    
                    T 1 Reply Last reply Reply Quote 0
                    • T
                      ticaki Developer @MiniBlister last edited by

                      @miniblister

                      Jap wir haben uns gegenseitig mit erfolg verwirrt - 10 Punkte 🙂

                      Du hast oben ein Array verwendet um Daten abzuspeichern und dieses Daten waren wiederrum ein Array - Das letzte würde ich durch ein Json ersetzten und es dann so suchen wie du vorgeschlagen hast.

                      Wenn die Datensätze im Array jedoch kaum Gemeinsamkeiten hätten, würde ich alles im JSON haben und dann die ID nicht als KEY verwenden.

                      Entschuldige die Verwirrung ich hab in letzter Zeit einige meiner Skripte auf Selektor umgebaut und dann speichere ich die Daten dazu in einer DB mit Key ID und dem Datensatz. Von Hand mache ich es aber nicht so.

                      M 1 Reply Last reply Reply Quote 0
                      • M
                        MiniBlister @ticaki last edited by

                        @ticaki

                        nur nochmals um sicher zu gehen, dass ich deine zwei Ansätze verstehe. Du schreibst im zweiten Teila ja, dass du die ID NICHT als KEY verwenden würdest.

                        Ansatz 1: Array mit JSON

                        let myPVAidsPower = [
                            { "dataPointId": "alias.0.KG.HR.FroniusGen24.P_PV", "value": 0},
                            { "dataPointId": "alias.0.OD.GA.FroniusSymo.P_PV", "value": 0},
                            { "dataPointId": "alias.0.OD.GH.Hoymiles1500.power", "value": 0}
                        ]
                        

                        Ansatz 2: Array mit JSON

                        let myPVAidsPower = {
                            { "dataPointId": "alias.0.KG.HR.FroniusGen24.P_PV", "value": 0},
                            { "dataPointId": "alias.0.OD.GA.FroniusSymo.P_PV", "value": 0},
                            { "dataPointId": "alias.0.OD.GH.Hoymiles1500.power", "value": 0}
                        }
                        
                        T 1 Reply Last reply Reply Quote 0
                        • T
                          ticaki Developer @MiniBlister last edited by

                          @miniblister

                          Du must mir mehr zeigen, ich weiß nicht was myPVAidsPower ist und wie das im Zusammenhang steht. Davon hängt es ab, wie mein Rat lautet.

                          M 1 Reply Last reply Reply Quote 0
                          • M
                            MiniBlister @ticaki last edited by

                            @ticaki

                            Ok, was ich eigentlich habe sind 3 Wechselrichter, eine Gen24 für das Hausdach, ein Symo für die Garage und ein Hoymiles für das Gartenhaus.
                            Alle liefern einen Leistungwert und einen gesamten Energie Wert seit Beginn des Betriebs. Beides habe ich als Alias verfügbar.
                            Weiterhin habe ich zwei E-Meter die mir den Netzbezug bzw. die Einspießung liefert. Mit all diesen Werten möchte ich die folgenden Daten berechnen.

                            • Gesamt Leistung aller Wechselrichter = alias.0.KG.HR.FroniusGen24.P_PV + alias.0.OD.GA.FroniusSymo.P_PV + alias.0.OD.GH.Hoymiles1500.power
                            • Gesamte Energie aller Wechselricht = ....
                            • Tägliche Energie aller Wechselricht = ....
                            • Wie viel Produzierte PV Energie wurde von der Wärmepumpe verbraucht (das mach ich dann über die Energieflüsse und einer Prozentuale aufteilung)

                            Was ich mir schon überlegt hatte ist eine Strukture wie folgt aufzubauen:

                            let datastuctur = 
                            {
                                'type': 'wechselrichter',
                                'name': 'GEN24',
                                'power': {
                                             id: 'alias.0.KG.HR.FroniusGen24.P_PV',
                                             unit: 'W'
                                             }
                                'energie': {
                                             id: 'alias.0.KG.HR.FroniusGen24.E_PV',
                                             unit: 'kW'
                                             }
                            },
                            {
                                'type': 'wechselrichter',
                                'name': 'Symo',
                                'power': {
                                             id: 'alias.0.KG.HR.FroniusSymo.P_PV',
                                             unit: 'W'
                                             }
                                'energie': {
                                             id: 'alias.0.KG.HR.FroniusSymo.E_PV',
                                             unit: 'kW'
                                             }
                            },
                            {
                                'type': 'PVTotalPower',
                                'name': 'Total',
                                'datapoint': {
                                             id: 'userdata.0.blbla.PowerGesamt',
                                             unit: 'kW'
                                             init: true
                                             }
                                'daily' : {
                                             id: 'userdata.0.blbla.DailyPowerGesamt',
                                             unit: 'kW'
                                             init: true
                                             }
                            },
                            
                            

                            Dann würde ich durch gehen und mit dieser Struktur alle Datenpunkte automatisch generieren und dann je nach type verschiedene Funktionen ausführe.

                            T 1 Reply Last reply Reply Quote 0
                            • T
                              ticaki Developer @MiniBlister last edited by ticaki

                              @miniblister
                              Das sieht gut aus. Aber datapoint würde ich noch einen weniger generischen namen geben.

                              1 Reply Last reply Reply Quote 0
                              • First post
                                Last post

                              Support us

                              ioBroker
                              Community Adapters
                              Donate

                              794
                              Online

                              31.8k
                              Users

                              80.0k
                              Topics

                              1.3m
                              Posts

                              5
                              18
                              709
                              Loading More Posts
                              • Oldest to Newest
                              • Newest to Oldest
                              • Most Votes
                              Reply
                              • Reply as topic
                              Log in to reply
                              Community
                              Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen
                              The ioBroker Community 2014-2023
                              logo