[Dernière mise à jour 14-03-2026]
Sur le marché des sirènes, il y a peu de modèles en Zigbee et aucun modèle n’est particulièrement reconnu pour son intégration ou sa simplicité. J’ai voulu réaliser un test. Je peux aujourd’hui vous proposer un test de 7 sirènes Zigbee qui occupent le marché domotique actuellement. Lire la suite
En mars 2026, Heiman a remplacé le HS1SA-E par le HS1SA-E-PLUS mais qui parfois s’écrit HS1SA-E et c’est là que cela devient compliqué à suivre. Les deux modèles sont physiquement identiques à part leurs étiquettes qui affichent tous les deux HS1SA-E. Lire la suite
Un soir en cuisine, mon détecteur de fumée se déclenche pour la énième fois à cause de la fumée des steaks hachés.
Fatigué des fausses alertes, je cherche sur les forums domotique une solution fiable.
C’est là que je découvre le détecteur de chaleur intelligent Zigbee 3.0 HESZB-120 de Frient.
Il ne réagit qu’à la chaleur excessive, ce qui semble parfait pour ma cuisine, mon garage et mon salon avec cheminée.
Je passe commande chez Domadoo, car il est en promotion.
Il me semble parfait : alertes push fiables, sirène puissante de 85 décibels et longue autonomie sans maintenance. Je teste tout cela… Lire la suite
J’ai voulu utiliser OneDrive for Business comme destination de sauvegarde dans Home Assistant.
L’intégration officielle permet bien d’envoyer les sauvegardes vers OneDrive Entreprise, mais elle demande de préparer au préalable une application dans Microsoft Entra, avec un Tenant ID, un Client ID, un Client secret et une URI de redirection précise.
Avant de commencer, il vous faut :
Depuis très longtemps, j’ai des détecteurs de fumée Heiman HS1SA-E pour protéger mon logement, ce module économique me donne pleinement satisfaction pour un usage basique.
Dans le cadre de la rédaction de mon comparatif des détecteurs de fumée Zigbee, j’ai questionné Heiman pour savoir s’ils envisageaient une évolution de ce produit.
Et surprise, une mise à jour du HS1SA-E était en cours de développement, ils m’ont envoyé trois exemplaires du nouveau produit qui devrait être le HS1SA-E-PLUS avec une quantité d’évolutions dans les expositions Zigbee, comme je vais l’expliquer plus loin.
Trois produits car une des grandes nouveautés c’est l’interconnexion des détecteurs, je vais donc tester cela.
Le HS1SA-E est à gauche et le HS1SA-E-PLUS est à droite, à moins que ce soit l’inverse. Je plaisante bien sur, ils sont totalement identiques de l’extérieur.
Pour savoir qui est qui, il faut aller comparer les étiquettes à l’intérieur.
J’ai reçu une préversion, les deux sont mentionnés HS1SA-E, je pense que la référence du nouveau serait modifiée dans les versions commercialisées.
Sur l’image, le nouveau est à gauche, avec le QR Code, il est mentionné Manufacture Date : 12/2025.
Voici l’étiquette complète, une fois dépliée :
Indique que le détecteur respecte la réglementation britannique sur la sécurité des produits, la CEM, la radio, etc.
Obligatoire pour la mise sur le marché en Grande‑Bretagne (Angleterre, Écosse, Pays de Galles).
Symbole de produit destiné à un usage résidentiel (habitations).
On le voit souvent sur les détecteurs de fumée conformes aux normes de sécurité domestique en Europe.
Signale surtout le domaine d’usage, plus qu’une certification légale autonome.
Atteste que l’appareil a passé les tests de conformité de la Zigbee Alliance pour Zigbee 3.0 (interopérabilité, protocole radio, sécurité).
Pertinent mondialement pour l’écosystème domotique, pas lié à un pays en particulier.
Indique conformité aux directives européennes (sécurité, CEM, radio RED, etc.), permettant la mise sur le marché dans tous ces pays.
Numéro d’organisme notifié « 2531 »
Identifie l’organisme qui a évalué la conformité (ici un laboratoire notifié européen pour la directive équipements radio / produits de construction).
Ce numéro complète le CE et est reconnu dans l’UE/EEE.
Obligatoire ou fortement recommandée dans la plupart des pays de l’UE pour les détecteurs de fumée résidentiels (France, Allemagne, Belgique, etc.).
Reconnue aussi par certains pays hors UE qui adoptent les normes EN.
Organisme danois (« Dansk Brand- og sikringsteknisk Institut ») accrédité pour certifier les produits de sécurité incendie.
Certification surtout pertinente pour le Danemark et les pays nordiques où les assurances/autorités peuvent la valoriser.
Renforce la crédibilité du produit sur les marchés européens, sans être obligatoire partout.
Symbole DEEE (Déchets d’Équipements Électriques et Électroniques).
Indique que le détecteur ne doit pas être jeté avec les ordures ménagères mais dans une filière de recyclage spécifique.
Utilisé dans l’UE, le Royaume‑Uni et plus largement en Europe.
 |
 |
 |
 |
Le détecteur est compact, livré avec un support à coller ou à visser au plafond. Un système de plaques métalliques, un jeu de vis et un outil de reset.
Le nouveau modèle propose un système génial de plaques magnétiques avec deux aimants et des double-face 3M
Voici le lien vers la page dédiée au HS1SA-E-PLUS. J’y ai référencé les vendeurs et les prix.
Pour des mesures fiables, je choisis le plafond au centre de la chambre. J’évite les coins, cuisines ou garage pour faux positifs à cause des fumées de cuisine ou de la poussière.
Je retire le socle (il suffit de dévisser de quelques degrés), puis je tire la languette pour alimenter le détecteur.
Je mets Zigbee2MQTT en mode appairage au moment où je retire la languette, mais rien ne se passe (ce n’est pas automatique sur ce modèle).
Je trouve donc le petit trou sur le côté, j’y glisse un trombone pour appuyer quelques secondes jusqu’à ce que la LED clignote en vert.
L’appairage démarre aussitôt et, en quelques secondes, le module est intégré !
Ci-dessous, les 3 nouveaux produits détectés en HS1SA-E-PLUS et tout en haut, le produit précédent reconnu en HS1SA-E.
en Heiman Test 01 pour poursuivre les tests.
L’exposition Battery correspond au pourcentage de batterie restant remonté par le détecteur. En pratique, c’est l’indicateur le plus simple pour suivre l’autonomie au quotidien, par exemple 100% juste après installation.
Je l’affiche sur mon dashboard Home Assistant pour repérer rapidement une baisse anormale. Quand le niveau passe bas (typiquement sous 20%), je planifie le remplacement de la pile CR123A avant d’avoir des bips intempestifs ou une perte de supervision. On peut choisir de faire un test numérique sur cette exposition ou utiliser l’exposition Battery low qui est binaire, chacun sa préférence, l’appareil donne le choix.
L’exposition Identify sert à identifier physiquement le détecteur. Quand je déclenche cette action, le détecteur lance un clignotement de LED pour que je sache lequel est lequel.
C’est très utile si j’installe plusieurs détecteurs identiques dans la maison. Je peux les renommer proprement dans Zigbee2MQTT sans me tromper de pièce.
L’exposition Temperature remonte une température mesurée par le détecteur (en °C). Ce n’est pas la fonction principale d’un détecteur de fumée, mais c’est une donnée pratique, par exemple 20,9°C.
Je peux l’afficher sur le dashboard, ou l’utiliser dans une automatisation simple (ventilation, fenêtre, chauffage). Je garde en tête que ce n’est pas une sonde “précision” dédiée, mais plutôt un bonus pour contextualiser l’environnement.
L’exposition Smoke indique si le détecteur a détecté de la fumée sous forme d’un état binaire (Vrai/Faux). Tant qu’il n’y a rien à signaler, je vois “Faux” sur le dashboard.
C’est l’exposition la plus importante pour la sécurité, car je m’en sers pour déclencher les notifications et les scénarios d’urgence. Par exemple : notification push immédiate, allumage des lumières, ouverture de volets, et éventuellement déclenchement de sirènes supplémentaires.
L’exposition Battery low est un indicateur binaire qui signale si la batterie est presque vide. Même si la valeur “Battery” peut encore afficher un pourcentage, ce statut est un excellent déclencheur d’alertes car il représente un seuil “critique” côté appareil.
Je l’utilise pour envoyer une notification prioritaire et pour éviter de repousser le remplacement de pile. L’objectif est clair : ne pas attendre que le détecteur passe en mode bip régulier ou devienne instable sur le réseau.
L’exposition Test indique si le détecteur est en train d’effectuer un test. C’est un état binaire (Vrai/Faux) qui devient “Vrai” pendant la phase de test, puis revient à “Faux” ensuite.
Je m’en sers pour vérifier que mes automatisations réagissent correctement à un test sans déclencher une panique générale. Ce mode est conçu pour être utilisé en dashboard, en notification et en automatisation.
L’exposition Fault state correspond à l’état de défaut du détecteur. Elle indique si l’appareil est dans un état normal, ou s’il remonte un type de problème (selon les “fault types” possibles).
Je l’affiche sur mon dashboard sécurité, car un défaut peut être aussi important qu’une alarme. Si ce statut change, je prévois une vérification sur place (pile, encrassement, positionnement) et je surveille la stabilité Zigbee.
L’exposition Muted indique si le détecteur est actuellement en mode muet ou en état normal. La précision importante est que ce statut est surtout pertinent quand le détecteur a été rendu muet pendant un état d’alarme, et pas comme un simple “mode silencieux” permanent.
Je l’utilise pour confirmer visuellement qu’un mute a bien été appliqué après un faux positif. C’est aussi très pratique pour éviter de “croire” que l’alarme est coupée alors qu’elle ne l’est pas.
L’exposition Trigger selftest déclenche un auto-test à distance du détecteur. L’idée est simple : je peux vérifier périodiquement que l’appareil répond, sans appuyer physiquement sur le bouton.
Le self-test dure suffisamment longtemps (environ 21 secondes) pour que l’automatisation ait le temps d’agir. Dans mon cas, quand je lance un selftest, je surveille que Test passe à “Vrai”, que Smoke ne passe pas à “Vrai”, et j’écoute les bips de test (2 fois 3 bips) pour valider le bon fonctionnement.
L’exposition Temporary mute permet de demander au détecteur de se mettre en mode muet à distance. C’est une commande très utile quand l’alarme sonne pour une cause non dangereuse, mais elle doit être utilisée avec bon sens : je vérifie toujours qu’il n’y a pas de vrai départ de feu avant de couper le son.
Le comportement dépend du contexte.
L’exposition Heartbeat indicator sert à activer ou désactiver l’indicateur lumineux (heartbeat). L’objectif est de gérer le clignotement de la LED, souvent utile pour confirmer que l’appareil est vivant, mais parfois gênant dans une chambre.
La documentation recommande de ne pas le désactiver “à l’aveugle” : si je coupe la LED, je compense avec un contrôle périodique (selftest programmé) et une détection d’appareil indisponible (offline) dans Home Assistant.
L’exposition Interconnectable est prévue pour l’interconnexion entre détecteurs (logique “si un détecte, les autres réagissent”). L’explication fournie indique que cette exposition est pensée comme un déclencheur d’automatisation, plus simple et flexible que de s’appuyer uniquement sur “Smoke” ou “Test” pour piloter des sirènes externes.
Je l’utiliserais pour créer une alerte globale : si un seul détecteur déclenche, je fais sonner d’autres appareils (sirènes, enceintes, autres détecteurs) afin que l’alerte soit audible partout.
A ce stade, j’ai besoin de faire des essais avec au moins deux détecteurs pour tester cela.
L’exposition Smoke level remonte un niveau de fumée mesuré sous forme de valeur numérique (par exemple 0.00 en situation normale). C’est une information plus fine qu’un simple “Smoke = Vrai/Faux”.
Je peux l’exploiter en prévention : afficher la tendance sur un dashboard, ou déclencher une notification “pré-alerte” si le niveau monte progressivement avant le déclenchement de l’alarme.
J’ai également un moniteur de qualité de l’air dans la pièce, je vais pouvoir voir si le détecteur de fumée réagit quand le moniteur de qualité de l’air m’informe que la qualité de l’air intérieur est devenue mauvaise.
L’exposition Smoke unit précise l’unité associée à la mesure “Smoke level”. Dans la documentation, cette unité est pensée pour faciliter les scripts et automatisations, notamment parce que le produit vise un usage international.
Concrètement, ça m’évite de faire des hypothèses dans mes automatisations. Je peux aussi adapter mes seuils si je change de modèle plus tard, en gardant une logique cohérente.
L’exposition Chamber contamination indique le niveau d’encrassement de la chambre de détection à fumée.
Les valeurs possibles sont :
Je peux l’utiliser pour programmer une notification automatique dès light_contamination, et une alerte forte à critical_contamination. Cela évite que la poussière rende le détecteur inopérant sans que je m’en rende compte.
L’exposition Siren for automation only permet de piloter la sirène via une action domotique.
Cette fonctionnalité est juste géniale pour les amateurs de domotique. Trois boutons sont actionnables : stop, smokesiren ou cosiren, on a donc le choix entre deux sonneries. Dommage, c’est un peu limité, mais c’est déjà énorme pour construire des scénarios.
Je pense l’utiliser uniquement dans un cadre contrôlé : tests, scénarios, ou interconnexion. Cela me permet par exemple de déclencher la sirène d’un détecteur depuis une automation, sans attendre qu’il détecte lui-même de la fumée.
L’exposition Reported packages est un compteur qui indique combien de paquets Zigbee l’appareil a publiés sur une 24h. C’est une donnée de diagnostic très utile si je trouve que la pile se vide trop vite.
Dans ce contexte, “reported” signifie envoyé / transmis : c’est le nombre total de paquets Zigbee que le détecteur a envoyés vers le réseau sur une journée. Ces paquets correspondent aux messages de “reporting” (états automatiques comme batterie, température, niveau de fumée, qualité de lien, etc.). Chaque fois que le détecteur remonte un état, un changement, ou un heartbeat périodique, cela compte +1 paquet.
Si ce compteur devient anormalement élevé, je dois chercher la cause (réseau instable, paramètres trop bavards, interférences radio).
L’exposition Rejoin count indique combien de fois le détecteur a rejoint à nouveau le réseau Zigbee.
En diagnostic, c’est un indicateur clair de stabilité : plus il monte, plus mon réseau est probablement limite à l’endroit où se trouve le détecteur. Si je vois des rejoins fréquents, j’ajoute un routeur Zigbee (prise, ampoule routeur) à proximité ou je rapproche le coordinateur.
Je gagne à la fois en fiabilité d’alerte et en autonomie de pile.
L’exposition Reboot count compte le nombre de redémarrages de l’appareil. C’est encore une donnée purement diagnostic, mais elle peut aider à détecter un comportement instable.
Si ce compteur augmente, je suspecte une pile faible, un problème firmware, ou une alimentation interne instable. Dans tous les cas, je préfère investiguer rapidement, car un détecteur de fumée doit rester fiable en continu.
L’exposition Linkquality représente la qualité du lien Zigbee (LQI). Ce n’est pas un indicateur “sécurité” direct, mais c’est un excellent thermomètre pour savoir si le détecteur communique facilement avec le réseau.
Si le LQI est trop bas ou fluctue beaucoup, je revois le placement ou j’ajoute un routeur Zigbee. Je garde en tête que de bonnes communications Zigbee augmentent les chances que l’alerte et les statuts remontent vite, surtout en situation réelle.
L’exposition Temperature calibration permet d’ajuster la température absolue rapportée par le détecteur. En entrant une valeur offset (par exemple +1,5°C ou -0,5°C), je compense les écarts mesurés par rapport à une sonde de référence fiable.
Je m’en sers pour affiner les mesures dans une pièce spécifique, surtout si je compare avec d’autres capteurs maison. Cette calibration se règle à 0.1°C près. Cela est très utile pour compenser le positionnement des capteurs, souvent au plafond, et donc avec quelques degrés de plus que la température à hauteur d’homme.
Attention : cette calibration impacte directement tous les reports de température, donc je teste après réglage et je note la valeur pour reproductibilité.
Ce paramètre définit le nombre de décimales affiché pour la température (par exemple 0 pour entier, 1 pour 21,0°C, 2 pour 21,05°C). Il contrôle la précision du report sans changer la mesure réelle.
Je choisis 1 ou 2 décimales pour un affichage lisible sur dashboard sans surcharge inutile. Plus de décimales = reports légèrement plus longs (impact mineur conso), mais précision visuelle accrue pour tendances fines.
Ce réglage fixe la durée en secondes pendant laquelle le détecteur clignote sa LED lors d’une commande Identify (plage 1 à 30 secondes, valeur par défaut 3 secondes).
Je l’adapte à mes besoins : court (5s) pour localisation rapide, long (20s) si je galère à repérer parmi plusieurs détecteurs. Ça évite de relancer plusieurs fois l’Identify lors d’installation ou maintenance.
J’y retrouve tout de suite mon équipement.
Les contrôles sont bien présents.
Je retrouve tous les capteurs disponibles
Dans Configuration, je trouve bien l’option de mise à jour OTA (génial !) ainsi que la commande d’identification qui fait clignoter le détecteur.
Enfin dans Diagnostic, j’ai bien tous les éléments. A noter que chez moi j’ai activé automatiquement Linkquality et Last Seen, si cela peut intéresser, j’ai réalisé un Retex qui explique cela :
Je remarque que deux éléments portent le même nom Batterie, je ne sais pas si c’est un souci de l’intégration ou une autre raison, il faudra que je sois vigilant de les renommer pour ne pas m’embrouiller.
friendly_name: detecteur_fumee_chambre device_class: smoke smoke: binary_sensor.smoke battery_low: binary_sensor.battery_low test: button.test
Je retrouve l’appareil dans HA : entités smoke (état fumée), battery, test. Badge d’alarme avec sirène et notification push. Tout fonctionne parfaitement.
| Date | État fumée | Batterie % | Test | Notes |
|---|---|---|---|---|
| 02/03/2026 | Clear | 100% | OK | Installation |
| 03/03/2026 | Clear | 100% | OK | Stable |
✅ Forts : Détection rapide, intégration parfaite Z2M/HA, autonomie longue, prix abordable.
❌ Faibles : Pas de CO, sirène modérée, pas d’extérieur.
Mon verdict : Excellent pour domotique Zigbee ! Recommandé pour tous débutants sécurité incendie.
Objectif : rendre visibles (et exploitables) deux infos clés pour chaque device Zigbee :
Cela afin de repérer immédiatement une sirène “perdue” ou une batterie HS, sans attendre de le découvrir par hasard.
Avec 69 appareils Zigbee, je n’avais pas de visibilité simple pour répondre à deux questions basiques : est-ce que l’appareil capte correctement ? et est-ce qu’il a communiqué récemment ?
Sur une sirène, ce n’est pas acceptable de le découvrir “au hasard” : je veux voir immédiatement si elle est muette, hors réseau, ou en difficulté radio.
J’ai donc décidé d’afficher partout :
Au début, je me suis fait avoir : dans Home Assistant, il y a bien deux fichiers différents.
Important : pour last_seen et (en pratique) l’exposition/activation par défaut, tout se configure côté Zigbee2MQTT, donc dans /config/zigbee2mqtt/configuration.yaml.
J’ai eu un comportement très pénible : j’ajoutais des options avancées, je sauvegardais… puis l’interface de l’add-on semblait “simplifier” le fichier en supprimant ce qu’elle ne comprenait pas.
La méthode fiable (chez moi) :
/config/zigbee2mqtt/configuration.yaml (File Editor ou SSH)last_seen dans Zigbee2MQTT (obligatoire)Par défaut, Zigbee2MQTT peut ne pas publier last_seen (valeur “disable”).
Pour l’activer, j’ajoute ceci dans la section advanced de /config/zigbee2mqtt/configuration.yaml :
advanced: # Ajoute "last_seen" dans les messages MQTT # valeurs possibles: disable, ISO_8601, ISO_8601_local, epoch last_seen: ISO_8601_local
Ce réglage indique à Zigbee2MQTT d’ajouter l’attribut last_seen aux messages MQTT, avec un format lisible en heure locale.
last_seen et linkquality “par défaut” dans Home Assistant (facultatif)
Une fois last_seen activé côté Zigbee2MQTT, il reste un point : dans Home Assistant, ces entités sont souvent classées “diagnostic”, donc elles peuvent être créées mais désactivées automatiquement.
Pour que chaque nouvel appareil Zigbee ajouté arrive directement “prêt à superviser”, j’ajoute ceci dans /config/zigbee2mqtt/configuration.yaml :
device_options:
homeassistant:
last_seen:
enabled_by_default: true
linkquality:
enabled_by_default: true
Puis je redémarre Zigbee2MQTT.
Ce réglage aide surtout les nouveaux appareils (ou les appareils redécouverts).
Pour les devices déjà présents, il faut souvent activer manuellement les entités correspondantes dans Home Assistant.
Le “risque” n’est pas tellement Zigbee2MQTT (il ajoute juste un champ timestamp dans les messages), mais plutôt Home Assistant si on enregistre chaque update de last_seen dans la base : ça peut générer beaucoup d’écritures avec beaucoup de capteurs.
Mon choix : je veux voir ces valeurs partout, mais je n’ai pas besoin de graphes minute par minute. J’exclus donc ces entités du recorder.
/config/recorders.yamlrecorder:
exclude:
entity_globs:
- sensor.*_last_seen
- sensor.*_linkquality
Après ça, je redémarre Home Assistant : les valeurs restent visibles en temps réel, mais je limite fortement la création d’historique inutile.
Je ne voulais pas “une entité perdue dans une liste” : je voulais une supervision visuelle, immédiatement lisible.
Principe :
J’utilise la magie de la carte decluttering_templates que j’avais décrite dans cette page il y a 3 ans :
Ainsi decluttering_templates + custom:decluttering-card pour réutiliser le même composant partout, en ne changeant que 4 variables.
Je défini tout simplement 4 éléments qui sont différents pour chaque appareils :
type: picture-elements
image: /local/maison/1920x1000/off_0800.png
elements:
- type: custom:decluttering-card
template: linkquality
variables:
- zone: sensor.lumiere_chambre_parents
- top: 20%
- left: 35%
- router: 1
- type: custom:decluttering-card
template: linkquality
variables:
- zone: sensor.fenetre_de_la_chambre_des_parents
- top: 15%
- left: 37%
- router: 0
linkquality (le “gros morceau”)decluttering_templates:
linkquality:
default:
- top: 5%
- left: 95%
- router: 0
element:
type: custom:button-card
entity: |
[[[
return `[[zone]]_linkquality`;
]]]
show_icon: false
name: |
[[[
return '[[zone]]'
.replace(/^sensor\./i, '')
.replace(/_/g, ' ')
.trim();
]]]
show_state: true
show_units: false
custom_fields:
lastseen: |
[[[
const obj = states[`[[zone]]_last_seen`];
if (!obj || !obj.state || obj.state === 'unavailable') return '!!';
const last = new Date(obj.state);
if (isNaN(last.getTime())) return '!!';
const now = new Date();
const seconds = Math.floor((now - last) / 1000);
if (seconds < 60) return `${seconds}s`;
const minutes = Math.floor(seconds / 60);
if (minutes < 60) return `${minutes}m`;
const hours = Math.floor(minutes / 60);
if (hours < 24) return `${hours}h`;
const days = Math.floor(hours / 24);
return `${days}d`;
]]]
styles:
card:
- border: |
[[[ return ([[router]] == 1) ? '2px solid black' : 'none'; ]]]
- box-shadow: none
- position: relative
- border-radius: 8px
- min-width: 100px
- height: 45px
- display: flex
- flex-direction: column
- justify-content: center
- align-items: center
- color: white
name:
- font-size: 10px
- line-height: '1'
- padding: 0
- margin: 0
- text-align: center
- color: white
- flex: 1
- max-width: 95px
- word-wrap: break-word
- overflow: hidden
- white-space: normal
state:
- font-size: 15px
- font-weight: bold
- line-height: '1'
- padding: 0
- margin: 0
- text-align: center
- color: white
- flex: 1
custom_fields:
lastseen:
- position: absolute
- bottom: 0px
- right: 0px
- font-size: 10px
- color: black
- padding: 2px 4px
- border-radius: 4px
- box-shadow: 0 1px 3px rgba(0,0,0,0.3)
- background: |
[[[
const obj = states[`[[zone]]_last_seen`];
if (!obj || !obj.state) return 'rgba(128,128,128,0.5)';
const last = new Date(obj.state);
const now = new Date();
const seconds = Math.floor((now - last) / 1000);
if (seconds < 1200) return 'rgba(0,255,0,0.9)'; // Vert <20min
if (seconds < 1800) return 'rgba(255,255,0,0.9)'; // Jaune 20-30min
if (seconds < 7200) return 'rgba(255,165,0,0.9)'; // Orange <2h return 'rgba(255,0,0,0.9)'; // Rouge >2h
]]]
state:
- value: unavailable
styles:
card:
- background: rgba(255,0,0,0.3)
- operator: '>'
value: 200
styles:
card:
- background: rgba(0,180,0,0.3)
- operator: '>'
value: 150
styles:
card:
- background: rgba(34,255,34,0.3)
- operator: '>'
value: 130
styles:
card:
- background: rgba(255,255,0,0.3)
- operator: '>='
value: 80
styles:
card:
- background: rgba(255,165,0,0.3)
- operator: '<'
value: 80
styles:
card:
- background: rgba(255,107,53,0.3)
style:
top: '[[top]]'
left: '[[left]]'
Ce template définit un modèle unique de carte que tu réutilises pour tous tes appareils Zigbee, en ne changeant que la variable [[zone]].
La propriété entity est construite dynamiquement en JavaScript ([[[ … ]]]) pour pointer vers l’entité [[zone]]_linkquality, ce qui permet d’afficher automatiquement la qualité de lien du device (valeur LQI remontée par Zigbee2MQTT ou ZHA).
Le name est lui aussi généré côté client : on retire le préfixe sensor. puis on remplace les _ par des espaces et on fait un trim(), ce qui produit un libellé lisible à partir de l’ID de l’entité.
Le champ personnalisé lastseen lit l’entité [[zone]]_last_seen dans states[], convertit sa valeur en objet Date, puis calcule la différence avec l’heure actuelle pour afficher un temps relatif (s, m, h, d). Si la valeur est vide, unavailable ou une date invalide, il affiche !! au lieu de laisser apparaître une valeur incohérente.
Le style du badge lastseen en bas à droite utilise une fonction JavaScript qui renvoie une couleur RGBA différente selon l’âge de la dernière communication (gris si pas de valeur, puis vert → jaune → orange → rouge en fonction du nombre de secondes écoulées), ce qui encode visuellement la fraîcheur des données.
La section state: du button-card définit plusieurs seuils sur la valeur de LinkQuality : indisponible, puis tranches >200, >150, >130, >=80, <80, chacune appliquant un fond coloré spécifique à la carte, ce qui transforme une valeur numérique en indicateur de qualité radio immédiatement lisible.
Les propriétés de mise en forme (flex, min-width, height, border-radius, position absolute du badge, etc.) assurent un rendu compact et uniforme, avec une bordure noire optionnelle quand [[router]] == 1 pour identifier visuellement les routeurs Zigbee par rapport aux simples terminaux.
type: picture-elements
image: /local/maison/1920x1000/off_0800.png
elements:
- type: custom:mod-card
card:
type: entities
title: Zigbee2MQTT
show_header_toggle: false
entities:
- entity: switch.zigbee2mqtt_bridge_permit_join
name: Autoriser inclusion
- entity: button.zigbee2mqtt_bridge_restart
name: Redémarrer
- entity: select.zigbee2mqtt_bridge_log_level
name: Niveau de log
- entity: binary_sensor.zigbee2mqtt_bridge_connection_state
name: État de connexion
- type: custom:template-entity-row
name: Lancé depuis
state: >
{% set e = states.binary_sensor.zigbee2mqtt_bridge_connection_state
%} {% if e is not none and e.state not in ['unavailable', 'unknown']
%}
{{ ((now() - e.last_changed).total_seconds() / 3600) | round(1) }} h
{% else %}
Non disponible
{% endif %}
- entity: sensor.zigbee2mqtt_bridge_coordinator_version
name: Version coordinateur
- entity: sensor.zigbee2mqtt_bridge_version
name: Version Zigbee2MQTT
- entity: sensor.nombre_de_capteurs_linkq_en_erreur
name: Injoignables
icon: mdi:alert-circle
- entity: sensor.nombre_de_capteurs_linkq
name: Total
icon: mdi:devices
- entity: sensor.zigbee_linkquality_moyenne
name: Moyenne LinkQuality
icon: mdi:signal
style:
top: 35%
left: 75%
width: 450px
Ce capteur s’ajoute dans le fichier templates.yaml, voici son code :
- name: "zigbee_linkquality_moyenne"
unique_id: zigbee_linkquality_moyenne
unit_of_measurement: "LQI"
state_class: measurement
state: >-
{% set linkqualities = states.sensor
| selectattr('entity_id', 'search', '_linkquality')
| selectattr('state', 'is_number')
| map(attribute='state') | map('float') | list %}
{% if linkqualities | length > 0 %}
{{ (linkqualities | sum / linkqualities | length) | round(1) }}
{% else %} 0 {% endif %}
- name: "Nombre de capteurs Linkq"
unique_id: sensor.nombre_capteurs_linkq
state: >-
{% set lq_sensors = states.sensor
| selectattr('entity_id', 'search', '_linkquality$')
| list %}
{{ lq_sensors | count }}
icon: mdi:signal-variant
unit_of_measurement: "capteurs"
- name: "Nombre de capteurs Linkq en erreur"
unique_id: sensor.nombre_capteurs_linkq_erreur
state: >-
{% set lq_sensors = states.sensor
| selectattr('entity_id', 'search', '_linkquality$')
| selectattr('state', 'in', ['unavailable', 'unknown', 'None'])
| list %}
{{ lq_sensors | count }}
icon: mdi:alert-circle
unit_of_measurement: "capteurs"
Tout d’abord ce template pour afficher xx en erreur / yy au total
- name: "zigbee_injoignables_synthese"
unique_id: sensor.zigbee_injoignables_synthese
state: >-
{{ states('sensor.nombre_de_capteurs_linkq_en_erreur') }}/{{ states('sensor.nombre_de_capteurs_linkq') }}
icon: mdi:alert-circle
Et dans mon picture-elements, j’ajoute :
- type: conditional
conditions:
- condition: state
entity: sensor.nombre_de_capteurs_linkq_en_erreur
state_not: "0"
elements:
- type: custom:button-card
entity: sensor.zigbee_injoignables_synthese
icon: mdi:zigbee
show_name: false
show_state: true
style:
top: 5%
left: 5%
transform: translate(-50%, -50%)
styles:
state:
- color: red
- font-weight: 700
- font-size: 16px
icon:
- color: red
- width: 20px
- height: 20px
card:
- border-radius: 999px
- padding: 4px 6px
- background: transparent
- box-shadow: none
Ce bloc sert à afficher un petit indicateur rouge « Zigbee en erreur » sur le dashboard plan uniquement quand il y a au moins un capteur problématique.
C’est un élément conditional dans une carte picture-elements : il ne montre son contenu que si sensor.nombre_de_capteurs_linkq_en_erreur est différent de « 0 » (donc si au moins un capteur est injoignable ou en erreur de LinkQuality).
Quand la condition est vraie, il affiche un custom:button-card basé sur sensor.zigbee_injoignables_synthese, qui contient probablement un texte du style « 3 en erreur » ou similaire.
Le bouton est placé en haut à gauche du plan (5 % / 5 %), centré grâce au transform: translate(-50%, -50%), avec un fond transparent et sans ombre pour ne garder que l’icône Zigbee et le texte.
L’icône Zigbee et l’état sont stylés en rouge, en gras et en taille 16 px, avec un border-radius: 999px pour donner un aspect de pastille/étiquette, ce qui en fait un avertissement visuel discret mais bien visible tant qu’il existe des capteurs en erreur.
Pour avoir d’un coup d’œil la liste des équipements en erreur, voici les codes nécessaires.
La déclaration des templates
- name: "Nombre de capteurs Linkq en erreur"
unique_id: sensor.nombre_capteurs_linkq_erreur
state: >-
{% set lq_sensors = states.sensor
| selectattr('entity_id', 'search', '_linkquality$')
| selectattr('state', 'in', ['unavailable', 'unknown', 'None'])
| list %}
{{ lq_sensors | count }}
icon: mdi:alert-circle
unit_of_measurement: "capteurs"
- name: "Liste capteurs Linkquality en erreur"
unique_id: sensor.liste_capteurs_linkquality_erreur
state: >-
{% set lq_sensors = states.sensor
| selectattr('entity_id', 'search', '_linkquality$')
| selectattr('state', 'in', ['unavailable', 'unknown', 'None'])
| map(attribute='entity_id')
| map('regex_replace', 'sensor\\\\\\\\.(.*)_linkquality$', '\\\\\\\\1')
| list %}
{% set count = lq_sensors | length %}
{% if count == 0 %}
Aucun
{% elif count <= 5 %}
{{ lq_sensors | join(', ') }}
{% else %}
{{ lq_sensors[:5] | join(', ') ~ ' + ' ~ count }}
{% endif %}
attributes:
count: >-
{% set lq_sensors = states.sensor
| selectattr('entity_id', 'search', '_linkquality$')
| selectattr('state', 'in', ['unavailable', 'unknown', 'None'])
| map(attribute='entity_id')
| map('regex_replace', 'sensor\\\\\\\\.(.*)_linkquality$', '\\\\\\\\1')
| list %}
{{ lq_sensors | length }}
full_list: >-
{% set lq_sensors = states.sensor
| selectattr('entity_id', 'search', '_linkquality$')
| selectattr('state', 'in', ['unavailable', 'unknown', 'None'])
| map(attribute='entity_id')
| map('regex_replace', 'sensor\\\\\\\\.(.*)_linkquality$', '\\\\\\\\1')
| list %}
{{ lq_sensors | join(', ') | default('Aucun') }}
icon: mdi:alert-circle
Et sur le Dasboard, toujours dans le picture-elements
type: picture-elements
image: /local/maison/1920x1000/off_0800.png
elements:
- type: custom:mod-card
card:
type: entities
title: Capteurs Zigbee en erreur
entities:
- type: custom:template-entity-row
entity: sensor.liste_capteurs_linkquality_en_erreur
name: Liste
state: >
{% set s = states('sensor.liste_capteurs_linkquality_en_erreur')
%} {% if s not in ['unknown', 'unavailable', ''] %}
{{ s.replace(',', '\\\\n') }}
{% else %}
Aucun
{% endif %}
style:
top: 80%
left: 75%
width: 450px
advanced: last_seen: ISO_8601_local
device_options:
homeassistant:
last_seen:
enabled_by_default: true
linkquality:
enabled_by_default: true
recorder:
exclude:
entity_globs:
- sensor.*_last_seen
- sensor.*_linkquality
Cette discussion (si elle est encore ouverte) est disponible :
Je décide un jour d’intégrer mes appareils Withings – ma balance connectée et mon tensiomètre – directement dans Home Assistant pour suivre ma santé en temps réel dans ma domotique.
En tant que débutant, vous vous demandez peut-être : « Comment faire pour que ma balance communique avec mon système domotique ? »
Pas de panique, je vous raconte étape par étape cette aventure comme si vous étiez à mes côtés, en expliquant chaque clic et chaque raison.
Je commence par ouvrir Home Assistant sur mon navigateur. J’accède aux Paramètres > Appareils et services > Intégrations > Ajouter une intégration.
Dans la barre de recherche, je tape « Withings » et je sélectionne l’intégration officielle.
Home Assistant me demande alors un Client ID et un Client Secret – des codes secrets que je vais obtenir chez Withings.
C’est comme s’inscrire à un club exclusif pour que les deux systèmes puissent discuter.
Avant de plonger tête la première, je lis la documentation fournie par Home Assistant.
Elle m’indique précisément où obtenir ces fameuses clés : sur le portail développeur de Withings.
Pour un débutant, c’est crucial – imaginez-vous essayer d’ouvrir une porte sans clé ! La doc est claire : direction le dashboard développeur Withings.
Je clique sur le lien et atterris sur la page d’accueil du développeur. Je sélectionne Public Cloud car c’est le mode pour les intégrations comme Home Assistant – pas besoin de serveur privé compliqué. Ensuite, je me connecte avec mon compte Withings personnel, celui lié à mes appareils de santé.
Une fois connecté, je clique sur Créer une nouvelle application. Je remplis le formulaire avec des infos basiques :
Je valide la création. Withings génère alors mon Client ID (public) et Client Secret (secret, à ne jamais partager !).
Le bouton « Test » peut afficher une erreur à ce stade – c’est normal.
De retour dans Home Assistant, je colle le Client ID et le Client Secret dans les champs de l’intégration.
Je valide. Immédiatement, ça me redirige vers Withings pour autoriser l’accès.
Par défaut, Withings essaie de revenir sur http://homeassistant.local:8123, mais ce lien local n’est pas accessible depuis les serveurs Withings (qui sont loin de chez moi). J’obtiens une erreur classique :
Je retourne dans mon app Withings, j’édite l’URL de redirection pour utiliser mon accès externe via Nabucasa
Je sauvegarde et je recommence la config. Victoire !
Une fois connecté, Home Assistant détecte automatiquement mes appareils : « Mes données », « Ma balance » et « Mon tensiomètre ».
Chacun apparaît comme un capteur avec poids, tension artérielle, batterie, etc.
Je renomme pour plus de clarté : « Santé Lionel » pour mes données globales, « Balance » et « Tensiomètre ».
Notez que la balance et le tensiomètre n’ont souvent qu’un seul capteur utile : la batterie.
Pour la famille, j’ajoute les profils : ma fille indépendante (profil séparé >16 ans), mon autre fille (<16 ans) sur mon compte, et celui de ma femme.
Home Assistant liste tout proprement.
Attention : les batteries peuvent générer des doublons inutiles, j’ai désactivé ces capteurs pour éviter les spams de données.
Dès que je trouve comment faire…🤣simplement.
Si vous bloquez, la communauté aide :
Maintenant, mes données santé s’affichent en direct dans Home Assistant – prêt pour des automatisations fun comme des alertes si mon poids décolle !
J’ai besoin de surveiller ma maison contre les risques d’incendie dès l’apparition des premières fumées.
Le détecteur de fumée Zigbee Nous E8 est idéal pour cette mission, il fait partie des 3 équipements Zigbee de la gamme grand public. Pour arriver à les départager, j’ai réaliser un comparatif :
Les données du E8 permettent des alertes précises dans Zigbee2MQTT et Home Assistant, comme des sirènes, des notifications push et une ventilation automatique.
La sécurité de ma maison est ainsi renforcée de manière simple et efficace.
Cet appareil respecte les normes européennes EN14604 pour les détecteurs de fumée autonomes (DAAF), ainsi que les certifications CE et RoHS, garantissant sa conformité aux standards de sécurité européens.
Le détecteur de fumée photoélectrique Nous E8 home ZigBee détecte un incendie en repérant la fumée dans l’air et déclenche une alarme sonore et lumineuse dès qu’un certain seuil de concentration est atteint. Il est conçu pour les bâtiments résidentiels et sa chambre de détection à source unique est protégée contre les faux positifs causés par la poussière, les insectes ou l’humidité.
La conception interne de type « labyrinthe » permet une détection d’incendie rapide, tout en limitant les déclenchements intempestifs. Le boîtier est en plastique ignifuge avec une finition brillante. Lire la suite
Aujourd’hui, je vous emmène dans mon aventure, étape par étape, à travers la dernière gamme de modules Sonoff Zigbee sortie fin 2025. Qu’est-ce que c’est que ces « modules Sonoff Zigbee » ? Laissez-moi tout expliquer depuis le début, comme si on était assis autour d’une table avec un café.
Imaginez : vous avez un interrupteur mural banal qui allume votre lampe de salon. Avec un de ces modules, cet interrupteur devient intelligent. Vous pouvez l’allumer depuis votre smartphone, dire « Alexa, éteins la cuisine », ou programmer « s’éteint auto après 5 minutes si oublié ». Pas de câbles partout, pas de WiFi qui rame : c’est du Zigbee, une radio spéciale domotique super stable (comme le WiFi mais dédiée, portée 10 à 30 mètres par module, et ça s’étend automatiquement en « mesh » – chaque module relaie le signal des autres, comme une chaîne d’amis qui passent le mot).
Ces modules sont des petits boîtiers électroniques (39 mm de long, 45 mm de large, 17 mm d’épaisseur). Vous les cachez derrière votre interrupteur existant, sans changer le bouton visible ni refaire l’électricité. Ils coûtent entre 15 et 25 euros pièce, se vissent en 10 minutes (deux vis, fils phase/noire + neutre/bleu ou pas selon modèle), et marchent avec Home Assistant (HA, logiciel gratuit sur un mini-PC ou Raspberry Pi qui centralise toute votre maison smart).
French 
English 
Spanish 
Chinese 
German