Bonjour à tous!
J’ai une question concernant l’entité « Daily Precipitation » de ce que je comprends il s’agit des precipitation pas jour, donc accumulation de pluie par journée calendaire.
Or, quand je regarde l’historique de l’entité, la valeur monte (logique) mais descend également ce qui n’est pas possible …
Est ce que cette entité doit etre comprise comme « precipitation depuis la derniere info »?
Quelqu’un pourrait m’éclairer?
Bonjour
d’où vient cette entité « Dayly preicpitation » ? Un pluviomètre, une api météo ?
De l’integration météo France
La valeur peut changer, suivant les informations remontées par Météo-France. Mais ça devrait être le cumul de la journée de pluie prévu. C’est pas non plus 100% fiable, Météo France. 
Il faudrait surtout savoir comment le recalcul est fait. Si de la pluie est prévue mais qu’il n’a pas plu, comment est-ce pris en compte ?
Par nature, un capteur reçoit une valeur à un instant t, donc à 16h tu devrais avoir la pluie tombée jusqu’à 16h, mais il faut que cette information soit déjà consolidée en temps réel, et j’en doute.
D’après la doc, c’est la prévision de cumul de pluie dans les prochaines 24h (le nom n’est donc pas très adapté). Il est donc normal que cela puisse décroître.
OK c’est un peu plus clair. Ce n’est donc pas ce que je recherche… 
J’ai trouvé via les API météo France les précipitations en temps réel. Par contre il va me falloir comprendre comment l’utiliser proprement, mais ca fera l’objet d’un autre sujet!
Elles se trouvent où ?
Des infos ici: GitHub - Syxxxx/meteofrance-observation · GitHub
Ça serait intéressant de comparer les résultats de cette intégration avec les informations de l’intégration native rafraîchie toutes les 6 minutes.
J’essaie déjà de comprendre comment « ajouter » les quantités d’eau tombés sur une journée en sachant que l’info est donnée toute les 6 minutes par l’API
bonjour,
j’ai une solution un peu compliquée car je l’utilise avec plusieurs données différentes. je te la propose quand même :
1/ script
script:
- service: python_script.exec
alias: cumul des précipitations sur 24h
data:
new_datage: sensor.macon1_reference_time
new_data: sensor.macon1_precipitation
sensor_cumul_nom: sensor.macon1_precipitation_cumul_24h
sensor_cumul_attribut: données_24
sensor_cumul_heures: 24
sensor_cumul_cle_data: cumul_24h
sensor_cumul_attributs_complementaires: >
{'friendly_name': "mâcon 1h précipitation cumul 24h", 'unit_of_measurement': 'mm', 'icon': 'mdi:weather-rainy',
'alias': 'cumul des précipitations 1 heure sur 24 heures en mm'}
file: include/python_scripts/meteofrance_cumul.py
2/fichier Python
'''
meteofrance_cumul.py
calcul du cumul de pluie, ensoleillement,... sur 1h, 24h,... à partir des données 6mn ou 1h
'''
from datetime import datetime, timedelta
import json
print = logger.debug
print(f'démarrage de meteofrance_cumul.py pour {data.get('sensor_cumul_nom')}')
def ComputeCumul(print, state_datage: datetime, state_last: float, sensor_cumul, attr_historique: str, duree_heures: int) -> [float, list, str]:
from datetime import datetime, timedelta
from dateutil.relativedelta import relativedelta
if state_datage.second != 0: # on ne prend pas en compte les secondes
return None, None, None
# cumul
data_cumul_hh = None
txt_reset = None
if sensor_cumul is not None:
state_cumul = sensor_cumul.state # state
attr_cumul = sensor_cumul.attributes.copy() # attributs
data_cumul_hh = attr_cumul.get(attr_historique) # historique -> [[datetime, float],...]
datage_dernier_cumul = datetime.strptime(attr_cumul.get('datage'), '%d/%m/%Y %H:%M:%S') # datage du dernier passage
# passage à minuit => on reprend à 0
if True:
txt_reset = 'pas de remise à 0 à minuit'
else:
txt_reset = attr_cumul.get('txt_reset') # si pas de modif, on conserve la précédente valeur
if state_datage.day != datage_dernier_cumul.day:
txt_reset = f'day={state_datage.day}, cumul={datage_dernier_cumul.day}, now={datetime.now()}' # nouvelle valeur
data_cumul_hh = None # on reprend avec une liste vide
# cumul HH heures
if data_cumul_hh is not None: # réinitialisation manuelle possible du sensor en supprimant l'attribut 'données_24'
# ajout de la nouvelle donnée
if (len(data_cumul_hh) > 0) and (state_datage != data_cumul_hh[-1][0]): # pour éviter le 'surcumul' en cas de déclenchement manuel
print(f'{duree_heures}/ajouté : {state_datage}, {state_last}')
data_cumul_hh.append([state_datage, state_last])
# calcul du cumul
datage_limite = state_datage - relativedelta(hours=duree_heures)
print(f'{duree_heures}/datage limite={datage_limite}')
cumul_hh = 0
nbre_hh = 0
n_limite = -1
for n, p in enumerate(data_cumul_hh):
# print(f'{duree_heures}/?? : {p}')
if p[0] <= datage_limite:
print(f'{duree_heures}/supprimé : {p[0]}')
n_limite = n
continue
print(f'{duree_heures}/conservé : {p[0]}, {p[1]}')
cumul_hh += p[1]
nbre_hh += 1
data_cumul_hh = data_cumul_hh[n_limite + 1:]
print(f'{duree_heures}/cumul de {nbre_hh} valeurs = {cumul_hh}')
else:
# nouvelle donnée
print(f'{duree_heures}/nouvelle donnée : {state_last}')
data_cumul_hh = [[state_datage, state_last]]
cumul_hh = state_last
nbre_hh = 1
return cumul_hh, data_cumul_hh, txt_reset
# datage de la nouvelle donnée
sensor_datage = hass.states.get(data.get('new_datage'))
attr = data.get('new_datage_attribut')
if attr is not None:
attributs = sensor_datage.attributes.copy() # attributs
datage = attributs.get(attr)
else:
datage = sensor_datage.state
state_datage = datetime.strptime(datage, '%d/%m/%Y %H:%M:%S')
state_datage -= timedelta(seconds=state_datage.second) # on ne prend pas en compte les secondes
# nouvelle donnée
sensor_last = hass.states.get(data.get('new_data'))
state_last = float(sensor_last.state)
# cumul
sensor_cumul_nom = data.get('sensor_cumul_nom')
sensor_cumul_attribut = data.get('sensor_cumul_attribut')
sensor_cumul_heures = data.get('sensor_cumul_heures')
sensor_cumul = hass.states.get(sensor_cumul_nom)
# compléments pour les attributs du sensor de cumul : clés et attributs complémentaires
sensor_cumul_cle_data = data.get('sensor_cumul_cle_data')
sensor_cumul_attributs_complementaires = data.get('sensor_cumul_attributs_complementaires')
sensor_cumul_attributs_complementaires = sensor_cumul_attributs_complementaires.replace("'", "\"") # mise en forme pour json
sensor_cumul_attributs_complementaires = json.loads(sensor_cumul_attributs_complementaires) # passage en dict
# calcul
print(f'calcul de {sensor_cumul_nom} sur {sensor_cumul_heures} heures')
cumul_hh, data_cumul_hh, txt_reset = ComputeCumul(print, state_datage, state_last, sensor_cumul, sensor_cumul_attribut, sensor_cumul_heures)
# mise à jour du sensor de cumul
attr = {'datage': datetime.now().strftime("%d/%m/%Y %H:%M:%S"),
'txt_reset': txt_reset,
sensor_cumul_attribut: data_cumul_hh, sensor_cumul_cle_data: cumul_hh} # nouvelles données
attr = {**attr, **sensor_cumul_attributs_complementaires} # attributs complémentaires
hass.states.set(sensor_cumul_nom, cumul_hh, attr)
print(f'meteofrance_cumul terminé pour {sensor_cumul_nom}')
j’espère que les commentaires sont suffisants !
bon courage
peut être avec un utility meter, qui reset tous les jours :
ou statistics :
Cela renvoie les précipitations des 6 dernières minutes ? Ou une consolidation toutes les 6 minutes pour la journée ?
J’ai trouvé la réponse dans la documentation « quantité de précipitations tombées sur 6 mn en mm ».
Il faut pas se rater, il faut un HA qui ne sera jamais arrêté plus de 6 min, il faut gérer le dédoublement en cas de multiple appels en moins de 6 min … beaucoup de choses à gérer.
OK, les statistiques pourraient fonctionner, il faudrait que je teste avec mon automation.
Pour l’utility meter j’ai testé déjà, le probleme c’est que la valeur est mise à jour toute les 6 minutes et j’ai l’impression que ca ne marche pas bien avec l’utility meter…