Wetterdaten Min. und Max. Temperaturen der nächsten 5 Tage

Guten Morgen Zusammen,

ein Freund hat in mehreren Räumen noch Nachspeicheröfen und eine PV auf dem Dach.
Jetzt hat er mich gefragt, wie er die Nachspeicher mit Überschussstrom betreiben kann.

Jetzt habe wir bei ihm Raspberry mit HA installiert, die PV und die Nachtspeicher mit Temperaturfüllern bestückt und schaltbar gemacht.

Da diese Speicher ziemlich träge sind brauchen wir noch eine Vorhersage für die nächsten Tage (min und max).
Wir habe jetzt die Integration Meteorologisk Institutt Installiert und den Standort eingerichtet, also haben wir das Wetter.

Wir möchten jetzt je einen Template Sensor (minTemperautur_Tag_0 so weiter) für die nächsten 5 Tage erstellen und jeweils die min und die max Temperatur übergeben.

Kann mir jemand sagen, wie wir diese Daten (min und max) auslesen können?

Vielen Dank im Voraus
Viele Grüße
Ingo

Da müsste man per Forecast die Wetter Daten holen und mit denen dann Automatisierungen aufbauen.
Sonst schaue dir das mal an: Home Assistant: Die Zukunft enthüllen: Prognosedaten ohne Grafana visualisieren!

du kannst dir mit der Action weather.get_forecasts die Vorhersage holen, sowohl stündlich als auch täglich. Bei der DWD Integration für 10 Tage.

Mit der Antwort kannst du dann zum Beispiel template sensoren füllen, hier das Beispiel aus der Doku:

template:
  - trigger:
      - trigger: time_pattern
        hours: /1
    action:
      - action: weather.get_forecasts
        data:
          type: hourly
        target:
          entity_id: weather.home
        response_variable: hourly
    sensor:
      - name: Temperature forecast next hour
        unique_id: temperature_forecast_next_hour
        state: "{{ hourly['weather.home'].forecast[0].temperature }}"
        unit_of_measurement: °C

Die „Weather Forecasts“ wurden vor einiger Zeit umgestellt, somit sind nicht alle im Netz vorhandenen und teilweise recht populären Videos und Anleitungen noch aktuell.

2 „Gefällt mir“

Der beschrieben Weg von Nicknol wird funktionieren, aber wenn die Integration Meteorologisk einen forecast bereitstellt, müsste man doch mit Template Sensoren die Daten ebenfalls abgrenzen können.

template:
  - sensor:
      - name: "Min Temperatur"
        unit_of_measurement: "°C"
        state: "{{ state_attr('weather.meteologisk_institutt', 'forecast')[0].tempminlow }}"
      - name: "Max Temperatur"
        unit_of_measurement: "°C"
        state: "{{ state_attr('weather.meteologisk_institutt', 'forecast')[0].temperature }}"
  - sensor:
      - name: "Min Temperatur 1"
        unit_of_measurement: "°C"
        state: "{{ state_attr('weather.meteologisk_institutt', 'forecast')[1].templow }}"
      - name: "Max Temperatur 1"
        unit_of_measurement: "°C"
        state: "{{ state_attr('weather.meteologisk_institutt', 'forecast')[1].temperature }}"
# usw. für die nächsten Tage

Könnte man auch über Template Helfer in UI realisieren und nur die Templates darin hinterlegen, wenn die config.yaml nicht gewünscht ist.

{{ state_attr('weather.meteologisk_institutt', 'forecast')[1].templow }}

Oder habe ich da gerade einen Denkfehler. :thinking:

Na mal sehen ob ich hier nie Lösung zu meinem Thema von vor paar Tagen finde weil es genau auf das selbe raus läuft.. Vll läuft es dann mit dem Code hier :see_no_evil_monkey:

Hallo Zusammen,

Danke erstmal für Eure Unterstützung.
Und sorry für die späte Antwort, ich bin leider nicht früher zum Testen gekommen.

Ich habe jetzt im Template geschaut, ob ich mit euren Beispielen Werte bekomme, aber irgendwie stelle ich mich heute zu Doof an.

Die Entität heiß bei mir weather.forecast_home.

@jayjojayson ich verstehe dich so, dass ich mit deinem Beispiel die Temperaturen direkt auslesen kann.
Wenn ich das auf meine Entität anpasse
" {{ state_attr(‚weather.forecast_home‘, ‚forecast‘)[0].temperature }}"
und im Template teste, dann bekomme ich None has no element 0 angezeigt.

@Nicknol deine Methode habe ich schonmal gesehen…
Ich denke Simon42 hat das mal in einem Video gezeigt.
Das finde ich eigentlich auch nicht schlecht, aber ich verstehe das System nicht so ganz, und ich nutze gerne Sachen, die ich von der Syntax her verstanden habe.
Wenn du aber etwas Zeit hättest, wäre ich nicht abgeneigt :slight_smile:

Viele Grüße Ingo

Guten Morgen @Nicknol,

Ich habe mir das mit deinem Beispiel und der Vorlage von Simon mal gebaut.
Was ich nicht geschafft habe, den Wert für die Tiefste Temperatur zu finden.

Kannst du mir hier weiterhelfen?

Vielen Dank Gruß Ingo

klasse, du kommst vorwärts! :slight_smile:

das ist allerdings nicht mein Beispiel, sondern ein Auszug aus der Doku :wink:

da ich das selbst auch noch nicht implementiert habe, habe ich mal die KI gefragt:

Prompt
die typischen weather integrationen stellen einen stündlichen und täglichen forecast zur Verfügung. Ich möchte nun für die nächsten 5 Tage template sensoren erstellen, die die min und max Temperaturen je Tag bereitstellen. Wie sehen die templates aus?

Antwort
Sehr gute Frage :+1: – genau das lässt sich mit den neuen Template-Sensoren in Home Assistant elegant lösen.
Ich zeige dir ein konkretes Beispiel, wie du aus einem beliebigen weather-Entity (z. B. weather.home) die minimale und maximale Temperatur für die nächsten 5 Tage als eigene Sensoren extrahierst.


1. Voraussetzungen

  • Du hast eine Wetterintegration, die forecast bereitstellt (hourly oder daily).
  • Beispiel: weather.home

Die Datenstruktur sieht typischerweise so aus (gekürzt):

state: "sunny"
attributes:
  temperature: 23
  forecast:
    - datetime: "2025-09-28T00:00:00+00:00"
      condition: "rainy"
      temperature: 21
      templow: 12
    - datetime: "2025-09-29T00:00:00+00:00"
      condition: "cloudy"
      temperature: 19
      templow: 10
    ...

:backhand_index_pointing_right: temperature = Maximaltemperatur,
:backhand_index_pointing_right: templow = Minimaltemperatur.

  1. Templates für die nächsten 5 Tage

In deiner configuration.yaml (oder templates.yaml wenn ausgelagert):

template:
  - sensor:
      - name: "Forecast Day 1 Min Temp"
        unit_of_measurement: "°C"
        state: >
          {{ state_attr('weather.home', 'forecast')[0].templow }}

      - name: "Forecast Day 1 Max Temp"
        unit_of_measurement: "°C"
        state: >
          {{ state_attr('weather.home', 'forecast')[0].temperature }}

      - name: "Forecast Day 2 Min Temp"
        unit_of_measurement: "°C"
        state: >
          {{ state_attr('weather.home', 'forecast')[1].templow }}

      - name: "Forecast Day 2 Max Temp"
        unit_of_measurement: "°C"
        state: >
          {{ state_attr('weather.home', 'forecast')[1].temperature }}

      - name: "Forecast Day 3 Min Temp"
        unit_of_measurement: "°C"
        state: >
          {{ state_attr('weather.home', 'forecast')[2].templow }}

      - name: "Forecast Day 3 Max Temp"
        unit_of_measurement: "°C"
        state: >
          {{ state_attr('weather.home', 'forecast')[2].temperature }}

      - name: "Forecast Day 4 Min Temp"
        unit_of_measurement: "°C"
        state: >
          {{ state_attr('weather.home', 'forecast')[3].templow }}

      - name: "Forecast Day 4 Max Temp"
        unit_of_measurement: "°C"
        state: >
          {{ state_attr('weather.home', 'forecast')[3].temperature }}

      - name: "Forecast Day 5 Min Temp"
        unit_of_measurement: "°C"
        state: >
          {{ state_attr('weather.home', 'forecast')[4].templow }}

      - name: "Forecast Day 5 Max Temp"
        unit_of_measurement: "°C"
        state: >
          {{ state_attr('weather.home', 'forecast')[4].temperature }}

3. Hinweise

  • forecast[0] = heute
  • forecast[1] = morgen
  • usw.
  • Manche Integrationen liefern nicht templow, sondern nur temperature (dann musst du Minimum selbst aus den hourly Forecasts berechnen).
  • Die Einheit "°C" kannst du natürlich anpassen.

2. Prompt
Manche Integrationen liefern nicht templow, sondern nur temperature (dann musst du Minimum selbst aus den hourly Forecasts berechnen). Gib mir mal den Code für die Berechnung der Minima und Maxima

Antwort
Wenn deine Wetter-Integration nur einen stündlichen Forecast (forecast mit 24–120 Stunden in temperature) liefert, musst du die Minima und Maxima pro Tag gruppieren und berechnen.


Beispiel: Min/Max aus stündlichem Forecast

Nehmen wir an, dein Entity ist weather.home, und die Struktur sieht so aus:

attributes:
  forecast:
    - datetime: "2025-09-28T01:00:00+00:00"
      temperature: 16
    - datetime: "2025-09-28T02:00:00+00:00"
      temperature: 15
    - datetime: "2025-09-28T03:00:00+00:00"
      temperature: 14
    - datetime: "2025-09-29T01:00:00+00:00"
      temperature: 12
    ...

:backhand_index_pointing_right: Dann berechnest du so:

  1. Template-Sensoren für heute
template:
  - sensor:
      - name: "Today's Min Temp"
        unit_of_measurement: "°C"
        state: >
          {% set today = now().date() %}
          {% set temps = state_attr('weather.home', 'forecast')
            | selectattr('datetime', 'defined')
            | selectattr('temperature', 'defined')
            | selectattr('datetime', 'search', today.isoformat())
            | map(attribute='temperature')
            | list %}
          {{ temps | min if temps | count > 0 else 'unknown' }}

      - name: "Today's Max Temp"
        unit_of_measurement: "°C"
        state: >
          {% set today = now().date() %}
          {% set temps = state_attr('weather.home', 'forecast')
            | selectattr('datetime', 'defined')
            | selectattr('temperature', 'defined')
            | selectattr('datetime', 'search', today.isoformat())
            | map(attribute='temperature')
            | list %}
          {{ temps | max if temps | count > 0 else 'unknown' }}

2. Für die nächsten Tage

Hier änderst du nur den Vergleichstag (today + timedelta(days=1) usw.):

      - name: "Tomorrow Min Temp"
        unit_of_measurement: "°C"
        state: >
          {% set day = (now().date() + timedelta(days=1)) %}
          {% set temps = state_attr('weather.home', 'forecast')
            | selectattr('datetime', 'defined')
            | selectattr('temperature', 'defined')
            | selectattr('datetime', 'search', day.isoformat())
            | map(attribute='temperature')
            | list %}
          {{ temps | min if temps | count > 0 else 'unknown' }}

      - name: "Tomorrow Max Temp"
        unit_of_measurement: "°C"
        state: >
          {% set day = (now().date() + timedelta(days=1)) %}
          {% set temps = state_attr('weather.home', 'forecast')
            | selectattr('datetime', 'defined')
            | selectattr('temperature', 'defined')
            | selectattr('datetime', 'search', day.isoformat())
            | map(attribute='temperature')
            | list %}
          {{ temps | max if temps | count > 0 else 'unknown' }}

3. Wiederholen bis +5 Tage

  • Ersetze timedelta(days=1) durch timedelta(days=2), days=3 usw.
  • So bekommst du Min/Max für 5 Tage.

habe ich alles nicht getestet oder gar selber in Benutzung. Vielleicht hilft’s dir.

1 „Gefällt mir“

eine andere KI antwortet etwas weniger weitschweifig:

mit den täglichen Forecast-Daten der typischen weather-Integrationen (z. B. OpenWeatherMap, DWD, Met.no) kannst du dir ganz einfach Template-Sensoren für die nächsten 5 Tage erstellen, die jeweils Min- und Max-Temperaturen anzeigen.

:puzzle_piece: Grundstruktur der Forecast-Daten

Die meisten weather-Integrationen stellen die tägliche Vorhersage über:

state_attr('weather.dein_wetter_entity', 'forecast')

bereit. Das ist eine Liste von Dictionaries, z. B.:

[
  {'datetime': '2025-09-28T00:00:00', 'temperature': 21, 'templow': 13, ...},
  {'datetime': '2025-09-29T00:00:00', 'temperature': 20, 'templow': 12, ...},
  ...
]

:hammer_and_wrench: Beispiel: Template-Sensor für Tag 1 (heute)

sensor:
  - platform: template
    sensors:
      forecast_day_1_max:
        friendly_name: "Max Temp Tag 1"
        unit_of_measurement: "°C"
        value_template: >
          {{ state_attr('weather.dein_wetter_entity', 'forecast')[0].temperature }}
      forecast_day_1_min:
        friendly_name: "Min Temp Tag 1"
        unit_of_measurement: "°C"
        value_template: >
          {{ state_attr('weather.dein_wetter_entity', 'forecast')[0].templow }}

:repeat_button: Wiederholung für Tag 2 bis Tag 5

Du musst nur den Index [1], [2], [3], [4] anpassen:

forecast_day_2_max → forecast[1].temperature
forecast_day_2_min → forecast[1].templow
...
forecast_day_5_max → forecast[4].temperature
forecast_day_5_min → forecast[4].templow

:package: Komplette Vorlage für alle 5 Tage

Hier ein kompaktes Beispiel für alle 5 Tage:

sensor:
  - platform: template
    sensors:
      forecast_day_1_max:
        value_template: "{{ state_attr('weather.dein_wetter_entity', 'forecast')[0].temperature }}"
        unit_of_measurement: "°C"
      forecast_day_1_min:
        value_template: "{{ state_attr('weather.dein_wetter_entity', 'forecast')[0].templow }}"
        unit_of_measurement: "°C"
      forecast_day_2_max:
        value_template: "{{ state_attr('weather.dein_wetter_entity', 'forecast')[1].temperature }}"
        unit_of_measurement: "°C"
      forecast_day_2_min:
        value_template: "{{ state_attr('weather.dein_wetter_entity', 'forecast')[1].templow }}"
        unit_of_measurement: "°C"
      # … bis Tag 5

Moin, das war ja auch schon mein Vorschlag. :slight_smile:

Wir wissen halt immer noch nicht wirklich was er für Entitäten bereitgestellt bekommt. Ein Screenshot wäre da sehr hilfreich.

ich weiß :slight_smile:
doch ich habe halt die komplette Antwort der KI bereitgestellt.
Und es ist ja schon vielversprechend, wenn die Antworten sich ähneln :slight_smile:

1 „Gefällt mir“

Hallo @Nicknol und @jayjojayson,
vielen Dank für eure Hilfe, ich denke, ich habe es geschafft.

Ich habe mir jetzt eine Yaml Datei erstellt, die nach dem ersten Beispiel von Nicknol die Daten liest und die jeweiligen Daten den erstellten Sensoren übergibt.

Die Datei sieht jetzt so aus und liefert die gewünschten Sensoren:

template:
  - trigger:
      - platform: time_pattern
        hours: "/1"  

    action:
      - service: weather.get_forecasts
        target:
          entity_id:
            - weather.forecast_home
           
        data:
            type: daily
        response_variable: vorhersage
        
    sensor:
      - name: Temperatur Max Tag 0
        unique_id: temperatur_max_tag_0
        state: "{{ vorhersage['weather.forecast_home'].forecast[0].temperature }}"
        unit_of_measurement: °C
        
      - name: Temperatur Max Tag 1
        unique_id: temperatur_max_tag_1
        state: "{{ vorhersage['weather.forecast_home'].forecast[1].temperature }}"
        unit_of_measurement: °C
        
      - name: Temperatur Max Tag 2
        unique_id: temperatur_max_tag_2
        state: "{{ vorhersage['weather.forecast_home'].forecast[2].temperature }}"
        unit_of_measurement: °C
        
      - name: Temperatur Max Tag 3
        unique_id: temperatur_max_tag_3
        state: "{{ vorhersage['weather.forecast_home'].forecast[3].temperature }}"
        unit_of_measurement: °C
    
      - name: Temperatur Max Tag 4
        unique_id: temperatur_max_tag_4
        state: "{{ vorhersage['weather.forecast_home'].forecast[4].temperature }}"
        unit_of_measurement: °C
        
      - name: Temperatur Max Tag 5
        unique_id: temperatur_max_tag_5
        state: "{{ vorhersage['weather.forecast_home'].forecast[5].temperature }}"
        unit_of_measurement: °C
        
      - name: Temperatur Min Tag 0
        unique_id: temperatur_min_tag_0
        state: "{{ vorhersage['weather.forecast_home'].forecast[0].templow }}"
        unit_of_measurement: °C
        
      - name: Temperatur Min Tag 1
        unique_id: temperatur_min_tag_1
        state: "{{ vorhersage['weather.forecast_home'].forecast[1].templow }}"
        unit_of_measurement: °C
        
      - name: Temperatur Min Tag 2
        unique_id: temperatur_min_tag_2
        state: "{{ vorhersage['weather.forecast_home'].forecast[2].templow }}"
        unit_of_measurement: °C
        
      - name: Temperatur Min Tag 3
        unique_id: temperatur_min_tag_3
        state: "{{ vorhersage['weather.forecast_home'].forecast[3].templow }}"
        unit_of_measurement: °C
    
      - name: Temperatur Min Tag 4
        unique_id: temperatur_min_tag_4
        state: "{{ vorhersage['weather.forecast_home'].forecast[4].templow }}"
        unit_of_measurement: °C
        
      - name: Temperatur Min Tag 5
        unique_id: temperatur_min_tag_5
        state: "{{ vorhersage['weather.forecast_home'].forecast[5].templow }}"
        unit_of_measurement: °C
        

Eine Frage habe ich aber noch…
Wie kann ich das einstellen, dass es nur einmal am Tag aktualisiert wird und dann am besten 0 Uhr?

Wäre das ne Einstellung für einmal Täglich lesen?

  - platform: time_pattern
        hours: "/23"  

Viele Grüße Ingo

Die Doku ist dein Freund:

Dort findet sich neben der Beschreibung auch ein Beispiel:

automation:
  - triggers:
    - trigger: time
      # 24-hour time format. This trigger will fire at 3:32 PM
      at: "15:32:00"

Vielen Dank

1 „Gefällt mir“