Betriebsstundenzähler auf Basis eines Bool-Items

[MaHe]

Die Version aus dem Beitrag passt aber nicht auf Anhieb. Da wurde kein "Eltern-Item" time verwendet, in der Betriebsstundenberechung hier aber schon. Da bin ich gestern nacht auch drüber gestolpert und hab den Fehler eben erst entdeckt.
Eine der beiden Seiten muss angepasst werden.

Hier sind meine angepassten Dateien, so dass "Time" als oberstes Item steht. Dann sieht es auch im Backend etwas aufgeräumter aus.


time.conf

[time]
    [[month]]
       [[[since]]]
          [[[[year]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.month.since.year
                eval = str(sh.time.month.since.year()) + 'm'
       [[[until]]]
           [[[[year]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.month.until.year
                eval = str(sh.time.month.until.year()) + 'm'
    [[week]]
       [[[since]]]
           [[[[month]]]]
            type = num
           [[[[year]]]]
            type = num
       [[[until]]]
           [[[[month]]]]
            type = num
           [[[[year]]]]
            type = num
    [[day]]
       [[[since]]]
           [[[[week]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.day.since.week
                eval = str(sh.time.day.since.week()) + 'd'
           [[[[month]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.day.since.month
                eval = str(sh.time.day.since.month()) + 'd'
           [[[[year]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.day.since.year
                eval = str(sh.time.day.since.year()) + 'd'
       [[[until]]]
           [[[[week]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.day.since.week
                eval = str(sh.time.day.since.week()) + 'd'
           [[[[month]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.day.until.month
                eval = str(sh.time.day.until.month()) + 'd'
           [[[[year]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.day.until.year
                eval = str(sh.time.day.until.year()) + 'd'
    [[hour]]
       [[[since]]]
           [[[[midnight]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.hour.since.midnight
                eval = str(sh.time.hour.since.midnight()) + 'h'
           [[[[week]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.hour.since.week
                eval = str(sh.time.hour.since.week()) + 'h'
           [[[[month]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.hour.since.month
                eval = str(sh.time.hour.since.month()) + 'h'
           [[[[year]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.hour.since.year
                eval = str(sh.time.hour.since.year()) + 'h'
       [[[until]]]
           [[[[midnight]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.hour.until.midnight
                eval = str(sh.time.hour.until.midnight()) + 'h'
           [[[[week]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.hour.until.week
                eval = str(sh.time.hour.until.week()) + 'h'
           [[[[month]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.hour.until.month
                eval = str(sh.time.hour.until.month()) + 'h'
           [[[[year]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.hour.until.year
                eval = str(sh.time.hour.until.year()) + 'h'
    [[minute]]
       [[[since]]]
           [[[[hour]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.minute.since.hour
                eval = str(sh.time.minute.since.hour()) + 'i'
           [[[[midnight]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.minute.since.midnight
                eval = str(sh.time.minute.since.midnight()) + 'i'
           [[[[week]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.minute.since.week
                eval = str(sh.time.minute.since.week()) + 'i'
           [[[[month]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.minute.since.month
                eval = str(sh.time.minute.since.month()) + 'i'
           [[[[year]]]]
            type = num   
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.minute.since.year
                eval = str(sh.time.minute.since.year()) + 'i'
       [[[until]]]
           [[[[hour]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.minute.until.hour
                eval = str(sh.time.minute.until.hour()) + 'i'
           [[[[midnight]]]]
            type = num
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.minute.until.midnight
                eval = str(sh.time.minute.until.midnight()) + 'i'
           [[[[week]]]]
            type = num   
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.minute.until.week
                eval = str(sh.time.minute.until.week()) + 'i'
           [[[[month]]]]
            type = num   
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.minute.until.month
                eval = str(sh.time.minute.until.month()) + 'i'
           [[[[year]]]]
            type = num   
               [[[[[dbstr]]]]]
                type = str
                eval_trigger = time.minute.until.year
                eval = str(sh.time.minute.until.year()) + 'i'
    [[second]]
       [[[since]]]
           [[[[minute]]]]
            type = num
           [[[[hour]]]]
            type = num
           [[[[midnight]]]]
            type = num
           [[[[week]]]]
            type = num
           [[[[month]]]]
            type = num
           [[[[year]]]]
            type = num
       [[[until]]]
           [[[[minute]]]]
            type = num
           [[[[hour]]]]
            type = num
           [[[[midnight]]]]
            type = num
           [[[[week]]]]
            type = num
           [[[[month]]]]
            type = num
           [[[[year]]]]
            type = num

zeit.py

#/logics/zeit.py
#!/usr/bin/env python
sh_now = sh.now()
debug = False

# Funktionen                    

#def leap_year(year):
#    if (year % 400 == 0) or ((year % 4 == 0) and not (year % 100 == 0)):
#        return True
#    else:
#        return False

def days_of_month(month, year):
    if month in [1, 3, 5, 7, 8, 10, 12]:
        days = 31
    elif month in [4, 6, 9, 11]:
        days = 30
    elif (year % 400 == 0) or ((year % 4 == 0) and not (year % 100 == 0)):  #Schaltjahr
        days = 29
    else:
        days = 28
    return days

def days_of_year(year):
    period_end = datetime.datetime(year,12,31)
    days_of_year = (period_end - datetime.datetime(period_end.year, 1, 1)).days + 1
    return(days_of_year)

def day_of_year(year,month,day):
    period_end = datetime.datetime(year,month,day)
    day_of_year = (period_end - datetime.datetime(period_end.year, 1, 1)).days + 1
    return(day_of_year)

if debug == True:
    print("RUNNING LOGIC OF TIME - REMOVE AFTER DEBUG")
    print(sh_now.hour) #Stunde
    print(sh_now.minute) #Minute
    print(sh_now.second) #Sekunde
    print(sh_now.day)  #Tag
    print(sh_now.month) #Monat
    print(sh_now.isoweekday()) #Wochentag
    print(sh.now().isocalendar()[1]) #Kalenderwoche

# Sekunde/Minute
sh.time.second.since.minute(sh_now.second)
sh.time.second.until.minute(60 - sh_now.second - 1)

# Minute/Stunde
sh.time.minute.since.hour(sh_now.minute)
sh.time.minute.until.hour(60 - sh_now.minute - 1)

# Stunde/Tag
sh.time.hour.since.midnight(sh_now.hour)
sh.time.hour.until.midnight(24 - sh_now.hour - 1)

# Tag/Woche
sh.time.day.since.week(sh_now.isoweekday())
sh.time.day.until.week(7 - sh_now.isoweekday())

# Stunde/Woche
sh.time.hour.since.week(sh.time.hour.since.midnight() + (24 * (sh.time.day.since.week() - 1)))
sh.time.hour.until.week(sh.time.hour.until.midnight() + (24 * sh.time.day.until.week()))

# Kalenderwoche/Jahr
sh.time.week.since.year(sh.now().isocalendar()[1])

# Monat/Jahr
sh.time.month.since.year(sh_now.month)
sh.time.month.until.year(12-sh_now.month)

# Sekunde/Stunde
sh.time.second.since.hour(sh.time.second.since.minute() + (60 * sh.time.minute.since.hour()))
sh.time.second.until.hour(sh.time.second.until.minute() + (60 * sh.time.minute.until.hour()))

# Sekunde/Tag
sh.time.second.since.midnight(sh.time.second.since.minute() + (3600 * sh.time.hour.since.midnight()))
sh.time.second.until.midnight(sh.time.second.until.minute() + (3600 * sh.time.hour.until.midnight()))

# Minute/Tag
sh.time.minute.since.midnight(sh.time.minute.since.hour() + (60 * sh.time.hour.since.midnight()))
sh.time.minute.until.midnight(sh.time.minute.until.hour() + (60 * sh.time.hour.until.midnight()))

# Minute/Woche
sh.time.minute.since.week(sh.time.minute.since.hour() + (60 * sh.time.hour.since.week()))
sh.time.minute.until.week(sh.time.minute.until.hour() + (60 * sh.time.hour.until.week()))

# Sekunde/Woche
sh.time.second.since.week(sh.time.second.since.minute() + (60 * sh.time.minute.since.week()))
sh.time.second.until.week(sh.time.second.until.minute() + (60 * sh.time.minute.until.week()))

# Tage/Monat
sh.time.day.since.month(sh_now.day - 1)
sh.time.day.until.month(days_of_month(sh_now.month,sh_now.year) - sh.time.day.since.month() - 1)

# Tage/Jahr
sh.time.day.since.year(day_of_year(sh_now.year,sh_now.month,sh_now.day) - 1)
sh.time.day.until.year(days_of_year(sh_now.year) - sh.time.day.since.year() - 1)

# Stunde/Monat
sh.time.hour.since.month((24 * sh.time.day.since.month()) + sh.time.hour.since.midnight())
sh.time.hour.until.month((24 * days_of_month(sh_now.month,sh_now.year)) - sh.time.hour.since.month() - 1) 

# Stunde/Jahr
sh.time.hour.since.year((24 * sh.time.day.since.year()) + sh.time.hour.since.midnight())
sh.time.hour.until.year((24 * days_of_year(sh_now.year)) - sh.time.hour.since.year() - 1)

# Minute/Monat
sh.time.minute.since.month((60 * sh.time.hour.since.month()) + sh.time.minute.since.hour())
sh.time.minute.until.month(sh.time.minute.since.month() - (60 * sh.time.hour.until.month()) - 1)

# Minute/Jahr
sh.time.minute.since.year((60 * sh.time.hour.since.year()) + sh.time.minute.since.hour())
sh.time.minute.until.year((60 * sh.time.hour.until.year()) + sh.time.minute.until.hour())

# Sekunde/Monat
sh.time.second.since.month((60 * sh.time.minute.since.month()) + sh.time.second.since.minute())
sh.time.second.until.month((60 * sh.time.minute.until.month()) + sh.time.second.until.minute())

# Sekunde/Jahr
sh.time.second.since.year((60 * sh.time.minute.since.year()) + sh.time.second.since.minute())
sh.time.second.until.year((60 * sh.time.minute.until.year()) + sh.time.second.until.minute())

[Tontechniker]

Hallo MaHe,
ich habe Deine neuen Dateien eingefügt - jetzt funktioniert es hervorragend!
Gruß Hans

[Tontechniker]

Hallo MaHe,
mein Raspi hängt sich reproduzierbar auf. Das passiert, wenn das zu zählende Eingangssignal "über Nacht" ansteht. Ich vermute, das das beim Tagesübergang passiert. Hast Du dafür eine Lösung?
Gruß Hans

[MaHe]

Hallo Tontechniker ,
da kann ich dir leider nicht helfen, mein Raspi ist noch nie abgestürzt (außer ich hab irgendeinen Mist programmiert ).
Bin aber auch nicht so fit in den Programmiersprachen, ich bastel mir das immer nur aus fertigen Code zusammen.
Hab neulich einen ganzen Tag versucht, die Anzahl der Starts von mehreren Pumpen mit einer allgemeinen Logik zu realisieren, hat aber nicht geklappt.
Am Sonntag hab ich wahrscheinlich nochmal Zeit, mich um SH zu kümmern, dann guck ich da mal rein, vielleicht finde ich ja was.

Gruß Marc

[Sisamiwe]

Tontechniker Auch ich verwende die Logik und auch bei mir hängt sich nichts auf. Meine Heizungsumwälzpumpe läuft auch über Nacht und wird "beobachtet".

MaHe Be der Logik zum Zählen der Starts kann ich helfen. Ich mache das so:

        [[[zyklen]]]
            name = Zyklen Umwälzpumpe Heizung
            type = num
            visu = yes
            visu_acl = ro
            sqlite = yes
            eval = sh.heizung.umwaelzpumpe.zyklen() + int(sh.heizung.umwaelzpumpe.prev_value())
            eval_trigger = heizung.umwaelzpumpe
            [[[[heute]]]]
                type = num
                visu = yes
                visu_acl = ro
                sqlite = yes
                crontab = init | * * * * = 1
                eval = sh.heizung.umwaelzpumpe.zyklen() - sh.heizung.umwaelzpumpe.zyklen.db('max', sh.time.minute.since.midnight.dbstr(), sh.time.minute.since.midnight.dbstr())
                eval_trigger = heizung.umwaelzpumpe.zyklen
            [[[[gestern]]]]
                type = num
                visu = yes
                visu_acl = ro
                sqlite = yes
                crontab = init | 0 0 * * = 1
                eval = sh.heizung.umwaelzpumpe.zyklen() - sh.heizung.umwaelzpumpe.zyklen.db('max', '1d','1d')
            [[[[vorgestern]]]]
                type = num
                visu = yes
                visu_acl = ro
                sqlite = yes
                eval = sh.heizung.umwaelzpumpe.zyklen.db('max', '1d','1d') - sh.heizung.umwaelzpumpe.zyklen.db('max', '2d','2d')
                crontab = init | 0 0 * * = 1

Sprich, wenn die Pumpe eingeschaltet wird also "wahr" nehme ich davon den integer (das ist dann 1) und addiere das einfach auch einen Zähler auf.
Klappt prima. Vielleicht hilfts

[MaHe]

Ich hatte da was ähnliches drin (kann gerade nicht gucken, bin auf der Arbeit), das Zählen war kein Problem. Nur wollte ich den Zähler um 0:00 Uhr zurücksetzen per Logik, das klappte mit meiner Version nur nicht, weil eval den alten Wert wieder rein geschrieben hat.
Da kam ich dann auf die Idee, das ganze mit einer Logik zu erschlagen, die zyklisch aufgerufen wird und auf einen Parameter am Item reagiert ("zaehler = yes" oder sowas).
Deine Version gefällt mir, werde mir das morgen mal so einbauen Auf die Idee, den Zählerstand aus der Datenbank zu holen, kam ich gar nicht.


Wollte mit meiner Logik auch die Betriebsstunden hochzählen, da die Version mit der Datenbank Fehler liefert, wenn für den jeweiligen Tag kein Eintrag da ist und der aktuelle Wert erst verfügbar ist, wenn die Pumpe wieder abschaltet.

Vielleicht hab ich Python irgendwann auch mal begriffen, werde morgen auf alle Fälle noch mal "üben"

[Sisamiwe]

MaHe
Um den Fehler der Datenbank bei "Nichteinschalten" zu vermeiden, könnte man das Item kurz nach Mitternacht für eine Sekunde oder kürzer einschalten (und danach wieder aus). Damit gäbe es einen Eintrag in der Datenbank und die Auswertung geht problemlos. Die kurze Zeit sollte bei den Betriebsstunden eine untergeordnete Rolle spielen. Den Zykluszähler muss man dann um 1 korrigieren.

Was hältst Du davon?

[MaHe]

Da hab ich auch schon drüber nachgedacht, wäre wahrscheinlich die einfachste Lösung. Ich wollte nur noch bis heute abwarten, was die Startzähler-Lösung von dir macht, da gestern nach dem Einbau nur der Gesamtzähler hochzählte, der Tageszähler aber bei "0" blieb. Heute hat es aber dann funktioniert.
Werde das gleich mal in meine Logo einbauen (die steuert bei mir die Heizung) und testen und berichten.

Edit:
Hab das jetzt mal eingebaut, das SH mit einen 1-Sek.-Impuls um Mitternacht an die Logo schickt und alle Pumpen aktiviert. Der Zähler kriegt das auf alle Fälle mit, muss dann morgen mal im Log gucken, wie es da aussieht.

[Sisamiwe]

MaHe Könntest Du die Umsetzung des 1-Sek Impulses mal posten?
DANKE

[MaHe]

Ja klar:

in der logic.conf

[tageswechsel]
    filename = tageswechsel.py
    crontab = 1 0 * *

in tageswechsel.py steht

sh.intern.impuls.mitternacht(1) 
sh.zentral.heizung.uwp_solar.starts(sh.zentral.heizung.uwp_solar.starts() - 1)
sh.zentral.heizung.uwp_wt_solar.starts(sh.zentral.heizung.uwp_wt_solar.starts() - 1)
sh.zentral.heizung.uwp_heizung.starts(sh.zentral.heizung.uwp_heizung.starts() - 1)
sh.zentral.heizung.zirkulation.starts(sh.zentral.heizung.zirkulation.starts() - 1)

das erste, um den Impuls zu generieren, der Rest um jeweils 1 vom Startzähler abzuziehen

In der Item.conf steht dann

[intern]
    [[impuls]]
        [[[mitternacht]]]
            type = bool
            autotimer = 1 = 0
            logo_write = M14

Den Autotimer, um das Item nach einer Sekunde wieder zurück zu setzen, das logo_write, um die Antriebe kurz einzuschalten. Ist in der Logo entsprechend verschaltet.

Es funktioniert jedoch noch nicht richtig, da zwar gezählt wird, in der DB aber trotzdem kein Eintrag abgelegt wird.
Hatte aber noch keine Zeit, da weiter zu suchen.

[Sisamiwe]

Nicht per eval sondern als Logik und dann zusätzlich zum Statuswechsel noch einen cron spendieren. In der Logik muß dann natürlich unterschieden werden, woher der Trigger kommt, ob cron oder ob trigger vom Statuswechsel.

Hallo,

ich krame das hier nochmal raus....

Nochmal zu Erinnerung: Ich möchte auf Basis eines Bool-Items die Laufzeit bzw. Einschaltzeit ermitteln. Das klappt über div. Eval mit dem properties "age" bzw. "prev_age" ziemlich gut.

Verbessern möchte ich die Erfassung von Items mit rel. langer Laufzeit wie bspw. der Pumpe des Heizkreislaufs. Bislang wird die Laufzeit nur bei Statuswechsel des Bool-Items ermittelt. Nun möchte ich mit einer Logik auch Zwischenwerte ermitteln.

Die Idee für die Logik:

• die Logik wird von cycle (also zyklisch) und dem Status Item getriggert
• bei Logikstart und Statuswechsel wird der aktuelle Laufzeitwert in eine persistente Variable in der Logik gespeichert.
• bei Trigger durch cycle wird zum gespeicherten Laufzeitwert aus der persistente Variable das Produkt aus integer Wert des Statusitems (0 oder 1) und dem Alter des Statusitems addiert und in das Zielitem geschrieben
• bei Trigger durch Statuswechsel wird zum gespeicherten Laufzeitwert aus der persistente Variable das Produkt aus integer Wert des letzten Wertes des Statusitems (0 oder 1) und dem letzen Alter des Statusitems addiert und in das Zielitem geschrieben sowie die persistente Variable aktualisiert.

So sollen Zwischenwerte erzeugt werden (die durchaus ungenau sein können) und dann bei Statuswechsel wieder ein "richtiger" Wert geschrieben werden.

Hier meine Umsetzung:

#!/usr/bin/env python3
# pumpenlaufzeit.py

# Die Logik ermittelt die Laufzeit eines Gerätes basierend auf einem boolschen Item für AN und AUS inkl. Zwischenwerte durch das zyklische (cylce) Aufruf der Logik

logger.warning("Logik '{}' durch: {} und {}".format(logic.id(), trigger['by'], trigger['source'] ))

from lib.item import Items
items = Items.get_instance()

#Speicher für den Laufzeitwert, der auf Basis Statusänderung des boolschen Items errechnet wurde
if not hasattr(logic, 'last_status_change_m2'):
    logic.last_status_change_m2 = sh.heizung.heizkreis_m2.status.hk_pumpe_knx.betriebsstunden.betriebsstunden_sek()
    logger.warning("Logik '{}' hat folgenden Wert für die letzte Statusänderung M2 gesetzt:{}".format(logic.id(), logic.last_status_change_m2))
    
# wenn von cylce getriggert, errechne einen Zwischenwert für die Laufzeit
if trigger['by'] == 'Scheduler':
    new_interim_value_m2 = logic.last_status_change_m2 + sh.heizung.heizkreis_m2.status.hk_pumpe_knx.property.last_change_age * int(sh.heizung.heizkreis_m2.status.hk_pumpe_knx.property.value)
    sh.heizung.heizkreis_m2.status.hk_pumpe_knx.betriebsstunden.betriebsstunden_sek(new_interim_value_m2)
    
# wenn vom Status Item getriggert, errechne die Laufzeit
if trigger['by'] == 'Item':
    if 'm2' in trigger['source']:
        new_value_m2 = logic.last_status_change_m2 + sh.heizung.heizkreis_m2.status.hk_pumpe_knx.property.prev_update_age * int(sh.heizung.heizkreis_m2.status.hk_pumpe_knx.property.last_value)
        sh.heizung.heizkreis_m2.status.hk_pumpe_knx.betriebsstunden.betriebsstunden_sek(new_value_m2)

Was meint Ihr dazu?
Was passiert bei Neustart von shNG mit den Altern?
Kann man auch eine Aktion in der Logik definieren, wie beim beenden dieser ausgeführt werden soll?

Danke für Euer Feedback

[Onkelandy]

Beim Neustart wird imho das Alter aus dem Cache ausgelesen, funktioniert also "im Prinzip".

Beim Beenden von shng läuft deine Logik ja vermutlich nicht grad zufällig, insofern bringt eine Funktion beim "Beenden der Logik" nix. Cool wäre in diesem Fall, man könnte als watch_item "shutdown" oä. angeben, damit die Logik fix nochmals beim Stoppen getriggert wird.
Alternativ kannst du dir ein Dummy-Plugin anlegen, das in der stop Methode deine Logik ausführt. Ob das mit logics.Logikname geht, weiß ich aber nicht, müsstest du probieren. Im ärgsten Notfall eine Methode mit deiner Logik ins Plugin nehmen und die dann beim Stop ausführen.

[Msinn]

Cool wäre in diesem Fall, man könnte als watch_item "shutdown" oä. angeben, damit die Logik fix nochmals beim Stoppen getriggert wird.

Ich habe das mal ins Backlog für v1.9 genommen.

[Sisamiwe]

Ich habe das mal ins Backlog für v1.9 genommen.

Top!

[Sisamiwe]

Ich habe das mal ins Backlog für v1.9 genommen.

Konntest Du Dir dazu schon mal Gedanken machen?