Creare un sensore weather (previsioni del tempo) da Meteo & Radar in Home Assistant




In questa guida cerco di spiegare passo-passo (diciamo per principianti) come creare un'entità di tipo "weather" (previsioni del tempo) in Home Assistant, prendendo i dati dal sito Meteo & Radar (Meteo & Radar Italia (meteoeradar.it)).

EDIT 13/04/2023: ho aggiunto il punto 8. che "ottimizza" il codice sfruttando la nuova funzionalità "macro" (disponibile da HA 2023.4.0)

EDIT 26/08/2023: ho rafforzato il codice del sensore weather (resiste meglio all'assenza di attributi) e inserito la nuova sintassi dei sensori command_line

EDIT 26/11/2023: gestita anche la neve (precipitazioni di tipo "snow")

EDIT 15/01/2024: riaggiunto l'attributo forecast_weather, visto che in realtà non è stato più deprecato e lo usano anche loro (forse si sono resi conto che da lovelace non è possibile chiamare servizi)

EDIT 04/04/2024: rimosso nuovamente l'attributo forecast_weather, tolto definitivamente nella versione 2024.4.0 di HA

Da quanto ho avuto modo di verificare nelle ultime 2 settimane, Meteo & Radar fornisce delle previsioni tra le più affidabili (confrontato con 3B Meteo, IlMeteo.it e Meteo Aeronautica), è più facile da integrare degli altri ed offre dati sia su base giornaliera, che oraria (oltre che per "fase" della giornata: mattino, pomeriggio, sera e notte).
Come sempre cercherò di scrivere un articolo come piace a me: inserirò le informazioni necessarie senza dilungarmi troppo, senza continue ripetizioni (in stile SEO) e andando al punto, ma inserendo le informazioni che è necessario sapere (per capire cosa si sta facendo).

Come prima cosa, naturalmente, dovete avere un’installazione di Home Assistant funzionante e correttamente configurata.

1. Configurazione tipo (HW/SW)

Nel mio caso mi trovo nella seguente situazione (cioè, se avete la mia stessa configurazione e seguite la guida, vi garantisco che funziona):

  • Raspberry Pi 4 – 8 GB
  • Home Assistant 2023.4.2
    • Supervisor 2023.04.0
    • Operating System 9.5

2. Prerequisiti

 Come già detto dovete avere:

  • Installazione di Home Assistant (qualunque tipologia) funzionante

3. Breve introduzione/spiegazione e avvertenze

Faccio una piccola premessa: bisogna avere un minimo di dimestichezza con i Developer Tools (o strumenti sviluppatore) del browser per andare ad intercettare l'URL della chiamata per ottenere i dati relativi alla località di nostro interesse.

Seconda premessa: l'idea nasce da un post su Facebook nel gruppo di Home Assistant Italia (https://www.facebook.com/groups/147299622598134/) dove un utente segnalava questo servizio, indicandolo come "il più affidabile" per la sua zona. Se non siete ancora iscritti al gruppo, vi consiglio di farlo subito!

AVVISO 1: tengo a precisare che questa soluzione NON E' UFFICIALE e che quindi può smettere di funzionare in qualunque momento, se wetteronline.de (fonte originale dei dati) decide di bloccare le richieste o se decide di cambiare qualcosa nella struttura delle sue API.
AVVISO 2: ribadendo che non è un'integrazione ufficiale, e che non è disponibile una documentazione sui valori restituiti, va tenuto conto che tutto quanto è frutto di un lavoro di reverse-engineering e che quindi potrebbe non funzionare correttamente in caso di valori non previsti.

Se ciò non vi preoccupa, siete pronti per proseguire con la lettura.

    4. Trovare gli API Endpoint

Bene, per prima cosa dobbiamo recuperare gli endpoint delle API di wetteronline.de, che ci permetteranno di recuperare le informazioni meteo per la nostra zona.
Per fare ciò basta aprire il browser (con Chrome, Edge e Firefox potete seguire puntualmente questa procedura, se usate altri browser il procedimento sarà sicuramente molto simile) e andare sulla pagina Meteo & Radar Italia (meteoeradar.it).
A questo punto aprite i "Developer Tools" o "Strumenti Sviluppatore" (a seconda del browser o della lingua impostata). Per farlo avete 3 possibilità:
  • Premendo sulla tastiera il tasto F12
  • Premendo sulla tastiera contemporaneamente i tasti Ctrl+Shift+I
  • Usando il menu come da immagine qui sotto


Si aprirà a questo punto un pannello laterale (di default sulla destra, ma può essere spostato dove vi dà meno fastidio, anche in una finestra separata) con tutti gli strumenti più utilizzati per il debug e l'analisi della pagina visualizzata.
Spostiamoci sulla scheda "Network" o "Rete"



Se non è visibile, cliccate sul simbolo ">>" che vi mostrerà l'elenco di tutte le schede, anche quelle "nascoste"

Nei filtri scegliamo "Fetch/XHR" (potrebbe chiamarsi in maniera leggermente diversa a seconda del browser e della versione) e digitiamo "api" nella casella di testo, in modo da filtrare il più possibile tutte le chiamate fatta dalla pagina per trovare più facilmente quelle che ci interessano

Adesso cliccate nelle barra di ricerca

E cercate la vostra località


Vedrete quindi popolarsi la scheda "Network" con un'enorme quantità di righe (nonostante i filtri applicati)

A questo punto vi conviene premere il tasto F5 o cliccare sul tasto per ricaricare la pagina, in modo da partire un po' più sul pulito e "snellire" la lista


Partendo dal fondo della lista, cerchiamo una voce con nome "v6?astro_latitude ecc." e che abbia nella colonna Tipo il valore "xhr"

Clicchiamoci sopra con il tasto destro del mouse e selezioniamo la voce "Copia" -> "Copia indirizzo link"

Ora incolliamo da qualche parte questo link appena copiato (ad esempio nel Blocco Note) perchè è importante, ma ci servirà più tardi.
Il link incollato sarà simile a questo:
https://api-web.wo-cloud.com/weather/nowcast/v6?astro_latitude=45.06&astro_longitude=9.68&c=xYzxyzxyz==&grid_latitude=45.06&grid_longitude=9.68&language=it&location_id=16084&system_of_measurement=metric&timeformat=HH:mm&timezone=Europe/Rome&windunit=kmh
QUESTO E' L'URL DELLE INFORMAZIONI METEO ATTUALI!

Allo stesso modo cerchiamo una riga con nome simile a "forecast?av2&c=..." e con tipo "xhr"

Facciamo di nuovo la stessa procedura di click con il tasto destro "Copia" -> "Copia indirizzo link" e incolliamo anche questo link nel Blocco Note. Sarà un indirizzo simile a questo:
https://api-app.wetteronline.de/app/weather/forecast?av=2&c=xyZAbcDef=&location_id=16084&mv=13&timezone=Europe/Rome
QUESTO E' L'URL DELLE PREVISIONI!


    5. Creare i sensori REST

Per memorizzare i dati attuali la soluzione più comoda è creare dei sensori REST (purtroppo non va bene per le previsioni, poi vi spiego il motivo) e da un unico URL possiamo creare molte entità con i vari dati che ci interessano.

Come già detto altre volte in questo Blog, do per scontato che abbiate un editor testuale installato e configurato in HA (File editor, Filebrowser o Studio Core Server) e che quindi li sappiate usare. Se avete anche abilitato la cartella Packages, vi consiglio di creare un file .yaml dedicato ai sensori meteo (per pulizia e ordine io preferisco fare così).
Andiamo quindi ad aggiungere al file configuration.yaml (o ad un altro file *.yaml nella cartella Packages) il seguente codice:
rest:
  ####################################################
  #                                                  #
  #                      METEO                       #
  #                                                  #
  ####################################################
  - resource: MIO_URL_ACTUAL
    scan_interval: 600
    timeout: 60
    headers:
      Content-Type: application/json
    sensor:
      - name: MeteoRadar Current pressure
        value_template: "{{ value_json.current.air_pressure.hpa }}"
        unit_of_measurement: hPa
        device_class: atmospheric_pressure
      - name: MeteoRadar Current dew point
        value_template: "{{ value_json.current.dew_point.celsius }}"
        unit_of_measurement: °C
        device_class: temperature
      - name: MeteoRadar Current humidity
        value_template: "{{ value_json.current.humidity * 100 }}"
        unit_of_measurement: "%"
        device_class: humidity
      - name: MeteoRadar Current precipitation probability
        value_template: "{{ value_json.current.precipitation.probability * 100 }}"
        unit_of_measurement: "%"
      - name: MeteoRadar Current smog level
        value_template: "{{ value_json.current.smog_level }}"
      - name: MeteoRadar Current sunrise
        value_template: "{{ value_json.current.sun.rise }}"
        device_class: timestamp
      - name: MeteoRadar Current sunset
        value_template: "{{ value_json.current.sun.set }}"
        device_class: timestamp
      - name: MeteoRadar Current solar elevation
        value_template: "{{ value_json.current.sun.solar_elevation }}"
        unit_of_measurement: "°"
      - name: MeteoRadar Current weather symbol
        value_template: "{{ value_json.current.symbol }}"
      - name: MeteoRadar Current air temperature
        value_template: "{{ value_json.current.temperature.air }}"
        unit_of_measurement: °C
        device_class: temperature
      - name: MeteoRadar Current apparent temperature
        value_template: "{{ value_json.current.temperature.apparent }}"
        unit_of_measurement: °C
        device_class: temperature
      - name: MeteoRadar Current wind direction
        value_template: "{{ value_json.current.wind.direction }}"
        unit_of_measurement: °
      - name: MeteoRadar Current wind speed
        value_template: "{{ value_json.current.wind.speed.meter_per_second.value }}"
        unit_of_measurement: m/s
        device_class: speed
      - name: MeteoRadar Current weather
        value_template: "{{ value_json.current.weather_condition_image }}"
      - name: MeteoRadar Trend description
        value_template: "{{ value_json.trend.description }}"
che si occuperà di richiedere (con frequenza oraria) le ultime informazioni sui rilevamenti climatici della nostra zona.

Dove:
  • MIO_URL_ACTUAL l'URL che abbiamo incollato prima nel blocco note (quello riferito alla situazione attuale). Per intenderci quello che comincia con "https://api-web.wo-cloud.com/weather/nowcast/v6?"
Ora andiamo su "Strumenti per sviluppatori"

Clicchiamo su "VERIFICA CONFIGURAZIONE"

Attendiamo che finisca con esito positivo

Scendiamo nella pagina fino a trovare la voce "ENTITÀ REST E SERVIZI DI NOTIFICA REST" e clicchiamoci sopra


Ora andiamo su "Impostazioni"

Poi su "Dispositivi e servizi"


Selezioniamo "Entità" nel tab in alto


E filtriamo per i nostri nuovi sensori. Dovremmo vederli tutti con i valori corrispondenti a ciò che vediamo nell'interfaccia web di meteoeradar.it



    6. Creare il sensore COMMAND_LINE

Prima vi dicevo che la via più comoda è usare i sensori REST, ma che purtroppo non sempre è possibile. Questo è uno di quei casi dove non avrebbe senso usare un sesnore REST, a meno di non voler creare a mano (e poi vanno anche gestite) centinaia di entità.
Purtroppo infatti i sensori REST hanno attualmente un enorme limite che li rende assolutamente inadatti a gestire strutture composte da array di dati (cioè nel caso ci si trovi a dover interagire con sequenze di dati complessi che è necessario scorrere e/o elaborare): non permettono di salvare i dati negli attributi, ma solo nello stato. Questo significa essere limitati a 255 caratteri, che sono pochissimi, oltre ad essere sottoposti a "storicizzazione" (HA tiene traccia dei cambiamenti tramite il recorder e si salva lo storico a breve termine), di cui non ci frega nulla in caso di chiamate REST.

Per aggirare il problema fortunatamente c'è un modo, anche se non è tra i più puliti ed eleganti: usare un sensore "command_line" per effettuare una chiamata (tramite "curl") all'indirizzo in questione e poi poter gestire il risultato.

Anche in questo caso, se avete abilitato la cartella Packages, vi consiglio di creare un file YAML a parte per i sensori "command_line", in modo da poterli facilmente trovare e "convertire" una volta che i sensori REST permetteranno la gestione degli attributi.
Andiamo quindi ad aggiungere al file configuration.yaml (o ad un altro file *.yaml nella cartella Packages) il seguente codice:
sensor:
  - platform: command_line
    name: MeteoRadar Forecast Raw Data
    scan_interval: 3600
    command: >
      echo "{\"forecast\":" $(
      curl 
      -s 
      'MIO_URL_FORECAST'
      ) "}"
    value_template: >
      {{ value_json.forecast | length }}
    json_attributes:
      - forecast

che si occuperà di richiedere (con frequenza oraria) le previsioni della nostra zona.

Dove:
  • MIO_URL_FORECAST l'URL che abbiamo incollato prima nel blocco note (quello riferito alle previsioni). Per intenderci quello che comincia con "https://api-app.wetteronline.de/app/weather/forecast?".
    ATTENZIONE a non togliere gli apici quando si sostituisce MIO_URL_FORECAST con l'URL vero e proprio

ATTENZIONE! Dalla versione 2023.7.0 il sensore command_line deve essere scritto in questo modo:

command_line:
  - sensor:
      name: MeteoRadar Forecast Raw Data
      scan_interval: 3600
      command: >
        echo "{\"forecast\":" $(
        curl 
        -s 
        'MIO_URL_FORECAST'
        ) "}"
      value_template: >
        {{ value_json.forecast | length }}
      json_attributes:
        - forecast




Ora andiamo su "Strumenti per sviluppatori"

Clicchiamo su "VERIFICA CONFIGURAZIONE"

Attendiamo che finisca con esito positivo

Scendiamo nella pagina fino a trovare la voce "ENTITÀ DI RIGA DI COMANDO" e clicchiamoci sopra

Se non trovate il pulsante relativo a "ENTITÀ DI RIGA DI COMANDO" perché non avete mai aggiunto sensori command_line, dovete per forza procedere con un riavvio di HA, poi potete proseguire da questo punto in avanti.
Ora andiamo su "Impostazioni"

Poi su "Dispositivi e servizi"


Selezioniamo "Entità" nel tab in alto


E filtriamo per "MeteoRadar Forecast". Trovata la nostra nuova entità clicchiamoci sopra per aprirne il dettaglio

Se espandiamo gli attributi possiamo vedere tutti i dati memorizzati (l'intero json della risposta) nell'attributo "forecast"

Bene, ora abbiamo tutto quanto necessario per poter finalmente creare (e soprattutto valorizzare) l'entità di tipo "weather".

    7. Creare l'entità "weather"

EDIT 13/04/2023: se avete HA 2023.4.0 o superiore, andate al prossimo punto che gestisce meglio gli stati.

Prima di darvi il codice, voglio fare due piccole premesse:
  • "Esteticamente" il codice non mi piace: c'è una ripetizione che non sono riuscito ad eliminare, perché le variabili "globali" al momento sono disponibili solo negli script, mentre altrove le variabili hanno come scope solo il template in cui risiedono. Per cui se avete consigli su come fare per evitare di avere la lista del mapping duplicata, fatemelo sapere che tutti i consigli sono ben accetti
  • La lista degli stati mappati l'ho ricavata io andando un po' a cercare condizioni climatiche in giro per l'Europa, un po' ad intuito... Sicuramente ne mancano! Ad esempio non sono riuscito a capire come mappare la nebbia. Quindi tenete conto che potrebbero risultare giorni senza "icona".
    Ora dovrebbe essere completa
Detto ciò, possiamo procedere alla fase finale.

Di nuovo, andiamo ad aggiungere al file configuration.yaml (o ad un altro file *.yaml nella cartella Packages) il seguente codice:
weather:
  - platform: template
    name: "MeteoRadar Weather"
    unique_id: dc924bf6-5190-4c60-a44e-d254ba4472ee
    condition_template: >
      {% set climate_conditions = {
        'so____': 'sunny',
        'mo____': 'clear-night',
        'ms____': 'sunny',
        'bwr1__': 'pouring',
        'bwr2__': 'rainy',
        'bwr3__': 'rainy',
        'mwr1__': 'pouring',
        'mwr2__': 'rainy',
        'mwr3__': 'rainy',
        'bws1__': 'pouring',
        'bws2__': 'rainy',
        'bws3__': 'rainy',
        'mws1__': 'pouring',
        'mws2__': 'rainy',
        'mws3__': 'rainy',
        'wbs1__': 'pouring',
        'wbs2__': 'rainy',
        'wbs3__': 'rainy',
        'mbs1__': 'pouring',
        'mbs2__': 'rainy',
        'mbs3__': 'rainy',
        'bds1__': 'pouring',
        'bds2__': 'rainy',
        'bds3__': 'rainy',
        'mds1__': 'pouring',
        'mds2__': 'rainy',
        'mds3__': 'rainy',
        'bdr1__': 'pouring',
        'bdr2__': 'rainy',
        'bdr3__': 'rainy',
        'mdr1__': 'pouring',
        'mdr2__': 'rainy',
        'mdr3__': 'rainy',
        'wbr1__': 'rainy',
        'wbr2__': 'rainy',
        'wbr3__': 'rainy',
        'mbr1__': 'rainy',
        'mbr2__': 'rainy',
        'mbr3__': 'rainy',
        'wb____': 'partlycloudy',
        'mb____': 'partlycloudy',
        'mm____': 'partlycloudy',
        'bw____': 'cloudy',
        'mw____': 'cloudy',
        'bd____': 'cloudy',
        'md____': 'cloudy',
        'bwg1__': 'lightning-rainy',
        'bwg2__': 'lightning-rainy',
        'bwg3__': 'lightning-rainy',
        'mwg1__': 'lightning-rainy',
        'mwg2__': 'lightning-rainy',
        'mwg3__': 'lightning-rainy',
        'bdg1__': 'lightning-rainy',
        'bdg2__': 'lightning-rainy',
        'bdg3__': 'lightning-rainy',
        'mdg1__': 'lightning-rainy',
        'mdg2__': 'lightning-rainy',
        'mdg3__': 'lightning-rainy',
        'mbg1__': 'lightning-rainy',
        'mbg2__': 'lightning-rainy',
        'mbg3__': 'lightning-rainy',
        'bwsrs1': 'lightning-rainy',
        'bwsrs2': 'lightning-rainy',
        'bwsrs3': 'lightning-rainy',
        'mwsrs1': 'lightning-rainy',
        'mwsrs2': 'lightning-rainy',
        'mwsrs3': 'lightning-rainy',
        'wbg1__': 'lightning-rainy',
        'wbg2__': 'lightning-rainy',
        'wbg3__': 'lightning-rainy',
        'bdsns1': 'snowy',
        'bdsns2': 'snowy',
        'bdsns3': 'snowy',
        'mdsns1': 'snowy',
        'mdsns2': 'snowy',
        'mdsns3': 'snowy',
        'bdsn1_': 'snowy',
        'bdsn2_': 'snowy',
        'bdsn3_': 'snowy',
        'mdsn1_': 'snowy',
        'mdsn2_': 'snowy',
        'mdsn3_': 'snowy',
        'bwsn1_': 'snowy',
        'bwsn2_': 'snowy',
        'bwsnm_': 'snowy',
        'mwsn1_': 'snowy',
        'mwsn2_': 'snowy',
        'mwsn3_': 'snowy',
        'bwsns1': 'snowy',
        'bwsns2': 'snowy',
        'bwsns3': 'snowy',
        'mwsns1': 'snowy',
        'mwsns2': 'snowy',
        'mwsns3': 'snowy',
        'wbsg__': 'snowy',
        'mbsg__': 'snowy',
        'wbsn1_': 'snowy',
        'wbsn2_': 'snowy',
        'wbsn3_': 'snowy',
        'mbsn1_': 'snowy',
        'mbsn2_': 'snowy',
        'mbsn3_': 'snowy',
        'wbsns1': 'snowy',
        'wbsns2': 'snowy',
        'wbsns3': 'snowy',
        'mbsns1': 'snowy',
        'mbsns2': 'snowy',
        'mbsns3': 'snowy',
        'bdgr1_': 'snowy-rainy',
        'bdgr2_': 'snowy-rainy',
        'mdgr1_': 'snowy-rainy',
        'mdgr2_': 'snowy-rainy',
        'bdsr1_': 'snowy-rainy',
        'bdsr2_': 'snowy-rainy',
        'bdsr3_': 'snowy-rainy',
        'mdsr1_': 'snowy-rainy',
        'mdsr2_': 'snowy-rainy',
        'mdsr3_': 'snowy-rainy',
        'bdsrs1': 'snowy-rainy',
        'bdsrs2': 'snowy-rainy',
        'bdsrs3': 'snowy-rainy',
        'mdsrs1': 'snowy-rainy',
        'mdsrs2': 'snowy-rainy',
        'mdsrs3': 'snowy-rainy',
        'bwgr1_': 'snowy-rainy',
        'bwgr2_': 'snowy-rainy',
        'mwgr1_': 'snowy-rainy',
        'mwgr2_': 'snowy-rainy',
        'bwsr1_': 'snowy-rainy',
        'bwsr2_': 'snowy-rainy',
        'bwsr3_': 'snowy-rainy',
        'mwsr1_': 'snowy-rainy',
        'mwsr2_': 'snowy-rainy',
        'mwsr3_': 'snowy-rainy',
        'wbgr1_': 'snowy-rainy',
        'wbgr2_': 'snowy-rainy',
        'mbgr1_': 'snowy-rainy',
        'mbgr2_': 'snowy-rainy',
        'wbsr1_': 'snowy-rainy',
        'wbsr2_': 'snowy-rainy',
        'wbsr3_': 'snowy-rainy',
        'mbsr1_': 'snowy-rainy',
        'mbsr2_': 'snowy-rainy',
        'mbsr3_': 'snowy-rainy',
        'wbsrs1': 'snowy-rainy',
        'wbsrs2': 'snowy-rainy',
        'wbsrs3': 'snowy-rainy',
        'mbsrs1': 'snowy-rainy',
        'mbsrs2': 'snowy-rainy',
        'mbsrs3': 'snowy-rainy',
        'bdsg__': 'snowy',
        'mdsg__': 'snowy',
        'bwsg__': 'snowy',
        'mwsg__': 'snowy',
        'nb____': 'fog',
        'nm____': 'fog',
        'ns____': 'fog',
      } %}
      {{ climate_conditions[states('sensor.meteoradar_current_weather_symbol')] }}
    temperature_template: "{{ states('sensor.meteoradar_current_air_temperature') | float }}"
    temperature_unit: "°C"
    humidity_template: "{{ states('sensor.meteoradar_current_humidity') | float }}"
    pressure_template: "{{ states('sensor.meteoradar_current_pressure') | float }}"
    pressure_unit: "hPa"
    wind_speed_template: "{{ states('sensor.meteoradar_current_wind_speed') | float }}"
    wind_speed_unit: "m/s"
    wind_bearing_template: "{{ states('sensor.meteoradar_current_wind_direction') | float }}"
    precipitation_unit: "mm"
    forecast_template: >
      {% set mainArray = namespace (z=[]) %}
      {% set climate_conditions = {
        'so____': 'sunny',
        'mo____': 'clear-night',
        'ms____': 'sunny',
        'bwr1__': 'pouring',
        'bwr2__': 'rainy',
        'bwr3__': 'rainy',
        'mwr1__': 'pouring',
        'mwr2__': 'rainy',
        'mwr3__': 'rainy',
        'bws1__': 'pouring',
        'bws2__': 'rainy',
        'bws3__': 'rainy',
        'mws1__': 'pouring',
        'mws2__': 'rainy',
        'mws3__': 'rainy',
        'wbs1__': 'pouring',
        'wbs2__': 'rainy',
        'wbs3__': 'rainy',
        'mbs1__': 'pouring',
        'mbs2__': 'rainy',
        'mbs3__': 'rainy',
        'bds1__': 'pouring',
        'bds2__': 'rainy',
        'bds3__': 'rainy',
        'mds1__': 'pouring',
        'mds2__': 'rainy',
        'mds3__': 'rainy',
        'bdr1__': 'pouring',
        'bdr2__': 'rainy',
        'bdr3__': 'rainy',
        'mdr1__': 'pouring',
        'mdr2__': 'rainy',
        'mdr3__': 'rainy',
        'wbr1__': 'rainy',
        'wbr2__': 'rainy',
        'wbr3__': 'rainy',
        'mbr1__': 'rainy',
        'mbr2__': 'rainy',
        'mbr3__': 'rainy',
        'wb____': 'partlycloudy',
        'mb____': 'partlycloudy',
        'mm____': 'partlycloudy',
        'bw____': 'cloudy',
        'mw____': 'cloudy',
        'bd____': 'cloudy',
        'md____': 'cloudy',
        'bwg1__': 'lightning-rainy',
        'bwg2__': 'lightning-rainy',
        'bwg3__': 'lightning-rainy',
        'mwg1__': 'lightning-rainy',
        'mwg2__': 'lightning-rainy',
        'mwg3__': 'lightning-rainy',
        'bdg1__': 'lightning-rainy',
        'bdg2__': 'lightning-rainy',
        'bdg3__': 'lightning-rainy',
        'mdg1__': 'lightning-rainy',
        'mdg2__': 'lightning-rainy',
        'mdg3__': 'lightning-rainy',
        'mbg1__': 'lightning-rainy',
        'mbg2__': 'lightning-rainy',
        'mbg3__': 'lightning-rainy',
        'bwsrs1': 'lightning-rainy',
        'bwsrs2': 'lightning-rainy',
        'bwsrs3': 'lightning-rainy',
        'mwsrs1': 'lightning-rainy',
        'mwsrs2': 'lightning-rainy',
        'mwsrs3': 'lightning-rainy',
        'wbg1__': 'lightning-rainy',
        'wbg2__': 'lightning-rainy',
        'wbg3__': 'lightning-rainy',
        'bdsns1': 'snowy',
        'bdsns2': 'snowy',
        'bdsns3': 'snowy',
        'mdsns1': 'snowy',
        'mdsns2': 'snowy',
        'mdsns3': 'snowy',
        'bdsn1_': 'snowy',
        'bdsn2_': 'snowy',
        'bdsn3_': 'snowy',
        'mdsn1_': 'snowy',
        'mdsn2_': 'snowy',
        'mdsn3_': 'snowy',
        'bwsn1_': 'snowy',
        'bwsn2_': 'snowy',
        'bwsnm_': 'snowy',
        'mwsn1_': 'snowy',
        'mwsn2_': 'snowy',
        'mwsn3_': 'snowy',
        'bwsns1': 'snowy',
        'bwsns2': 'snowy',
        'bwsns3': 'snowy',
        'mwsns1': 'snowy',
        'mwsns2': 'snowy',
        'mwsns3': 'snowy',
        'wbsg__': 'snowy',
        'mbsg__': 'snowy',
        'wbsn1_': 'snowy',
        'wbsn2_': 'snowy',
        'wbsn3_': 'snowy',
        'mbsn1_': 'snowy',
        'mbsn2_': 'snowy',
        'mbsn3_': 'snowy',
        'wbsns1': 'snowy',
        'wbsns2': 'snowy',
        'wbsns3': 'snowy',
        'mbsns1': 'snowy',
        'mbsns2': 'snowy',
        'mbsns3': 'snowy',
        'bdgr1_': 'snowy-rainy',
        'bdgr2_': 'snowy-rainy',
        'mdgr1_': 'snowy-rainy',
        'mdgr2_': 'snowy-rainy',
        'bdsr1_': 'snowy-rainy',
        'bdsr2_': 'snowy-rainy',
        'bdsr3_': 'snowy-rainy',
        'mdsr1_': 'snowy-rainy',
        'mdsr2_': 'snowy-rainy',
        'mdsr3_': 'snowy-rainy',
        'bdsrs1': 'snowy-rainy',
        'bdsrs2': 'snowy-rainy',
        'bdsrs3': 'snowy-rainy',
        'mdsrs1': 'snowy-rainy',
        'mdsrs2': 'snowy-rainy',
        'mdsrs3': 'snowy-rainy',
        'bwgr1_': 'snowy-rainy',
        'bwgr2_': 'snowy-rainy',
        'mwgr1_': 'snowy-rainy',
        'mwgr2_': 'snowy-rainy',
        'bwsr1_': 'snowy-rainy',
        'bwsr2_': 'snowy-rainy',
        'bwsr3_': 'snowy-rainy',
        'mwsr1_': 'snowy-rainy',
        'mwsr2_': 'snowy-rainy',
        'mwsr3_': 'snowy-rainy',
        'wbgr1_': 'snowy-rainy',
        'wbgr2_': 'snowy-rainy',
        'mbgr1_': 'snowy-rainy',
        'mbgr2_': 'snowy-rainy',
        'wbsr1_': 'snowy-rainy',
        'wbsr2_': 'snowy-rainy',
        'wbsr3_': 'snowy-rainy',
        'mbsr1_': 'snowy-rainy',
        'mbsr2_': 'snowy-rainy',
        'mbsr3_': 'snowy-rainy',
        'wbsrs1': 'snowy-rainy',
        'wbsrs2': 'snowy-rainy',
        'wbsrs3': 'snowy-rainy',
        'mbsrs1': 'snowy-rainy',
        'mbsrs2': 'snowy-rainy',
        'mbsrs3': 'snowy-rainy',
        'bdsg__': 'snowy',
        'mdsg__': 'snowy',
        'bwsg__': 'snowy',
        'mwsg__': 'snowy',
        'nb____': 'fog',
        'nm____': 'fog',
        'ns____': 'fog',
      } %}
      {%  for i in states.sensor.meteoradar_forecast_raw_data.attributes.forecast -%}
        {% set precipitation = 0 -%}
        {% if "details" in i.precipitation -%}
          {% set precipitation = i.precipitation.details.rainfall_amount.millimeter.interval_end -%}
          {% if precipitation is defined %}
          {% else %}
            {% set precipitation = i.precipitation.details.rainfall_amount.millimeter.interval_begin -%}
          {% endif %}
        {% endif -%}
        {% set singleObj = 
        {
          'condition': climate_conditions[i.symbol],
          'datetime': as_datetime(as_timestamp(i.date) + (2*3600)).isoformat(),
          'wind_bearing': i.wind.direction,
          'temperature': i.temperature.max.air,
          'templow': i.temperature.min.air,
          'wind_speed': i.wind.speed.meter_per_second.value,
          'precipitation': precipitation,
          'precipitation_probability': i.precipitation.probability,
          'pressure': i.air_pressure.hpa
        } %}
        {% set mainArray.z = mainArray.z + [singleObj] %}
      {% endfor %}
      {{ mainArray.z }}


Ora andiamo su "Strumenti per sviluppatori"

Clicchiamo su "VERIFICA CONFIGURAZIONE"

Attendiamo che finisca con esito positivo

Scendiamo nella pagina fino a trovare la voce "ENTITÀ MODELLO" e clicchiamoci sopra

Ora andiamo su "Impostazioni"

Poi su "Dispositivi e servizi"


Selezioniamo "Entità" nel tab in alto


E filtriamo per "weather.meteoradar". Trovata la nostra nuova entità clicchiamoci sopra per aprirne il dettaglio

E si aprirà la nostra nuova entità con il dettaglio

Avendo anche impostato uno Unique ID (potete modificarlo se volete) avete anche la possibilità di personalizzare l'entità cambiando il nome o convertendo le unità di misura, direttamente da interfaccia.

Ottimo! Ora potete usare l'entità nella vostra Plancia Lovelace!


    8. Miglioria usando le MACRO

Su suggerimento di un altro utente ho cercato di risolvere il "problema" della duplicazione della lista usando le nuove macro per jinja: 2023.4: Custom template macros, and many more new entity dialogs! - Home Assistant (home-assistant.io)
Per sfruttare questa funzionalità basta seguire questa guida: Templating - Home Assistant (home-assistant.io)
Nello specifico andiamo a creare una cartella chiamata "custom_templates" dentro a "config". Per capirci deve trovarsi allo stesso livello dove è presente la cartella "packages".
Dentro alla cartella custom_templates creiamo un nuovo file con estensione ".jinja" dove insrire la nostra macro (ad esempio io ho creato il file "meteoradar.jinja"), poi incolliamoci dentro questo contenuto:
{% macro translate_weather_state(meteoradar_symbol) -%}
{%- set climate_conditions = {
'so____': 'sunny',
'mo____': 'clear-night',
'ms____': 'sunny',
'bwr1__': 'pouring',
'bwr2__': 'rainy',
'bwr3__': 'rainy',
'mwr1__': 'pouring',
'mwr2__': 'rainy',
'mwr3__': 'rainy',
'bws1__': 'pouring',
'bws2__': 'rainy',
'bws3__': 'rainy',
'mws1__': 'pouring',
'mws2__': 'rainy',
'mws3__': 'rainy',
'wbs1__': 'pouring',
'wbs2__': 'rainy',
'wbs3__': 'rainy',
'mbs1__': 'pouring',
'mbs2__': 'rainy',
'mbs3__': 'rainy',
'bds1__': 'pouring',
'bds2__': 'rainy',
'bds3__': 'rainy',
'mds1__': 'pouring',
'mds2__': 'rainy',
'mds3__': 'rainy',
'bdr1__': 'pouring',
'bdr2__': 'rainy',
'bdr3__': 'rainy',
'mdr1__': 'pouring',
'mdr2__': 'rainy',
'mdr3__': 'rainy',
'wbr1__': 'rainy',
'wbr2__': 'rainy',
'wbr3__': 'rainy',
'mbr1__': 'rainy',
'mbr2__': 'rainy',
'mbr3__': 'rainy',
'wb____': 'partlycloudy',
'mb____': 'partlycloudy',
'mm____': 'partlycloudy',
'bw____': 'cloudy',
'mw____': 'cloudy',
'bd____': 'cloudy',
'md____': 'cloudy',
'bwg1__': 'lightning-rainy',
'bwg2__': 'lightning-rainy',
'bwg3__': 'lightning-rainy',
'mwg1__': 'lightning-rainy',
'mwg2__': 'lightning-rainy',
'mwg3__': 'lightning-rainy',
'bdg1__': 'lightning-rainy',
'bdg2__': 'lightning-rainy',
'bdg3__': 'lightning-rainy',
'mdg1__': 'lightning-rainy',
'mdg2__': 'lightning-rainy',
'mdg3__': 'lightning-rainy',
'mbg1__': 'lightning-rainy',
'mbg2__': 'lightning-rainy',
'mbg3__': 'lightning-rainy',
'bwsrs1': 'lightning-rainy',
'bwsrs2': 'lightning-rainy',
'bwsrs3': 'lightning-rainy',
'mwsrs1': 'lightning-rainy',
'mwsrs2': 'lightning-rainy',
'mwsrs3': 'lightning-rainy',
'wbg1__': 'lightning-rainy',
'wbg2__': 'lightning-rainy',
'wbg3__': 'lightning-rainy',
'bdsns1': 'snowy',
'bdsns2': 'snowy',
'bdsns3': 'snowy',
'mdsns1': 'snowy',
'mdsns2': 'snowy',
'mdsns3': 'snowy',
'bdsn1_': 'snowy',
'bdsn2_': 'snowy',
'bdsn3_': 'snowy',
'mdsn1_': 'snowy',
'mdsn2_': 'snowy',
'mdsn3_': 'snowy',
'bwsn1_': 'snowy',
'bwsn2_': 'snowy',
'bwsnm_': 'snowy',
'mwsn1_': 'snowy',
'mwsn2_': 'snowy',
'mwsn3_': 'snowy',
'bwsns1': 'snowy',
'bwsns2': 'snowy',
'bwsns3': 'snowy',
'mwsns1': 'snowy',
'mwsns2': 'snowy',
'mwsns3': 'snowy',
'wbsg__': 'snowy',
'mbsg__': 'snowy',
'wbsn1_': 'snowy',
'wbsn2_': 'snowy',
'wbsn3_': 'snowy',
'mbsn1_': 'snowy',
'mbsn2_': 'snowy',
'mbsn3_': 'snowy',
'wbsns1': 'snowy',
'wbsns2': 'snowy',
'wbsns3': 'snowy',
'mbsns1': 'snowy',
'mbsns2': 'snowy',
'mbsns3': 'snowy',
'bdgr1_': 'snowy-rainy',
'bdgr2_': 'snowy-rainy',
'mdgr1_': 'snowy-rainy',
'mdgr2_': 'snowy-rainy',
'bdsr1_': 'snowy-rainy',
'bdsr2_': 'snowy-rainy',
'bdsr3_': 'snowy-rainy',
'mdsr1_': 'snowy-rainy',
'mdsr2_': 'snowy-rainy',
'mdsr3_': 'snowy-rainy',
'bdsrs1': 'snowy-rainy',
'bdsrs2': 'snowy-rainy',
'bdsrs3': 'snowy-rainy',
'mdsrs1': 'snowy-rainy',
'mdsrs2': 'snowy-rainy',
'mdsrs3': 'snowy-rainy',
'bwgr1_': 'snowy-rainy',
'bwgr2_': 'snowy-rainy',
'mwgr1_': 'snowy-rainy',
'mwgr2_': 'snowy-rainy',
'bwsr1_': 'snowy-rainy',
'bwsr2_': 'snowy-rainy',
'bwsr3_': 'snowy-rainy',
'mwsr1_': 'snowy-rainy',
'mwsr2_': 'snowy-rainy',
'mwsr3_': 'snowy-rainy',
'wbgr1_': 'snowy-rainy',
'wbgr2_': 'snowy-rainy',
'mbgr1_': 'snowy-rainy',
'mbgr2_': 'snowy-rainy',
'wbsr1_': 'snowy-rainy',
'wbsr2_': 'snowy-rainy',
'wbsr3_': 'snowy-rainy',
'mbsr1_': 'snowy-rainy',
'mbsr2_': 'snowy-rainy',
'mbsr3_': 'snowy-rainy',
'wbsrs1': 'snowy-rainy',
'wbsrs2': 'snowy-rainy',
'wbsrs3': 'snowy-rainy',
'mbsrs1': 'snowy-rainy',
'mbsrs2': 'snowy-rainy',
'mbsrs3': 'snowy-rainy',
'bdsg__': 'snowy',
'mdsg__': 'snowy',
'bwsg__': 'snowy',
'mwsg__': 'snowy',
'nb____': 'fog',
'nm____': 'fog',
'ns____': 'fog',
} -%}
{{ climate_conditions[meteoradar_symbol] }}
{%- endmacro -%}


Ora andiamo su "Strumenti per sviluppatori"

In alto selezioniamo il tab "SERVIZI"

Cerchiamo il servizio "homeassistant.reload_custom_templates"
E clicchiamo su "INVOCA IL SERVIZIO"


Di nuovo, andiamo ad aggiungere al file configuration.yaml (o ad un altro file *.yaml nella cartella Packages) il seguente codice (se avete la versione di HA Core < 2023.9.0):
weather:
  - platform: template
    name: "MeteoRadar Weather"
    unique_id: dc924bf6-5190-4c60-a44e-d254ba4472ee
    condition_template: >
      {% from 'meteoradar.jinja' import translate_weather_state %}
      {{ translate_weather_state(states('sensor.meteoradar_current_weather_symbol')) }}
    temperature_template: "{{ states('sensor.meteoradar_current_air_temperature') | float }}"
    temperature_unit: "°C"
    humidity_template: "{{ states('sensor.meteoradar_current_humidity') | float }}"
    pressure_template: "{{ states('sensor.meteoradar_current_pressure') | float }}"
    pressure_unit: "hPa"
    wind_speed_template: "{{ states('sensor.meteoradar_current_wind_speed') | float }}"
    wind_speed_unit: "m/s"
    wind_bearing_template: "{{ states('sensor.meteoradar_current_wind_direction') | float }}"
    precipitation_unit: "mm"
    forecast_template: >
      {% from 'meteoradar.jinja' import translate_weather_state %}
      {% set mainArray = namespace (z=[]) %}
      {%  for i in states.sensor.meteoradar_forecast_raw_data.attributes.forecast -%}
        {% set precipitation = 0 -%}
        {% if "details" in i.precipitation -%}
          {% set precipitation = i.precipitation.details.rainfall_amount.millimeter.interval_end -%}
          {% if precipitation is defined %}
          {% else %}
            {% set precipitation = i.precipitation.details.rainfall_amount.millimeter.interval_begin -%}
          {% endif %}
        {% endif -%}
        {% set singleObj =
        {
          'condition': translate_weather_state(i.symbol),
          'datetime': as_datetime(as_timestamp(i.date) + (2*3600)).isoformat(),
          'wind_bearing': i.wind.direction,
          'temperature': i.temperature.max.air | float | round(1),
          'templow': i.temperature.min.air | float | round(1),
          'wind_speed': i.wind.speed.meter_per_second.value | float,
          'precipitation': precipitation,
          'precipitation_probability': i.precipitation.probability,
          'pressure': i.air_pressure.hpa
        } %}
        {% set mainArray.z = mainArray.z + [singleObj] %}
      {% endfor %}
      {{ mainArray.z }}


Se, invece, avete la HA Core almeno alla versione 2023.9.0, ma inferiore a 2024.4.0, usate questo codice che è compatibile con il nuovo standard delle entità weather, e include sia il dato giornaliero che quello "orario" (in realtà a blocchi di 4 ore), oltre ad alcune aggiunte di proprietà ora disponibili per la configurazione da template (es. "uv_index"):
weather:
  - platform: template
    name: "MeteoRadar Weather"
    unique_id: dc924bf6-5190-4c60-a44e-d254ba4472ee
    condition_template: >
      {% from 'meteoradar.jinja' import translate_weather_state %}
      {{ translate_weather_state(states('sensor.meteoradar_current_weather_symbol')) }}
    temperature_template: "{{ states('sensor.meteoradar_current_air_temperature') | float | round(1) }}"
    temperature_unit: "°C"
    humidity_template: "{{ states('sensor.meteoradar_current_humidity') | float }}"
    pressure_template: "{{ states('sensor.meteoradar_current_pressure') | float }}"
    pressure_unit: "hPa"
    wind_speed_template: "{{ states('sensor.meteoradar_current_wind_speed') | float }}"
    wind_speed_unit: "m/s"
    wind_bearing_template: "{{ states('sensor.meteoradar_current_wind_direction') | float }}"
    precipitation_unit: "mm"
    forecast_template: >
      {% from 'meteoradar.jinja' import translate_weather_state %}
      {% set mainArray = namespace (z=[]) %}
      {%  for i in states.sensor.meteoradar_forecast_raw_data.attributes.forecast -%}
        {% set precipitation = 0 -%}
        {% if "details" in i.precipitation -%}
          {% if i.precipitation.type == 'rain' %}
            {% set precipitation = i.precipitation.details.rainfall_amount.millimeter.interval_end -%}
            {% if precipitation is defined %}
            {% else %}
              {% set precipitation = i.precipitation.details.rainfall_amount.millimeter.interval_begin -%}
            {% endif %}
          {% elif i.precipitation.type == 'snow' %}
            {% set precipitation = i.precipitation.details.snow_height.centimeter.interval_end -%}
            {% if precipitation is defined %}
              {% set precipitation = precipitation * 10 -%}
            {% else %}
              {% set precipitation = i.precipitation.details.snow_height.centimeter.interval_begin * 10 -%}
            {% endif %}
          {% endif %}
        {% endif -%}
        {% set singleObj =
        {
          'condition': translate_weather_state(i.symbol),
          'datetime': as_datetime(as_timestamp(i.date)).timestamp() | timestamp_local,
          'humidity': i.humidity * 100,
          'precipitation_probability': i.precipitation.probability,
          'precipitation': precipitation,
          'pressure': i.air_pressure.hpa,
          'temperature': i.temperature.max.air | float | round(1),
          'templow': i.temperature.min.air | float | round(1),
          'wind_bearing': i.wind.direction,
          'wind_speed': i.wind.speed.meter_per_second.value | float,
          'uv_index': i.uv_index.value,
        } %}
        {% set mainArray.z = mainArray.z + [singleObj] %}
      {% endfor %}
      {{ mainArray.z }}
    forecast_daily_template: >
      {% from 'meteoradar.jinja' import translate_weather_state %}
      {% set mainArray = namespace (z=[]) %}
      {%  for i in states.sensor.meteoradar_forecast_raw_data.attributes.forecast -%}
        {% set precipitation = 0 -%}
        {% if "details" in i.precipitation -%}
          {% if i.precipitation.type == 'rain' %}
            {% set precipitation = i.precipitation.details.rainfall_amount.millimeter.interval_end -%}
            {% if precipitation is defined %}
            {% else %}
              {% set precipitation = i.precipitation.details.rainfall_amount.millimeter.interval_begin -%}
            {% endif %}
          {% elif i.precipitation.type == 'snow' %}
            {% set precipitation = i.precipitation.details.snow_height.centimeter.interval_end -%}
            {% if precipitation is defined %}
              {% set precipitation = precipitation * 10 -%}
            {% else %}
              {% set precipitation = i.precipitation.details.snow_height.centimeter.interval_begin * 10 -%}
            {% endif %}
          {% endif %}
        {% endif -%}
        {% set singleObj =
        {
          'condition': translate_weather_state(i.symbol),
          'datetime': as_datetime(as_timestamp(i.date)).timestamp() | timestamp_local,
          'humidity': i.humidity * 100,
          'precipitation_probability': i.precipitation.probability,
          'precipitation': precipitation,
          'pressure': i.air_pressure.hpa,
          'temperature': i.temperature.max.air | float | round(1),
          'templow': i.temperature.min.air | float | round(1),
          'wind_bearing': i.wind.direction,
          'wind_speed': i.wind.speed.meter_per_second.value | float,
          'uv_index': i.uv_index.value,
        } %}
        {% set mainArray.z = mainArray.z + [singleObj] %}
      {% endfor %}
      {{ mainArray.z }}
    forecast_hourly_template: >
      {% from 'meteoradar.jinja' import translate_weather_state %}
      {% set mainArray = namespace (z=[]) %}
      {%  for i in states.sensor.meteoradar_forecast_raw_data.attributes.forecast -%}
        {%  for h in i.dayparts -%}
          {% set precipitation = 0 -%}
          {% if "details" in h.precipitation -%}
            {% if h.precipitation.type == 'rain' %}
              {% set precipitation = h.precipitation.details.rainfall_amount.millimeter.interval_end -%}
              {% if precipitation is defined %}
              {% else %}
                {% set precipitation = h.precipitation.details.rainfall_amount.millimeter.interval_begin -%}
              {% endif %}
            {% elif h.precipitation.type == 'snow' %}
              {% set precipitation = h.precipitation.details.snow_height.centimeter.interval_end -%}
              {% if precipitation is defined %}
                {% set precipitation = precipitation * 10 -%}
              {% else %}
                {% set precipitation = h.precipitation.details.snow_height.centimeter.interval_begin * 10 -%}
              {% endif %}
            {% endif %}
          {% endif -%}
          {% set singleObj =
          {
            'condition': translate_weather_state(h.symbol),
            'datetime': as_datetime(as_timestamp(h.date)).timestamp() | timestamp_local,
            'humidity': h.humidity * 100,
            'precipitation_probability': h.precipitation.probability,
            'precipitation': precipitation,
            'pressure': h.air_pressure.hpa,
            'temperature': h.temperature.air | float | round(1),
            'native_apparent_temperature': h.temperature.apparent | float | round(1),
            'wind_bearing': h.wind.direction,
            'wind_speed': h.wind.speed.meter_per_second.value | float,
            'native_dew_point': h.dew_point.celsius | float,
          } %}
          {% set mainArray.z = mainArray.z + [singleObj] %}
        {% endfor %}
      {% endfor %}
      {{ mainArray.z }}


Se avete la HA Core versione 2024.4.0 o successiva, usate questo codice che è l'unico funzionante (rimosso il supporto all'attributo forecast):
weather:
  - platform: template
    name: "MeteoRadar Weather"
    unique_id: dc924bf6-5190-4c60-a44e-d254ba4472ee
    condition_template: >
      {% from 'meteoradar.jinja' import translate_weather_state %}
      {{ translate_weather_state(states('sensor.meteoradar_current_weather_symbol')) }}
    temperature_template: "{{ states('sensor.meteoradar_current_air_temperature') | float | round(1) }}"
    temperature_unit: "°C"
    humidity_template: "{{ states('sensor.meteoradar_current_humidity') | float }}"
    pressure_template: "{{ states('sensor.meteoradar_current_pressure') | float }}"
    pressure_unit: "hPa"
    wind_speed_template: "{{ states('sensor.meteoradar_current_wind_speed') | float }}"
    wind_speed_unit: "m/s"
    wind_bearing_template: "{{ states('sensor.meteoradar_current_wind_direction') | float }}"
    precipitation_unit: "mm"
    forecast_daily_template: >
      {% from 'meteoradar.jinja' import translate_weather_state %}
      {% set mainArray = namespace (z=[]) %}
      {%  for i in states.sensor.meteoradar_forecast_raw_data.attributes.forecast -%}
        {% set precipitation = 0 -%}
        {% if "details" in i.precipitation -%}
          {% if i.precipitation.type == 'rain' %}
            {% set precipitation = i.precipitation.details.rainfall_amount.millimeter.interval_end -%}
            {% if precipitation is defined %}
            {% else %}
              {% set precipitation = i.precipitation.details.rainfall_amount.millimeter.interval_begin -%}
            {% endif %}
          {% elif i.precipitation.type == 'snow' %}
            {% set precipitation = i.precipitation.details.snow_height.centimeter.interval_end -%}
            {% if precipitation is defined %}
              {% set precipitation = precipitation * 10 -%}
            {% else %}
              {% set precipitation = i.precipitation.details.snow_height.centimeter.interval_begin * 10 -%}
            {% endif %}
          {% endif %}
        {% endif -%}
        {% set singleObj =
        {
          'condition': translate_weather_state(i.symbol),
          'datetime': as_datetime(as_timestamp(i.date)).timestamp() | timestamp_local,
          'humidity': i.humidity * 100,
          'precipitation_probability': i.precipitation.probability,
          'precipitation': precipitation,
          'pressure': i.air_pressure.hpa,
          'temperature': i.temperature.max.air | float | round(1),
          'templow': i.temperature.min.air | float | round(1),
          'wind_bearing': i.wind.direction,
          'wind_speed': i.wind.speed.meter_per_second.value | float,
          'uv_index': i.uv_index.value,
        } %}
        {% set mainArray.z = mainArray.z + [singleObj] %}
      {% endfor %}
      {{ mainArray.z }}
    forecast_hourly_template: >
      {% from 'meteoradar.jinja' import translate_weather_state %}
      {% set mainArray = namespace (z=[]) %}
      {%  for i in states.sensor.meteoradar_forecast_raw_data.attributes.forecast -%}
        {%  for h in i.dayparts -%}
          {% set precipitation = 0 -%}
          {% if "details" in h.precipitation -%}
            {% if h.precipitation.type == 'rain' %}
              {% set precipitation = h.precipitation.details.rainfall_amount.millimeter.interval_end -%}
              {% if precipitation is defined %}
              {% else %}
                {% set precipitation = h.precipitation.details.rainfall_amount.millimeter.interval_begin -%}
              {% endif %}
            {% elif h.precipitation.type == 'snow' %}
              {% set precipitation = h.precipitation.details.snow_height.centimeter.interval_end -%}
              {% if precipitation is defined %}
                {% set precipitation = precipitation * 10 -%}
              {% else %}
                {% set precipitation = h.precipitation.details.snow_height.centimeter.interval_begin * 10 -%}
              {% endif %}
            {% endif %}
          {% endif -%}
          {% set singleObj =
          {
            'condition': translate_weather_state(h.symbol),
            'datetime': as_datetime(as_timestamp(h.date)).timestamp() | timestamp_local,
            'humidity': h.humidity * 100,
            'precipitation_probability': h.precipitation.probability,
            'precipitation': precipitation,
            'pressure': h.air_pressure.hpa,
            'temperature': h.temperature.air | float | round(1),
            'native_apparent_temperature': h.temperature.apparent | float | round(1),
            'wind_bearing': h.wind.direction,
            'wind_speed': h.wind.speed.meter_per_second.value | float,
            'native_dew_point': h.dew_point.celsius | float,
          } %}
          {% set mainArray.z = mainArray.z + [singleObj] %}
        {% endfor %}
      {% endfor %}
      {{ mainArray.z }}

Sempre nel caso di HA Core almeno alla versione 2024.4.0, il forecast non è più disponibile come attributo (e quindi non è più utilizzabile ad esempio nei template), per cui è necessario crearci un sensore "di appoggio" che svolga lo stesso compito e sia accessibile ovunque:
template:
  - trigger:
      - platform: state
        entity_id:
          - sensor.meteoradar_forecast_raw_data
        not_to:
          - "unknown"
          - "unavailable"
    sensor:
      - name: "MeteoRadar Weather Forecast Daily"
        unique_id: 66a04e2b-2603-400a-8f13-1b92f3a03c52
        state: "{{ now() }}"
        attributes:
          forecast: >
            {% from 'meteoradar.jinja' import translate_weather_state %}
            {% set mainArray = namespace (z=[]) %}
            {%  for i in states.sensor.meteoradar_forecast_raw_data.attributes.forecast -%}
              {% set precipitation = 0 -%}
              {% if "details" in i.precipitation -%}
                {% if i.precipitation.type == 'rain' %}
                  {% set precipitation = i.precipitation.details.rainfall_amount.millimeter.interval_end -%}
                  {% if precipitation is defined %}
                  {% else %}
                    {% set precipitation = i.precipitation.details.rainfall_amount.millimeter.interval_begin -%}
                  {% endif %}
                {% elif i.precipitation.type == 'snow' %}
                  {% set precipitation = i.precipitation.details.snow_height.centimeter.interval_end -%}
                  {% if precipitation is defined %}
                    {% set precipitation = precipitation * 10 -%}
                  {% else %}
                    {% set precipitation = i.precipitation.details.snow_height.centimeter.interval_begin * 10 -%}
                  {% endif %}
                {% endif %}
              {% endif -%}
              {% set singleObj =
              {
                'condition': translate_weather_state(i.symbol),
                'datetime': as_datetime(as_timestamp(i.date)).timestamp() | timestamp_local,
                'humidity': i.humidity * 100,
                'precipitation_probability': i.precipitation.probability,
                'precipitation': precipitation,
                'pressure': i.air_pressure.hpa,
                'temperature': i.temperature.max.air | float | round(1),
                'templow': i.temperature.min.air | float | round(1),
                'wind_bearing': i.wind.direction,
                'wind_speed': i.wind.speed.meter_per_second.value | float,
                'uv_index': i.uv_index.value,
              } %}
              {% set mainArray.z = mainArray.z + [singleObj] %}
            {% endfor %}
            {{ mainArray.z }}
          forecast_hourly: >
            {% from 'meteoradar.jinja' import translate_weather_state %}
            {% set mainArray = namespace (z=[]) %}
            {%  for i in states.sensor.meteoradar_forecast_raw_data.attributes.forecast -%}
              {%  for h in i.dayparts -%}
                {% set precipitation = 0 -%}
                {% if "details" in h.precipitation -%}
                  {% if h.precipitation.type == 'rain' %}
                    {% set precipitation = h.precipitation.details.rainfall_amount.millimeter.interval_end -%}
                    {% if precipitation is defined %}
                    {% else %}
                      {% set precipitation = h.precipitation.details.rainfall_amount.millimeter.interval_begin -%}
                    {% endif %}
                  {% elif h.precipitation.type == 'snow' %}
                    {% set precipitation = h.precipitation.details.snow_height.centimeter.interval_end -%}
                    {% if precipitation is defined %}
                      {% set precipitation = precipitation * 10 -%}
                    {% else %}
                      {% set precipitation = h.precipitation.details.snow_height.centimeter.interval_begin * 10 -%}
                    {% endif %}
                  {% endif %}
                {% endif -%}
                {% set singleObj =
                {
                  'condition': translate_weather_state(h.symbol),
                  'datetime': as_datetime(as_timestamp(h.date)).timestamp() | timestamp_local,
                  'humidity': h.humidity * 100,
                  'precipitation_probability': h.precipitation.probability,
                  'precipitation': precipitation,
                  'pressure': h.air_pressure.hpa,
                  'temperature': h.temperature.air | float | round(1),
                  'native_apparent_temperature': h.temperature.apparent | float | round(1),
                  'wind_bearing': h.wind.direction,
                  'wind_speed': h.wind.speed.meter_per_second.value | float,
                  'native_dew_point': h.dew_point.celsius | float,
                } %}
                {% set mainArray.z = mainArray.z + [singleObj] %}
              {% endfor %}
            {% endfor %}
            {{ mainArray.z }}



Ora andiamo su "Strumenti per sviluppatori"

Clicchiamo su "VERIFICA CONFIGURAZIONE"

Attendiamo che finisca con esito positivo

Scendiamo nella pagina fino a trovare la voce "ENTITÀ MODELLO" e clicchiamoci sopra

Ora andiamo su "Impostazioni"

Poi su "Dispositivi e servizi"


Selezioniamo "Entità" nel tab in alto


E filtriamo per "weather.meteoradar". Trovata la nostra nuova entità clicchiamoci sopra per aprirne il dettaglio

E si aprirà la nostra nuova entità con il dettaglio

Avendo anche impostato uno Unique ID (potete modificarlo se volete) avete anche la possibilità di personalizzare l'entità cambiando il nome o convertendo le unità di misura, direttamente da interfaccia.

Ottimo! Ora potete usare l'entità nella vostra Plancia Lovelace!




Commenti

  1. Ciao sto cercando di usare tutto questo integrandolo con My Garden, cortesemente, come faccio a trovare il sensore che mi dica la piaggia che cade in mm ?

    RispondiElimina
    Risposte
    1. Ciao Saverio, scusa ma non mi è arrivata la notifica del commento. Spiegami meglio cosa vuoi fare e cosa ti serve, perché non mi è chiaro (non so cosa sia My Garden e la ricerca su Google non aiuta)

      Elimina
  2. Ciao, ho aggiornato l'integrazione per supportare l'ultima versione di HA e non riesco a visualizzare più le previsioni nella custom weather-card che utilizzo (https://github.com/bramkragten/weather-card). Si può fare qualcosa? Grazie in anticipo.

    RispondiElimina
    Risposte
    1. Ciao, se vai nella lista delle entità e cerchi "weather.meteoradar_weather", dovresti vedere l'entità meteo. Funziona correttamente? Vedi le previsioni giornaliere e orarie?

      Elimina
    2. Si si, è tutto ok anche con la card meteo nativa di HA. E' solo con quella che ti ho linkato il problema ed è per questo che mi pare strano.

      Elimina
    3. Mi viene da pensare che non abbiano ancora aggiornato il componente alla nuova struttura del compoente Weather di HA. Stai usando la verisone beta (v2.0.0b0)?
      Perchè la stabile vedo che è ferma al 2020

      Elimina
    4. Utilizzo l'ultima versione beta, per farti capire meglio ti mostro un immagine:
      https://pasteboard.co/rcTECd4mTTk8.jpg
      Quella sulla sinistra è la card meteo "nativa" di HA che utilizza la tua integrazione Meteoradar, quella al centro è la custom weather card che utilizza 'integrazione meteo nativa di HA mentre quella sulla destra è la custom weather card che utilizza la tua integrazione Meteoradar. Naturalmente in entrambi i due ultimi casi sono attive le visualizzazioni degli stessi elementi. Non so davvero che pesci prendere, credo che comunque il problema sia più della custom card che della tua integrazione. Grazie per il supporto.

      Elimina
    5. Ho provato a dare un'occhiata ad altre integrazioni di HA, a quanto pare molte (tra cui met.no, quella "ufficiale") tengono entrambi i sistemi, sia il meteodo vecchio che quello nuovo. Penso che la custom card non supporti ancora il sistema nuovo, però puoi provare questa versione di codice per il sensore meteo e dirmi se funziona: https://pastebin.com/siT462DQ

      Elimina
    6. Grazie mille! con questa versione funziona perfettamente come prima.

      Elimina
    7. Ottimo, allora poi aggiorno anche il blog (appena ho tempo), se lo fanno quelli di HA di usare un sistema ibrido, non vedo perchè non dovrei farlo pure io 😁
      Grazie

      Elimina
  3. Ciao Andrea, innanzitutto grazie per condividere la tua esperienza in maniera cosìben fatta. Ho seguito la tua guida ma, avrò sbagliato qualche cosa perchè cliccando sull'entità weather_meteoradar non leggo tutte le informazioni che nvece vedo nei tuoi screenshot.
    Leggo infatti i seguenti dati: Temperatura, Pressione atmosferica, umidità e velocità del vento. Non leggo, invece, le informazioni sulla riga "MeteoRadar Weather" (mi da solo sconosciuto) e le previsioni.
    Dov'è, secondo te, che posso avere sbagliato? per Il sensore di "appoggio" ho copiato il tuo codice codice in un file con estensione.yaml all'interno della cartella packages, può essere questo il problema?
    Ciao e grazie

    RispondiElimina
    Risposte
    1. Ciao, avevo già affrontato questo problema con un altro utente. Chiaramente i componenti da interfaccia (lovelace) non possono chiamare servizi, quindi si è presentato il problema che avevo paventato: per poter gestire dei componenti che mostrano le previsioni, è necessario sviluppare tutta la parte di backend in un custom component o con un'integrazione (follia).
      Quindi in realtà non c'è molto da fare, se non usare lo stesso metodo che al momento usano direttamente gli sviluppatori di HA: fregarsene del "deprecato" e usare anche l'attributo "forecast_template". Comparirà l'avviso nei log, ma al momento è solo un avviso senza una data di scadenza.
      Se prendi la versione aggiornata del codice dovrebbe risolvere il tuo problema (poi si vedrà)

      Elimina
    2. Ciao Andrea, grazie mille per la tua guida anzitutto. Utilizzo la tua integrazione da un pò , ma da qualche settimana non mi funziona più la visualizzazione dei dati delle previsioni.
      Spulciando i log, vedo che lui riceve un `None` quando cerca di accedere all'attributo `attributes` del sensor `sensor.meteoradar_forecast_raw_data.attributes.forecast` e quindi ovviamente l'iterazione che viene fatta, fallisce ` {% for i in states.sensor.meteoradar_forecast_raw_data.attributes.forecast -%}
      `. Nello specifico l'eccezione è :
      ```
      ERROR (MainThread) [homeassistant.helpers.template] Template variable error: 'None' has no attribute 'attributes' when rendering '{% from 'meteoradar.jinja' import translate_weather_state %} {% set mainArray = namespace (z=[]) %} {% for i in states.sensor.meteoradar_forecast_raw_data.attributes.forecast -%}
      ```
      Ti ringrazio in anticipo per tutto!

      Elimina
    3. Ciao Luca, molto strano come comportamento. Hai un altro errore nei log legato al recupero dei dati del command line sensor?
      Se guardi dalla lista delle entità, che valore ha meteoradar_forecast_raw_data ?

      Elimina
    4. Ciao Andrea, è proprio questo il problema, non ho `meteoradar_forecast_raw_data` nelle mie entities

      Elimina
  4. Ciao Andrea, lascia perdere, come sempre era un problema tra sedia e tastiera. Mi ero dimenticato di riscrivere il sensore nel nuovo formato :( . Ora funziona tutto e scusami per il disturbo

    RispondiElimina
    Risposte
    1. Ok, meglio così allora ^_^
      A volte sono cose banali di cui non ci si accorge fino a che non ci si riguarda per la 100esima volta

      Elimina
  5. Ciao, grazie per la suer guida, ma non son riuscito ad arrivare a capo. La mia situazione dovrebbe essere addirittura più semplice, ma mi mancano le basi per capire come modificare i passaggi. Sono iscritto al gruppo Home Assistant su Facebook, ma il post che hai linkato non riesco a vederlo, non mi si apre, si apre solo il gruppo. Ma veniamo a noi, io ero partito da questo post https://www.facebook.com/share/p/1tW2AZzYFXK2dnoN/ dove un utente ha estrapolato e creato i sensori dal bollettino dell'Arpav. Io son riuscito a modificare quel file yaml, implementando tutti i dati disponibili, ma li mi fermo. Vorrei creare l'entità weather come spieghi tu, m non ho capito se sia fattibile.

    RispondiElimina
    Risposte
    1. Dunque, ho dato un'occhiata alla formattazione dell'XML indicato in quel post e, secondo me, è molto difficile creare un sensore weather da quei dati per un semplice motivo: sono testuali. Sono fatti per essere letti da un essere umano, non per essere interpretati dal codice, quindi vanno parsati in maniera un po' complicata.
      Se vuoi comunque cimentarti nell'impresa, puoi iniziare cercando di implementare un sensore weather che abbia solo il parametro "condition_template", che va valorizzato
      con questi dati: https://www.arpa.veneto.it/previsioni/it/xml/bollettino_utenti.xml
      In pratica potresti basarti sul sensore "arpav_simbolo0" per mappare le varie immagini (ad esempio "a2.png") con gli stati accettati da HA. Man mano implementi gli altri.

      Però ho visto che c'è anche una versione in formato più utile al tuo scopo: https://wwwold.arpa.veneto.it/previsioni/it/xml/bollettino_widget.xml
      Con questo dovrebbe essere molto più facile estrapolare i dati. Tipo:
      sensor:
      - platform: rest
      resource: https://wwwold.arpa.veneto.it/previsioni/it/xml/bollettino_widget.xml
      name: arpav_simbolo0
      value_template: "{{ value_json.bulletin.meteograms.meteogram[states('sensor.arpav_zona_id')|int].days.day[0].sky['@img'] }}"
      scan_interval: 600

      Elimina
    2. Grazie della risposta! Tutto decisamente troppo fuori dalle mie conoscenze :-) Pensa che tutto sto bordello volevo farlo semplicemente per fare una card con il meteo. Ho pensato di poter fare una entità weather così da poterla usare al posto della weather.forecast, in modo da avere quindi poi la possibilità di usare integrazioni già create e disponibili in rete.
      ho provato ad aggiungere il codice che mi hai scritto, lo crea il sensore, ma mi rimane come sconosciuto. Penso le mie conoscenze siano troppo limitate per affrontare una cosa del genere

      Elimina
    3. Eh, quello che volevi fare non è sbagliato, anzi. Solo che è un po' complicato perchè bisogna andare a mappare e interpretare tutti gli stati. Purtroppo non c'è qualcosa di già pronto, magari la persona che aveva creato il package originale ha già fatto (anche se non l'ha pubblicato) un altro package per l'entità weather, si può provare a sentire lui

      Elimina
    4. Purtroppo come avrai visto ho ripescato un post su FB di 3 anni fa, e nessuno di quelli che hanno partecipato al post sono intervenuti, ne l'autore ne nessun altro. Nel frattempo son riuscito a far comparire il sensore come mi avevi scritto, ma non ho capito come dovrei procedere per fare il tutto. Se è una procedura lunga non mi spaventa, se complessa invece mi spaventa di più. Nel file che dici tu chiamato widget, vedo che ci sarebbero questi dati

      Coperto
      Piogge modeste per ognuno dei 7 momenti (5 mezze giornate e 2 giornata per arrivare a coprire i 5 giorni). I dati sarebbero sufficienti per costruire il sensore weather? Avresti voglia di spiegarmi come? Non ho capito cosa cambi da usare questo file invece dell'altro, e nemmeno come potrei poi usare miei file locali al posto delle immagini di Arpav, ma quello sarebbe un passaggio successivo.

      Elimina
    5. Ho provato a chiedere nella community home assistant https://community.home-assistant.io/t/how-to-create-a-forecast-entity-from-a-weather-report-in-xml/693948/4 e addirittura mi rispondono che non è possibile creare un entità forecast da altri sensori... vorrei contraddirli, ma mi mancano le conoscenze. Se avrai voglia di spiegarmi come, io ci provo anche, ma se è impossibile, allora mi arrendo :-) grazie cmq

      Elimina
    6. Purtroppo non è molto facile da spiegare. Il sensore che ti ho messo come esempio nell'altro commento, ti dà un "simbolo" che corrisponde a una condizione atmosferica. Devi mapparli tutti (e già qui c'è da capire se da qualche parte si trova l'elenco completo) come ho fatto io nella macro "translate_weather_state()". Poi ci sono poche altre informazioni (dipende anche dalla zona, vedo che zone diverse hanno informazioni diverse), che puoi mappare. C'è sicuramente la data che puoi prendere con
      value_json.bulletin.meteograms.meteogram[states('sensor.arpav_zona_id')|int].days.day[0]['@date']
      mentre l'ora la devi "simulare" da "am" e "pm" (tipo che se trovi "am" metti 02:00, e se trovi "pm" metti 14:00, ad esempio). Poi puoi prendere la probabilità di pioggia con
      value_json.bulletin.meteograms.meteogram[states('sensor.arpav_zona_id')|int].days.day[0].rain['@perc']
      e la quantità la devi desumere mappando invece
      value_json.bulletin.meteograms.meteogram[states('sensor.arpav_zona_id')|int].days.day[0].rain
      come faresti con i simboli. Poi devi mettere tutti questi dati che ottieni nei vari template del sensore weather (o nel forecast_template per le previsioni).
      Però non è facile da spiegare, bisogna avere un po' di conoscenze e soprattutto molto tempo da dedicare ai vari tentativi per far funzionare il tutto. Io ti aiuterei volentieri, ma purtroppo di tempo in questo periodo non ne ho

      Elimina
    7. sei stato già molto gentile, ci proverò sicuramente, un po' alla volta voglio vedere se ci riesco

      Elimina
    8. Ciao, grazie per aver condiviso il tuo codice. Ho visto che sul sito "meteoeradar.it" sono presenti anche le previsioni orarie per le prossime 24h, sarebbe difficile inserirle nel tuo codice? in modo da renderlo identico a quelli già integrati in HA (tipo forecast.weather e simili) :) Tnks.

      Elimina
    9. Ciao Michele, cosa intendi esattamente? Perchè l'entità weather espone già le previsioni "orarie" (a blocchi di 6 ore) 🤔

      Elimina
    10. intendevo queste previsioni orarie: https://ibb.co/BZ516by ora vedo questo nella radar weather https://ibb.co/HHScymg mentre con integrazione di HA vedo anche le previsioni orarie https://ibb.co/j5VngGR (ho messo link agli screenshot dato che non è consentito postare img) . non vedo il sensore con le previsioni a blocchi di sei ora forse ho sbagliato a inserire parti del codice?

      Elimina
    11. Sei sicuro di aver preso la versione giusta e non quella per la vecchia versione di HA? Dovrebbe risultarti così: https://ibb.co/K0vzFTr
      Per le previsioni orarie effettive (queste sono ogni 6 ore) devo vedere se le hanno aggiunte al codice che restituiscono

      Elimina
    12. intanto ti ringrazio per aver condiviso il tuo codice, l'ho inserito in una card weather (ho utilizzato il tuo codice al punto 7, quello successivo al pt. 8 non mi funziona in nessun modo) animata che utilizzavo in precedenza la "Platinum Weather Card" (qui il git https://github.com/Makin-Things/platinum-weather-card ) con alcuni adattamenti dovuti alle diverse modalità di visualizzazione dei vari stati, es. l'umidità e il last update ecc. (c'è ancora qualche errore sulla visualizzazione degli stati relativi all'intensità dello stato "rainy" ma nulla di rilevante), qui il video della card https://youtu.be/sI1i3n9vdk0 e qui il codice del package: https://pastebin.com/CCqaCMnp e qui il codice del sensore ( https://pastebin.com/0FpdgGwu )

      Elimina
    13. Ok, allora è "normale" che non ti mostri i dati orari, perchè il codice al punto 7 è per una versione di HA che ancora non integrava la possibilità di avere le previsioni orarie. Quello che è strano è che non ti funzioni il codice del punto 8.
      Che errore ti dà?

      Elimina
    14. pur avendo inserito il file per le macro nella cartella "custom_template" mi visualizza uno "stato" di "sconosciuto" con in img che ti allego: https://ibb.co/FXct8r0 , uso OA OS aggiornato all'ultima versione 2024 ed ho provato il codice al punto 8 per entrambe le versioni (pre e post 2023.9.0) senza fortuna, sbaglio io sicuramente qualcosa.

      Elimina
    15. Questo commento è stato eliminato dall'autore.

      Elimina
    16. Questo commento è stato eliminato dall'autore.

      Elimina
    17. ho sistemato, avevo la dir custom_templates forse corrotta dopo il ripristino di un backup e non mi permetteva di leggere i file jinja caricati all'interno, l'ho eliminata e ricreata ed è andato tutto ok :) https://ibb.co/5RXGD7h

      Elimina
    18. Ah, ottimo! Stranissima cosa, comunque 🤔
      Era chiaro che non ti caricasse il modulo dall'errore che avevi, ma non avrei mai pensato che fosse da eliminare la cartella e ricrearla

      Elimina
    19. infatti stavo uscendo pazzo avrò riletto il codice 100 volte :) riguardo i dati orari ho visto che Mereto&Radar fornisce anche i dati con intervalli di 1 h giornaliera (e non di 6) trovi il link come hai spiegato tu nel post con indicazione "hourcast" (https://api-app.wetteronline.de/app/weather/hourcast?av....) questo permette di avere una previsione oraria con intervalli di 1 ora molto utile per me che la utilizzo per le automazioni per la gestione efficiente dell'autoconsumo da fotovoltaico. ho integrato il tuo codice come in figura: https://ibb.co/sJQwFrC

      Elimina
    20. Ciao, sai se è possibile estrapolare la percentuale di copertura nuvolosa? o la luminosità sempre in percentuale...Grazie!!

      Elimina
    21. @Michele Mercuri
      Ottimo, grazie. Quando ho tempo magari lo aggiungo al blog 👍

      @delumerlino
      Mas ono informazioni che vedi da qualche parte nella pagina web di Meteoradar? Perché io non ho trovato quest informazioni anche scorrendo la pagina 🤔

      Elimina
    22. @Michele Mercuri
      gentilmente puoi indicare il codice che hai integrato per visualizzare i dati ogni ora ?
      Grazie

      Elimina
    23. eccolo, è l'intero codice, rest + command_line + weather sensor ma c'è un minimo di commento quindi lo vedrai ;) https://pastebin.com/bbTvBibc

      Elimina
  6. @AF - My Tech Blog
    in effetti non c'è controllando bene...
    Sarebbe carino integrare anche in una iframe card anche il radar ma tira dentro anche icone non necessarie...

    RispondiElimina
    Risposte
    1. @delumerlino devi integrare quello tedesco la versione ita non va. https://ibb.co/Lpgh6nV

      Elimina
  7. con il nuovo update 2024.4.0 il "forecast_template:" è stato definitivamente deprecato, quindi il sensore smette di funzionare :(

    RispondiElimina
    Risposte
    1. Ok, in giornata aggiorno il blog. Però torniamo al punto di partenza: le weather card personalizzate smetteranno di funzionare. Sono curioso di vedere come pensano di gestire la cosa.
      PS: non capisco perchè questa smania di rimuovere le proprietà, invece di farle coesistere

      Elimina
    2. Infatti mi sembra una scelta alquanto singolare. Mi dispiace doverla abbandonare pure io (dopo una intera giornata impiegata per configurarla a dovere :(

      Elimina
    3. Ciao quindi scusate, come possiamo ovviare al problema che non viene più letta l'entità "meteoradar weather"? Ho delle attivazioni in risposta ai dati di questa identità, come la chiusura delle tapparelle in caso di temporali, aiutateci grazie

      Elimina
    4. Puoi usare il "sensore di appoggio" al posto dell'entità weather. L'attributo forecast funziona allo stesso modo.

      Elimina
    5. Grazie, scusa l'ignoranza cosa intendi parli di "sensor.meteoradar_current_weather" ?

      Elimina
    6. Questo commento è stato eliminato dall'autore.

      Elimina
    7. No, intendo sensor.meteoradar_weather_forecast_daily che corrisponde all'attributo forcast

      Elimina
    8. Ok immaginavo, però quello mi dà come stato "unknown", c'è qualcosa che non và allora...

      Elimina
    9. L'entità weather di meteoradar funziona correttamente e puoi usarla tranquillamente nelle automazioni. Quello che non funziona più sono le card meteo personalizzate (io sto usando quella ufficiale, l'unica che funziona per ora)

      Elimina
    10. Anche a me dava stato "unknown" solo riavviando HA è partito 😁

      Elimina
    11. Ah, si giusto. Essendo un trigger sensor, si aggiorna solo quando si verifica l'evento. Quindi appena lo crei rimane unknown fino al successivo aggiornamento del sensore rest. Riavviando si forza l'aggiornamento e quindi va a posto, dovrebbe bastare semplicemente aggiornare (dai developer tools) i sensori rest e command line 👍

      Elimina
  8. Buongiorno e grazie per aver condiviso il tuo lavoro. Essendo anch'io interessato ad integrare in HA i dati di Meteo & Radar ho seguito la guida ma mi sono fermato subito al punto 4 perché applicando il filtro indicato non risultano file di tipo xhr. Ci sono solo file con nome v9?astro_latitude... fetch. Dove sbaglio?

    RispondiElimina
    Risposte
    1. Buongiorno Filippo, è corretto quello che vedi, stai facendo correttamente. Se clicchi con il tasto destro su "v9?astro_latitude=..." o su "forecast?av=..." dovresti trovare l'opzione "Copia URL" che ti permette di copiare l'indirizzo completo da incollare in HA

      Elimina
  9. Ciao, è possibile estrarre i dati di pioggia in mm? Grazie mille!!

    RispondiElimina
    Risposte
    1. nel sensore sensor.meteoradar_weather_forecast_daily hai già i dati pronti per quello che ti serve, compresi i mm previsti

      Elimina
    2. Grazie ho visto, ma come posso estrapolarli in un sensore? o meglio, avere la quantità di pioggia accumulata nelle 24h?

      Elimina
    3. Non puoi avere la quantità di pioggia accumulata nelle ultime 24 ore, perchè questo sistema restituisce le previsioni, e non lo "storico" (non so se c'è qualche API di Meteo&Radar che lo fa, bisognerebbe controllare).
      Per sapere la quantità di precipitazioni previste per la giornata odierna puoi fare in questo modo (giusto come esempio):
      {{ state_attr('sensor.meteoradar_weather_forecast_daily', 'forecast')[0].precipitation }}

      Elimina
    4. Ecco perchè non le vedo....mi manca proprio il sensore meteoradar_weather_forecast_daily, ho solo il raw_data....ripasso l'integrazione per vedere cosa ho perso...

      Elimina
    5. E' nell'ultimissimo template che vedi

      Elimina

Posta un commento

Post popolari in questo blog

Home Assistant - Recuperare informazioni aggiuntive da Netatmo (termostato)

Installare Frigate su Raspberry Pi con HAssOS

Creare un sensore del prezzo del gas (PSBIL_BUY) in Home Assistant

Installare Portainer su NAS Synology

Creare MQTT Server (broker) in Home Assistant (HASSIO)

Ricevere la posizione GPS quando si parcheggia l'automobile (con Home Assistant)

Esporre UPS da NAS Synology verso Home Assistant (NUT)

Tasmota (via OTA) su BlitzWolf BW-SHP10 (e su Tuya ESP in generale)

JC vs Khaby Lame