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. Skripten / Logik
  4. [Vorlage] Ventilsteuerung PWM-Ansatz für FBH/IR-Panele o.ä.

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
    2.0k

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

[Vorlage] Ventilsteuerung PWM-Ansatz für FBH/IR-Panele o.ä.

Geplant Angeheftet Gesperrt Verschoben Skripten / Logik
83 Beiträge 22 Kommentatoren 19.2k Aufrufe 9 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.
  • E Offline
    E Offline
    e-i-k-e
    schrieb am zuletzt editiert von
    #42

    Danke für den Ansatz!

    Ich werde es mal versuchen :)

    1 Antwort Letzte Antwort
    0
    • E Offline
      E Offline
      e-i-k-e
      schrieb am zuletzt editiert von
      #43

      Guten Abend,

      der weg über den Scenen Adapter hat funktioniert.

      Das Skript lief bis gestern super.

      Ich musste ein Neustart meiner CCU (Raspberry) durchführen und habe seit dem folgendes im ioBroker log.

      8064_1.jpg
      8064_2.jpg

      1 Antwort Letzte Antwort
      0
      • apollon77A Offline
        apollon77A Offline
        apollon77
        schrieb am zuletzt editiert von
        #44

        Restarte mal die hm-* Adapter

        Beitrag hat geholfen? Votet rechts unten im Beitrag :-) https://paypal.me/Apollon77 / https://github.com/sponsors/Apollon77

        • Debug-Log für Instanz einschalten? Admin -> Instanzen -> Expertenmodus -> Instanz aufklappen - Loglevel ändern
        • Logfiles auf Platte /opt/iobroker/log/… nutzen, Admin schneidet Zeilen ab
        1 Antwort Letzte Antwort
        0
        • E Offline
          E Offline
          e-i-k-e
          schrieb am zuletzt editiert von
          #45

          Das war es schon! :lol:

          Danke!!

          Folgende Wahrung erscheint weiterhin.

          Was bedeutet diese?

          javascript.0 2018-11-11 23:12:12.271 warn at Object. <anonymous>(script.js.Fußbodenheizung:368:9)

          javascript.0 2018-11-11 23:12:12.270 warn at ventilLogik (script.js.Fußbodenheizung:248:25)

          javascript.0 2018-11-11 23:12:12.270 warn at controlFBHAktor (script.js.Fußbodenheizung:387:9)

          javascript.0 2018-11-11 23:12:12.270 warn Wrong type of scene.Fußboden_Flur_OnTime: "number". Please fix, while deprecated and will not work in next versions.</anonymous>

          1 Antwort Letzte Antwort
          0
          • apollon77A Offline
            apollon77A Offline
            apollon77
            schrieb am zuletzt editiert von
            #46

            Was hat der Scene Datenpunkt denn für einen Datentyp? Das Skript schreibt eine zahl rein. Das heisst der sollte "number" oder "Mixed" haben, sonst kommt diese Meldung

            Beitrag hat geholfen? Votet rechts unten im Beitrag :-) https://paypal.me/Apollon77 / https://github.com/sponsors/Apollon77

            • Debug-Log für Instanz einschalten? Admin -> Instanzen -> Expertenmodus -> Instanz aufklappen - Loglevel ändern
            • Logfiles auf Platte /opt/iobroker/log/… nutzen, Admin schneidet Zeilen ab
            1 Antwort Letzte Antwort
            0
            • E Offline
              E Offline
              e-i-k-e
              schrieb am zuletzt editiert von
              #47

              Kurze Rückmeldung, funktioniert nun alles wie gewollt.

              Vielen Dank für deine super arbeit und den guten Support :!:

              1 Antwort Letzte Antwort
              0
              • jedoJ Offline
                jedoJ Offline
                jedo
                schrieb am zuletzt editiert von
                #48

                Hallo in die Runde,

                da wir hier nur Wand- und Fussbodenheizung mit allen bekannten Vor- und Nachteilen haben,

                gefällt mir das Script eigentlich ganz gut. :)

                Der einzige Haken für mich ist ich möchte das gern mit "Non" HM-Hardware verwenden da ich nun mal keine HM-Hardware habe. ;)

                Abhilfe soll folgendes Konstrukt in der Funktion "controlFBHAktor" bringen.

                function controlFBHAktor(roomName, enabled, time) {
                    var useSupport = false;
                    if (rooms[roomName].stateIdHeizungUnterstuetzungAktor) {
                        var isttemperatur = getState(rooms[roomName].stateIdIstTemperatur).val;
                        var solltemperatur = getState(rooms[roomName].stateIdSollTemperatur).val;
                        if (enabled && solltemperatur - isttemperatur > rooms[roomName].heizunterstuetzungKelvin) {
                            if (debug) {console.log('    Steuern UnterstützungsAktor FBH ' + roomName + ' --> ' + enabled + ' (time=' + time + ')');}
                            useSupport = true;
                        }
                        else if (!enabled || getState(rooms[roomName].stateIdHeizungUnterstuetzungAktor).val) useSupport = true;
                    }
                
                    if (enabled && time) {
                        time = Math.round(time);
                        setState(rooms[roomName].stateIdHeizungAktorOnTime, time, false, function() {
                            if (debug) {console.log('  *  Steuern Aktor FBH ' + roomName + ' --> ' + enabled + ' (time=' + time + ')');}
                            setState(rooms[roomName].stateIdHeizungAktor, true, false);
                
                // ************************************************************************
                // **************************  AB HIER ! ********************************
                
                            let startTime = new Date(Date.now() + time * 1000);
                            console.log(roomName + '.Aktor aus um: ' + startTime);
                            let endTime = new Date(startTime.getTime() + 1000);
                            //console.log(endTime);
                            clearSchedule(rooms[roomName].sch);
                             rooms[roomName].sch = schedule({ start: startTime, end: endTime, rule: '*/1 * * * * *' }, function () {
                                setState(rooms[roomName].stateIdHeizungAktor, false );
                                setState(rooms[roomName].stateIdHeizungAktorOnTime,0 );
                            clearSchedule(rooms[roomName].sch);
                            });
                
                 // **************************  BIS HIER ! ********************************
                 // ************************************************************************      
                
                            if (useSupport) {
                                setState(rooms[roomName].stateIdHeizungUnterstuetzungAktorOnTime, time, false, function() {
                                    if (debug) {console.log('    Steuern UnterstützungsAktor FBH ' + roomName + ' --> ' + enabled + ' (time=' + time + ', tempDiff=' + (solltemperatur - isttemperatur) + ')');}
                                    setState(rooms[roomName].stateIdHeizungUnterstuetzungAktor, true, false);
                                });
                            }
                        });
                    }
                    else {
                        if (debug) {console.log('    Steuern Aktor FBH ' + roomName + '--> ' + enabled);}
                        setState(rooms[roomName].stateIdHeizungAktor, enabled, false);
                        if (useSupport) {
                            if (debug) {console.log('    Steuern UnterstützungsAktor FBH ' + roomName + '--> ' + enabled);}
                            setState(rooms[roomName].stateIdHeizungUnterstuetzungAktor, enabled, false);
                        }
                    }
                

                Ich lass da einfach für jeden Schaltvorgang ein "Schedulereintrag" erstellen welcher nach der errechneten Zeit den "Aktor" auf "false" und die "Zeit" auf "0" setzt und sich danach selbst löscht.

                Im "Trockentest" mit 4 Räumen klappt das schon mal wie gewünscht.

                Bevor ich das aber in die Praxis umsetze,

                was sagt ihr dazu?

                Kann man das so machen oder gibt es eine bessere (elegantere) Lösung?

                Viele Grüße,

                Jens

                1 Antwort Letzte Antwort
                0
                • D Offline
                  D Offline
                  DavidFD
                  schrieb am zuletzt editiert von
                  #49

                  Hab mir das vorhin aucb für sonoff 4ch umgeschrieben.

                  Ich nehme einfach ein settimeout von JS.

                  Im Livetest hatte ich vorhin die schönste Kurve bisher. Besser als meine PI - Regler Versuche

                  so siehts grad aus: Hab etwas abgespeckt mit den Supportaktoren.

                  function controlFBHAktor(roomName, enabled, time) {
                      var useSupport = false;
                  
                      if (enabled && time) {
                          time = Math.round(time);
                          if(debug) { console.log("switchoff timer: "+ time+""); }
                          clearTimeout(rooms[roomName].timeout)
                          setState(rooms[roomName].stateIdHeizungAktor, enabled, false);
                          rooms[roomName].timeout =  setTimeout(function() {switchOff(rooms[roomName].stateIdHeizungAktor); }, time * 1000);
                      } else {
                          console.log("enabled = "+enabled);
                          if (debug) {console.log('    Steuern Aktor FBH ' + roomName + '--> ' + enabled);}
                          setState(rooms[roomName].stateIdHeizungAktor, enabled, false);
                      }
                  }
                  
                  function switchOff(id) {
                     console.log("Ausschalten");
                     setState(id, false);
                  }
                  
                  

                  2 Raspis als Multihost, Homematic, Xiaomi und Hue.

                  Bastelprojekte auf www.derfrickler.de zu finden.

                  Aktuell:

                  1 Antwort Letzte Antwort
                  0
                  • apollon77A Offline
                    apollon77A Offline
                    apollon77
                    schrieb am zuletzt editiert von
                    #50

                    Hi, effektiv sind die Lösungen valide so.

                    Meine Idee wäre es über eigene Javascript-States wegzukapseln. Also einen "virtuellen" "on-time" und "state" Datenpunkt anlegen der dann gekapselt in einem eigenen Skript das ganze Schaltet.

                    Im Skript hier wäre es dann keine änderung sondern nurdie Nutzung dieser virtuellen State-IDs im Skript. Das ist das flexibelste um bei Skriptänderungen schnell updaten zu können … sonst müsst Ihr immer alle Eure Änderungen wieder mühselig einbauen.

                    Beitrag hat geholfen? Votet rechts unten im Beitrag :-) https://paypal.me/Apollon77 / https://github.com/sponsors/Apollon77

                    • Debug-Log für Instanz einschalten? Admin -> Instanzen -> Expertenmodus -> Instanz aufklappen - Loglevel ändern
                    • Logfiles auf Platte /opt/iobroker/log/… nutzen, Admin schneidet Zeilen ab
                    1 Antwort Letzte Antwort
                    0
                    • jedoJ Offline
                      jedoJ Offline
                      jedo
                      schrieb am zuletzt editiert von
                      #51

                      @apollon77:

                      Meine Idee wäre es über eigene Javascript-States wegzukapseln. Also einen "virtuellen" "on-time" und "state" Datenpunkt anlegen der dann gekapselt in einem eigenen Skript das ganze Schaltet. `

                      ..ich hatte ja nicht umsonst nach einer eleganteren Lösung gefragt. :D :D :D

                      Der Ansatz gefällt mir recht gut, vor allen das man nichts am eigentlichen Script ändern muss klingt gut.

                      Zum testen verwende ich ja aktuell "virtuelle" Datenpunkte, beste Basis also um das mal mit einem eigenen Script umzusetzen! :roll:

                      Vielen Dank für den Denkanstoss! :D

                      Danke auch an David für die Vorstellung seiner Lösung.

                      Viele Grüße,

                      Jens

                      1 Antwort Letzte Antwort
                      0
                      • D Offline
                        D Offline
                        DavidFD
                        schrieb am zuletzt editiert von
                        #52

                        @apollon77:

                        Meine Idee wäre es über eigene Javascript-States wegzukapseln. Also einen "virtuellen" "on-time" und "state" Datenpunkt anlegen der dann gekapselt in einem eigenen Skript das ganze Schaltet. `

                        ist wohl der sinnvollste Ansatz wenn die Entwicklung am Script dynamisch bleibt.

                        Was ich gern noch hätte wäre den Vorlauf einzubeziehen. Dieser schwankt bei mir recht stark zwischen 22 und 30 °C. Der verändert ja auch stark die Heizleistung die in den Boden gebracht werden kann.

                        Gedankengang wäre ein Vorlauf Soll anhand der Außentemperatur zu berechnen und dann die Zeit mit einem Faktor zum entsprechenden Soll anzupassen.

                        Wenn der Einzug endlich hinter mir ist, muss ich mir mal die Zeit nehmen das Script komplett zu verstehen :D

                        2 Raspis als Multihost, Homematic, Xiaomi und Hue.

                        Bastelprojekte auf www.derfrickler.de zu finden.

                        Aktuell:

                        1 Antwort Letzte Antwort
                        0
                        • apollon77A Offline
                          apollon77A Offline
                          apollon77
                          schrieb am zuletzt editiert von
                          #53

                          Ich habe(siehe erster Post) das Skript quasi aus einem Homematic Skript auf dem HM-Forum "portiert" und seitdem läuft es so.

                          Die Idee mit der Aussentemperatur-/Vorlaufsteuerung gabs im Thread auch schonmal … schau mal.

                          Die Idee von dem Skript ist ja das das am Ende alles egal ist. Das Skript schaut was "im Raum" passiert und das ist das relevante. Egal wieviel Sonne von draussen auf das Zimmer knallt (und heizt) und was der Boden mit der aktuellen Vorlauftemperatur heizt, das Skript schaut wie sich die Temperatur in den letzten 20 Minuten geändert hat und rechnet das hoch auf die Ist/Solltemperatur und entscheidet wie lange geheizt werden muss damit es auch nicht übersteuert (eins der großen Themen bei einer FBH) weil der Boden nämlich nachheizt. Und ein Raum im Dachgeschoss bei viel Sonne verhält sich (bei gleicher Vorlauftemperatur) ganz anders als einer im Erdgeschoss oder Keller :-)

                          In sofern entscheidet das Skript auch nur im Rahmen dieser 20 Minuten Zeitscheiben. Da Zeiten draufzuaddieren macht daher wenig sinn. Wenn es viel kälter ist ist die Heizung eh die ganzen 20 Minuten an. Wenn es weniger als 20 Minuten an ist dann liegt (bei normal-trägen FBHs) die Temperatur schon recht nah um die Zieltemperatur drum rum ...und wenn DU dann verlängerst übersteuerst Du.

                          AM besginn vom Skript sind ein paar Variablen wo du noch ein bissl mit rumspielen kannst um auf/abschläge zu realisieren. Details im HM Forum Thread. :-)

                          Ich selbst habe einiges rum experimentiert und ehrlich es kam immer müll raus weil du die vielen Faktoren alle nicht kontrollieren kannst und jeder Faktor andere Auswirkungen hat.

                          Ingo

                          Beitrag hat geholfen? Votet rechts unten im Beitrag :-) https://paypal.me/Apollon77 / https://github.com/sponsors/Apollon77

                          • Debug-Log für Instanz einschalten? Admin -> Instanzen -> Expertenmodus -> Instanz aufklappen - Loglevel ändern
                          • Logfiles auf Platte /opt/iobroker/log/… nutzen, Admin schneidet Zeilen ab
                          1 Antwort Letzte Antwort
                          0
                          • T Offline
                            T Offline
                            thobastian
                            schrieb am zuletzt editiert von thobastian
                            #54

                            Hi Apollon77,
                            ist dieser Thread eigentlich noch richtig ? Ich verwende Dies Script von Dir und finde wirklich gut.
                            Als Heizungsaktor habe ich einen Stellantrieb , der durch einen Meross-Switch angestoßen wird.
                            Dadurch dass ich einen Merossswitch nehme, kann ich auch nicht die Variable "stateIdHeizungAktorOnTime" füllen. Ich habe sie leergelassen, aber mich stört, dass ich dann eine Meldung im Log bekomme. Kann ich dort etwas eintragen?

                            Schöne Grüße
                            Thomas

                            HW: Homematic CCU2, Amazon Echo, diverse NodeMCU's mit Sensoren,

                            SW: IOBroker: immer neueste Version mit ESPEasy auf den NodeMCU's

                            1 Antwort Letzte Antwort
                            0
                            • U Offline
                              U Offline
                              Unterstedter
                              schrieb am zuletzt editiert von
                              #55

                              Wollte mich einfach mal für ein geiles Skript bedanken. Hab es vor ein paar Tagen in Betrieb genommen und funktioniert wunderbar

                              1 Antwort Letzte Antwort
                              0
                              • apollon77A apollon77

                                Hi,

                                ich habe vor kurzem die Ventilsteuerung meiner Fussbodenheizungssteuerung auf ioBroker umgestellt. Nachdem ich einige ANsätze, auch hier aus dem Forum nicht kapiert habe, bin ich im Homematic-Forum fündig geworden.

                                Basierend auf dem Skript "Fußbodenheizung - Steuerung/IR-Heizung-Steuerung" von twoxx aus dem Homematic-Forum (https://homematic-forum.de/forum/viewto … 31&t=24890) habe ich das nach ioBroker JavaScript portiert und etwas verschlankt.

                                Das interessante an dem Skriptansatz ist, dass es die Raumtemperatur "überwacht" und versucht die Ventile früh genug auszuschalten das die Temperatur nicht übersteuert, aber auch früh genug wieder einzuschalten. Das ganze folgt einem PWM-Ansatz im Default auf das 20 Minuten Skriptintervall und schaltet daher auch teilweise nur für ein paar Minuten ein.

                                Details zur Funktionsweise und der wichtigen Konfigurationsparameter am besten im Original-Thread im Homematic-Forum informieren. Die Parameternamen sind weiterstgehend die gleichen. Ich habe nur ein paar Dinge (Sicherheitsheizen bei bestimmten Außentemperaturen) weggenommen und einige Dinge so umgebaut das die Entwicklung der letzten 3 Skriptläufe (=60Min) "rollierend" betrachtet werden können.

                                In den Räumen an sich habe ich überall Homematic-Wandthermostate angebracht und die Ventile werden über Homematic-Schaltaktoren gesteuert. Die Skripte sind aber grundsätzlich so flexibel das problemlos auch andere Hersteller eingesetzt werden können. Keins davon steuert irgendwas an den Ventilen direkt, das macht alles dieses Skript!

                                Das Skript hier ist aber unabhängig von der Art wie die Thermostate und Programme ablaufen, es nimmt die Ist- und Solltemperarturen und steuert dann die Ventil-Aktoren.

                                Die Konfiguration besteht aus drei Teilen:

                                1.) Die Raum-Objekte am Anfang haben einen Eintrag pro Raum mit State-ID Definitionen. Die Namen der Räume können frei gewählt werden und sind primär für das Logging interessant. Die State-IDs wie bei "OG-Bad" zu sehen sind Pflicht. Bei EG-Wohnzimmer habe ich noch einen zweiten Heizkreis den ich nur zum hochheizen als "Unterstützung" nutze, der bleibt zum halten der Temperatur aber aus. Darüber könnte man auch ein IR-Panel oder einen Heizlüfter mit nutzen.

                                2.) Die 4 Werte danach definieren die Rahmenbedingungen für die Steuerung. Details siehe Homematic Forum, da ist auch eine Grafik :-)

                                Weiterhin kann man ausführliches Logging aktivieren.

                                3.) In der Funktion "initialize" werden noch einige Grundwerte eingetragen, die eher statisch sind.

                                In "Schaltschwelleniedertemp" und "Schaltschwellehochtemp" stehen an sich die Laufzeiten der Ventile (Auf-Zu) drin. Sind bei mir etwas mehr als 3 Minuten, sollte jeder selbst ermitteln.

                                In "heizunterstuetzungKelvin" ist drin ab wieviel Kelvin (=Grad) Temperaturunterschied ein pot. angegebener Unterstützungsaktor genutzt wird

                                Man kann all diese Object-Keys, wenn man Sie pro Raum anders braucht, auch direkt im rooms-Objekt beim Raum setzen, dann wird das genutzt.

                                Hier das Skript (20180101)

                                // Thread im ioBroker-Forum: http://forum.iobroker.net/viewtopic.php?f=21&t=10111
                                
                                var rooms= {
                                    'DG-Luca': {
                                        stateIdHeizungAktor: "hm-rpc.0.LEQ0282183.3.STATE",
                                        stateIdHeizungAktorOnTime: "hm-rpc.0.LEQ0282183.3.ON_TIME",
                                        stateIdSollTemperatur: "hm-rpc.0.NEQ0072178.2.SET_TEMPERATURE",
                                        stateIdIstTemperatur: "hm-rpc.0.NEQ0072178.1.TEMPERATURE"
                                    },
                                    'DG-Jana': {
                                        stateIdHeizungAktor: "hm-rpc.0.LEQ0282183.2.STATE",
                                        stateIdHeizungAktorOnTime: "hm-rpc.0.LEQ0282183.2.ON_TIME",
                                        stateIdSollTemperatur: "hm-rpc.0.NEQ0072437.2.SET_TEMPERATURE",
                                        stateIdIstTemperatur: "hm-rpc.0.NEQ0072437.1.TEMPERATURE"
                                    },
                                    'DG-Duschbad': {
                                        stateIdHeizungAktor: "hm-rpc.0.LEQ0282183.1.STATE",
                                        stateIdHeizungAktorOnTime: "hm-rpc.0.LEQ0282183.1.ON_TIME",
                                        stateIdSollTemperatur: "hm-rpc.0.NEQ0071913.2.SET_TEMPERATURE",
                                        stateIdIstTemperatur: "hm-rpc.0.NEQ0071913.1.TEMPERATURE"
                                    },
                                    'OG-Bad': {
                                        stateIdHeizungAktor: "hm-rpc.0.NEQ1503796.1.STATE",
                                        stateIdHeizungAktorOnTime: "hm-rpc.0.NEQ1503796.1.ON_TIME",
                                        stateIdSollTemperatur: "hm-rpc.0.NEQ0124378.2.SET_TEMPERATURE",
                                        stateIdIstTemperatur: "hm-rpc.0.NEQ0071913.1.TEMPERATURE"
                                    },
                                    'EG-Wohnzimmer': {
                                        stateIdHeizungAktor: "hm-rpc.0.OEQ0653582.1.STATE",
                                        stateIdHeizungAktorOnTime: "hm-rpc.0.OEQ0653582.1.ON_TIME",
                                        stateIdHeizungUnterstuetzungAktor: "hm-rpc.0.MEQ0361527.1.STATE",
                                        stateIdHeizungUnterstuetzungAktorOnTime: "hm-rpc.0.MEQ0361527.1.ON_TIME",
                                        stateIdSollTemperatur: "hm-rpc.0.OEQ0987006.2.SET_TEMPERATURE",
                                        stateIdIstTemperatur: "hm-rpc.0.JEQ0122620.1.TEMPERATURE"
                                    }
                                };
                                var hochtempAufschlag = 0.5; // hochtemp = solltemperatur + hochtempAufschlag
                                var niedertempAbschlag = 1; // niedertemp = solltemperatur - niedertempAbschlag
                                var hochstillAufschlag = 0.1; // hochstill = solltemperatur + hochstillAufschlag
                                var niederstillAbschlag = 0.2; // niederstill = solltemperatur - niederstillAbschlag
                                
                                var debug = true;
                                
                                initialize();
                                
                                function initialize() {
                                    for (var room in rooms) {
                                        if (!rooms[room].Sicherheitsheizzeit) rooms[room].Sicherheitsheizzeit = 240; // Heizzeit, falls errechnete Heizzeit im Minus
                                        if (!rooms[room].Schaltschwelleniedertemp) rooms[room].Schaltschwelleniedertemp = 190; // Sofern errechnete Schaltzeit kleiner, dann nicht einschalten
                                        if (!rooms[room].Schaltschwellehochtemp) rooms[room].Schaltschwellehochtemp = 190; // Sofern errechnete Schaltzeit kleiner, dann nicht einschalten
                                        if (!rooms[room].skriptZyklus) rooms[room].skriptZyklus = 20;
                                        if (!rooms[room].heizunterstuetzungKelvin) rooms[room].heizunterstuetzungKelvin = 1;  // Wenn Temperaturunterschied größer als diese ANzahl Kelvon dann wird Unterstützung verwendet
                                
                                        if (!rooms[room].FBStartTemperatur) rooms[room].FBStartTemperatur = [];
                                        if (!rooms[room].StartHeizzeit) rooms[room].StartHeizzeit = [new Date().getTime()-1000*60];
                                        if (!rooms[room].FBVergleichTemp) rooms[room].FBVergleichTemp = 0;
                                
                                        if (rooms[room].hochtempAufschlag === undefined) rooms[room].hochtempAufschlag = hochtempAufschlag;
                                        if (rooms[room].niedertempAbschlag === undefined) rooms[room].niedertempAbschlag = niedertempAbschlag;
                                        if (rooms[room].hochstillAufschlag === undefined) rooms[room].hochstillAufschlag = hochstillAufschlag;
                                        if (rooms[room].niederstillAbschlag === undefined) rooms[room].niederstillAbschlag = niederstillAbschlag;
                                
                                        rooms[room].letztesEIN = 0;
                                        rooms[room].skriptTimeout = null;
                                
                                        if (getState(rooms[room].stateIdHeizungAktor).val) {
                                            if (debug) {console.log('    ' + room + ': Aktor eingeschaltet');}
                                            rooms[room].letztesEIN = new Date().getTime();
                                        }
                                
                                        initializeSubscribes(room);
                                
                                        if (debug) {console.log('Ventillogik für Raum ' + room + ' initialisiert');}
                                        ventilLogik(room);
                                    }
                                }
                                
                                function initializeSubscribes(room) {
                                    on({id: rooms[room].stateIdHeizungAktor, change: 'any'}, function(state) {
                                        if (debug) {console.log('Änderung Status Aktor FBH ' + room + ': ' + state.oldState.val + '--> ' + state.state.val + ' (ack=' + state.state.ack + ', from=' + state.state.from + ')');}
                                        if (state.state.ack && state.state.val) {
                                            rooms[room].letztesEIN = new Date().getTime();
                                        }
                                    });
                                
                                    on({id: rooms[room].stateIdSollTemperatur, change: 'ne'}, function(state) {
                                        if (debug) {console.log('Änderung Solltemperatur ' + room + ': --> ' + state.state.val + ' (ack=' + state.state.ack + ', from=' + state.state.from + ')');}
                                        ventilLogik(room);
                                    });
                                }
                                
                                onStop(function (callback) {
                                    for (var room in rooms) {
                                        if (getState(rooms[room].stateIdHeizungAktor).val) {
                                            controlFBHAktor(room, false); // Alle ausschalten wenn Skript aus geht
                                            if (rooms[room].skriptTimeout) {
                                                clearTimeout(rooms[room].skriptTimeout);
                                                rooms[room].skriptTimeout = null;
                                            }
                                        }
                                    }
                                    setTimeout(callback, 1000);
                                }, 3000);
                                
                                function ventilLogik(roomName) {
                                    if (rooms[roomName].skriptTimeout) {
                                        clearTimeout(rooms[roomName].skriptTimeout);
                                        rooms[roomName].skriptTimeout = null;
                                    }
                                    // Temperaturen feststellen
                                    var isttemperatur = getState(rooms[roomName].stateIdIstTemperatur).val;
                                    var solltemperatur = getState(rooms[roomName].stateIdSollTemperatur).val;
                                    var schaltzustand = getState(rooms[roomName].stateIdHeizungAktor).val;
                                    var aktivSeit = 0;
                                    if (schaltzustand && rooms[roomName].letztesEIN) aktivSeit = (new Date().getTime() - rooms[roomName].letztesEIN) / 1000 / 60;
                                    if (debug) {console.log('Start Ventillogik ' + roomName + ': IstTemp=' + isttemperatur + ', VergleichTemp=' + rooms[roomName].FBVergleichTemp + ', SollTemp=' + solltemperatur + ', Aktor=' + schaltzustand + ' (seit ' + aktivSeit + 'm)');}
                                
                                    // GrenzTemperaturen berechnen
                                    var hochtemp = solltemperatur + rooms[roomName].hochtempAufschlag;
                                    var niedertemp = solltemperatur - rooms[roomName].niedertempAbschlag;
                                    var hochstill = solltemperatur + rooms[roomName].hochstillAufschlag;
                                    var niederstill = solltemperatur - rooms[roomName].niederstillAbschlag;
                                    var toleranz = hochtemp - niedertemp;
                                
                                    // rooms[roomName].StartHeizzeit in Systemvariable schreiben
                                    rooms[roomName].FBStartTemperatur.push(isttemperatur);
                                    if (rooms[roomName].FBStartTemperatur.length > 3) rooms[roomName].FBStartTemperatur.shift();
                                    if (debug) {console.log("    Start FBStartTemp=" + rooms[roomName].FBStartTemperatur[0]);}
                                
                                    // Differenz Starttemperatur und Endtemperatur ausrechnen
                                    var FBTempDiff = isttemperatur - rooms[roomName].FBStartTemperatur[0];
                                    if (FBTempDiff <= 0) {
                                        if (debug) {console.log("    TempDiff <= 0: " + FBTempDiff + " --> 0.01");}
                                        FBTempDiff = 0.01;
                                    }
                                    else {
                                        if (debug) {console.log("    TempfDiff > 0: " + FBTempDiff);}
                                    }
                                
                                    // Endheizzeit in Systemvariable, Isttemperatur in Systemvariable schreiben, Differenz heizzeit u Temp errechnen
                                    var EndHeizzeit = new Date().getTime();
                                
                                    // Heizzeit Differenz für Tempvorausrechnung errechnen
                                    var DiffStartEndHeizzeit = (EndHeizzeit - rooms[roomName].StartHeizzeit[0]) / 1000 / 60;
                                
                                    // Heizzeit Differenz für automatische Errechnung Scriptintervall errechnen
                                    var Scriptintervall = rooms[roomName].skriptZyklus;
                                
                                    // Steuerung Fussbodenheizung
                                    var heizleistung;
                                    var heizzeit;
                                    var heizzeit1;
                                    var einschaltzeitvergleichtemp;
                                    var tempdifferenzkalkreal;
                                    var reduzierungszeit;
                                    var neueheizzeit;
                                    // Einschaltzeit berechnen -----------------
                                    if (isttemperatur <= solltemperatur) {
                                        if (debug) {console.log("    Isttemperatur <= Solltemperatur");}
                                        heizleistung = ((solltemperatur + 0.2 - isttemperatur) / toleranz) * 100;
                                        heizzeit1 = (Scriptintervall * heizleistung) / 100;
                                        einschaltzeitvergleichtemp = (FBTempDiff * heizzeit1) / DiffStartEndHeizzeit;
                                        if (((toleranz * heizleistung) / 100) >= einschaltzeitvergleichtemp) {
                                            if (debug) {console.log("        heizzeit im original übernommen (heizleistung=" + heizleistung + ", Scriptintervall=" + Scriptintervall + ")");}
                                            heizzeit = heizzeit1 * 60;
                                        }
                                        else {
                                            if (debug) {console.log("        reduzierte heizzeit übernommen");}
                                            tempdifferenzkalkreal = einschaltzeitvergleichtemp - ((toleranz * heizleistung) / 100);
                                            reduzierungszeit = (tempdifferenzkalkreal * Scriptintervall) / FBTempDiff;
                                            neueheizzeit = heizzeit1 - reduzierungszeit;
                                            if (neueheizzeit <= 0) {
                                                heizzeit = rooms[roomName].Sicherheitsheizzeit;
                                                if (debug) {console.log("        sicherheitshalber 4 Minuten heizen");}
                                            }
                                            else {
                                                heizzeit = neueheizzeit * 60;
                                                if (debug) {console.log("        neueheizzeit übernommen");}
                                            }
                                        }
                                    }
                                    else {
                                        if (debug) {console.log("    Isttemperatur > solltemperatur");}
                                        heizleistung = ((hochtemp - isttemperatur) / toleranz) * 100;
                                        heizzeit1 = (Scriptintervall * heizleistung) / 100;
                                        einschaltzeitvergleichtemp = FBTempDiff * heizzeit1 / DiffStartEndHeizzeit;
                                        if (((toleranz * heizleistung) / 100) >= einschaltzeitvergleichtemp) {
                                            if (debug) {console.log("        heizzeit im original übernommen (heizleistung=" + heizleistung + ", Scriptintervall=" + Scriptintervall + ")");}
                                            heizzeit = heizzeit1 * 60;
                                        }
                                        else {
                                            if (debug) {console.log("        reduzierte heizzeit übernommen");}
                                            tempdifferenzkalkreal = einschaltzeitvergleichtemp - ((toleranz * heizleistung) / 100);
                                            reduzierungszeit = (tempdifferenzkalkreal * Scriptintervall) / FBTempDiff;
                                            neueheizzeit = heizzeit1 - reduzierungszeit;
                                            if (neueheizzeit <= 0) {
                                                heizzeit = rooms[roomName].Sicherheitsheizzeit;
                                                if (debug) {console.log("        sicherheitshalber 4 Minuten heizen??");}
                                            }
                                            else {
                                                heizzeit = neueheizzeit * 60;
                                                if (debug) {console.log("        neueheizzeit übernommen");}
                                            }
                                        }
                                    }
                                
                                    // Künftige Temperatur bei doppelter Schaltzeit vorausrechnen
                                    var tempvorausrechnung = FBTempDiff * (Scriptintervall * 2) / DiffStartEndHeizzeit;
                                    var Neueisttemperatur = isttemperatur + tempvorausrechnung;
                                
                                    if (debug) {console.log('    Errechnete Heizzeit=' + heizzeit + ' --> Neue-Ist-Temp=' + Neueisttemperatur + ' (+' + tempvorausrechnung + ')');}
                                
                                    // Schaltungen ausführen
                                    if ((isttemperatur < hochtemp) && (isttemperatur > niedertemp)) {
                                        if ((rooms[roomName].FBVergleichTemp === isttemperatur) && (isttemperatur > solltemperatur)) {
                                            if (debug) {console.log("    Ist = Vergleichstemperatur");}
                                            if (schaltzustand) {
                                                if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                                                controlFBHAktor(roomName, false);
                                            }
                                            else {
                                                if (debug) {console.log("        ist ausgeschaltet und soll ausgeschaltet sein");}
                                            }
                                        }
                                        else {
                                            if (debug) {console.log("    innerhalb toleranz");}
                                            if ((isttemperatur <= hochstill) && (isttemperatur >= niederstill)) {
                                                if (debug) {console.log("    innerhalb stille");}
                                                if (schaltzustand) {
                                                    if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                                                    controlFBHAktor(roomName, false);
                                                }
                                                else {
                                                    if (debug) {console.log("        ist ausgeschaltet und soll ausgeschaltet sein");}
                                                }
                                            }
                                            else {
                                                if (debug) {console.log("    ausserhalb stille");}
                                                if (isttemperatur < niederstill) {
                                                    if (heizzeit < rooms[roomName].Schaltschwelleniedertemp) {
                                                        if (debug) {console.log("    Schaltzeit zu klein");}
                                                        if (schaltzustand) {
                                                            if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                                                            controlFBHAktor(roomName, false);
                                                        }
                                                        else {
                                                            if (debug) {console.log("        ist ausgeschaltet und soll ausgeschaltet sein");}
                                                        }
                                                    }
                                                    else {
                                                        if (debug) {console.log("    kleiner niederstill");}
                                                        controlFBHAktor(roomName, true, heizzeit);
                                                    }
                                                }
                                                else {
                                                    if (rooms[roomName].FBVergleichTemp < isttemperatur) {
                                                        if (debug) {console.log("    über hochstill gestiegen");}
                                                        if (schaltzustand) {
                                                            if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                                                            controlFBHAktor(roomName, false);
                                                        }
                                                        else {
                                                            if (debug) {console.log("        ist ausgeschaltet und soll ausgeschaltet sein");}
                                                        }
                                                    }
                                                    else {
                                                        if (heizzeit < rooms[roomName].Schaltschwellehochtemp) {
                                                            if (debug) {console.log("    Schaltzeit zu klein");}
                                                            if (schaltzustand) {
                                                                if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                                                                controlFBHAktor(roomName, false);
                                                            }
                                                            else {
                                                                if (debug) {console.log("        ist ausgeschaltet und soll ausgeschaltet sein");}
                                                            }
                                                        }
                                                        else {
                                                            if (debug) {console.log("    größer als hochstill");}
                                                            controlFBHAktor(roomName, true, heizzeit);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    else {
                                        if (isttemperatur >= hochtemp) {
                                            if (debug) {console.log("    Isttemperatur größer als hochtemp");}
                                            if (schaltzustand) {
                                                if (Neueisttemperatur <= solltemperatur) {
                                                    if (debug) {console.log("        Neue Isttemp kleiner gleich Solltemperatur");}
                                                    if (debug) {console.log("        ist eingeschaltet und soll eingeschaltet sein");}
                                                }
                                                else {
                                                    if (debug) {console.log("        Neue Isttemp grösser Solltemperatur");}
                                                    if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                                                    controlFBHAktor(roomName, false);
                                                }
                                            }
                                            else {
                                                if (Neueisttemperatur <= solltemperatur) {
                                                    if (debug) {console.log("        Neue Isttemp kleiner gleich Solltemperatur");}
                                                    if (debug) {console.log("        ist ausgeschaltet und soll eingeschaltet sein");}
                                                    controlFBHAktor(roomName, true, 36000);
                                                }
                                                else {
                                                    if (debug) {console.log("        Neue Isttemp grösser Solltemperatur");}
                                                    if (debug) {console.log("        ist ausgeschaltet und soll ausgeschaltet sein");}
                                                }
                                            }
                                        }
                                        else {
                                            if (isttemperatur == niedertemp) {
                                                if (schaltzustand) {
                                                    if (Neueisttemperatur >= niederstill) {
                                                        if (debug) {console.log("        Neue Isttemp größer gleich Niederstill");}
                                                        if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                                                        controlFBHAktor(roomName, false);
                                                    }
                                                    else {
                                                        if (debug) {console.log("        Neue Isttemp kleiner Niederstill");}
                                                        if (debug) {console.log("        ist eingeschaltet und soll eingeschaltet sein");}
                                                    }
                                                }
                                                else {
                                                    if (Neueisttemperatur >= niederstill) {
                                                        if (debug) {console.log("        Neue Isttemp größer gleich Niederstill");}
                                                        if (debug) {console.log("        ist ausgeschaltet und soll eingeschaltet sein");}
                                                    }
                                                    else {
                                                        if (debug) {console.log("        Neue Isttemp kleiner Niederstill");}
                                                        if (debug) {console.log("        ist ausgeschaltet und soll eingeschaltet sein");}
                                                        controlFBHAktor(roomName, true, 36000);
                                                    }
                                                }
                                            }
                                            else {
                                                if (debug) {console.log("    Isttemperatur ist kleiner als niedertemp");}
                                                if (schaltzustand) {
                                                    if (Neueisttemperatur >= niederstill) {
                                                        if (debug) {console.log("        Neue Isttemp größer gleich Niederstill");}
                                                        if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                                                        controlFBHAktor(roomName, false);
                                                    }
                                                    else {
                                                        if (debug) {console.log("        Neue Isttemp kleiner Niederstill");}
                                                        if (debug) {console.log("        ist eingeschaltet und soll eingeschaltet sein");}
                                                    }
                                                }
                                                else {
                                                    if (Neueisttemperatur >= niederstill) {
                                                        if (debug) {console.log("        Neue Isttemp größer gleich Niederstill");}
                                                        if (debug) {console.log("        ist ausgeschaltet und soll eingeschaltet sein");}
                                                    }
                                                    else {
                                                        if (debug) {console.log("        Neue Isttemp kleiner Niederstill");}
                                                        if (debug) {console.log("        ist ausgeschaltet und soll eingeschaltet sein");}
                                                        controlFBHAktor(roomName, true, 36000);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    rooms[roomName].FBVergleichTemp = isttemperatur;
                                
                                    rooms[roomName].StartHeizzeit.push(new Date().getTime());
                                    if (rooms[roomName].StartHeizzeit.length > 3) rooms[roomName].StartHeizzeit.shift();
                                
                                    rooms[roomName].skriptTimeout = setTimeout(function() {
                                        //if (debug) {console.log('Timeout ausgelöst ' + roomName);}
                                        rooms[roomName].skriptTimeout = null;
                                        ventilLogik(roomName);
                                    }, rooms[roomName].skriptZyklus*60*1000);
                                    if (debug) {console.log("Ende " + roomName + ', Nächster Lauf in ' + (rooms[roomName].skriptZyklus) + 'm');}
                                }
                                
                                function controlFBHAktor(roomName, enabled, time) {
                                    var useSupport = false;
                                    if (rooms[roomName].stateIdHeizungUnterstuetzungAktor) {
                                        var isttemperatur = getState(rooms[roomName].stateIdIstTemperatur).val;
                                        var solltemperatur = getState(rooms[roomName].stateIdSollTemperatur).val;
                                        if (enabled && solltemperatur - isttemperatur > rooms[roomName].heizunterstuetzungKelvin) {
                                            if (debug) {console.log('    Steuern UnterstützungsAktor FBH ' + roomName + ' --> ' + enabled + ' (time=' + time + ')');}
                                            useSupport = true;
                                        }
                                        else if (!enabled || getState(rooms[roomName].stateIdHeizungUnterstuetzungAktor).val) useSupport = true;
                                    }
                                
                                    if (enabled && time) {
                                        time = Math.round(time);
                                        setState(rooms[roomName].stateIdHeizungAktorOnTime, time, false, function() {
                                            if (debug) {console.log('    Steuern Aktor FBH ' + roomName + ' --> ' + enabled + ' (time=' + time + ')');}
                                            setState(rooms[roomName].stateIdHeizungAktor, true, false);
                                            if (useSupport) {
                                                setState(rooms[roomName].stateIdHeizungUnterstuetzungAktorOnTime, time, false, function() {
                                                    if (debug) {console.log('    Steuern UnterstützungsAktor FBH ' + roomName + ' --> ' + enabled + ' (time=' + time + ', tempDiff=' + (solltemperatur - isttemperatur) + ')');}
                                                    setState(rooms[roomName].stateIdHeizungUnterstuetzungAktor, true, false);
                                                });
                                            }
                                        });
                                    }
                                    else {
                                        if (debug) {console.log('    Steuern Aktor FBH ' + roomName + '--> ' + enabled);}
                                        setState(rooms[roomName].stateIdHeizungAktor, enabled, false);
                                        if (useSupport) {
                                            if (debug) {console.log('    Steuern UnterstützungsAktor FBH ' + roomName + '--> ' + enabled);}
                                            setState(rooms[roomName].stateIdHeizungUnterstuetzungAktor, enabled, false);
                                        }
                                    }
                                }
                                
                                

                                Viel Spass bei der Nutzung. Klappt bei mir recht gut und die Räume übersteuern fast nicht …

                                Eine weitere Funktionalität zur Voraussteuerung und Aufheizzeitmessung gibt es unter http://forum.iobroker.net/viewtopic.php ... 89#p107689

                                Ingo

                                U Offline
                                U Offline
                                Unterstedter
                                schrieb am zuletzt editiert von
                                #56

                                @apollon77

                                Ich glaube ich habe noch einen kleinen Fehler im Skript gefunden. Müsste es nicht in der onstop Funktion in der if-Funktion

                                statt:
                                if (rooms[roomname].skriptTimeout) {

                                So lauten:
                                if (rooms[room].skriptTimeout) {

                                Danke und Grüße!

                                apollon77A 1 Antwort Letzte Antwort
                                0
                                • U Unterstedter

                                  @apollon77

                                  Ich glaube ich habe noch einen kleinen Fehler im Skript gefunden. Müsste es nicht in der onstop Funktion in der if-Funktion

                                  statt:
                                  if (rooms[roomname].skriptTimeout) {

                                  So lauten:
                                  if (rooms[room].skriptTimeout) {

                                  Danke und Grüße!

                                  apollon77A Offline
                                  apollon77A Offline
                                  apollon77
                                  schrieb am zuletzt editiert von
                                  #57

                                  @unterstedter Hast Recht!

                                  Beitrag hat geholfen? Votet rechts unten im Beitrag :-) https://paypal.me/Apollon77 / https://github.com/sponsors/Apollon77

                                  • Debug-Log für Instanz einschalten? Admin -> Instanzen -> Expertenmodus -> Instanz aufklappen - Loglevel ändern
                                  • Logfiles auf Platte /opt/iobroker/log/… nutzen, Admin schneidet Zeilen ab
                                  M 1 Antwort Letzte Antwort
                                  0
                                  • apollon77A apollon77

                                    @unterstedter Hast Recht!

                                    M Offline
                                    M Offline
                                    Morgennebel
                                    schrieb am zuletzt editiert von
                                    #58

                                    Moin,

                                    ich habe den Verdacht, daß das Script mit der aktuellen JS-Engine nicht richtig zusammenspielt.

                                    Das Script lief mehrere Monate fehlerfrei mit Homematic-230V DIN-Schienen 4fach Aktoren und 230V-Fußbodenreglern über ein Raspberrymatic mit Charly-Funkmodul.

                                    Seit 1-2 Wochen (in etwa, seit ein Update der JS-Engine kam) werden rein über die Fußbodenheizung beheizte Räume nicht mehr warm. In FLOT-Diagrammen zeigt sich, daß die Aktoren nur ganz kurz oder gar nicht angehen:

                                    Gästezimmer.PNG

                                    Oder nur viel zu spät und zögerlich angehen:

                                    Gästezimmer 2.PNG

                                    Ich bin ehrlich gesagt etwas ratlos, was sonst nicht funktionieren könnte.

                                    Hat jemand ähnliche Probleme?

                                    Danke, -MN

                                    --
                                    IOBroker nach 5.5 Jahren FHEM.
                                    Docker: IOB+redis+InfluxDB mit Devuan 6.0 (Linux).
                                    OPNSense, Ruckus, Homematic, HeatingControl, Hue, InfluxDB, Kodi, LinkedDevices, LGTV, LGTV11, Luftdaten, MQTT, MiHome-Vaccum, Pi-Hole, Pollenflug, Shelly, Telegram, Vis, Wolf,

                                    apollon77A 1 Antwort Letzte Antwort
                                    0
                                    • M Morgennebel

                                      Moin,

                                      ich habe den Verdacht, daß das Script mit der aktuellen JS-Engine nicht richtig zusammenspielt.

                                      Das Script lief mehrere Monate fehlerfrei mit Homematic-230V DIN-Schienen 4fach Aktoren und 230V-Fußbodenreglern über ein Raspberrymatic mit Charly-Funkmodul.

                                      Seit 1-2 Wochen (in etwa, seit ein Update der JS-Engine kam) werden rein über die Fußbodenheizung beheizte Räume nicht mehr warm. In FLOT-Diagrammen zeigt sich, daß die Aktoren nur ganz kurz oder gar nicht angehen:

                                      Gästezimmer.PNG

                                      Oder nur viel zu spät und zögerlich angehen:

                                      Gästezimmer 2.PNG

                                      Ich bin ehrlich gesagt etwas ratlos, was sonst nicht funktionieren könnte.

                                      Hat jemand ähnliche Probleme?

                                      Danke, -MN

                                      apollon77A Offline
                                      apollon77A Offline
                                      apollon77
                                      schrieb am zuletzt editiert von
                                      #59

                                      @morgennebel Hast du im Skript mal "debug" eingeschaltet, dann solltest Du sehen was er wann tut und wann/warum nicht

                                      Beitrag hat geholfen? Votet rechts unten im Beitrag :-) https://paypal.me/Apollon77 / https://github.com/sponsors/Apollon77

                                      • Debug-Log für Instanz einschalten? Admin -> Instanzen -> Expertenmodus -> Instanz aufklappen - Loglevel ändern
                                      • Logfiles auf Platte /opt/iobroker/log/… nutzen, Admin schneidet Zeilen ab
                                      M 2 Antworten Letzte Antwort
                                      0
                                      • apollon77A apollon77

                                        @morgennebel Hast du im Skript mal "debug" eingeschaltet, dann solltest Du sehen was er wann tut und wann/warum nicht

                                        M Offline
                                        M Offline
                                        Morgennebel
                                        schrieb am zuletzt editiert von
                                        #60

                                        @apollon77
                                        Gerade aktiviert. Bei 24 Kreisen ist das recht umfangreich. Lässt sich das auf 2 Kreise irgendwie reduzieren?

                                        Danke für die schnelle Hilfe,

                                        Ciao, -MN

                                        --
                                        IOBroker nach 5.5 Jahren FHEM.
                                        Docker: IOB+redis+InfluxDB mit Devuan 6.0 (Linux).
                                        OPNSense, Ruckus, Homematic, HeatingControl, Hue, InfluxDB, Kodi, LinkedDevices, LGTV, LGTV11, Luftdaten, MQTT, MiHome-Vaccum, Pi-Hole, Pollenflug, Shelly, Telegram, Vis, Wolf,

                                        apollon77A 1 Antwort Letzte Antwort
                                        0
                                        • M Morgennebel

                                          @apollon77
                                          Gerade aktiviert. Bei 24 Kreisen ist das recht umfangreich. Lässt sich das auf 2 Kreise irgendwie reduzieren?

                                          Danke für die schnelle Hilfe,

                                          Ciao, -MN

                                          apollon77A Offline
                                          apollon77A Offline
                                          apollon77
                                          schrieb am zuletzt editiert von
                                          #61

                                          @morgennebel Nicht ohne das Skript anzupassen ... debug mode geht nur alles oder nicht

                                          Beitrag hat geholfen? Votet rechts unten im Beitrag :-) https://paypal.me/Apollon77 / https://github.com/sponsors/Apollon77

                                          • Debug-Log für Instanz einschalten? Admin -> Instanzen -> Expertenmodus -> Instanz aufklappen - Loglevel ändern
                                          • Logfiles auf Platte /opt/iobroker/log/… nutzen, Admin schneidet Zeilen ab
                                          1 Antwort Letzte Antwort
                                          1
                                          Antworten
                                          • In einem neuen Thema antworten
                                          Anmelden zum Antworten
                                          • Älteste zuerst
                                          • Neuste zuerst
                                          • Meiste Stimmen


                                          Support us

                                          ioBroker
                                          Community Adapters
                                          Donate

                                          346

                                          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