Système d'alarme Gladys

Bonjour,

Après quelques jours d’utilisation, voici mon retour concernant la gestion du système d’alarme dans Gladys.

J’utilise plusieurs détecteurs et appareils pour mon système d’alarme :

  • environ 15 détecteurs d’ouverture
  • 4 détecteurs de mouvement zigbee
  • 1 clavier à code Zigbee ( le frient keyzb-110 )
  • 4 caméras
  • 1 FP2 aqara directement sur HomeKit

Actuellement il est possible de créer un système d’alarme sur Gladys en combinant les scènes, les déclencheurs et les détecteurs.
Cependant, après avoir utilisé Alarmo sous Home Assistant, je trouve qu’il manque aujourd’hui dans Gladys une véritable couche dédiée à la gestion d’un système d’alarme.

Le système actuel me semble très jeune et améliorable.

Le principal problème est que l’alarme est actuellement constituée de plusieurs automatisations indépendantes

Dans Gladys, on peut créer des scènes pour :

  • activer l’alarme en mode absence ;

  • activer l’alarme partiellement ;

  • désactiver l’alarme ;

  • déclencher une sirène ou une action lorsqu’un capteur détecte quelque chose ;

  • envoyer une notification ;

  • gérer éventuellement un délai d’entrée ou de sortie.

Cela fonctionne, mais toute la logique doit être construite manuellement : c’est long, fastidieux et possiblement générateur d’erreurs.

Le système ne possède pas réellement une logique dédiée.

A l’image d’Alarmo, j’aimerais disposer de véritables à états qui permettrait automatiquement de gérer des actions depuis une interface Alarme :

  • Désarmée

  • Armement en cours

  • Armée absence

  • Armée nuit

  • Armée présence

  • Délai d’entrée

  • Alarme déclenchée

Cette différence devient importante dès que l’installation commence à avoir plusieurs capteurs ou plusieurs modes d’armement.

Point important, il n’existe pas de mode le mode nuit et ce mode me manque terriblement :sob:

L’existence de ce mode nuit de l’alarme dans HomeKit me manque aussi.
Les modes disponibles sont : Au domicile, Absent et Désactivée.

En cas de déclenchement, je n’ai qu’un notification par télégram. Je n’ai plus d’alerte urgente sur HomeKit.

Gestion des capteurs par mode

Un autre point très pratique dans Alarmo est la possibilité de définir quels capteurs participent à chaque mode.

Par exemple :

Mode absence

  • portes ;

  • fenêtres ;

  • détecteurs de mouvement ;

  • garage.

Mode nuit

  • portes ;

  • fenêtres ;

  • garage ;

  • mais pas les détecteurs de mouvement intérieurs.

Mode présence

  • uniquement certaines ouvertures ou zones périphériques.

Dans Gladys, cette logique doit généralement être reproduite dans plusieurs scènes.

Cela entraîne rapidement de la duplication, rend les modifications plus difficiles et multiplie le risque d’erreurs.

Si j’ajoute un détecteur ou si je change le comportement d’une zone, je dois vérifier plusieurs scènes.

Gestion des délais d’entrée et de sortie

Pour une véritable alarme, certains capteurs doivent pouvoir avoir un comportement spécifique.

Par exemple :

Une ouverture de porte d’entrée lorsque l’alarme est active ne devrait pas forcément déclencher immédiatement la sirène.

Elle devrait pouvoir lancer un délai d’entrée de 30 secondes, permettant de saisir un code sur un clavier.

De la même manière, lors de l’activation de l’alarme, il faudrait pouvoir avoir un délai de sortie avant que les capteurs deviennent actifs.

Cette logique peut être créée avec des scènes, mais elle devient rapidement complexe.

Gestion des claviers

J’utilise par exemple un clavier Zigbee permettant :

  • armement total ;

  • armement nuit ;

  • désarmement ;

  • code PIN ;

  • lecture badge RFID.

Aujourd’hui, la logique entre le clavier et Gladys doit être construite manuellement, j’ai commencé cette construction dans Node Red mais je regrette que cette fonction ne soit pas intégrée à Gladys.

Une intégration alarme pourrait permettre d’avoir un socle :

Clavier → commande d’alarme → validation du code → changement d’état

Le clavier ne serait alors qu’une interface parmi d’autres.

On pourrait très bien avoir simultanément :

  • un ou plusieurs clavier Zigbee ;

  • l’application Gladys ;

  • des boutons bouton physique ;

  • un lecteur de badges

  • des scènes ;

  • API ;

  • un webhook.

Tous piloteraient le même système d’alarme.

Validation avant armement

Un autre comportement très utile serait la vérification de l’état des capteurs avant d’armer l’alarme.

Par exemple :

Impossible d’activer l’alarme : fenêtre de la cuisine ouverte.

Avec éventuellement la possibilité de :

  • annuler l’armement ;

  • ignorer temporairement le capteur ;

  • forcer l’armement.

C’est particulièrement pratique dans une maison ayant beaucoup de détecteurs d’ouverture.

Gestion des zones

Il pourrait également être intéressant d’introduire une notion de zone d’alarme.

Par exemple :

  • Maison

  • Garage

  • Extérieur

Chaque zone pourrait contenir plusieurs capteurs.

Cela permettrait ensuite de définir simplement :

Mode nuit = Maison périphérique + Garage

ou :

Mode absence = Toutes les zones

Centralisation de la configuration

Pour moi, le principal avantage d’une fonctionnalité dédiée serait d’avoir une page :

Gladys → Alarme

avec par exemple :

État

  • Désarmée

  • Armée

  • Délai d’entrée

  • Déclenchée

Modes

  • Absence

  • Nuit

  • Présence

Capteurs

  • Porte entrée

  • Fenêtre cuisine

  • Mouvement salon

  • Porte garage

Sirènes

Claviers

Délais

Notifications

Codes utilisateurs

Toute la logique serait ainsi centralisée.

Les scènes Gladys pourraient ensuite simplement exploiter les événements de l’alarme.

Par exemple :

Quand l’alarme passe à « déclenchée » → allumer les lumières + lancer la sirène + envoyer une notification.

Les scènes resteraient extrêmement utiles

L’idée ne serait surtout pas de remplacer le système de scènes de Gladys.

Le composant Alarme gérerait uniquement la logique métier :

  • états ;

  • capteurs ;

  • zones ;

  • délais ;

  • validation ;

  • codes.

Les scènes resteraient responsables des actions autour de l’alarme :

  • notifications ;

  • éclairage ;

  • TTS ;

  • caméras ;

  • sirènes supplémentaires ;

  • fermeture de volets ;

  • etc.

Cela permettrait de conserver toute la flexibilité actuelle de Gladys tout en évitant de devoir reconstruire toute la logique d’une centrale d’alarme dans les scènes.

Exemple concret

Aujourd’hui, pour mon installation, j’ai notamment dû construire une partie de cette logique avec Node-RED afin de gérer correctement mon clavier Zigbee et les différents modes d’alarme.

Cela fonctionne, mais je trouve dommage d’avoir besoin d’une solution externe pour une fonction qui me semble indispensable pour une solution domotique.

Idéalement, Node-RED devrait être utilisé pour des comportements très spécifiques, pas pour maintenir l’état d’une alarme.


Je pense qu’une solution inspirée d’Alarmo serait particulièrement intéressante pour Gladys, sans forcément chercher à reproduire exactement son fonctionnement.

Cela pourrait éventuellement prendre la forme :

  • d’un nouveau service Gladys ;

  • d’une fonctionnalité native ;

  • ou d’une intégration externe dans un premier temps.

Personnellement, je serais très intéressé pour participer aux réflexions, aux tests et éventuellement au développement d’une première intégration.

Je serais également curieux de savoir comment vous gérez vos systèmes d’alarme.

Utilisez-vous uniquement les scènes ?
Avez-vous développé votre propre solution ?
Utilisez-vous NodeRed ou un autre système externe ?

Que pensez vous de cette fonctionnalité « centrale d’alarme » dans Gladys ?
Est-ce que ça vous sembleutile ?

Je vous remercie d’avoir prit le temps de me lire :grinning_face:

De mon côté mon système d’alarme est depuis plusieurs années gérée par la centrale Myfox Control, rachetée depuis par Somfy. Elle avait à l’époque les avantages que tu évoques : facile à configurer, avec une logique de surveillance /on/off/nuit très simple. Mais elle n’a que peu de souplesse, et les capteurs coûtaient chers et sont maintenant introuvables sauf d’occasion…

Bref, je basculerais bien sur une surveillance basée sur Gladys. Mais j’avais testé le mode alarme sans être satisfait, en gros pour les mêmes raisons que toi.

Donc je rejoins la demande que tu exprimes :+1:

Je pense que tu peux changer la catégorie de ton sujet en « demande de fonctionnalités », et je voterai pour :wink:

Aujourd’hui je passe par les scenes et des tablettes murales.

Pour moi le mode nuit cest mon alarme partielle qui se déclenche sur les ouvertures de portes pas les capteurs de mouvement.

Mon clavier cest celui de gladys en mode tablettes.

Jai un timing de 15/30 secondes apres l’ouverture dune porte pour désactiver mon système. Mais tout est géré par gladys de mon côté. Je confirme néanmoins que cest sources d’erreur au moment de la mise en place. Mais je testais au fur et a mesure.

Jai des scènes qui en appel dautre etc mais cest une idée de ce qui a été fais a l’époque

Je vous rejoins sur certains points.

Je vais essayer de créer les Demandes de fonctionnalités liées et on développera selon l’importance et la facilité de chaque demande.

Est-ce que vous pourrez les compléter pour préciser le besoin ?

Bonjour @cicoub13.
J’ai demandé à Codex de m’aider à organiser les besoins.
Est-ce que ça répond à ta demande de précision ?

F01 État centralisé de l’alarme

Problème actuel

L’état d’un système d’alarme complexe doit actuellement être reproduit au travers de scènes, variables ou états intermédiaires.

Cela entraîne :

  • une duplication de logique ;

  • une difficulté à connaître l’état réel de l’alarme ;

  • une multiplication des scènes ;

  • une difficulté à gérer les transitions ;

  • un risque d’incohérence entre plusieurs moyens de commande.

Besoin

Gladys doit disposer d’un état d’alarme centralisé, utilisable par :

  • l’interface ;

  • les scènes ;

  • l’API ;

  • les intégrations.

États proposés

DISARMED
ARMING
ARMED
PENDING
TRIGGERED

Le mode d’armement est séparé de l’état :

HOME
NIGHT
AWAY

Exemple :

state = ARMED
mode = NIGHT

Transitions principales

DISARMED
    │ arm(NIGHT)
    ▼
ARMING
    │ délai sortie terminé
    ▼
ARMED
    │ capteur déclenché
    ▼
PENDING
    │ délai entrée terminé
    ▼
TRIGGERED
    │ disarm()
    ▼
DISARMED

Une détection sans délai peut passer directement de ARMED à TRIGGERED.

Actions attendues

  • Arm

  • Disarm

  • Trigger

  • Cancel pending

Critères d’acceptation

  • Un système d’alarme possède toujours un état unique.
  • L’état survit au redémarrage de Gladys.
  • Toutes les commandes passent par la même logique.
  • Les transitions sont disponibles pour les scènes.
  • L’API permet de lire l’état.
  • L’API permet l’armement et le désarmement.

Dépendance : aucune.


F02 Modes Absence / Nuit / Présence

Problème actuel

Une alarme domestique ne fonctionne pas uniquement en mode activé/désactivé.

L’utilisateur doit pouvoir protéger différemment son logement selon qu’il est :

  • absent ;

  • présent ;

  • en train de dormir.

Besoin

Ajouter trois modes standards :

Mode Signification
HOME Présence
NIGHT Nuit
AWAY Absence

Comportement attendu

Lors de l’armement :

Arm → Away
Arm → Night
Arm → Home

L’état central devient par exemple :

state = ARMED
mode = NIGHT

Interface

Le widget d’alarme pourrait proposer :

ALARME

● Désarmée

[ Présence ] [ Nuit ] [ Absence ]

Une fois armée :

ALARME

● Activée
Mode : Nuit

[ Désarmer ]

Critères d’acceptation

  • Les trois modes peuvent être sélectionnés indépendamment.
  • Le mode courant est consultable.
  • Une scène peut connaître le mode actif.
  • Une scène peut demander un mode d’armement.
  • L’API expose le mode.

Dépendance : F01.


F03 Affectation des capteurs aux modes

Problème actuel

Tous les capteurs ne doivent pas déclencher l’alarme dans tous les modes.

Un détecteur de mouvement du salon doit, par exemple, fonctionner en mode Absence, mais généralement pas en mode Nuit.

Besoin

Permettre d’associer chaque capteur à un ou plusieurs modes.

Exemple

Capteur Présence Nuit Absence
Porte entrée :white_check_mark: :white_check_mark: :white_check_mark:
Fenêtre séjour :white_check_mark: :white_check_mark: :white_check_mark:
Mouvement séjour :cross_mark: :cross_mark: :white_check_mark:
Mouvement couloir :cross_mark: :cross_mark: :white_check_mark:
Porte garage :white_check_mark: :white_check_mark: :white_check_mark:

Règle métier

Capteur change d’état
        │
        ▼
Alarme ARMED ?
        │
       Oui
        ▼
Capteur actif pour le mode ?
        │
       Oui
        ▼
Traiter l’intrusion

Sinon, l’événement est ignoré par le moteur d’alarme.

Critères d’acceptation

  • Un équipement Gladys existant peut devenir capteur d’alarme.
  • Un capteur peut appartenir à plusieurs modes.
  • Une modification ne nécessite pas de recréer les scènes.
  • Un capteur désactivé pour le mode courant ne déclenche pas l’alarme.

Dépendances : F01 + F02.


F04 Délais d’entrée et de sortie

Problème actuel

Une alarme doit permettre à l’utilisateur :

  • de quitter la maison après l’armement ;

  • d’entrer dans la maison avant de devoir désarmer l’alarme.

Besoin

Ajouter :

  • Exit delay — délai de sortie ;

  • Entry delay — délai d’entrée.

Délai de sortie

Exemple :

Arm Away
    │
    ▼
ARMING
    │
  30 secondes
    ▼
ARMED

Pendant ce délai, les capteurs ne provoquent pas d’intrusion.

Délai d’entrée

Le délai doit idéalement pouvoir être défini par capteur.

Capteur Délai
Porte entrée 30 s
Porte garage 45 s
Fenêtre Immédiat
Mouvement salon Immédiat

Une porte temporisée provoque :

ARMED
   │
   ▼
PENDING
   │
 30 s
   ▼
TRIGGERED

Si l’utilisateur désarme pendant les 30 secondes :

PENDING → DISARMED

Critères d’acceptation

  • Délai de sortie configurable.
  • Délai d’entrée configurable.
  • Possibilité de déclenchement immédiat.
  • Annulation du compte à rebours au désarmement.
  • Les changements ARMING et PENDING sont utilisables dans les scènes.

Dépendances : F01 + F03.


F05 Vérification avant armement et bypass

Problème actuel

Il est possible de demander l’activation alors qu’une porte ou une fenêtre est déjà ouverte.

Besoin

Avant l’armement, Gladys vérifie tous les capteurs concernés.

Exemple :

Impossible d'activer l'alarme

2 ouvertures détectées :

• Fenêtre cuisine
• Porte garage

[ Annuler ]
[ Réessayer ]
[ Ignorer les capteurs ouverts ]

Bypass

Un capteur ignoré devient temporairement :

BYPASSED

Le bypass disparaît automatiquement au prochain désarmement.

Sécurité

Le bypass doit être clairement visible :

ALARME

● Activée — Absence

⚠️ 1 capteur ignoré

Fenêtre cuisine

Critères d’acceptation

  • Vérification avant armement.
  • Liste des capteurs problématiques.
  • Possibilité de refuser l’armement.
  • Possibilité de bypass temporaire.
  • Suppression du bypass au désarmement.
  • Événement de bypass disponible pour les scènes et le journal.

Dépendances : F01 + F03.


F06 Intégration complète avec les scènes Gladys

Objectif

Le moteur d’alarme doit gérer la sécurité, puis laisser les scènes Gladys décider des conséquences.

Déclencheurs proposés

  • Alarme : armement demandé

  • Alarme : armée

  • Alarme : délai d’entrée démarré

  • Alarme : déclenchée

  • Alarme : désarmée

  • Alarme : capteur bypassé

Avec des informations contextuelles :

mode
sensor
room
timestamp
user

Actions proposées

Dans une scène :

Alarme → Armer → Absence
Alarme → Armer → Nuit
Alarme → Armer → Présence
Alarme → Désarmer

Exemple

QUAND
    Alarme déclenchée

SI
    Mode = Absence

ALORS
    → activer sirène
    → allumer éclairage
    → envoyer notification
    → lancer scène caméra

Critères d’acceptation

  • Chaque transition importante peut déclencher une scène.
  • Une scène peut armer/désarmer.
  • Le mode est disponible dans le contexte.
  • Le capteur ayant déclenché l’événement est identifiable.
  • Aucun comportement sirène/TTS/caméra n’est imposé par le moteur.

Dépendance : F01.


F07 Zones d’alarme

Problème

Configurer individuellement plusieurs dizaines de capteurs devient rapidement difficile.

Besoin

Permettre de regrouper les capteurs en zones logiques.

Exemple

Périmètre
├── Porte entrée
├── Fenêtre cuisine
└── Fenêtre séjour

Intérieur
├── Mouvement séjour
└── Mouvement couloir

Garage
├── Porte garage
└── Mouvement garage

Les modes peuvent ensuite utiliser les zones :

Zone Présence Nuit Absence
Périmètre :white_check_mark: :white_check_mark: :white_check_mark:
Intérieur :cross_mark: :cross_mark: :white_check_mark:
Garage :white_check_mark: :white_check_mark: :white_check_mark:

Critères d’acceptation

  • Création/modification/suppression d’une zone.
  • Ajout de plusieurs capteurs.
  • Une zone peut être utilisée par plusieurs modes.
  • L’origine exacte d’une intrusion reste identifiable.

Dépendance : F03.


F08 Codes PIN utilisateurs

Objectif

Permettre une authentification indépendante du périphérique utilisé.

Le PIN appartient donc à Gladys / à l’utilisateur, et non au clavier Zigbee.

Exemple

Quentin
PIN : ••••

Droits :
✓ Armer
✓ Désarmer
Invité
PIN : ••••

Droits :
✓ Désarmer

Validité :
08/09 → 15/09

Fonctionnalités

Prévoir :

  • PIN individuel ;

  • activation/désactivation ;

  • éventuellement une date de validité ;

  • identification de l’utilisateur ayant désarmé ;

  • possibilité future de permissions différentes.

Sécurité

:warning: Les PIN ne doivent jamais être stockés ou journalisés en clair.

Critères d’acceptation

  • Plusieurs PIN possibles.
  • Un PIN correspond à un utilisateur.
  • Vérification centralisée par Gladys.
  • PIN révocable.
  • PIN temporaire possible à terme.
  • Aucun PIN en clair dans les logs.

Dépendance : F01.


F09 Support des claviers d’alarme

Objectif

Permettre aux claviers physiques Zigbee / Zigbee2MQTT de commander la centrale.

Par exemple :

Frient KEYZB-110

Principe architectural

Le clavier ne contient aucune logique métier.

Clavier
   │
   ▼
Zigbee2MQTT
   │
   ▼
Gladys
   │
   ▼
Alarm Service

Il transmet par exemple :

ARM_HOME
ARM_NIGHT
ARM_AWAY
DISARM
PIN

Gladys décide ensuite si l’action est autorisée.

Retour vers le clavier

Lorsque le matériel le permet, Gladys doit pouvoir transmettre :

  • armement réussi ;

  • armement refusé ;

  • PIN incorrect ;

  • désarmement réussi ;

  • alarme déclenchée.

Avec éventuellement un retour :

  • sonore ;

  • LED ;

  • visuel.

Extensibilité

L’architecture ne doit pas être spécifique au Frient.

Un périphérique doit pouvoir exposer des fonctionnalités standardisées :

alarm-arm
alarm-disarm
alarm-code
alarm-status

Critères d’acceptation

  • Un clavier peut demander l’armement.
  • Un clavier peut demander le désarmement.
  • Le PIN est validé par Gladys.
  • Plusieurs claviers peuvent piloter la même alarme.
  • Le système reste fonctionnel sans clavier.
  • L’intégration n’est pas liée à un modèle particulier.

Dépendances : F01 + F02 + F08.


F10 Interface centralisée Alarme

Cette fonctionnalité rassemble tout le reste pour l’utilisateur.

Objectif

Créer dans Gladys une page dédiée :

Paramètres
└── Alarme

ou un service équivalent.

Écran principal

ALARME MAISON

État
● Désarmée

Modes
○ Présence
○ Nuit
○ Absence

Capteurs
18 configurés
✓ 17 OK
⚠️ 1 ouvert

[ Configurer ]

Configuration

Sections proposées :

  1. Général

  2. Modes

  3. Zones

  4. Capteurs

  5. Délais

  6. Utilisateurs / codes

  7. Claviers

  8. Historique

Dashboard

Un widget Gladys permettrait également :

┌─────────────────────────┐
│ 🛡️ Alarme maison        │
│                         │
│ ● Désarmée              │
│                         │
│ Présence   Nuit         │
│ Absence                 │
└─────────────────────────┘

En cas d’intrusion

🚨 ALARME DÉCLENCHÉE

Porte garage
19:42

[ Désarmer ]

Prévoir également la remontée des intrusions dans HomeKit sous forme de notification urgente, lorsque l’intégration le permet.

Critères d’acceptation

  • Consultation immédiate de l’état.
  • Armement/désarmement.
  • Choix du mode.
  • Visualisation des capteurs ouverts.
  • Visualisation des capteurs bypassés.
  • Configuration sans devoir créer manuellement des scènes.
  • Interface utilisable sur mobile.

Dépendances : idéalement F01 à F09.

@quentins33 merci pour ce travail d’organisation — ton découpage en F01 → F10 était directement exploitable, j’ai pu partir de là plutôt que de repartir d’une page blanche.

J’ai créé 9 demandes de fonctionnalités, une par sujet, pour qu’on puisse voter et avancer sur chacune indépendamment. Voici la correspondance avec tes besoins :

Ton besoin Demande créée Note
F01 État centralisé A6 · État « déclenchée » et contexte + A2 · Capteurs Réparti sur deux demandes, voir ci-dessous
F02 Modes Absence / Nuit / Présence A1 · Mode nuit
F03 Affectation des capteurs aux modes A2 · Capteurs surveillés et actifs par mode Le cœur du chantier
F04 Délais d’entrée et de sortie A3 · Délai d’entrée Le délai de sortie existe déjà
F05 Vérification avant armement et bypass A4 · Vérification et mise hors service
F06 Intégration avec les scènes A6 · État « déclenchée » et contexte
F07 Zones d’alarme A5 · Zones
F08 Codes PIN utilisateurs A7 · Un code par utilisateur
F09 Support des claviers A8 · Claviers physiques
F10 Interface centralisée A9 · Page Alarme dédiée

Pourquoi F01 n’a pas son propre sujet

Gladys a déjà un état d’alarme centralisé : il vit sur la maison, il survit au redémarrage, et toutes les commandes passent par lui. Ce qui manque n’est donc pas l’état lui-même, mais deux choses différentes — un état « déclenchée » distinct du bouton panique (A6), et un moteur capable de le faire changer tout seul quand un capteur détecte quelque chose (A2). Une demande « état centralisé » aurait été en grande partie déjà satisfaite, difficile à évaluer et à voter.

Ce qui existe déjà, pour situer

Utile pour comprendre pourquoi certaines demandes sont plus petites que d’autres : Gladys sait déjà armer, armer partiellement, désarmer avec un code et passer en panique ; le délai avant armement est réglable ; les tablettes se verrouillent quand la maison est armée ; six déclencheurs de scène et deux actions existent ; et l’alarme est exposée à HomeKit comme système de sécurité — sans le mode nuit, justement parce que Gladys ne l’a pas.

Ce qui n’existe pas du tout, c’est le lien entre un capteur et l’alarme. C’est ce qui explique que tout doive être reconstruit dans les scènes, et pourquoi A2 est la demande la plus lourde du lot.

Deux demandes du forum déjà ouvertes ont été reprises

Ajouter un déclencheur « Alarme : code entré » et pouvoir tester plusieurs modes dans une condition sont intégrées à A6 : elles vont exactement dans le même sens.

Par où on peut commencer

Quatre demandes ne dépendent de rien et peuvent être développées en parallèle : A1 (mode nuit), A2 (capteurs), A7 (codes) et une partie de A6. Tout le reste en découle. A1 est de loin la plus rapide à livrer et débloque déjà le bouton Nuit dans HomeKit.

Ce qui aiderait maintenant

Chaque sujet se termine par une liste de questions à trancher — ce sont les points qui bloquent la rédaction d’une spécification. Vos réponses, vos usages réels et vos désaccords sur ces questions sont exactement ce dont on a besoin pour avancer. Sachant qu’il faut garder le système flexible, mais le plus simple possible (pour pouvoir le développer facilement, le maintenir et pour qu’un utilisateur n’ait pas besoin de lire un manuel).

@quentins33 @StephaneB @spenceur si vous voyez un besoin mal traduit ou un découpage qui vous paraît bancal, dites-le : c’est le moment de le corriger, avant que le développement ne commence.

Bravo à tous les deux pour ce travail qui clarifie bien le besoin. Globalement, tout ce qui est listé me semble cohérent et je ne vois pas de ‹ trou dans la raquette › par rapport à ce que je peux faire aujourd’hui dans mon alarme Myfox. Et ça va même beaucoup plus loin, donc c’est top !

Je vais essayer de prendre le temps dimanche de donner mon avis sur les différentes 'questions à trancher '…

Super, merci pour la création des demandes de fonctionnalités.
Je regarde chacune en détail rapidement pour te faire un retour.