Update:

Version non maintenue car pas utilisée!

Intro

Dans cet article, je partage une automatisation Home Assistant pour contrôler vos volets roulants de manière intelligente en été. Cette solution ajuste progressivement la position des volets en fonction de la position du soleil (azimut et élévation), de la radiation solaire, et de la température extérieure. Le but ? Protéger votre maison de la chaleur tout en laissant entrer la lumière quand c’est nécessaire, avec une configuration simple via un blueprint.

Pourquoi cette automatisation ?

En été, le soleil peut transformer votre maison en fournaise, surtout si vos fenêtres sont exposées. Fermer les volets manuellement ou programmer des horaires fixes n’est pas toujours optimal. Cette automatisation utilise :

• L’azimut du soleil pour vérifier si une fenêtre est directement exposée.
• L’élévation du soleil pour ajuster progressivement l’ouverture des volets.
• La radiation solaire et la température extérieure pour fermer les volets quand il fait trop chaud ou que le soleil tape fort.

Le résultat : des volets qui s’adaptent automatiquement pour un confort maximal !

Le blueprint

Voici le blueprint mis à jour, qui permet une fermeture progressive des volets. Vous pouvez l’importer directement dans Home Assistant.

blueprint:
  name: Volets Suivi Azimuth Soleil Bureau Été (Progressif)
  description: >
    Automatisation pour une fermeture progressive des volets en fonction de l'élévation du soleil, de la radiation solaire et de la température extérieure.
  domain: automation
  input:
    volets_select:
      name: Sélecteur de mode des volets
      description: Entité input_select pour activer/désactiver le mode automatique
      selector:
        entity:
          domain: input_select
    orientation_volet:
      name: Orientation du volet
      description: Orientation de la fenêtre en degrés (input_number)
      selector:
        entity:
          domain: input_number
    angle_exposition:
      name: Angle d'exposition
      description: Angle d'exposition acceptable pour le suivi du soleil (input_number)
      selector:
        entity:
          domain: input_number
    elevation_min:
      name: Élévation minimale
      description: Élévation minimale du soleil pour activer le contrôle (input_number)
      selector:
        entity:
          domain: input_number
    radiation_sensor:
      name: Capteur de radiation solaire
      description: Capteur mesurant la radiation solaire
      selector:
        entity:
          domain: sensor
    radiation_seuil:
      name: Seuil de radiation
      description: Seuil de radiation solaire pour l'ajustement des volets (input_number)
      selector:
        entity:
          domain: input_number
    temperature_sensor:
      name: Capteur de température extérieure
      description: Capteur mesurant la température extérieure
      selector:
        entity:
          domain: sensor
    temperature_seuil:
      name: Seuil de température
      description: Seuil de température extérieure pour fermer complètement les volets (input_number)
      default: 30
      selector:
        entity:
          domain: input_number
    debug_text:
      name: Entité de débogage
      description: Entité input_text pour stocker les informations de débogage
      selector:
        entity:
          domain: input_text
    cover_entities:
      name: Volets à contrôler
      description: Liste des entités de volets à ajuster
      selector:
        target:
          entity:
            domain: cover

trigger:
  - trigger: time_pattern
    minutes: /10

condition:
  - condition: state
    entity_id: !input volets_select
    state: Auto Pos Soleil
  - condition: sun
    before: sunset
    after: sunrise

action:
  - variables:
      orientation_entity: !input orientation_volet
      angle_exposition_entity: !input angle_exposition
      elevation_min_entity: !input elevation_min
      radiation_sensor_entity: !input radiation_sensor
      radiation_seuil_entity: !input radiation_seuil
      temperature_sensor_entity: !input temperature_sensor
      temperature_seuil_entity: !input temperature_seuil
      orientation_volet: "{{ states(orientation_entity) | float }}"
      angle_exposition: "{{ states(angle_exposition_entity) | float }}"
      elevation_min: "{{ states(elevation_min_entity) | float }}"
      ouverture_min: 0
      ouverture_max: 100
      azimut_soleil: "{{ state_attr('sun.sun', 'azimuth') | float }}"
      elevation_soleil: "{{ state_attr('sun.sun', 'elevation') | float }}"
      azimut_min: "{{ orientation_volet - angle_exposition }}"
      azimut_max: "{{ orientation_volet + angle_exposition }}"
      radiation_solaire: "{{ states(radiation_sensor_entity) | float }}"
      radiation_seuil: "{{ states(radiation_seuil_entity) | float(0) }}"
      temperature_ext: "{{ states(temperature_sensor_entity) | float }}"
      temperature_seuil: "{{ states(temperature_seuil_entity) | float(30) }}"
      fermeture_brute: >-
        {% if elevation_soleil < elevation_min %}
          100
        {% else %}
          {{ 100 - (((elevation_soleil - elevation_min) / (90 - elevation_min)) * 100) | round(0) }}
        {% endif %}
      fermeture_finale: >-
        {% set pos = fermeture_brute | float %}
        {% set pos = [pos, ouverture_max] | min %}
        {% set pos = [pos, ouverture_min] | max %}
        {{ pos | round(0) }}
      position_effective: >-
        {% if azimut_min <= azimut_soleil <= azimut_max and temperature_ext > temperature_seuil %}
          0
        {% elif azimut_min <= azimut_soleil <= azimut_max and elevation_soleil > elevation_min and radiation_solaire > radiation_seuil %}
          {{ fermeture_finale }}
        {% elif radiation_solaire <= radiation_seuil and temperature_ext <= temperature_seuil %}
          100
        {% else %}
          unknown
        {% endif %}
  - action: system_log.write
    data:
      message: >
        Debug volet bureau (progressif): Azimut={{ azimut_soleil }} ({{ azimut_min }} → {{ azimut_max }}), Élévation={{ elevation_soleil }}, Radiation={{ radiation_solaire }} > seuil={{ radiation_seuil }}, Température={{ temperature_ext }} > seuil={{ temperature_seuil }}, fermeture_brute={{ fermeture_brute }}, clampée={{ fermeture_finale }}, appliquée={{ position_effective }}
  - action: input_text.set_value
    target:
      entity_id: !input debug_text
    data:
      value: |
        Azimut: {{ azimut_soleil }} ({{ azimut_min }} → {{ azimut_max }})
        Élévation: {{ elevation_soleil }}
        Radiation Moyenne: {{ radiation_solaire }} (seuil: {{ radiation_seuil }})
        Température: {{ temperature_ext }} (seuil: {{ temperature_seuil }})
        Fermeture brute: {{ fermeture_brute }}
        Clampée: {{ fermeture_finale }}
        Appliquée: {{ position_effective }}
  - choose:
      - conditions:
          - condition: template
            value_template: >-
              {{ azimut_min <= azimut_soleil <= azimut_max and temperature_ext > temperature_seuil }}
        sequence:
          - action: cover.set_cover_position
            data:
              position: 0
            target: !input cover_entities
      - conditions:
          - condition: template
            value_template: >-
              {{ azimut_min <= azimut_soleil <= azimut_max and elevation_soleil > elevation_min and radiation_solaire > radiation_seuil and temperature_ext <= temperature_seuil }}
        sequence:
          - action: cover.set_cover_position
            data:
              position: "{{ fermeture_finale }}"
            target: !input cover_entities
      - conditions:
          - condition: template
            value_template: >-
              {{ radiation_solaire <= radiation_seuil and temperature_ext <= temperature_seuil }}
        sequence:
          - action: cover.set_cover_position
            data:
              position: 100
            target: !input cover_entities
mode: single

Comment fonctionne l’automatisation ?

Cette automatisation ajuste les volets en fonction de plusieurs critères :

• Mode automatique : Activé via une entité input_select (par exemple, input_select.volets avec l’option « Auto Pos Soleil »).
• Elle est calculée seulement entre le lever et le couché du soleil
• Position du soleil : Utilise l’azimut (direction horizontale) et l’élévation (hauteur au-dessus de l’horizon) du soleil pour déterminer si une fenêtre est exposée.
• Radiation solaire : Si la radiation dépasse un seuil (par exemple, 500 W/m²), les volets se ferment partiellement pour bloquer la chaleur.
• Température extérieure : Si la température dépasse un seuil (par exemple, 30°C), les volets se ferment complètement pour protéger l’intérieur.
• Débogage : Les informations clés (azimut, élévation, radiation, etc.) sont enregistrées dans une entité input_text pour faciliter le suivi.

L’automatisation se déclenche toutes les 10 minutes entre le lever et le coucher du soleil, ajustant les volets progressivement pour un confort optimal.

Calcul de l’ouverture des volets

L’élément clé de cette automatisation est le calcul de la position des volets, qui détermine à quel point ils doivent être fermés (0 % = complètement ouverts, 100 % = complètement fermés) en fonction de la hauteur du soleil. Voici la formule utilisée :

{{ 100 - (((elevation_soleil - elevation_min) / (90 - elevation_min)) * 100) | round(0) }}

Explication simple

Cette formule ajuste l’ouverture des volets en fonction de l’élévation du soleil (angle au-dessus de l’horizon) par rapport à un seuil minimal (elevation_min, par exemple 10°). Voici comment ça marche :

1. Différence d’élévation : On calcule combien l’élévation du soleil (elevation_soleil) dépasse le seuil minimal (elevation_soleil - elevation_min).
2. Proportion : Cette différence est divisée par la plage entre le seuil minimal et le zénith (90°), soit (90 - elevation_min). Cela donne un pourcentage (0 % quand le soleil est au seuil minimal, 100 % au zénith).
3. Inversion : Le pourcentage est inversé (100 – pourcentage) pour que les volets soient fermés (100 %) quand le soleil est bas et ouverts (0 %) quand il est haut.
4. Arrondi : Le résultat est arrondi à un nombre entier pour la position des volets.

Exemple

Imaginons que le soleil est à 45° et que le seuil minimal est 10° :

• Différence : 45 - 10 = 35°.
• Plage totale : 90 - 10 = 80°.
• Proportion : 35 / 80 = 0,4375 (43,75 %).
• Inversion : 100 - 43,75 = 56,25.
• Arrondi : 56.

Résultat : Les volets sont positionnés à 56 % de fermeture (44 % d’ouverture).

Pourquoi ce calcul ?

Cette formule permet une fermeture progressive :

• Quand le soleil est bas (près de l’horizon), les volets sont presque fermés pour bloquer la lumière ou la chaleur.
• Quand le soleil est haut (près du zénith), les volets s’ouvrent pour laisser entrer la lumière.
• La transition est linéaire, offrant un contrôle fluide et naturel.

Cette valeur (fermeture_brute) est ensuite limitée entre 0 et 100 (fermeture_finale) et utilisée dans la logique pour ajuster les volets en fonction de l’azimut, de la radiation et de la température.

Installation et configuration

Pré-requis

Avant d’utiliser ce blueprint, assurez-vous d’avoir :

• Une entité input_select pour activer/désactiver le mode (par exemple, input_select.volets avec une option « Auto Pos Soleil »).
• Des entités input_number pour :
  • Orientation de la fenêtre (par exemple, input_number.orientation_volet_bureau, 180° pour sud).
  • Angle d’exposition (par exemple, input_number.angle_exposition_volet_bureau, 30°).
  • Élévation minimale (par exemple, input_number.elevation_mini_volets_bureaux, 10°).
  • Seuil de radiation (par exemple, input_number.radiation_seuil_volets, 500 W/m²).
  • Seuil de température (par exemple, input_number.temperature_seuil_volets, 30°C).
• Un capteur de radiation solaire (par exemple, sensor.vp2_radiation) moyenné pour éviter les mouvements intempestifs.
• Un capteur de température extérieure (par exemple, sensor.vp2_temp_out).
• Une entité input_text pour les logs (par exemple, input_text.volets_debug_bureau).
• Des volets compatibles (par exemple, cover.bureau_droit_2, cover.bureau_gauche_rts).

Étapes

1. Importer le blueprint :
   • Créer un fichier YAML sur ton système Home Assistant :
   • Emplacement :
     /config/blueprints/automation/<ton_nom>/nom_du_blueprint.yaml
   • Exemple :
     /config/blueprints/automation/rem81/volets_suivi_solaire.yaml
   • Copiez/Collez le code et enregistrez-le (par exemple, sous volets_suivi_soleil_progressif.yaml).
2. Créer l’automatisation :
   • Allez dans Configuration > Automatisations > Créer une automatisation > Utiliser un blueprint.
   • Sélectionnez « Volets Suivi Azimuth Soleil Bureau Été (Progressif) ».
   • Remplissez les champs avec vos entités (par exemple, input_select.volets, cover.bureau_droit_2, etc.).
3. Configurer l’affichage des logs :
   • Ajoutez une carte Markdown dans Lovelace pour voir les logs :type: markdown content: | {{ states('input_text.volets_debug_bureau') }}
   • Cela affiche les informations comme :Azimut: 180.5 (150 → 210) Élévation: 45.2 Radiation Moyenne: 600 (seuil: 500) Température: 28 (seuil: 30) Fermeture brute: 56 Clampée: 56 Appliquée: 56
4. Tester :
   • Activez le mode « Auto Pos Soleil » sur votre input_select.
   • Vérifiez les logs dans input_text.volets_debug_bureau ou dans Configuration > Journaux.
   • Assurez-vous que les volets s’ajustent correctement selon la position du soleil.

Personnalisation

• Modifier les seuils : Ajustez les seuils de radiation et de température via les entités input_number pour adapter l’automatisation à votre climat.
• Volets multiples : Créez une automatisation par volet avec des orientations différentes (par exemple, sud à 180°, ouest à 270°).
• Débogage : Les logs dans input_text.volets_debug_bureau vous aident à vérifier les calculs et à ajuster les paramètres si besoin.

---

Dashboard – Affichage clair

Ajoute ceci dans le dashboard Lovelace pour avoir sous les yeux les données et la position réellement appliquée :

type: markdown
title: 🪟 Volets Bureau – Debug
content: |
  {{ states('input_text.volets_debug_bureau') }}

📌 Exemple rendu :

Conclusion

Ce blueprint rend vos volets intelligents, en les ajustant automatiquement pour un confort optimal en été. La fermeture progressive basée sur l’élévation du soleil, combinée aux conditions d’azimut, de radiation et de température, en fait une solution puissante et flexible. Essayez-le et partagez vos retours dans les commentaires !

Pour plus de détails sur Home Assistant ou d’autres automatisations, explorez mon blog ou contactez-moi !