Weihnachtsangebot 2025! 🎄

[Homoran]

@paul53 sagte:

Dann stoppe auch timeout bei Ablauf der Zeit

jetzt bin ich irritiert. Nach Ablauf trotzdem stoppen?

@paul53 sagte in Wie die Parameter für History sinnvoll nutzen?:

und leere die Liste

der Baustein war beim umgestalten rausgefallen und ich wusste nicht mehr wohin :blush:

sieht im Moment so aus

@paul53 sagte in Wie die Parameter für History sinnvoll nutzen?:

Oder verwende ein Intervall.

das feuert aber stumpf alle 5 Minuten, oder?
ist eigentlich egal. Ich hatte gedacht immer 5 Minuten nach dem letzten Wert, auch wenn es ein "high priority" Wert war.

[paul53]

@homoran sagt: das feuert aber stumpf alle 5 Minuten, oder?

Ja, bis es gestoppt wird.

@homoran sagte in Wie die Parameter für History sinnvoll nutzen?:

immer 5 Minuten nach dem letzten Wert

Der Timer kann erst wieder starten, wenn die Variable timeout auf null zurück gesetzt wurde. Sonst wirkt die erforderliche Sperre.

[Homoran]

@paul53 jetzt si d wir schon lange nicht mehr beim Originalthema.
Wenn ich's nicht vergesse spalte ich den "nicht History" Teil ab und schieb ihn nach Blockly.

---

Das ganze wird langsam zum Mammutwerk.
Nachdem der Entladen-Teil gestern erwartungsgemäß lief, warf er heute bei Sonnenschein Fehler, dass ich einen Mittelwert aus einem leeren Array bilden wollte.
Also flugs noch das Intervall gestoppt.

Dieser startete heute abend nachdem die Solarenergie nicht mehr zum Laden reichte, und die Batterie wieder entlud, jedoch nicht.
Also muss ich den Start Intervall irgendwie anders lösen.

Was mir auch nicht präsent war ist die Tatsache, dass das kopieren des Timeout Konstrukts jedesmal die Intervall-Variable hochzählt.

Geht es irgendwie mit dem selben Intervall mehrfach zu arbeiten?
ggf. als Funktion?
So in der Art Start oder Stop Intervall "Laden", resp. Start/Stop Intervall "Entladen".

Sonst habe ich in der Endgültigen Fassung mindestens 6 Intervalle, die alle an allen möglichen Programmstellen gestoppt werden müssten.

[paul53]

@homoran sagte: Geht es irgendwie mit dem selben Intervall mehrfach zu arbeiten ggf. als Funktion?

Ja, wenn innerhalb der Intervall-Callback-Funktion die gleichen Kommandos abgearbeitet werden, kann man das Intervall in eine Funktion auslagern.

[Homoran]

@paul53 DANKE!

werde ich später versuchen umzusetzen!

[AndyGR42]

@homoran irgendwie finde ich ein Script übersichtlicher :)

Im Prinzip bestimmst Du mit "historyArrayLength" und "updateFrequence", zusammen mit der Frequenz des eingehenden Signals, wie oft die History geschrieben wird und wie "glatt" das Ergebnis wird. Je länger das Array desto "glatter" die Kurve. History wird geschrieben, sobald das Array voll ist, um fehlerhafte Einträge zu vermeiden.

const historyArrayLength = 5;
const updateFrequence = 5;

var updateFrequencecounter = updateFrequence;

// create memory persistent arrays

let historyArray = new Array(historyArrayLength); 

var i;

for (i = 0; i < historyArrayLength; i++){ //fill array with -1
    
    historyArray[i] = -1;
}

// process avarage

on({id: "0_userdata.0.IoT.DaylightSensor.DayLight02", change: "any"}, function (obj) {
    var value = obj.state.val;

    update_historyArry(value);

    var index = historyArray.indexOf(-1);

    if (index == -1 && updateFrequencecounter <= 0)
    {
        
        var sum = historyArray.reduce((a, b) => a + b, 0);
        var avg = (sum / historyArray.length) || 0;
        
        setState('0_userdata.0.Test.Test01', Number(avg));
        updateFrequencecounter = updateFrequence;
    }

    updateFrequencecounter--;

});


// ################################### helper funcions

// shift and update the array

function update_historyArry(value)
{
    var i;

    for (i = historyArrayLength - 1; i >= 0; i--)
    {
        if (i > 0)
        {
           historyArray[i] = historyArray[i - 1];
        }
        else
        {
            historyArray[i] = value;
        }
    }
}

[Homoran]

@andygr42 sagte in Werteabhängiges loggen per Skript:

irgendwie finde ich ein Script übersichtlicher

beim Lesen kann ich dir fast zustimmen.
Schreiben kann ich es nicht

[paul53]

@homoran
Meiner Meinung wird zu früh zwischen Laden und Entladen unterschieden. Ich würde erst auswerten, ob gegenüber dem zuletzt geschriebenen Wert eine große Leistungsänderung (in beiden Richtungen) stattgefunden hat und diese protokollieren. Bei der Mittelwertbildung über 2 Minuten würde ich den Mittelwert auswerten.

[AndyGR42]

@homoran

Ich habe es nochmal etwas aufgeräumt. Im Prinzip reicht Copy & Paste sowie das Ändern der ersten 4 Zeilen.

Das Skript macht ganz simpel eine Mittelwertberechnung ohne Normalisierung. Mit den Werten kannst Du dann etwas rumspielen. Es macht natürlich keinen Sinn, dass die Array Länge kleiner als die Update Frequenz ist. Dann gehen Informationen verloren. Wenn aber (bei einem Signal mit 1Hz) bei einem Schreiben der History alle 60 Sekunden die Kurve immer noch zu unruhig ist, kann die Verlängerung des Arrays auf 120 oder 180 eine deutliche Verbesserung bringen.

Ich habe auch noch ein Script mit einer Normalisierung, bei der vorher per Normalverteilung die höchsten und tiefsten Ausreißer abgeschnitten werden können. Das ist aber lange nicht so universell und selbsterklärend. Zudem könnte es in deinem Fall die Messwerte verfälschen, da Peaks keinen Einfluss auf den Durchschnitt mehr haben.

Ach ja, für eine große Zahl an DP macht es natürlich keinen Sinn jeweils ein Script zu erstellen. Wenn gewünscht kann ich das noch umbauen um mehrere DP einfacher und übersichtlicher zu verwalten.

const inputDP = '0_userdata.0.IoT.DaylightSensor.DayLight02';
const historyDP = '0_userdata.0.Test.Test01';

const historyArrayLength = 5;
const updateFrequence = 5;

/** nothing to chage below this line */
/** -------------------------------- */

var updateFrequenceCounter = updateFrequence; /** reset update counter */
var i;

let historyArray = new Array(historyArrayLength); /** create persistent arry */

for (i = 0; i < historyArrayLength; i++){ /** fill array with "false" for data consistancy check */
    historyArray[i] = -1;
}

/** wait for changes and calculate avarage */

on({id: inputDP, change: "any"}, function (obj) {
    var value = obj.state.val;

    update_historyArray(value); /** run shift & update array */

    var index = historyArray.indexOf(-1); /** search for remaining -1 in arry */

    if (index == -1 && updateFrequenceCounter <= 0) /** update history DP when data is consistent (array filled) and update cycle is reached */
    {
        
        var sum = historyArray.reduce((a, b) => a + b, 0); /** calculate average from the array */
        var avg = (sum / historyArray.length) || 0;
        
        setState(historyDP, Number(avg)); /** write history DP */
        updateFrequenceCounter = updateFrequence; /** reset update counter */
    }
    else
    {
        updateFrequenceCounter--; /** count down until next update */
    }
});


// ################################### helper funcions

// shift and update the array

function update_historyArray(value)
{
    var i;

    for (i = historyArrayLength - 1; i >= 0; i--) 
    {
        if (i > 0)
        {
           historyArray[i] = historyArray[i - 1];
        }
        else
        {
            historyArray[i] = value;
        }
    }
}

[Homoran]

@paul53 sagte:

Meiner Meinung wird zu früh zwischen Laden und Entladen unterschieden.

ich habe einen Datenpunkt mit wechselndem Vorzeichen.
natürlich kann ich da eine Hysterese einbauen, aber was soll die bringen (für das Skript)?
je nach Verbraucher oder Wechsel in der Sonneneinstrahlung kann der Verbrauch/die Produktion immer schleichend an der Entscheidungsgrenze liegen oder auch noch nach einiger Zeit zwischen Be- und Entladung umschalten.

Amüsantes Beispiel war heute Morgen die Moccamaster Kaffeemaschine, die Intervallbrühen betreibt, so dass mit 1500W oder 0W Last tatsächlich die Ladung dauernd umschaltete.

bin gerade dabei dein Blockly häppchenweise zu verdauen :-)

[AndyGR42]

@homoran Negative Vorzeichen und schnell wechselnde Lasten wären bei der einfachen Durchschnittsrechnung kein Problem. So lange Array Länge eine ganzzahliges, Vielfaches der Update Frequenz ist, stimmt auch der Durchschnitt.

[AndyGR42]

@homoran So, ich hab es nochmal für mehrere DP in einem Script optimiert. Und dabei gelernt, dass man einen Trigger nicht in einer Funktion erstellen kann / sollte. Schade, aber auch irgendwie logisch.

Um die Komplexität nicht noch weiter zu erhöhen, benutzen alle DP die gleichen Vorgaben für Array Länge und Update Frequenz. Bei sehr vielen DP müsste man, allein der Übersichtlichkeit wegen, eh mehrere Skripte bauen.

Um die Anzahl globaler Variablen zu verringern, speichert das Skript einige Laufzeitdaten als DP. Um beim Neustart des Skripts fehlerhafte Mittelwerte auf Grund von veralteten Daten im Array zu verhindern, kann das Array optional beim Start zurückgesetzt werden. Wenn nicht benötigt die Zeilen einfach löschen oder auskommentieren.

Der Block mit dem Trigger kann beliebig per Copy & Paste vervielfältigt werden. Es müssen dann entsprechend die Pfade zu den DP angepasst werden.

/** global history array length and update frequency for ALL DP in this script */
/** the array length MUST be an integer multiple of the update frequency */

const inputArrayLength = 5;
const updateFrequency = 5;

/** reset input arrays if required */

resetInputArray('0_userdata.0.Test.TestArray01');
resetInputArray('0_userdata.0.Test.TestArray02');

/** Triggers */

on({id: '0_userdata.0.IoT.DaylightSensor.DayLight01', change: "any"}, function (obj) { /** Daylight Sensor 01 */
    var value = obj.state.val;

    const historyDP = '0_userdata.0.Test.Test01';
    const updateFrequencyCounterDP = '0_userdata.0.Test.TestCounter01';
    const inputArrayDP = '0_userdata.0.Test.TestArray01';

    updateHistory(value, historyDP, updateFrequencyCounterDP, inputArrayDP);
});

on({id: '0_userdata.0.IoT.DaylightSensor.DayLight02', change: "any"}, function (obj) { /** Daylight Sensor 02 */
    var value = obj.state.val;

    const historyDP = '0_userdata.0.Test.Test02';
    const updateFrequencyCounterDP = '0_userdata.0.Test.TestCounter02';
    const inputArrayDP = '0_userdata.0.Test.TestArray02';

    updateHistory(value, historyDP, updateFrequencyCounterDP, inputArrayDP);
});


/** nothing to chage below this line */
/** ------------------------------------------------------------------------------------------------------------------------ */

function updateHistory(value, historyDP, updateFrequencyCounterDP, inputArrayDP)
{
    let inputArray = new Array(inputArrayLength);
    var updateFrequencyCounter = getState(updateFrequencyCounterDP).val;
    inputArray = getState(inputArrayDP).val;

    updateArray(value,inputArray) /** shift and update input array */
    var index = inputArray.indexOf(-1);

    if (updateFrequencyCounter <= 1 && index == -1) /** update history DP when update cycle is reached */
    {
        var sum = inputArray.reduce((a, b) => a + b, 0); /** calculate average from the array */
        var avg = (sum / inputArray.length) || 0;
        
        setState(historyDP, Number(avg)); /** write history DP */
        updateFrequencyCounter = updateFrequency; /** reset update counter */
    }
    else
    {
        updateFrequencyCounter--; /** count down until next update */
    }

    setState(inputArrayDP, inputArray); /** save input array */
    setState(updateFrequencyCounterDP, updateFrequencyCounter); /** save update counter */
}

/** helper functions */

function updateArray(newValue, array) /** shift and update the array */
{
    var i;

    for (i = inputArrayLength - 1; i >= 0; i--) 
    {
        if (i > 0)
        {
           array[i] = array[i - 1];
        }
        else
        {
            array[i] = newValue;
        }
    }
    return array;
}

function resetInputArray(inputArrayDP) /** reset input array */
{
    let inputArray = new Array(inputArrayLength);
    //inputArray = getState(inputArrayDP).val;
    var i;

    for (i = 0; i < inputArrayLength; i++)
    {
    
        inputArray[i] = -1;
    }
    setState(inputArrayDP, inputArray);
}

[Homoran]

@andygr42 sagte in Werteabhängiges loggen per Skript:

@homoran Negative Vorzeichen und schnell wechselnde Lasten wären bei der einfachen Durchschnittsrechnung kein Problem. So lange Array Länge eine ganzzahliges, Vielfaches der Update Frequenz ist, stimmt auch der Durchschnitt.

ja, das klappt problemlos.
Ich hatre aber bisher nur die Entladung "fertig"

Bedingung ist dass alle 0 und alle Werte über einer gewissen Schwelle (im Moment 1000W) sofort geschrieben werden, alles andere soll gemittelt und alle 2 Minuten geschrieben werden.
Kommt innerhalb der 2 Minuten ein (oder mehrere) "Priority Wert" soll erst danach in 2 Minuten der nächster gemittelte Wert geschrieben werden.

klappt soweit auch fast immer. jetzt muss ich nur noch herausfinden warum nicht wirklich immer.

@andygr42 sagte in Werteabhängiges loggen per Skript:

ich hab es nochmal für mehrere DP in einem Script optimiert.

das ist ganz lieb von dir, aber ich möchte es verstehen, damit ich es später selber machen kann.
Das ist mit Javascript für mich nicht machbar.
selbst das letzte Blockly von @paul53 nachzuvollziehen habe ich noch nicht vollständig geschafft.
von verstehen reden wir jetzt gar nicht.
Scheint wieder eine hochoptimierte Version a la Paul von dem zu sein, was mir vorschwebte.

[AndyGR42]

@homoran sagte in Werteabhängiges loggen per Skript:

Bedingung ist dass alle 0 und alle Werte über einer gewissen Schwelle (im Moment 1000W) sofort geschrieben werden, alles andere soll gemittelt und alle 2 Minuten geschrieben werden.
Kommt innerhalb der 2 Minuten ein (oder mehrere) "Priority Wert" soll erst danach in 2 Minuten der nächster gemittelte Wert geschrieben werden.

Was willst Du damit erreichen? Im Grunde verfälschst Du damit deine Daten und alle Aggregationen von Flott wären mehr oder weniger falsch (vermutlich fast immer zu hoch).

Ich vermute mal, Du möchtest zwei Dinge erreichen:

• Reduzierung der Daten für die Langzeitaufzeichnung. Bei einer Aggregation über Monate oder Jahre spielt eine Auflösung von 1 Sekunden keine Rolle. Dennoch sollten die Mittelwerte halbwegs stimmen.

• Eine sehr granulare Sicht auf einen kurzen Zeitraum, mit der Möglichkeit sekundengenau zu beobachten, das System zu optimieren und Fehler zu finden.

Das bekommst Du meiner Meinung nach nicht unter einen Hut. Ich würde daher zwei Werte nutzen. Den hochfrequenten Messwert, ggf. mit Glättung im Flott Diagramm, aber nur 2 Wochen oder einen Monat History. Mehr macht hier auch kaum Sinn. Das Langzeitdiagramm verwendet dann die gemittelten Werte für einen sehr langen Zeitraum.

Natürlich könnte man die Langzeit Daten auch von Flott aggregieren und Glätten lassen. Das würde aber einen große, robuste Datenbank vorrausetzen. Bei den meisten Benutzern würden wahrscheinlich schon bei deinen aktuellen 50GB Probleme auftreten.

[Homoran]

@andygr42 sagte in Werteabhängiges loggen per Skript:

Was willst Du damit erreichen?

ich benötige die Übersicht über Leistungsspitzen
und die 0 damit es nicht zu den Artefakten kommt.

Das war der Aufhänger für die gesamte Diskussion.

[AndyGR42]

@homoran Über welchen Zeitraum?

P.S.: anders gefragt, wie lange willst Du diese Ansicht mit diesem Zeitausschnitt aufbewahren?

[Homoran]

@andygr42 den Kontext zu dieser Frage sehe ich jetzt nicht.

Insgesamt soll die Datenaufzeichnung darauf ausgelegt sein.
Ich will nicht alle Werte doppelt aufzeichnen und eigentlich auch nicht per Skript manipulieren.
Deswegen war das Ursprungsthema auf die Filterrfunktionen von History bezogen.

[AndyGR42]

@homoran In der Regel manipuliert man die Daten in der Ansicht und nicht in der Speicherung. Daher halt meine Frage, wie weit eine so granulare Ansicht zurückreichen soll. Und wie genau die historischen Werte sein sollen, wenn Du z.B. mal die Daten über mehrere Monate vergleichst

[Homoran]

@andygr42 sagte in Werteabhängiges loggen per Skript:

wie weit eine so granulare Ansicht zurückreichen soll.

die soll ja nur die Spitzen zeigen, der Rest ist nicht feingranular

[AndyGR42]

@homoran Hast Du mal mit der Aggregation von Flott rumgespielt? Vielleicht reicht es hier die Parameter zu ändern, dann brauchst Du gar nichts an den Messwerten zu manipulieren.