SOLVED - Verbrauch von heute (seit Mitternacht) anzeigen

[peter-pan]

Also ich denke das muss wohl so sein, da es sich hier nicht um einen "nomalen" Durchschnitt handelt.

Der wird ja schon in der ersten Zeile

Code: Alles auswählen

   val Leistung = Solarpanel_PowerConsumption.averageSince(ZonedDateTime.now().with(LocalTime.MIDNIGHT)) as Number

ermittelt. Als Ergebnis der Summe der Einzelwerte dividiert durch die Anzahl der Einzelwerte.

Nun kommt aber auch noch der Faktor Zeit (LocalDateTime.now().toLocalTime().toSecondOfDay() / 3600000) bzw. anteilige Tageszeit mit in die Berechnung.

[udo1toni]

Ich hatte das ja oben erläutert, das Ganze funktioniert nur, wenn die Werte gleichmäßig rein kommen. Wobei die Doku davon spricht, dass die Messwerte beim Errechnen des Durchschnitts zeitlich gewichtet werden. Wenn also z.B. ein Messwert 10 rein kommt, dann 10 Minuten nichts, dann ein Messwert 100, aber nach einer Minute 0, dann neun Minuten nichts und dann wieder 10, dann sollte der Durchschnitt über die zwanzig Minuten eigentlich 10 sein, das heißt, es wäre egal, ob die Lücken zwischen den Messungen immer gleich groß sind. Für die Genauigkeit der Kalkulation gibt es aber auch noch andere Faktoren, wie stark schwankt der Messwert (vor allem zwischen zwei Messungen)

[peter-pan]

..also wie gesagt: Meine Mathe-Kenntnisse sind nicht so besonders. Ich bin da relativ einfach gestrickt. Bei mir sieht das so aus:

10 + 100 + 0 +10 = 120 (Summe) Anzahl Messungen = 4 also 120 : 4 = 30 (Durchschnitt)

Wie ihr seht habe ich den Zeitfaktor in dieser Rechnung überhaupt nicht berücksichtigt. Sorry

dann sollte der Durchschnitt über die zwanzig Minuten eigentlich 10 sein

Wärst du so nett und könntest mir den Rechenweg zeigen, bitte ! Weil, wenn ich 120 (Summe) durch 20 (Minuten) teile komme ich auf 6 . Da fehlt's halt doch

[udo1toni]

Ja, das ist aber der Punkt. Laut Doku sieht das nämlich so aus: 10 Minuten 10 -> 10/10 | 1 Minute 100 -> 100/1 | 9 Minuten 0 -> 0/9 | Summe 200/20 -> Durchschnitt 10
Und so sollte es eigentlich auch sein, Der Wert wird abhängig von der Dauer der Gültigkeit (also bis zum nächsten Wert) anteilig berücksichtigt.

Oder um es mathematisch korrekt auszudrücken:

Code: Alles auswählen

10 Minuten á  10 -> 10 *  10 = 100, Teiler 10
 1 Minute  á 100 ->  1 * 100 = 100, Teiler  1
 9 Minuten á   0 ->  9 *   0 =   0, Teiler  9
Summe                          200, Teiler 20

Das ist wie beim Errechnen des Notendurchschnitts:
fünf Kinder haben eine eins (die Streber mal wieder),
sieben Kinder eine zwei,
dreizehn Kinder eine drei (Die drei ist die eins des kleinen Mannes),
sechs Kinder eine vier,
zwei Kinder eine fünf und
ein Kind eine sechs (beim Abschreiben erwischt, der Pechvogel) ->

Code: Alles auswählen

(5*1 + 7*2 + 13*3 + 6*4 + 2*5 + 1*6)/(5+7+13+6+2+1) = (5 + 14 + 39 + 24 + 10 + 6)/34 = 98/34 ~ 2,88

Hätten die Schüler:innen mal besser gelernt...

[peter-pan]

Ja, das ist aber der Punkt.

Da hab ich ja schon mal den ganz falschen Ansatz gehabt. Danke für deine Erläuterungen. Super !!

Edit: Hab auch das Beispiel in der Doku gefunden. Nicht nur Mathe-Nachhilfe ist nötig, auch wer lesen kann ist klar im Vorteil

[zinnik]

Hallo ich mal wieder,

da ihr mir ja so fleißig geholfen habt die Rule für den tag anzupassen und die My Strom App nun aber leider keine Wochen Monats und jahreswerte ohne Abo liefert wollte ich fragen ob ihr mir die Rule so anpassen könntet dass der Ertrag für Tag, Woche, Monat und Jahr ausgeben wird.

Code: Alles auswählen

rule "Solarpanel Ertrag Tag"
when
    Item Solarpanel_PowerConsumption received update
then
    val Leistung = Solarpanel_PowerConsumption.averageSince(ZonedDateTime.now().with(LocalTime.MIDNIGHT)) as Number
    val Sekunde = LocalDateTime.now().toLocalTime().toSecondOfDay()
    val Ertrag = Leistung * Sekunde / 3600000

    logInfo("Solarpanel","Leistung: {} Sekunde: {} Tagesertrag: {} kWh",Leistung,Sekunde,Ertrag)
    Solarpanel_Ertrag_Tag.postUpdate(Ertrag)
end

und hier wäre die Rule die Chat gpt ausspuckt:

Code: Alles auswählen

rule "Solarpanel Ertrag Tag, Woche, Monat und Jahr"
when
    // Berechne den Tagesertrag bei jeder Aktualisierung
    Item Solarpanel_PowerConsumption received update or
    // Berechne die aggregierten Erträge einmal täglich um Mitternacht
    Time cron "0 0 0 * * ?" 
then
    if (Solarpanel_PowerConsumption.state == NULL || Solarpanel_PowerConsumption.state == UNDEF) {
        logWarn("Solarpanel", "Solarpanel_PowerConsumption hat keinen gültigen Wert.")
        return
    }

    // Berechnung des Tagesertrags in kWh bei jeder Aktualisierung
    val startOfDay = ZonedDateTime.now().with(LocalTime.MIDNIGHT)
    val avgLeistungTag = Solarpanel_PowerConsumption.averageSince(startOfDay) as Number
    val sekundenSeitMitternacht = LocalDateTime.now().toLocalTime().toSecondOfDay()
    val ertragTagKWh = (avgLeistungTag.doubleValue * sekundenSeitMitternacht) / 3600000

    // Ergebnis in das Item für den Tagesertrag schreiben
    Solarpanel_Ertrag_Tag.postUpdate(ertragTagKWh)
    logInfo("Solarpanel", "Tagesertrag: {} kWh", ertragTagKWh)

    // Berechne Woche, Monat und Jahr nur einmal täglich um Mitternacht
    if (now.with(LocalTime.MIDNIGHT).equals(startOfDay)) {
        try {
            // Berechnung des wöchentlichen Ertrags in kWh
            val startOfWeek = ZonedDateTime.now().minusWeeks(1).with(LocalTime.MIDNIGHT)
            val avgLeistungWoche = Solarpanel_PowerConsumption.averageSince(startOfWeek) as Number
            val ertragWocheKWh = (avgLeistungWoche.doubleValue * 7 * 24 * 3600) / 3600000
            Solarpanel_Ertrag_Woche.postUpdate(ertragWocheKWh)
            logInfo("Solarpanel", "Wöchentlicher Ertrag: {} kWh", ertragWocheKWh)

            // Berechnung des monatlichen Ertrags in kWh
            val startOfMonth = ZonedDateTime.now().minusMonths(1).with(LocalTime.MIDNIGHT)
            val avgLeistungMonat = Solarpanel_PowerConsumption.averageSince(startOfMonth) as Number
            val ertragMonatKWh = (avgLeistungMonat.doubleValue * 30 * 24 * 3600) / 3600000
            Solarpanel_Ertrag_Monat.postUpdate(ertragMonatKWh)
            logInfo("Solarpanel", "Monatlicher Ertrag: {} kWh", ertragMonatKWh)

            // Berechnung des jährlichen Ertrags in kWh
            val startOfYear = ZonedDateTime.now().minusYears(1).with(LocalTime.MIDNIGHT)
            val avgLeistungJahr = Solarpanel_PowerConsumption.averageSince(startOfYear) as Number
            val ertragJahrKWh = (avgLeistungJahr.doubleValue * 365 * 24 * 3600) / 3600000
            Solarpanel_Ertrag_Jahr.postUpdate(ertragJahrKWh)
            logInfo("Solarpanel", "Jährlicher Ertrag: {} kWh", ertragJahrKWh)
            
        } catch (Exception e) {
            logError("Solarpanel", "Fehler in der Berechnung der Erträge: {}", e.toString)
        }
    }
end

Die Items sind:
Solarpanel_Ertrag_Tag
Solarpanel_Ertrag_Woche
Solarpanel_Ertrag_Monat
Solarpanel_Ertrag_Jahr

PS: ich habe es mit Chat Gpt versucht anzupassen aber da werden so viele Datenbankabfragen gestartet das alles einbricht und es kommen auch nicht die richtigen Werte
Lg Sven

[udo1toni]

Ach ja, ChatGPT... Ich wiederhole mich ja nur ungern (oder doch...), aber ChatGPT ist weder intelligent noch hat es von irgendetwas Ahnung. Das einzige, was ChatGPT sehr gut kann, ist intelligent erscheinen.
Achso, ja, und abschreiben kann ChatGPT auch extrem gut.

Und damit ist auch sofort klar, dass ChatGPT für openHAB nichts bringt, denn die Datenbasis ist mit ein paar zehntausend Anwendern weltweit um Größenordnungen zu klein, um durch Klauen intelligent erscheinen zu können.

Aber wenn Du die Werte eingesammelt hast, kannst Du die Persistence sehr einfach abfragen, je nachdem, was Du wissen willst, mit deltaSince (oder deltaBetween) für monoton wachsende Werte (Zählerstände z.B.) oder halt mit averageSince bzw. averagreBetween für Werte, die zwischen einem MAximum und einem Minimum schwanken. Für solche Werte kann auch ein maximum/minimumSince bzw. ...Between interessant sein, um den höchsten oder auch niedrigsten Wert in einem Zeitraum zu ermitteln.

Einer fertige Rule kann ich heute nicht liefern, weil ich morgen arbeiten muss und es schon etwas spät ist...

[zinnik]

Ach ja, ChatGPT... Ich wiederhole mich ja nur ungern (oder doch...), aber ChatGPT ist weder intelligent noch hat es von irgendetwas Ahnung. Das einzige, was ChatGPT sehr gut kann, ist intelligent erscheinen.
Achso, ja, und abschreiben kann ChatGPT auch extrem gut.

Und damit ist auch sofort klar, dass ChatGPT für openHAB nichts bringt, denn die Datenbasis ist mit ein paar zehntausend Anwendern weltweit um Größenordnungen zu klein, um durch Klauen intelligent erscheinen zu können.

Aber wenn Du die Werte eingesammelt hast, kannst Du die Persistence sehr einfach abfragen, je nachdem, was Du wissen willst, mit deltaSince (oder deltaBetween) für monoton wachsende Werte (Zählerstände z.B.) oder halt mit averageSince bzw. averagreBetween für Werte, die zwischen einem MAximum und einem Minimum schwanken. Für solche Werte kann auch ein maximum/minimumSince bzw. ...Between interessant sein, um den höchsten oder auch niedrigsten Wert in einem Zeitraum zu ermitteln.

Einer fertige Rule kann ich heute nicht liefern, weil ich morgen arbeiten muss und es schon etwas spät ist...

Ja Udo ich weiss und ich kenne auch deine Meinung zu Chat GPT aber was soll ich machen. ich verstehe diese Rules einfach nicht und versuche mich damit ein bisschen zu verhelfen um nicht andauernd wegen jeder kleinigkeit nach zufragen.

Und meine google Anfragen dazu bringen mich auch nicht zum Erfolg.... meist bist du immer meine einzige Rettung.
Aber es eillt nicht mit der Rule.... ich habe versucht mit der von dir erstellten Rule für den Heizungsverbrauch abzuleiten aber auch da scheitere ich.

Code: Alles auswählen

rule "Heizung Verbrauch Kosten Tag Woche Monat Jahr"                                                              // Deutscher Zeichensatz zulässig
when
    Item Heizung_Zaehlerstand_errechnet changed                                                         // changed reicht.
then

    val Preis  = 0.2561
    val Preis_letztes_Jahr  = 0.2868
    val Grundgeb_letztes_Jahr  = 107.16

    val ZonedDateTime zdt            = ZonedDateTime.now()                                              // jetzt
    val ZonedDateTime start_of_day   = zdt.with(LocalTime.MIDNIGHT)                                     // heute, Mitternacht
    val ZonedDateTime start_of_week  = start_of_day.minusDays(start_of_day.getDayOfWeek.getValue - 1)   // Montag 
    val ZonedDateTime start_of_month = start_of_day.withDayOfMonth(1)                                   // Erster Tag des Monats (1)
    val ZonedDateTime start_of_year  = start_of_day.withDayOfYear(1)                                    // Erster Tag des Jahres (1)

    val strom_Heute = (Heizung_Zaehlerstand_errechnet.deltaSince(start_of_day)   as Number).floatValue
    val strom_Woche = (Heizung_Zaehlerstand_errechnet.deltaSince(start_of_week)  as Number).floatValue
    val strom_Monat = (Heizung_Zaehlerstand_errechnet.deltaSince(start_of_month) as Number).floatValue
    val strom_Jahr  = (Heizung_Zaehlerstand_errechnet.deltaSince(start_of_year)  as Number).floatValue

    Heizung_Verbrauch_Tag.postUpdate(strom_Heute)
    Heizung_Verbrauch_Woche.postUpdate(strom_Woche)
    Heizung_Verbrauch_Monat.postUpdate(strom_Monat)
    Heizung_Verbrauch_Jahr.postUpdate(strom_Jahr)


    Heizung_Kosten_Tag.postUpdate(strom_Heute * Preis)
    Heizung_Kosten_Woche.postUpdate(strom_Woche * Preis)
    Heizung_Kosten_Monat.postUpdate(strom_Monat * Preis)
    Heizung_Kosten_Jahr.postUpdate(strom_Jahr * Preis)

    Heizung_Kosten_Vortag.postUpdate(Heizung_Verbrauch_Vortag.state as Number * Preis)
    Heizung_Kosten_letzte_Woche.postUpdate(Heizung_Verbrauch_letzte_Woche.state as Number * Preis)
    Heizung_Kosten_letzter_Monat.postUpdate(Heizung_Verbrauch_letzter_Monat.state as Number * Preis)
    Heizung_Kosten_letztes_Jahr.postUpdate(Heizung_Verbrauch_letztes_Jahr.state as Number * Preis_letztes_Jahr + Grundgeb_letztes_Jahr)
    
end

[udo1toni]

Ich erinnere mich dunkel an die Rule.
Woran ich mich nicht erinnere, das ist die Erweiterung um die Vorwerte (Verbrauch und Kosten Vortag bzw. letzte...) und das kann so eigentlich auch nicht stimmen - also abgesehen davon, dass diese Werte fix sind, also nie häufiger als einmal berechnet werden müssten.
Du hast ja schon eine Rule, welche den Tagesertrag für den aktuellen Tag errechnet. Von dort gibt es verschiedene Möglichkeiten, wie es weiter geht.
Z.B.: Du schreibst "eine Sekunde" vor Mitternacht den Tagesertrag in ein Item, welches Du nicht automatisch persistierst. z.B. so:

Code: Alles auswählen

rule "Tagesertrag persistieren"
when
    Time cron "58 59 23 * * ?" // täglich um 23:59:58 Uhr
then
    if(Solarpanel_Ertrag_Tag.state instanceof Number) {
        solarPanel_Ertrag_Speicher.postUpdate((Solarpanel_Ertrag_Tag.state as Number))
        Thread.sleep(250)
        solarPanel_Ertrag_Speicher.persist
    ]
end

So ist sichergestellt, dass pro Tag nur ein Messwert in der Persistence landet. Alternativ könnte man auch das Speichern über die Persistence automatisch erledigen lassen, wichtig ist aber, dass zu der Zeit der korrekte Wert anliegt und nur ein Wert pro Tag geschrieben wird.
Nun kannst Du - bezogen auf dieses Item - mittels sumSince() oder sumBetween() die Summen der Tageswerte für beliebige Zeiträume erfragen.
Das funktioniert natürlich nicht für alte Werte aber da die aktuelle Version von openHAB auch das persistieren mit beliebigem Zeitstempel unterstützt, könnte man die benötigten Werte aus dem persistierten Item Solarpanel_Ertrag_Tag einmalig auslesen lassen, per persistedState(Zeitstempel vor Mitternacht).
Das Problem hierbei ist, dass man jeden Zeitstempel errechnen muss. Man könnte das auch on-the-fly erledigen lassen, aber dann läuft so eine Rule mutmaßlich etwas länger (bis zu 366 Durchläufe und Datenbankabfragen für das aktuelle Jahr...) und das Ganze ist ja bezogen auf Zeitstempel, das ist definitiv nicht trivial. Die einfache Lösung ist daher, die Werte automatisch in einer separaten Tabelle zu speichern, die dann leicht abgefragt werden kann.
Wichtig wäre hier auch, dass solarPanel_Ertrag_Speicher nicht mit rrd4j persistiert werden darf, weil rrd4j zwingend everyMinute vorschreibt, was die Berechnung zunichte machen würde...

[zinnik]

Hallo,

also das bedeutet wenn solarPanel_Ertrag_Speicher nicht persistiert werden darf, dann müsst ich meine Persist für rrd4j erstmal so konfigurieren, dass standardmäßig nicht alle Items persistiert wird?
Das bedeutet erstmal einiges an Arbeit, durch die ganz Wetter items ist die Liste der Items ganz schön angestiegen.
Denn ein einzelnes Item kann ich ja nicht ausschließen?
sondern nur nicht mit in die persist.config schreiben.

Du hast es zwar wieder supewr erklärt aber leider kann ich mir auch nichts drunter vorstellen wie dann so eine Gesamte >Rule mittels sumSince() oder sumBetween() aussehen soll.
Die Werte in eine separate <Tabelle speichern habe ich auch nicht verstanden.

Lg Sven