Script Betiebsstundenzähler

HMIP lokale Installation

Moderator: Co-Administratoren

Antworten
Henke
Beiträge: 136
Registriert: 27.06.2022, 20:51
System: CCU
Hat sich bedankt: 34 Mal
Danksagung erhalten: 38 Mal

Script Betiebsstundenzähler

Beitrag von Henke » 22.09.2022, 23:37

Um die Heizung zu optimieren brauchte ich mehrere Betriebsstundenzähler mit Min/Max,etc.. Wichtig war es mir hierbei, das die Installation und die Wartung einzelner Messpunkte möglichst einfach ist.

Vielleicht kann das von euch auch jemand gebrauchen.

Ziel:
Screenshot 2022-09-22 231756.jpg
Anzeige beim Datenpunkt
Implementierung:
Script:

Code: Alles auswählen

!Betriebsstundenzähler
!Copyleft M.Henke
!V 0.91
!Systemvariablen behalten Namen nach löschen
!https://homematic-forum.de/forum/viewtopic.php?f=60&t=75670
!Anpassungen am Script sind nicht nötig!

string ScriptName = "BetrDP";
boolean debug = false;
boolean write = true;
if (("$val$").Find("val") >= 0) { WriteLine("write off"); write = false; debug = true; }

string sResult;

!id 4850 14085 14060       11632
!this: 21846 Zeitmodul CALENDARDP - 1 - 24765
integer srcId = ("$src$").ToInteger();
if (srcId > 0) {
    object oSrc = dom.GetObject(srcId);
    if (!oSrc) { quit; };
}
else { quit; }

object oPrg = dom.GetObject("$this$");
if (!oPrg) { quit; };

string trennZeile = "\n";
string trennWerte = ";";

string praefix = "x_";

string sv_ref_Scr = praefix # "Script " # ScriptName;
object svOj_Scr = dom.GetObject(ID_SYSTEM_VARIABLES).Get(sv_ref_Scr);
if (!svOj_Scr) {
    WriteLine("Erstelle: " # sv_ref_Scr);
    object svOj_list = dom.GetObject(ID_SYSTEM_VARIABLES);
    svOj_Scr = dom.CreateObject(OT_VARDP, sv_ref_Scr);
    svOj_list.Add(svOj_Scr.ID());
    svOj_Scr.ValueType(ivtString);
    svOj_Scr.ValueSubType(istChar8859);
    svOj_Scr.DPInfo("Script " # ScriptName # " Setup\nVariable nicht umbenennen!");
    svOj_Scr.ValueUnit('');
    svOj_Scr.State("");
    svOj_Scr.Internal(true);
    svOj_Scr.Visible(true);
    dom.RTUpdate(0);
}

string list = "";

if (oSrc.Type() == OT_CALENDARDP) {
    string s;
    integer run = 0;
    !WriteLine(oSrc.TypeName());
    foreach(s, oPrg.Rule().RuleConditions().EnumIDs()) {
        object o = dom.GetObject(s);
        !WriteLine(run);

        !erster Aussenbereich
        if (!run) {
        }
        else {
            string item;

            foreach(item, o.CndSingleConditions()) {
                object oi = dom.GetObject(item);
                integer id = oi.LeftVal().ToInteger();
                list = list # id # trennWerte;
            }
        }
        run = run + 1;
    }
}
else {
    list = srcId # ",";
}

if (false) {
    foreach(item, list.Split(trennWerte)){
        Write(item + " ");
    }
    WriteLine("");
}

foreach(item, list.Split(trennWerte)){
    integer dp1 = item.ToInteger();
    !WriteLine(item);
    object oSrc = dom.GetObject(dp1);
    object oCh = channels.Get(oSrc.Channel());
    if (oSrc.Type() == OT_VARDP) {
        string chName = oSrc.Name();
        integer chID = oSrc.ID();
    }
    else {
        !WriteLine(oCh.ID() # " " # oCh.Name());
        string chName = oCh.Name();
        integer chID = oCh.ID();
    }
    !WriteLine(chID # " " # chName);
    !WriteLine(oSrc.HssType());
    !WriteLine(chID # " " # oSrc.Type());

    if (oSrc.Type() == OT_VARDP) {
        object oDP = oSrc;
    }
    else {
        object oDP = oCh.DPByHssDP(oSrc.HssType());
    }
    !WriteLine(chID # " " # oDP.ID());

    if (debug) {
        sResult = "run val: "# "$val$" # " this: " # "$this$" # " " # oSrc.FullName() # " " # oSrc.TypeName() # "-" # oSrc.ValueName() # "-" # oSrc.ID();
    }

    string sv_Info = "Betriebsstunden "; !Info Test
    string sv_ref_Name = praefix # sv_Info # oDP.ID();
    boolean initOk = false;

    integer svNr_Info = 1;
    object svOj_Info = 0;

    string setUpList = svOj_Scr.Value();
    !WriteLine(setUpList);

    integer version = 2;

    if (true) {
        string setUp;
        foreach(setUp, setUpList.Split(trennZeile)){
            if (setUp) {
                if (version == setUp.StrValueByIndex(trennWerte, 0).ToInteger()) {
                    integer chIdGet = setUp.StrValueByIndex(trennWerte, 1).ToInteger();
                    if (chIdGet == oDP.ID()) {
                        !WriteLine(setUp);

                        if (!debug) {
                            debug = setUp.StrValueByIndex(trennWerte, 2).ToInteger();
                            debug = false;
                        }
                        sv_ref_Name = setUp.StrValueByIndex(trennWerte, 3);
                        !WriteLine(sv_ref_Name);
                        !if (sv_ref_Name != chName) { WriteLine("name geändert"); }
                        !4 Typ
                        svNr_Info = setUp.StrValueByIndex(trennWerte, 5).ToInteger();

                        initOk = true;
                        break;
                    }
                }
            }
        }
    }
    if (initOk) {
        if (svNr_Info > 1) {
            svOj_Info = dom.GetObject(ID_SYSTEM_VARIABLES).Get(svNr_Info);
            if (!svOj_Info) { svNr_Info = 0; }
        }

        if (!svNr_Info) {
            WriteLine("Reset?");
            svNr_Info = 1;
        }
    }

    !Wenn noch keine Systemvariable vorhanden, diese anlegen
    if (!svOj_Info) { svOj_Info = dom.GetObject(ID_SYSTEM_VARIABLES).Get(sv_ref_Name); }

    if (!svOj_Info) {
        WriteLine("Erstelle: " # sv_ref_Name);
        object svOj_list = dom.GetObject(ID_SYSTEM_VARIABLES);
        svOj_Info = dom.CreateObject(OT_VARDP, sv_ref_Name);
        svOj_list.Add(svOj_Info.ID());
        svOj_Info.ValueType(ivtString);
        svOj_Info.ValueSubType(istChar8859);
        svOj_Info.DPInfo(sv_Info # chName);
        svOj_Info.ValueUnit('');
        svOj_Info.State("Start");
        svOj_Info.Internal(false);
        svOj_Info.Visible(true);
        if (oCh) {
            svOj_Info.Channel(oCh.ID());
            oCh.DPs().Add(svOj_Info);
        }
        dom.RTUpdate(0);
    }
    sv_ref_Name = svOj_Info.Name();

    if (false && oCh) {
        object dev = dom.GetObject(oCh.Device());
        string dp0 = dev.FullName();
        string myName = chName.Replace(dp0, "");
        integer ff = myName.Find(":");
        if (ff >= 0) {
            myName = myName.Substr(ff + 1);
            ff = myName.Find(" ");
            if (ff >= 0) {
                myName = myName.Substr(ff + 1).Trim();
            }
            else {
                myName = "";
            }

        }
        if (myName) {
            WriteLine(chName # "->" # praefix # "BS " # myName);
            !svOj_Info.Name(praefix # "BS " # myName);
            sv_ref_Name = praefix # "BS " # myName;
        }
        else {
            WriteLine(chName # "->" # praefix # sv_Info # myName);
        }
    }
    if (svOj_Info) { svNr_Info = svOj_Info.ID(); }

    string meta_key = "MH-LOG-STATE";
    string log = svOj_Info.MetaData(meta_key);
    if (!log) {
        svOj_Info.AddMetaData(meta_key);
    }
    else {
        !WriteLine("MetaDa");
    }

    if (false && (!log)) {
        log = oDP.MetaData(meta_key);
        oDP.RemoveMetaData(meta_key);
        svOj_Info.MetaData(meta_key, log);
        WriteLine("Log Alt");
    }
    !WriteLine(log);

    if (svOj_Info) {
        string infoVal = svOj_Info.Value();
        if ((!infoVal) || (infoVal == "reset")) {
            log = "";
            svOj_Info.State("Reset");
        }
    }

    if (!initOk) {
        setUpList = setUpList # version # trennWerte # oDP.ID()  # trennZeile;
        WriteLine("neu");
    }

    string    setUpListNeu = "";
    boolean done = false;
    foreach(setUp, setUpList.Split(trennZeile)){
        if (setUp) {
            if (version == setUp.StrValueByIndex(trennWerte, 0).ToInteger()) {
                integer chId = setUp.StrValueByIndex(trennWerte, 1).ToInteger();
                if (chId == oDP.ID()) {

                    string hssType = "STATE";
                    if (oSrc.Type() != OT_VARDP) { hssType = oSrc.HssType(); }

                    string defSetup = version
    # trennWerte # oDP.ID()
    # trennWerte # 0
    # trennWerte # sv_ref_Name.Replace(trennWerte, "")
    # trennWerte # hssType
    # trennWerte # svNr_Info
                        ;

                    if (!done) {
                        setUpListNeu = setUpListNeu # defSetup # trennZeile;
                        done = true;
                    }
                }
                else {
                    setUpListNeu = setUpListNeu # setUp # trennZeile;
                }
            }
        }
    }
    if (setUpListNeu != setUpList) {
        svOj_Scr.State(setUpListNeu);
        WriteLine(setUpListNeu);
    }

    integer timeSys = (system.Date("%F %T")).ToTime().ToInteger();
    real stunde = 60.0 * 60.0;
    real tag = 24.0 * 60.0 * 60.0;
    string out;

    !WriteLine(oDP.Timestamp() # " " # oDP.LastTimestamp() # " " # timeSys);

    string eintr = "x" # trennWerte # oDP.Value().ToInteger() # trennWerte #oDP.Timestamp().ToInteger();
    if (log) { log = log # trennZeile; }
    log = log # eintr;
    !WriteLine(log);

    integer anz = 0;
    integer laufzeit = 0;
    real diffMin = 0;
    real diffMax = 0;
    integer startTime = timeSys;

    string logNeu;
    if (log) {
        string wert;
        integer LastOnOff = -1;

        foreach(wert, log.Split(trennZeile))
        {
            string typ;
            if (wert) {
                typ = wert.StrValueByIndex(trennWerte, 0);
            }
            boolean keep = false;

            if (typ == "x") {
                integer onOff = wert.StrValueByIndex(trennWerte, 1).ToInteger();
                !WriteLine(wert);

                if (LastOnOff != onOff) {
                    keep = true;
                    LastOnOff = onOff;
                }
            }

            if (typ == "S") { keep = true; }

            if (keep) {
                if (logNeu) { logNeu = logNeu # trennZeile; }
                logNeu = logNeu # wert;
            }
            else {
                !if (debug) { WriteLine("rausAkt " # wert); }
            }
        }
    }
    log = logNeu;
    logNeu = "";

    real lastTime;
    if (true) {
        integer run = 0;
        if (log) {
            string wert;
            integer LastOnOff = -1;
            real lastTime;
            boolean delNext = false;

            foreach(wert, log.Split(trennZeile)) {
                real start;
                ! if (debug) { WriteLine(wert); }
                if (delNext) {
                    delNext = false;
                    LastOnOff = wert.StrValueByIndex(trennWerte, 1).ToInteger();
                    start = wert.StrValueByIndex(trennWerte, 2).ToFloat();
                    lastTime = start;
                    !if (debug) { WriteLine("raus delNext " # wert); }
                }
                else {
                    string typ;
                    if (wert) {
                        typ = wert.StrValueByIndex(trennWerte, 0);

                    }
                    boolean keep = true;

                    if (typ == "x") {
                        integer onOff = wert.StrValueByIndex(trennWerte, 1).ToInteger();
                        !WriteLine(wert);

                        if (onOff) {
                            start = wert.StrValueByIndex(trennWerte, 2).ToInteger();
                            if (startTime > start) {
                                startTime = start;
                            }

                            if (start < timeSys - tag) {
                                string wertNext = log.StrValueByIndex(trennZeile, run + 1);
                                if (wertNext) {
                                    if (wertNext.StrValueByIndex(trennWerte, 0) == "x") {
                                        integer end = wertNext.StrValueByIndex(trennWerte, 2).ToInteger();
                                        if (end < timeSys - tag) {
                                            delNext = true;
                                            keep = false;
                                            integer diff = end - start;
                                            laufzeit = laufzeit + diff;
                                            anz = anz + 1;
                                            !WriteLine("dd " # anz # " " # laufzeit # " " # diff.ToInteger());
                                            start = end;
                                            lastTime = end;
                                        }
                                    }
                                }
                            }

                        }

                        LastOnOff = onOff;
                        lastTime = start;
                    }

                    if (typ == "S") {
                        keep = false;
                        integer anzS = wert.StrValueByIndex(trennWerte, 1).ToInteger();
                        anz = anz + anzS;
                        integer startS = wert.StrValueByIndex(trennWerte, 2).ToInteger();
                        if (startTime > startS) {
                            startTime = startS;
                        }

                        integer laufZeitS = wert.StrValueByIndex(trennWerte, 3).ToInteger();
                        if (laufZeitS < 0) {
                            laufZeitS = 0; WriteLine("Err Zeit");
                            debug = true; sResult = sResult # "Err Zeit";
                        }
                        laufzeit = laufzeit + laufZeitS;
                        !WriteLine("Testen");
                    }

                    if (keep) {
                        if (logNeu) { logNeu = logNeu # trennZeile; }
                        logNeu = logNeu # wert;
                    }
                    else {
                        !if (debug) { WriteLine("raus2 " # wert); }
                    }
                }
                run = run + 1;
            }
        }
        if (logNeu) { logNeu = logNeu # trennZeile; }
        logNeu = logNeu # "S" # trennWerte # anz # trennWerte # startTime.ToInteger() # trennWerte # laufzeit.ToInteger();

        if (write && (log != logNeu)) { svOj_Info.MetaData(meta_key, logNeu); }
        log = logNeu;
        !svOj_Info.MetaData(meta_key, ""); alle Reseten
        !WriteLine(log);
    }

    integer anzH1 = 0;
    integer laufzeitH1 = 0;
    integer diffMinH1 = 0;
    integer timeDiffMinH1;
    integer diffMaxH1 = 0;
    integer timeDiffMaxH1;
    integer anzH24 = 0;
    integer laufzeitH24 = 0;
    integer diffMinH24 = 0;
    integer timeDiffMinH24;
    integer diffMaxH24 = 0;
    integer timeDiffMaxH24;

    if (log) {
        string wert;
        integer LastOnOff = -1;

        foreach(wert, log.Split(trennZeile))        {
            string typ;
            if (wert) {
                typ = wert.StrValueByIndex(trennWerte, 0);
            }

            if (typ == "x") {
                integer onOff = wert.StrValueByIndex(trennWerte, 1).ToInteger();
                integer start = wert.StrValueByIndex(trennWerte, 2).ToInteger();
                if (startTime > start) {
                    startTime = start;
                }
                !WriteLine(wert);

                if (LastOnOff != onOff) {
                    ! if (debug) { if (onOff) { WriteLine(wert # " " #(timeSys - lastTime).ToString(0) # " " # " " #(start - (timeSys - stunde)).ToString(0)); } }
                    if ((LastOnOff >= 0) && !onOff) {
                        real diff = start - lastTime;

                        if (!anz) { diffMin = diff; }
                        if (diff > diffMax) { diffMax = diff; }
                        if (diff < diffMin) { diffMin = diff; }
                        laufzeit = laufzeit + diff;
                        anz = anz + 1;
                        ! if (debug) { WriteLine(wert # " " #(timeSys - lastTime).ToString(0) # " " # diff.ToString((0)) # " " #(start - (timeSys - stunde)).ToString(0)); }

                        if (start >= timeSys - stunde) {
                            boolean abgeschnitten = false;

                            integer ref = lastTime;
                            !WriteLine(ref - (timeSys - stunde));
                            if (ref <= timeSys - stunde) {
                                ref = timeSys - stunde;
                                !WriteLine(ref - (timeSys - stunde));
                                abgeschnitten = true;
                            }
                            integer diffH1 = start - ref;
                            if (!anzH1) { diffMinH1 = diffH1; timeDiffMinH1 = start; }
                            if (!abgeschnitten) {
                                if (diffH1 > diffMaxH1) { diffMaxH1 = diff; timeDiffMaxH1 = start; }
                                if (diffH1 < diffMinH1) {
                                    diffMinH1 = diff;
                                    timeDiffMinH1 = start;
                                }
                            }
                            laufzeitH1 = laufzeitH1 + diffH1;
                            anzH1 = anzH1 + 1;
                        }

                        if (start >= timeSys - tag) {
                            boolean abgeschnitten = false;

                            integer ref = lastTime;
                            !WriteLine(ref - (timeSys - tag));
                            if (ref <= timeSys - tag) {
                                ref = timeSys - tag;
                                !WriteLine(ref - (timeSys - tag));
                                abgeschnitten = true;
                            }
                            integer diffH24 = start - ref;
                            if (!anzH24) { diffMinH24 = diffH24; timeDiffMinH24 = start; }
                            if (!abgeschnitten) {
                                if (diffH24 > diffMaxH24) { diffMaxH24 = diff; timeDiffMaxH24 = start; }
                                if (diffH24 < diffMinH24) { diffMinH24 = diff; timeDiffMinH24 = start; }
                            }
                            laufzeitH24 = laufzeitH24 + diffH24;
                            anzH24 = anzH24 + 1;
                        }

                    }
                    LastOnOff = onOff;
                    lastTime = start;
                }
            }
        }
    }

    boolean laeuftNoch = false;
    if ((LastOnOff == 1) && (oDP.Value().ToInteger() == 1)) {
        laeuftNoch = true;
        diff = timeSys - lastTime;
        if (diff > diffMax) { diffMax = diff; }
        if (diff < diffMin) { diffMin = diff; }
        laufzeit = laufzeit + diff;
        anz = anz + 1;

        diffH1 = diff;
        if (diffH1 > stunde) {
            diffH1 = stunde;
        }
        laufzeitH1 = laufzeitH1 + diffH1;
        anzH1 = anzH1 + 1;
        diffH24 = diff;
        if (diffH24 > tag) {
            diffH24 = tag;
        }
        laufzeitH24 = laufzeitH24 + diffH24;
        anzH24 = anzH24 + 1;
    }

    integer aM = 0; !Stellen Minuten
    integer aP = 0; !Stellen Prozent
    string line = "---------------";

    real zeit = stunde / 60;
    real lz = (laufzeitH1.ToFloat() / 60).ToFloat();
    real az = (zeit - lz).ToFloat();
    out = ""
# " 1h " # line # " " # anzH1 # " x";
    if (lz) {
        out = out # ""
# "\nAn " # lz.ToString(aM) # " min / " #((lz * 100) / zeit).ToString(aP) # " %"
# "\nAus " # az.ToString(aM) # " min / " #((az * 100) / zeit).ToString(aP) # " %";
        if (anzH1 > 1) {
            string heute = "H ";
            if (timeDiffMinH1.ToTime().ToString('%j') != timeSys.ToTime().ToString('%j')) {
                heute = "G ";
            }
            out = out # "\nMin " # heute # timeDiffMinH1.ToTime().ToString('%X') # " " #(diffMinH1.ToFloat() / 60).ToString(aM) # " min";

            string heute = "H ";
            if (timeDiffMaxH1.ToTime().ToString('%j') != timeSys.ToTime().ToString('%j')) {
                heute = "G ";
            }
            out = out # "\nMax " # heute # timeDiffMaxH1.ToTime().ToString('%X') # " " #(diffMaxH1.ToFloat() / 60).ToString(aM) # " min";
        }
    }
    !    if (debug) { WriteLine(out); }
    !    if (svOj_Info) { svOj_Info.State(out); }

    real zeit = tag / 60;
    real lz = (laufzeitH24.ToFloat() / 60).ToFloat();
    real az = (zeit - lz).ToFloat();
    out = out # "\n"
# "\n24h " # line # " " # anzH24 # " x";
    if (lz) {
        out = out # ""
# "\nAn " # lz.ToString(aM) # " min / " #((lz * 100) / zeit).ToString(aP) # " %"
# "\nAus " # az.ToString(aM) # " min / " #((az * 100) / zeit).ToString(aP) # " %";
        if (anzH24 > 1) {
            string heute = "H ";
            if (timeDiffMinH24.ToTime().ToString('%j') != timeSys.ToTime().ToString('%j')) {
                heute = "G ";
            }
            out = out # "\nMin " # heute # timeDiffMinH24.ToTime().ToString('%X') # " " #(diffMinH24.ToFloat() / 60).ToString(aM) # " min";

            string heute = "H ";
            if (timeDiffMaxH24.ToTime().ToString('%j') != timeSys.ToTime().ToString('%j')) {
                heute = "G ";
            }
            out = out # "\nMax " # heute # timeDiffMaxH24.ToTime().ToString('%X') # " " #(diffMaxH24.ToFloat() / 60).ToString(aM) # " min";
        }
    }

    !    if (debug) { WriteLine(out); }

    real zeit = (timeSys - startTime) / 60;
    real lz = (laufzeit.ToFloat() / 60).ToFloat();
    real az = (zeit - lz).ToFloat();
    real tage = (timeSys - startTime).ToFloat() / (60 * 60 * 24);
    out = out # "\n"
# "\n" # tage.ToString(2) # " Tage " # line # " " # anz # " x";
    if (lz) {
        out = out # ""
# "\nAn " # lz.ToString(aM) # " min / " #((lz * 100.0) / zeit).ToString(aP) # " %"
# "\nAus " # az.ToString(aM) # " min / " #((az * 100) / zeit).ToString(aP) # " %";
    }
    !out = out # "\n\nStand " #  lastTime.ToTime().ToString('%d.%m.%Y %H:%M:%S') # " " # LastOnOff # "\n";
    !WriteLine(out);
    if (debug) { WriteLine(out); }
    if (svOj_Info) { svOj_Info.State(out); }
}
if (debug) { WriteLine("--------------------------"); }

if (sResult && debug) {
    WriteLine(sResult);
    string lg = 'logger -t SDV-H-$ScriptName$ -p user.debug "$sResult$"';
    lg = lg.Replace("$sResult$", sResult).Replace("$ScriptName$", ScriptName);
    system.Exec(lg);
}
Screenshot 2022-09-22 232232.jpg
CCU-Programm das 15 Betriebsstundenzähler anlegt
Als Datenpunkt können sowohl Kanäle als auch Systemvariablen verwendet werden. Das Zeitmodul dient zur Aktualisierung der Anzeige und sollte daher nicht kleiner als 1 Stunde gewählt werden (Ablauf der 1/24 Stunden). Die eigentlichen Daten werden durch die Einträge der Messpunkte aktualisiert. Die Systemvariablen, die zur Anzeige verwendet werden, können umbenannt werden. Wird eine Systemvariable gelöscht, so wird sie neu angelegt und damit ein Reset ausgeslöst.

Für die Programmierer unter euch ist die Methode, wie die Systemvariablen angelegt werden, mit ihrer ID verwaltet, die Messdaten gespeichert und das Konzept Datenpunkte bzw. ein Script zu konfigurieren vielleicht interessant.

G
Michael

Antworten

Zurück zu „HomeMatic IP mit CCU“