Purge de la BdD InfluxDB

Entraide Home Assistant
9

bonjour,
comme crampes2 j’ai eu bcp de mal avec le post que tu sites Pulpy-Luke, surtout quand on est débutant. Quand on suit un post assez long c’est difficile de savoir ce qui est du test, du tuto, de la question…
quand à la doc, tout le monde ne maitrise pas l’anglais, et même si on maitrise un peu la langue de Shakespeare c’est pas évident…
je vais essayé de faire un résumé de ma solution (très très très largement inspiré du post) :

  1. creation des bases : il te faut plusieurs base dans influxdb :
  • 1 base qui va recueillir toutes tes données de HA : db_ha_all (par exemple) avec une rétention de 1 ou 2 mois
  • 1 base qui va recueillir les infos réduites (les min.max, les valeurs par jour, mois année) : db_ha_forever (par exemple) avec une rétention sans limite
  1. création de tasks qui va prendre les données de db_ha_all, les réduires et les mettre dans la base db_ha_forever :
  • sous influxdb, tu vas dans Task puis create task, voici une tache qui prend toutes tes données en kWh et calcule toutes les heures la différence entre le min et le max :
import "date"
import "experimental"
import "math"

option task = {name: "hourly_kwh", cron: "@hourly"}

heure = date.truncate(t: now(), unit: 1h)
heure_avant = experimental.addDuration(d: -1h, to: heure)

DATA1 =
    from(bucket: "db_ha_all")
        |> range(start: heure_avant, stop: heure)
        |> filter(fn: (r) => r["_measurement"] == "kWh")
        |> filter(fn: (r) => r["_field"] == "value")

DATA1
    |> set(key: "source", value: "calculated")
    |> reduce(
        fn: (r, accumulator) =>
            ({
                min:
                    if r._value < accumulator.min and r._value != 0.0 then
                        r._value
                    else
                        accumulator.min,
                max: if r._value > accumulator.max then r._value else accumulator.max,
                _time: r._time,
            }),
        identity: {min: 10000000000.0, max: -10000000000.0, _time: now()},
    )
    |> map(fn: (r) => ({r with _time: heure_avant}))
    |> map(fn: (r) => ({r with _value: math.round(x: (r.max - r.min) * 100.0) / 100.0}))
    |> to(bucket: "db_ha_forever")
  • pour faire la même chose tous les jours pour toutes les données kWh et € :
import "date"
import "experimental"
import "math"

option task = {name: "daily_kwh_€", cron: "@daily"}

TODAY = date.truncate(t: now(), unit: 1d)
YESTERDAY = experimental.addDuration(d: -1d, to: TODAY)

DATA1 =
    from(bucket: "db_ha_all")
        |> range(start: YESTERDAY, stop: TODAY)
        |> filter(fn: (r) => r["_measurement"] == "kWh" or r["_measurement"] == "€")
        |> filter(fn: (r) => r["_field"] == "value")

DATA1
    |> set(key: "source", value: "calculated")
    |> reduce(
        fn: (r, accumulator) =>
            ({
                min:
                    if r._value < accumulator.min and r._value != 0.0 then
                        r._value
                    else
                        accumulator.min,
                max: if r._value > accumulator.max then r._value else accumulator.max,
                _time: r._time,
            }),
        identity: {min: 10000000000.0, max: -10000000000.0, _time: YESTERDAY},
    )
    |> map(fn: (r) => ({r with _time: YESTERDAY}))
    |> map(fn: (r) => ({r with _value: math.round(x: (r.max - r.min) * 100.0) / 100.0}))
    |> map(fn: (r) => ({r with min: r.min}))
    |> map(fn: (r) => ({r with min: r.max}))
    |> to(bucket: "db_ha_forever")
  • idem mais tous les mois :
import "date"
import "experimental"
import "math"

option task = {name: "monthly_kwh_€", cron: "@monthly"}

MONTH = date.truncate(t: now(), unit: 1mo)
MONTH_avant = experimental.addDuration(d: -1mo, to: MONTH)

DATA1 =
    from(bucket: "db_ha_all")
        |> range(start: MONTH_avant, stop: MONTH)
        |> filter(fn: (r) => r["_measurement"] == "kWh" or r["_measurement"] == "€")
        |> filter(fn: (r) => r["_field"] == "value")

DATA1
    |> set(key: "source", value: "calculated")
    |> reduce(
        fn: (r, accumulator) =>
            ({
                min:
                    if r._value < accumulator.min and r._value != 0.0 then
                        r._value
                    else
                        accumulator.min,
                max: if r._value > accumulator.max then r._value else accumulator.max,
                _time: r._time,
            }),
        identity: {min: 10000000000.0, max: -10000000000.0, _time: now()},
    )
    |> map(fn: (r) => ({r with _time: MONTH}))
    |> map(fn: (r) => ({r with _value: math.round(x: (r.max - r.min) * 100.0) / 100.0}))
    |> to(bucket: "db_ha_forever")
  • pour les températures :
import "date"
import "experimental"
import "math"

option task = {name: "daily_temperature ", cron: "@daily"}

TODAY = date.truncate(t: now(), unit: 1d)
YESTERDAY = experimental.addDuration(d: -1d, to: TODAY)
DATA =
    from(bucket: "db_ha_all")
        |> range(start: YESTERDAY, stop: TODAY)
        |> filter(fn: (r) => r["_measurement"] == "°C" or r["_measurement"] == "%")
        |> filter(fn: (r) => r["_field"] == "value")

DATA
    |> mean()
    |> map(fn: (r) => ({r with _time: YESTERDAY}))
    |> set(key: "statistics", value: "mean")
    |> set(key: "source", value: "calculated")
    |> map(fn: (r) => ({r with _value: math.round(x: r._value * 10.0) / 10.0}))
    |> to(bucket: "db_ha_jour")
DATA
    |> min()
    |> map(fn: (r) => ({r with _time: YESTERDAY}))
    |> set(key: "statistics", value: "min")
    |> set(key: "source", value: "calculated")
    |> to(bucket: "db_ha_jour")
DATA
    |> max()
    |> map(fn: (r) => ({r with _time: YESTERDAY}))
    |> set(key: "statistics", value: "max")
    |> set(key: "source", value: "calculated")
    |> to(bucket: "db_ha_forever")

tu y retrouves les task de Neuvidor… :slight_smile:
En jouant sur date.truncate tu peux faire pareil par année. y a aussi moyen de faire les mois, jour et heure en cours ( pour ne pas attendre la fin de la période pour avoir la valeur courant : voir les posts de Neuvidor).
après il faut que tu crées les liens entre Grafana et ces 2 bases. faut jouer un peu sur les paramètres de grafana pour avoir des histogramme qui tiennent le route.

1 « J'aime »