Lampe de garage Home Assistant : plus de lumière à chaque appui

Avant de commencer. Le module qui commande la lampe est branché sur le secteur : toute intervention dans un boîtier se fait courant coupé, et par un électricien en cas de doute. Faire une sauvegarde complète de Home Assistant avant de modifier quoi que ce soit. Tout ce qui suit se crée à côté de l’existant, désactivé, et ne s’active qu’à la fin.

À quoi ça sert

Dans un garage, la lampe s’éteint souvent toute seule après quelques minutes. C’est pratique, sauf au milieu d’un rangement. Ce guide de lampe de garage Home Assistant montre comment chaque appui rapide sur l’interrupteur habituel ajoute du temps :

Appuis rapides (moins de 3 s entre deux)	Durée d’allumage
1	8 minutes
2	16 minutes
3	24 minutes
4 ou plus	32 minutes, le maximum

Une enceinte connectée annonce la durée (« Lumière allumée encore 16 minutes. »), puis prévient une minute avant l’extinction. Un seul appui éteint, comme avant.

Ce qu’il faut avoir

• Home Assistant (testé en version 2026.9).
• Une lampe commandée par un module relais, derrière un interrupteur ou un va-et-vient. Chaque appui doit faire basculer le relais, et Home Assistant doit voir chaque bascule.
• Une enceinte compatible Google Cast dans la pièce, pour les annonces.
• La voix française locale Piper. Elle est décrite dans le guide « Faire parler Home Assistant en français ».

Les entités à remplacer

Les noms ci-dessous sont des exemples. Les remplacer partout par ceux de l’installation.

Dans les blocs	À remplacer par
switch.lampe_garage	l’interrupteur de la lampe
automation.ancienne_extinction_garage	l’automatisation qui éteint la lampe aujourd’hui
media_player.enceinte_garage	l’enceinte du garage
tts.piper	le moteur de synthèse vocale Piper
timer.nouveau_garage_lampe	créée à l’étape 2
timer.nouveau_garage_preavis	créée à l’étape 2
counter.nouveau_garage_appuis	créé à l’étape 2
script.nouveau_garage_annonce	créé à l’étape 3
automation.nouveau_garage_appuis, automation.nouveau_garage_extinction, automation.nouveau_garage_preavis, automation.nouveau_garage_securite	créées aux étapes 4 à 7

Les éléments marqués « créé » sont fabriqués par ce guide. Leurs noms peuvent rester tels quels. Pour en changer un, le changer partout à la fois. Le nom d’une automatisation vient de son alias au moment où elle est enregistrée : garder l’alias des blocs, ou adapter les étapes 9 et suivantes.

Les blocs utilisent le préfixe nouveau_garage_ : tout ce qui est neuf se repère d’un coup d’œil.

Les étapes

1. Regarder ce qui existe

Ouvrir Paramètres, Automatisations, et chercher celle qui éteint la lampe. Noter sa durée réelle. Dans la maison où ce guide a été écrit, tout le monde parlait de 5 minutes. L’automatisation coupait en fait après 8 minutes sans changement d’état. Le nouveau montage reprend donc 8 minutes pour un appui simple, pour ne rien changer au quotidien.

Vérifier aussi dans l’historique de la lampe que chaque appui apparaît bien, à la seconde près.

2. Créer les minuteries et le compteur

Dans Paramètres, Appareils et services, Entraides : deux minuteries et un compteur. L’équivalent en YAML :

timer:
  nouveau_garage_lampe:
    duration: 00:08:00
    restore: true
    icon: mdi:timer-outline
    name: nouveau_garage_lampe
  nouveau_garage_preavis:
    duration: 00:07:00
    restore: true
    icon: mdi:bullhorn-outline
    name: nouveau_garage_preavis
counter:
  nouveau_garage_appuis:
    initial: 0
    step: 1
    minimum: 0
    restore: false
    icon: mdi:counter
    name: nouveau_garage_appuis

La minuterie principale garde son état après un redémarrage (restore: true). Le compteur repart de zéro.

3. Créer le script d’annonce

Ce script règle l’enceinte à 30 % du volume, parle, attend la fin de la phrase, puis remet le volume d’avant. Il est décrit en détail dans le guide sur la voix française.

nouveau_garage_annonce:
  alias: nouveau_garage_annonce
  description: Annonce sur l'enceinte du garage à 30 % de volume, puis rétablit le volume d'avant (0.30 s'il était illisible).
  mode: queued
  max: 5
  fields:
    message:
      name: Message
      required: true
      selector:
        text: {}
  sequence:
  - variables:
      volume_avant: '{{ state_attr(''media_player.enceinte_garage'', ''volume_level'') }}'
  - variables:
      volume_lisible: '{{ volume_avant is number and 0 <= volume_avant <= 1 }}'
      volume_retour: '{{ volume_avant if (volume_avant is number and 0 <= volume_avant <= 1) else 0.3 }}'
  - action: media_player.volume_set
    continue_on_error: true
    target:
      entity_id: media_player.enceinte_garage
    data:
      volume_level: 0.3
  - action: tts.speak
    continue_on_error: true
    target:
      entity_id: tts.piper
    data:
      media_player_entity_id: media_player.enceinte_garage
      message: '{{ message }}'
      language: fr_FR
      cache: true
      options:
        voice: fr_FR-tom-medium
  - wait_template: '{{ is_state(''media_player.enceinte_garage'', ''playing'') }}'
    timeout:
      seconds: 8
    continue_on_timeout: true
  - wait_template: '{{ not is_state(''media_player.enceinte_garage'', ''playing'') }}'
    timeout:
      seconds: 28
    continue_on_timeout: true
  - action: media_player.volume_set
    continue_on_error: true
    target:
      entity_id: media_player.enceinte_garage
    data:
      volume_level: '{{ volume_retour }}'

4. Créer l’automatisation des appuis

C’est le cœur du montage. Elle compte les appuis d’une même série, puis décide en fin de série :

- alias: nouveau_garage_appuis
  description: Compte les appuis rapprochés sur le va-et-vient du garage et prolonge l'allumage (+8 min par appui, 32 min maximum). Inerte tant que l'ancienne automatisation est active.
  triggers:
  - trigger: state
    entity_id: switch.lampe_garage
    from:
    - 'on'
    - 'off'
    to:
    - 'on'
    - 'off'
  conditions:
  - condition: template
    value_template: '{{ trigger.to_state.context.parent_id is none }}'
  - condition: state
    entity_id: automation.ancienne_extinction_garage
    state: 'off'
  actions:
  - action: counter.increment
    target:
      entity_id: counter.nouveau_garage_appuis
  - delay:
      seconds: 3
  - variables:
      n: '{{ [states(''counter.nouveau_garage_appuis'') | int(1), 1] | max }}'
      allumee: '{{ is_state(''switch.lampe_garage'', ''on'') }}'
      reste: '{% set f = state_attr(''timer.nouveau_garage_lampe'', ''finishes_at'') %}{% if is_state(''timer.nouveau_garage_lampe'', ''active'') and f %}{{ [((as_datetime(f) - now()).total_seconds()) | int(0), 0] | max }}{% else %}0{% endif %}'
  - variables:
      brut: '{%- set etait = allumee if n % 2 == 0 else not allumee -%}{%- if n >= 2 -%}{%- set base = reste if (etait and reste > 0) else 480 -%}{{ base + 480 * (n - 1) }}{%- else -%}{{ [480, reste] | max }}{%- endif -%}'
  - variables:
      duree: '{{ [brut | int(0), 1920] | min }}'
  - variables:
      duree_sure: '{{ duree if (duree is number and 0 < duree <= 1920) else 480 }}'
  - action: counter.reset
    target:
      entity_id: counter.nouveau_garage_appuis
  - choose:
    - conditions:
      - condition: template
        value_template: '{{ n == 1 and not allumee }}'
      sequence:
      - action: timer.cancel
        target:
          entity_id:
          - timer.nouveau_garage_lampe
          - timer.nouveau_garage_preavis
    default:
    - action: timer.cancel
      target:
        entity_id:
        - timer.nouveau_garage_lampe
        - timer.nouveau_garage_preavis
    - action: timer.start
      target:
        entity_id: timer.nouveau_garage_lampe
      data:
        duration: '{{ (duree_sure) | int | timestamp_custom(''%H:%M:%S'', false) }}'
    - if:
      - condition: template
        value_template: '{{ duree_sure > 60 }}'
      then:
      - action: timer.start
        target:
          entity_id: timer.nouveau_garage_preavis
        data:
          duration: '{{ (duree_sure - 60) | int | timestamp_custom(''%H:%M:%S'', false) }}'
    - if:
      - condition: template
        value_template: '{{ n >= 2 }}'
      then:
      - action: script.turn_on
        continue_on_error: true
        target:
          entity_id: script.nouveau_garage_annonce
        data:
          variables:
            message: '{% set m = [((duree_sure / 60) | round(0)) | int, 1] | max %}Lumière allumée encore {{ m }} minute{{ ''s'' if m > 1 else '''' }}.{{ " C''est le maximum." if (brut | int(0)) > 1920 else '''' }}'
    - if:
      - condition: template
        value_template: '{{ not allumee }}'
      then:
      - action: switch.turn_on
        target:
          entity_id: switch.lampe_garage
  mode: restart
  id: nouveau_garage_appuis

Trois points méritent une explication.

• Le mode restart. Chaque nouvel appui relance le délai de 3 secondes. La décision ne tombe qu’une fois la série finie.
• Les commandes de Home Assistant ne comptent pas. Quand Home Assistant rallume la lampe lui-même, le changement d’état porte un « parent ». La condition parent_id is none ne garde que les vrais appuis.
• La parité. Chaque appui bascule la lampe. Après 2 appuis, elle est donc éteinte. L’automatisation la rallume en fin de série. L’état d’avant la série se déduit du nombre d’appuis, sans rien stocker.

La condition sur automation.ancienne_extinction_garage rend l’automatisation inerte tant que l’ancienne est active. Les deux ne peuvent pas se gêner.

5. Créer l’extinction

Elle éteint la lampe quand la minuterie arrive à zéro. Elle oublie aussi la minuterie si la lampe reste éteinte 11 secondes, quelle qu’en soit la cause :

- alias: nouveau_garage_extinction
  description: Éteint la lampe du garage quand la minuterie nouveau_garage_lampe arrive à zéro. Annule les minuteries si la lampe reste éteinte, quelle qu'en soit la cause, pour que le temps restant ne se reporte jamais sur l'allumage suivant.
  triggers:
  - trigger: event
    event_type: timer.finished
    event_data:
      entity_id: timer.nouveau_garage_lampe
    id: echeance
  - trigger: state
    entity_id: switch.lampe_garage
    to: 'off'
    for:
      seconds: 11
    id: eteinte
  conditions:
  - condition: state
    entity_id: automation.ancienne_extinction_garage
    state: 'off'
  actions:
  - choose:
    - conditions:
      - condition: trigger
        id: eteinte
      sequence:
      - action: timer.cancel
        target:
          entity_id:
          - timer.nouveau_garage_lampe
          - timer.nouveau_garage_preavis
      - action: counter.reset
        target:
          entity_id: counter.nouveau_garage_appuis
    default:
    - action: switch.turn_off
      target:
        entity_id: switch.lampe_garage
    - action: timer.cancel
      target:
        entity_id: timer.nouveau_garage_preavis
  mode: queued
  id: nouveau_garage_extinction

6. Créer le préavis

Une minute avant la fin, l’enceinte prévient. Le préavis ne sonne que si la lampe est allumée et la minuterie en cours :

- alias: nouveau_garage_preavis
  description: Annonce sur l'enceinte du garage que la lumière s'éteint dans une minute.
  triggers:
  - trigger: event
    event_type: timer.finished
    event_data:
      entity_id: timer.nouveau_garage_preavis
  conditions:
  - condition: state
    entity_id: automation.ancienne_extinction_garage
    state: 'off'
  - condition: state
    entity_id: switch.lampe_garage
    state: 'on'
  - condition: state
    entity_id: timer.nouveau_garage_lampe
    state: active
  actions:
  - action: script.turn_on
    continue_on_error: true
    target:
      entity_id: script.nouveau_garage_annonce
    data:
      variables:
        message: La lumière s'éteint dans une minute.
  mode: single
  id: nouveau_garage_preavis

7. Créer la coupure de sécurité

Elle éteint la lampe après 32 minutes d’allumage continu. Elle ne dépend ni des minuteries, ni du compteur, ni de l’annonce. Après un redémarrage de Home Assistant, elle réarme une minuterie si la lampe est restée allumée :

- alias: nouveau_garage_securite
  description: Coupe la lampe du garage après 32 minutes d'allumage continu, quoi qu'il arrive aux minuteries. Réarme une minuterie au démarrage de HA.
  triggers:
  - trigger: state
    entity_id: switch.lampe_garage
    to: 'on'
    for:
      seconds: 1920
    id: plafond
  - trigger: homeassistant
    event: start
    id: demarrage
  conditions:
  - condition: state
    entity_id: automation.ancienne_extinction_garage
    state: 'off'
  actions:
  - choose:
    - conditions:
      - condition: trigger
        id: plafond
      sequence:
      - action: switch.turn_off
        target:
          entity_id: switch.lampe_garage
      - action: timer.cancel
        continue_on_error: true
        target:
          entity_id:
          - timer.nouveau_garage_lampe
          - timer.nouveau_garage_preavis
    - conditions:
      - condition: trigger
        id: demarrage
      sequence:
      - delay:
          seconds: 82
      - if:
        - condition: state
          entity_id: switch.lampe_garage
          state: 'on'
        - condition: not
          conditions:
          - condition: state
            entity_id: timer.nouveau_garage_lampe
            state: active
        then:
        - action: timer.start
          target:
            entity_id: timer.nouveau_garage_lampe
          data:
            duration: '{{ (480) | int | timestamp_custom(''%H:%M:%S'', false) }}'
        - action: timer.start
          target:
            entity_id: timer.nouveau_garage_preavis
          data:
            duration: '{{ (420) | int | timestamp_custom(''%H:%M:%S'', false) }}'
  mode: queued
  id: nouveau_garage_securite

8. Désactiver les nouvelles automatisations

Home Assistant active une automatisation à l’enregistrement. Les désactiver une par une, à la main. Même oubliées, elles restent inertes tant que l’ancienne est active, grâce à leur condition de garde.

9. Activer

Dans Outils de développement, Actions, passer les nouvelles en service, puis désactiver l’ancienne. Rien n’est supprimé :

action: automation.turn_on
target:
  entity_id:
    - automation.nouveau_garage_appuis
    - automation.nouveau_garage_extinction
    - automation.nouveau_garage_preavis
    - automation.nouveau_garage_securite

action: automation.turn_off
target:
  entity_id: automation.ancienne_extinction_garage

Si la lampe est allumée à ce moment-là, démarrer la minuterie timer.nouveau_garage_lampe pour 8 minutes. Sinon, seule la coupure de sécurité l’éteindra.

Le résultat attendu

• 3 appuis rapides : la lampe clignote, se rallume, et l’enceinte dit « Lumière allumée encore 24 minutes. ».
• Un appui simple sur une lampe allumée : elle s’éteint, la minuterie est annulée.
• Une minute avant la fin : « La lumière s’éteint dans une minute. ».

Tester sans risque

Le calcul de la durée se vérifie sans toucher à la lampe. Dans Outils de développement, Modèles, coller par exemple :

{% set n = 3 %}{% set allumee = true %}{% set reste = 0 %}
{%- set etait = allumee if n % 2 == 0 else not allumee -%}
{%- set base = reste if (etait and reste > 0) else 480 -%}
{{ [base + 480 * (n - 1), 1920] | min }}

Le résultat attendu est 1440 secondes, soit 24 minutes. En changeant n, vérifier que la durée ne dépasse jamais 1920 secondes (32 minutes).

La voix se teste sans l’enceinte : Médias, Synthèse vocale, puis écouter la phrase dans le navigateur.

Si ça ne marche pas

• Rien ne se passe. Vérifier que l’ancienne automatisation est bien désactivée : sinon la garde rend tout inerte.
• La durée est trop courte. Ouvrir la trace de automation.nouveau_garage_appuis et lire la valeur de n. Si des appuis manquent, la lampe met peut-être plus de 3 secondes à remonter son état.
• L’enceinte se tait. Voir le guide sur la voix française : volume, bonne enceinte, enceinte en veille.
• La lampe reste allumée sans minuterie. C’est le cas si elle était allumée au moment de l’activation. La coupure de sécurité l’éteindra au bout de 32 minutes.

Revenir en arrière

Réactiver l’ancienne automatisation, puis désactiver les quatre nouvelles. Les nouvelles deviennent inertes à l’instant même où l’ancienne est réactivée :

action: automation.turn_on
target:
  entity_id: automation.ancienne_extinction_garage

action: automation.turn_off
target:
  entity_id:
    - automation.nouveau_garage_appuis
    - automation.nouveau_garage_extinction
    - automation.nouveau_garage_preavis
    - automation.nouveau_garage_securite

Attention : l’ancienne automatisation ne s’arme qu’au prochain changement d’état. Si la lampe est allumée au moment du retour, l’éteindre une fois.

Les pièges rencontrés

• La durée réelle n’était pas celle qu’on croyait : 8 minutes et non 5. Lire l’automatisation avant de concevoir.
• Le va-et-vient bascule à chaque appui. Une série paire éteint la lampe : il faut la rallumer en fin de série.
• Allumer puis éteindre en moins de 3 secondes est lu comme une série de 2 appuis. La lampe reste alors 16 minutes. Ce geste a été vu deux fois en une semaine dans l’historique. Pour éteindre, attendre un instant puis appuyer une fois.
• Une extinction sans appui (lampe revenue d’« indisponible », commande d’une autre automatisation) laissait la minuterie tourner. L’appui suivant reprenait l’ancien temps. D’où la règle des 11 secondes dans l’extinction.
• La coupure de sécurité et la minuterie peuvent tomber ensemble. La minuterie démarre 3 secondes après le dernier appui. La sécurité coupe donc parfois 3 secondes plus tôt, et le préavis précède alors l’extinction de 57 secondes au lieu de 60.
• Une automatisation n’est pas créée désactivée. La condition de garde couvre l’instant entre l’enregistrement et la désactivation.
• Si le module passe par un service en ligne, une coupure d’Internet empêche toute extinction, ancienne comme nouvelle.

Ce qui est vérifié en usage réel, et ce qui ne l’est pas

Vérifié le 1er octobre 2026 avec la vraie lampe : 3 appuis donnent 24 minutes et l’annonce ; une série sur une lampe déjà allumée ajoute 8 minutes par appui au temps restant ; un appui simple éteint et annule la minuterie ; l’annonce de test à 30 % du volume. Le calcul a aussi été rendu par Home Assistant lui-même sur 71 cas, sans échec, plafond compris.

Pas encore vérifié en usage réel : le préavis d’une minute (la lampe a toujours été éteinte avant), la coupure de sécurité à 32 minutes, la reprise après un redémarrage, et la règle des 11 secondes, ajoutée après les essais.

Responsabilité. Ce guide décrit un montage réel, donné à titre d’exemple. Chaque installation est différente. L’adapter, le tester et l’utiliser se fait sous la responsabilité de la personne qui l’installe. Pour tout travail sur l’installation électrique, faire appel à un professionnel.

À lire aussi

• Domotique avec Home Assistant et Google Home : le guide d’introduction
• Faire parler Home Assistant en français avec Piper, au bon volume