Bitte Programmierhilfe

paul53

@ticaki sagte: Die Automatik sollte aber wirklich nicht noch unendlich rumschalten daher:

Diese Wiederholungsbegrenzung kann man natürlich ergänzen.

skorpil

was genau ist jetzt der Unterschied zwischen dem Vorschlag von ticaki:

const retrys = 3
var autoAusZ = getState(KlimAut).val ? retrys : 0;
 
function Regler() {
     if(auto) {
         if (temp >= maxSoll) {
             if (!istEin) setState(klimEin, true);
         } else if (temp <= minSoll && istEin) {
             setState(klimAus, true);
         }
     } else if (autoAusZ-- > 0 && istEin) {       
         setState(klimAus, true);
     } 
 } 
 
 Regler(); // Sktiptstart
  
 on(KlimAut, function (dp) {
     auto = dp.state.val;
     autoAusZ = retrys;
     Regler();
 });

und meinem Script (siehe oben):

// ************Deklarationen********;

const KlimAut = 'hm-rega.0.9668'/*KlimaAutomatic*/;
const AktTemperaturChan = 'hm-rpc.0.JEQ0709626.1.TEMPERATURE'/*Thermostat Wohnzimmer 0 TEMPERATURE*/;
const Stromwert = 'hm-rpc.0.OEQ1544610.2.POWER'/*Zw Stecker 3 Wohnzimmer mM(WERTE):2 POWER*/;

// Schaltbefehle  
const klimEin = 'broadlink2.0.RM:Broadlink-RMPROPLUS-f4-3c-2b.L.Klima Weiden EIN'/*Klima Weiden EIN*/;
const klimAus = 'broadlink2.0.RM:Broadlink-RMPROPLUS-f4-3c-2b.L.Klima  Weiden AUS'/*Klima  Weiden AUS*/;

// Sollwert 23 Wohnzimmer ................
const Sollwert = 23;

//Erlaubten Schwankungsbereich der Temperatur setzen 
const maxSoll = Sollwert + 1; 
const minSoll = Sollwert - 1;

// Anzahl der Wiederholungen und Intervallzeit
const maxWiederholungen = 3;
const intervallzeit = 150000; // 2,5 Minuten in Millisekunden

//****************Programm*********;

on(KlimAut, function (dp) {
    if(!dp.state.val) setState(klimAus, true);
    else if(getState(AktTemperaturChan).val > maxSoll) {
        setState(klimEin, true);
        pruefeStromverbrauch();
    }
});
 
on(AktTemperaturChan, function(dp) {
    // Aktuelle Temperatur von Wohnzimmer ermitteln  
    let AktTemperatur = dp.state.val;
    if(getState(KlimAut).val) {
        // Bei aktueller Temperatur > Sollwert + 1.0 Aktor ausschalten
        // Bei aktueller Temperatur < Sollwert - 1.0 Aktor einschalten
        if (AktTemperatur > maxSoll) {
            setState(klimEin, true);
            pruefeStromverbrauch();
        } else if (AktTemperatur < minSoll) {
            setState(klimAus, true);
            pruefeStromverbrauch();
        }
    }
});

function pruefeStromverbrauch() {
    let wiederholungen = 0;
    let stromverbrauchPruefen = setInterval(function() {
        let stromverbrauch = getState(Stromwert).val;
        if (stromverbrauch > 100) {
            clearInterval(stromverbrauchPruefen);
        } else {
            wiederholungen++;
            if (wiederholungen > maxWiederholungen) {
                clearInterval(stromverbrauchPruefen);
                console.log('Schaltbefehl hat nicht funktioniert');
            } else {
                console.log('Schaltbefehl wiederholen');
                if (getState(klimEin).val) {
                    setState(klimEin, true);
                } else if (getState(klimAus).val) {
                    setState(klimAus, true);
                }
            }
        }
    }, intervallzeit);
}

Danke für Eure Hilfe

ticaki

@skorpil

Deine Bedingungen werden erfüllt, in deinem Skript wird nur 1 mal der Ausschaltbefehl geprüft.
wenn pruefeStr... 2 mal so aufgerufen wird das beide Interval gleichzeitig laufen, wird clearInterval im besten Fall den jüngsten beenden und der erste läuft unendlich weiter. k.A. da das nicht funktionieren kann, hab ichs nicht getestet. selbiges gilt für wiederholungen... eine Variable für Intervalle die mehrfach aufgerufen werden können ist quark. Ob sie es sollen ist was anderes wie ob sie es können :)

if (getState(klimEin).val) {
                     setState(klimEin, true);
                 } else if (getState(klimAus).val) {
                     setState(klimAus, true);
                 }

mal neben her... wer setzt klimEin auf false?

EDIT:
Ich würde den Infrarotteil wohl so lösen:

const ON = 1
const OFF = 2
var target_state = 0
var current_state = 0
function stromverbrauch(){
    // hier gucken ob an
    return // true oder false
}

setInterval(function(){
    if ( target_state == current_state) return
    if (target_state == ON) {
        if (!stromverbrauch) {
            //sende einschaltsignal
        } else  {
            current_state = ON
        }
    }
    if (target_state == OFF) {
        if (stromverbrauch ) {
            //sende auschaltsignal
        } else {
            current_state = OFF
        }
    }
},10000)

Noch ein EDIT:
über target_state steuert man das dann. Vielleicht noch ein Zähler der bei auto off hoch zählt und den return am anfang auslöst

if ( (target_state == current_state && auto) || (!auto && acount++ > 3)) // der zählt nur hoch wenn auto == false nur noch zurücksetzen beim on(auto)

Noch was:
so kannst du die Zahl der aufrufe insgesamt begrenzen

var retrys = 0;
function setTargetState(val) {
    target_state = val
    retrys = 0;
}
setInterval(function(){
    if (target_state == current_state || retrys++ > 3) return

dann steuert man über setTargetState(ON)

paul53

@ticaki sagte: wer setzt klimEin auf false?

Die meisten Button sind immer true und reagieren auf Aktualisierung des Zeitstempels.

ticaki

@paul53
ok. Er fragt auf true ab und das ist ja dann immer true?

paul53

@ticaki sagte: Er fragt auf true ab und das ist ja dann immer true?

Ja, die Abfrage ist sinnlos.

skorpil

Schon mal vorweg:

KlimAut = 'hm-rega.0.9668'/*KlimaAutomatic*/

ist eine Sytemvariable (Logik) mit wahr=ein und falsch=aus aus der homematic mit der die AUTOMATIC ein- und ausgeschaltet werden soll. In der Folge soll die Automatik dann prüfen, ob die Temperatur bestimmte Grenzwerte über- bzw. unterschreitet und die Klimaanlage mittels der BroadLink Infrarotbefehle ein- und ausschalten. Da die Infrarot Befehle unidirectional sind, muss jeweils noch mittels der Prüfung des Stromverbrauchs, der im Zwischenstecker ermittelt wird, geprüft werden, ob der Infrarot Befehl funktioniert hat. Falls ja (Stromverbrauch über 100) nichts tun, falls nein, Infrarot Befehl noch einmal senden und Prüfung wiederholen, max. 3 mal.

Eigentlich simple. Aber in JavaScript doch ziemlich kompliziert (für mich).

Wie gesagt, ich melde mich morgen Vormittag wieder, wenn ich konkret an den Skripten gearbeitet habe. Danke.

skorpil

Wie versprochen: ich habe noch einmal weiter gearbeitet und mir folgendes einfallen lassen:

// ************Deklarationen********;
const KlimAut = 'hm-rega.0.9668'; // KlimaAutomatic
const AktTemperaturChan = 'hm-rpc.0.JEQ0709626.1.TEMPERATURE'; // Thermostat Wohnzimmer 0 TEMPERATURE
const Stromwert = 'hm-rpc.0.OEQ1544610.2.POWER'; // Zw Stecker 3 Wohnzimmer mM(WERTE):2 POWER
const MAX_RETRY = 3;
let automaticActive = false; // Prüfvariable für Klimaautomatik

// Sollwert 23 Wohnzimmer ................
const Sollwert = 23;

// Erlaubten Schwankungsbereich der Temperatur setzen 
const maxSoll = Sollwert + 1; 
const minSoll = Sollwert - 1;

// Schaltbefehle 
const klimEin = 'broadlink2.0.RM:Broadlink-RMPROPLUS-f4-3c-2b.L.Klima Weiden EIN'; // Klima Weiden EIN
const klimAus = 'broadlink2.0.RM:Broadlink-RMPROPLUS-f4-3c-2b.L.Klima  Weiden AUS'; // Klima  Weiden AUS



//****************Programm*********;
on({ id: KlimAut, change: 'any' }, function (obj) {
    const automaticOn = obj.state.val; // Wert der Systemvariable KlimAut (true/false)

    if (automaticOn && !automaticActive) {
        automaticActive = true; // Klimaautomatik aktivieren
        checkTemperature();
    } else if (!automaticOn && automaticActive) {
        automaticActive = false; // Klimaautomatik deaktivieren
        sendIRCommand(klimAus); // Klimaanlage ausschalten
    }
});

on({ id: AktTemperaturChan, change: 'ne', ack: true }, function (obj) {
    if (automaticActive) {
        const currentTemperature = obj.state.val;

        if (currentTemperature > maxSoll) {
            sendIRCommand(klimEin);
        } else if (currentTemperature < minSoll) {
            sendIRCommand(klimAus);
        }
    }
});

function checkTemperature() {
    const currentTemperature = getState(AktTemperaturChan).val;

    if (currentTemperature > maxSoll) {
        sendIRCommand(klimEin);
    } else if (currentTemperature < minSoll) {
        sendIRCommand(klimAus);
    }
}

function sendIRCommand(command) {
    let retryCount = 0;

    while (retryCount < MAX_RETRY) {
        setState(command, true, function (err) {
            if (!err) {
                const powerConsumption = getState(Stromwert).val;

                if (powerConsumption > 100) {
                    retryCount++;
                } else {
                    return; // Erfolgreich, nichts weiter tun
                }
            } else {
                console.error('Fehler beim Setzen des Befehls:', err);
                return;
            }
        });

        if (retryCount === 0) {
            break; // Erfolgreich, keine Wiederholung erforderlich
        }
    }
}
um sicherzustellen, dass die Automatic nur arbeitet, wenn sie mit KlimAut eingeschaltet wird, habe ich noch eine Prüfvariable eingebaut. 

Ich teste gerade im Realbetrieb!

ticaki

@skorpil
ganz am Anfang dieses Topics wurde gesagt das warten in while schleifen nicht "gut" ist, und hier wartest du ja nicht mal. Die Schleife läut in unter 1 Millisekunde durch.

Das hier könnte funktioniert:
EDIT: mehr zusammengefasst, kürzer und nen logikfehler raus:

// ************Deklarationen********;
const KlimAut = 'hm-rega.0.9668'; // KlimaAutomatic
const AktTemperaturChan = 'hm-rpc.0.JEQ0709626.1.TEMPERATURE'; // Thermostat Wohnzimmer 0 TEMPERATURE
const Stromwert = 'hm-rpc.0.OEQ1544610.2.POWER'; // Zw Stecker 3 Wohnzimmer mM(WERTE):2 POWER
const MAX_RETRY = 3;
let automaticActive = false; // Prüfvariable für Klimaautomatik
 
// Sollwert 23 Wohnzimmer ................
const Sollwert = 23;
 
// Erlaubten Schwankungsbereich der Temperatur setzen 
const maxSoll = Sollwert + 1; 
const minSoll = Sollwert - 1;
 
// Schaltbefehle 
const klimEin = 'broadlink2.0.RM:Broadlink-RMPROPLUS-f4-3c-2b.L.Klima Weiden EIN'; // Klima Weiden EIN
const klimAus = 'broadlink2.0.RM:Broadlink-RMPROPLUS-f4-3c-2b.L.Klima  Weiden AUS'; // Klima  Weiden AUS
 
/********************* */
const maxPower = 100
var retrys = 0;
var target_state = getState(Stromwert).val > maxPower ? klimEin : klimAus
var current_state = target_state
/********************* */
//****************Programm*********;
on({ id: KlimAut, change: 'any' }, function (obj) {
    const automaticOn = obj.state.val; // Wert der Systemvariable KlimAut (true/false)
    
    if (automaticOn && !automaticActive) {
        automaticActive = true; // Klimaautomatik aktivieren
        checkTemperature(getState(AktTemperaturChan).val);
    } else if (!automaticOn && automaticActive) {
        retrys = 0
        automaticActive = false; // Klimaautomatik deaktivieren
        sendIRCommand(klimAus); // Klimaanlage ausschalten
    }
});
 
on({ id: AktTemperaturChan, change: 'ne', ack: true }, function (obj) {
    if (automaticActive) checkTemperature(obj.state.val)
});
 
function checkTemperature(val) {
    const currentTemperature = val;
 
    if (currentTemperature > maxSoll) {
        sendIRCommand(klimEin);
    } else if (currentTemperature < minSoll) {
        sendIRCommand(klimAus);
    }
}
 
function sendIRCommand(val) {
    target_state = val
    retrys = 0;
}
on({id:Stromwert, change:'ne'}, function(obj){
    if (obj.state.val > maxPower) current_state = klimEin
    else current_state = klimAus
})
setInterval(function(){
    if (target_state == current_state || ++retrys > MAX_RETRY) return
    setState(target_state, true)
},10000)

EDIT: stell die 10000 auf die Reaktionsgeschwindigkeit deiner Geräte ein, also x für das senden des Befehls + Y für die längste Zeit die es braucht bis ein Stromwert geliefert wird. Maßeinheit ist Millisekunden.

skorpil

@ticaki Dankeschön. Wo war der Logikfehler, den Du entdeckt hast?

Und das mit den while schleifen habe ich offenbar übersehen. Ich kann es auch nicht finden.

Aber Du hast recht, es ist gut, wenn ich eine Reaktionszeit für das Warten auf die Meldung des Zwischen Steckers eine Verzögerung einbaue.

ticaki

@skorpil
Ich hatte in der ersten Version einen Logikfehler, dann hab ich meine Teil vollständig in deinen integriert, bei beiden alles mehr zusammengefasst. Das sollte so laufen. Und die Reaktionszeit bezog sich auf das von mir gepostet Skript die 10000 am Schluß muß größer als die Reaktionszeit von allen Komponenten sein. Das ist nicht nur ein Beispiel :)

skorpil

@ticaki vieeeelen Dank. Ich habe das so übernommen. Es läuft!

skorpil

@ticaki kannst Du mir erklären, was diese Anweisung

var target_state = getState(Stromwert).val > maxPower ? klimEin : klimAus

macht?

Einen Fehler habe ich schon entdeckt. Das Script schaltet NICHT aus, wenn KlimAut aus aus gesetzt wird.

Und nicht nur das: kannst Du mir bitte, damit ich das verstehe und lerne auch erklären, wie jetzt Dein Teil mit meinem genau zusammenarbeitet?

ticaki

@skorpil sagte in Bitte Programmierhilfe:

wenn KlimAut aus aus gesetzt wird.**

Und nicht nur das

on({ id: KlimAut, change: 'any' }, function (obj) {
    const automaticOn = obj.state.val; // Wert der Systemvariable KlimAut (true/false)
    
    if (automaticOn && !automaticActive) {

Also wenn Klima aus war und du sie einschaltest passiert das

        automaticActive = true; // Klimaautomatik aktivieren
        checkTemperature(getState(AktTemperaturChan).val);

und wenn Klima An war und du schaltest sie aus das:

    } else if (!automaticOn && automaticActive) {
        retrys = 0
        automaticActive = false; // Klimaautomatik deaktivieren
        sendIRCommand(klimAus); // Klimaanlage ausschalten
    }
});

Und was passiert wenn die Anlage an ist und du das Skript neustartest? hehehe

// das oben ersetzten
let automaticActive = getState(KlimAut).val

ticaki

Erklärung mache ich gesondert:

Mein Code stellt ein gesonderter Teil dar, der nicht sychron läuft. Wenn du also die Klima an schaltest, kann es bis zur Intervalllänge dauern bis was passiert, beim Testen nervig, im normalen Betrieb wayne. :)

Der Stromverbrauch wird überwacht und in einer Variable current_state (aktueller Zustand) wird festgehalten ob das Gerät an oder aus ist.
Dein Code sendet an meinen Befehle was du gerne hättest, das wird in target_state also als Wunsch/Zielzustand gespeichert, dann wird alle X Sekunden geprüft ob der Zielzustand erreicht wurde und wenn nicht wird die Fernbedienung ausgelöst. MAX_RETRY begrenzt die Anzahl der Versuche.

EDIT: hab doch noch einen Fehler gefunden

setInterval(function(){
    if (target_state != current_state && ++retrys < MAX_RETRY) setState(target_state, true)   
},10000)

Vorher hat retrys nicht hochgezählt, wenn der Schaltvorgang erfolgt war. Das führt dazu dass das Skript das Gerät umschaltet wenn du es manuell bedienst.
Jetzt zählt es hoch und nach MAX_RETRY * 10000 (oder was du da stehen hast) macht das skript nichts mehr.

skorpil

@ticaki merci

paul53

@ticaki sagte: das wird in target_state also als Wunsch/Zielzustand gespeichert

Die Variablen target_state und current_state enthalten Datenpunkt-IDs. Die Bezeichnung "state" ist unglücklich gewählt, wie man an der Formulierung sieht.

ticaki

@paul53
Ja, hatte vorher ON und OFF, aber das ist doch nur mehr code :)

skorpil

Danke Euch beiden @paul53 @ticaki

ticaki

@skorpil
hmpf habs falsch rum gepostet:

setInterval(function(){
    if (++retrys < MAX_RETRY && target_state != current_state ) setState(target_state, true)   
},10000)

Community Forum

NEWS

Bitte Programmierhilfe

Support us

570

32.5k

81.8k

1.3m