> For the complete documentation index, see [llms.txt](https://docs.kiloiot.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.kiloiot.io/kilo-docs-fr/kilo-iot-server/rules-engine/triggers.md).
# Déclencheurs
Définissez une condition enregistrée qui démarre une règle Kilo immédiatement ou après un délai pour un ou plusieurs appareils.
Un **déclencheur** est une condition enregistrée qui peut lancer une règle. Elle indique à Kilo quelles données de l’appareil surveiller, quelle comparaison doit devenir vraie, et quel appareil sélectionné a provoqué la satisfaction de la condition.
Un déclencheur n’est pas seulement une minuterie et ce n’est pas non plus un groupe d’appareils réutilisable. La temporisation et la sélection des appareils sont deux parties indépendantes du même déclencheur :
* **Temporisation** décide si Kilo lance la règle immédiatement ou attend que la condition reste vraie.
* **Appareils** décident si la condition est évaluée pour un seul appareil ou séparément pour plusieurs appareils.
Par exemple, un déclencheur peut surveiller la `door_open` métrique sur 50 portes de chambre froide. Il peut lancer une règle partagée dès qu’une porte s’ouvre, ou seulement après que cette porte particulière est restée ouverte pendant 20 minutes. Chaque porte conserve son propre état et son propre compte à rebours.
## Quand utiliser un déclencheur
Chaque **Événement de début** a deux sources de démarrage :
| Comportement requis | Source de démarrage | Paramètre supplémentaire |
| ------------------------------------------------------------------------------------------------ | ------------------------------ | ---------------------------------------------------------------------------- |
| Exécuter chaque fois qu’un capteur signale | **Lecture de capteur** | Sélectionnez un appareil et un capteur dans l’événement de démarrage. |
| Exécuter lorsqu’une condition devient vraie | **Condition de déclenchement** | Réglez le déclencheur sur **Immédiatement**. |
| Ignorer les conditions de courte durée | **Condition de déclenchement** | Réglez le déclencheur sur **Seulement si cela dure** et saisissez une durée. |
| Appliquer la même condition et la même réponse à plusieurs appareils | **Condition de déclenchement** | Sélectionnez ces appareils dans le déclencheur. |
| Autoriser l’exécution de l’une ou l’autre source uniquement pendant des plages horaires définies | Conserver la source choisie | Activer **Activer la planification** dans l’événement de démarrage. |
Utilisez **Lecture de capteur** lorsque la règle a besoin de chaque événement de capteur normalisé et de son `vars.value`. Utilisez **Condition de déclenchement** lorsque Kilo doit décider si une condition enregistrée a été satisfaite avant le démarrage de la règle.
## Comment fonctionne un déclencheur
Le déclencheur et la règle ont des responsabilités distinctes :
1. Le déclencheur surveille les métriques normalisées et évalue sa condition.
2. Sa temporisation et son comportement de remise à l’état initial déterminent quand la condition devient active et revient à la normale.
3. Lorsque le déclencheur devient actif, il identifie l’appareil surveillé et signale chaque règle déployée qui utilise ce déclencheur.
4. La règle effectue la réponse opérationnelle, comme déclencher une alerte, enrichir les données ou envoyer une commande.
Enregistrer un déclencheur n’effectue donc pas d’action à lui seul. Vous devez le connecter à une règle, puis créer et déployer cette règle.
## D’un déclencheur à une règle en cours d’exécution
Un déclencheur est une **source de démarrage**, pas un nœud que vous faites glisser sur le canevas de la règle. La création du déclencheur et son association à une règle se font dans deux onglets différents :
1. Ouvrez **Moteur de règles → Déclencheurs**, cliquez sur **Ajouter un déclencheur**, configurez la condition, la temporisation et les appareils, puis cliquez sur **Créer le déclencheur**.
2. Revenez à l’onglet **Règles** . Le **Ajouter une règle** bouton est disponible là, et non dans l’onglet Déclencheurs.
3. Cliquez **Ajouter une règle**, ou modifiez une règle existante qui doit répondre au déclencheur.
4. Repérez le **Événement de début** déjà placé sur le canevas. Sélectionnez-le et cliquez sur le crayon sous le nœud pour ouvrir ses propriétés.
5. Définissez **Source de démarrage** à **Condition de déclenchement**, puis choisissez le déclencheur que vous avez enregistré.
6. Cliquez **Enregistrer** en bas du panneau Événement de démarrage. Cela applique la sélection au diagramme.
7. Ajoutez les nœuds d’alerte, de commande, d’enrichissement ou autres qui définissent la réponse. Puis cliquez sur **Enregistrer** dans l’éditeur de règles.
8. Cliquez **Construire** et déployez l’artefact résultant. Seule une règle déployée peut répondre lorsque le déclencheur devient actif.
Créer un déclencheur ne crée pas une règle, n’ajoute pas de nœud au canevas et ne sélectionne pas automatiquement le déclencheur. Le déclencheur détermine **quand et pour quel appareil** une règle démarre ; les nœuds après l’événement de démarrage décident **ce que fait la règle**.
## Créer un déclencheur
1. Ouvrez **Moteur de règles → Déclencheurs**.
2. Cliquez **Ajouter un déclencheur**.
3. Saisissez un **Nom** qui décrit la situation, par exemple `Porte de chambre froide restée ouverte`.
4. Sous **Qu’est-ce qui doit déclencher la règle ?**, cliquez sur **Ajouter une clé normalisée** et choisissez la métrique à évaluer.
5. Choisissez un **Est** opérateur et saisissez la comparaison **Valeur**.
6. Sous **Quand doit-elle démarrer ?**, choisissez **Immédiatement** ou **Seulement si cela dure**.
7. Configurer **Comportement de retour à la normale** si le retour à la normale nécessite sa propre condition ou son propre délai.
8. Sous **Appareils**, sélectionnez l’appareil ou les appareils dont les données seront utilisées par le déclencheur.
9. Vérifiez **Comment ce déclencheur s’exécutera**, puis cliquez sur **Créer le déclencheur**.
Le formulaire prend en charge jusqu’à 10 clés normalisées pour la condition de démarrage et la condition de retour à la normale facultative, jusqu’à 500 appareils sélectionnés, et une durée de 10 secondes à 30 jours.
Pour le comportement temporel complet, voir [Temporisation du déclencheur](/kilo-docs-fr/kilo-iot-server/rules-engine/triggers/trigger-timing.md). Pour la sélection des appareils, les lectures partagées et l’évaluation par appareil, voir [Un déclencheur pour plusieurs appareils](/kilo-docs-fr/kilo-iot-server/rules-engine/triggers/multiple-devices.md).
## Construire la condition
Pour chaque clé normalisée, choisissez la comparaison que Kilo doit effectuer :
* Les métriques numériques proposent **égal à**, **est supérieur à**, et **est inférieur à**.
* Les métriques de type chaîne et booléen proposent **égal à**.
* **Ajouter une vérification sur ‹metric›** ajoute une autre comparaison pour la même métrique.
* **Ajouter une clé normalisée** inclut une autre métrique dans la condition.
Utilisez **ET** lorsque chaque vérification doit être vraie, et **OU** lorsque n’importe quelle vérification peut être vraie. Un second contrôle ET/OU combine différentes clés normalisées. Ces contrôles combinent les lectures d’un seul appareil surveillé ; ils ne combinent pas les états de différents appareils surveillés.
## Où les déclencheurs peuvent être utilisés
Dans l’éditeur de règles actuel, l’événement de démarrage est le seul endroit où vous sélectionnez un déclencheur enregistré. Les déclencheurs ne sont pas disponibles sur les passerelles, Définir une alerte, Exécuter une commande, Enrichissement ou d’autres nœuds en aval.
Un déclencheur enregistré peut être sélectionné par plusieurs règles. Lorsqu’il devient actif, chaque règle déployée qui l’utilise peut s’exécuter. Chaque règle individuelle n’a toujours qu’un seul événement de démarrage et une seule source de démarrage.
Un événement de démarrage utilise **Lecture de capteur** ou **Condition de déclenchement**, jamais les deux. **Activer la planification** est une restriction facultative sur la source sélectionnée plutôt qu’une autre source de démarrage.
Le sélecteur de déclencheurs charge actuellement uniquement sa première page. Si le déclencheur requis n’est pas affiché, il ne peut pas encore être sélectionné dans ce champ.
## Données disponibles pour la règle
Une règle démarrée par un déclencheur reçoit des informations sur le signal de condition et l’appareil surveillé :
| Variable | Valeur |
| ------------------- | -------------------------------------------------------- |
| `vars.device_name` | Nom de l’appareil surveillé qui a satisfait la condition |
| `vars.subject_kind` | Type de ressource surveillée ; actuellement `appareil` |
| `vars.subject_id` | ID de l’appareil surveillé |
| `vars.sensor_id` | ID du capteur associé à l’exécution et à toute alerte |
| `vars.detector_id` | ID du déclencheur |
| `vars.timestamp` | Horodatage Unix du signal du déclencheur |
`vars.value` n’est pas disponible car le signal représente la transition de la condition du déclencheur plutôt qu’un seul événement de capteur normalisé. Mettez à jour les expressions qui nécessitent `vars.value` avant de modifier une règle existante de **Lecture de capteur** à **Condition de déclenchement**.
Pour identifier l’appareil concerné dans une alerte, incluez `vars.device_name` dans son **Message de motivation**:
```cel
"Door left open: " + vars.device_name
```
Le nom de l’appareil n’est pas inséré automatiquement.
## Modifier ou supprimer un déclencheur
La modification d’une condition peut redémarrer les comptes à rebours actifs. Kilo affiche un avertissement avant d’enregistrer une modification qui réinitialise l’état du déclencheur.
La suppression d’un déclencheur est irréversible. Elle arrête la surveillance future et empêche les règles connectées de démarrer à partir de lui. Examinez les règles qui utilisent le déclencheur et toute alerte en attente avant de le supprimer.
## Dépannage
| Problème | À vérifier |
| ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| Un appareil est manquant | Confirmez que ses données entrantes sont associées à une clé normalisée utilisée par le déclencheur. |
| Un capteur ne peut pas fournir une métrique | Confirmez que le capteur a un mappage de source. Si plusieurs capteurs répondent à la même métrique, sélectionnez le capteur prévu. |
| Le déclencheur ne s’enregistrera pas | Vérifiez la durée et examinez **Comment ce déclencheur s’exécutera** pour une métrique manquante ou partagée de manière ambiguë. |
| Une expression CEL échoue | Supprimez `vars.value` du chemin démarré par un déclencheur et utilisez les variables répertoriées ci-dessus. |
| Une alerte n’identifie pas l’appareil | Ajoutez `vars.device_name` au message d’alerte. |
## Voir aussi
* [Créer des règles](/kilo-docs-fr/kilo-iot-server/rules-engine/creating-rules.md) — choisissez la bonne source d’événement de démarrage
* [Temporisation du déclencheur](/kilo-docs-fr/kilo-iot-server/rules-engine/triggers/trigger-timing.md) — immédiat, durée, retour à la normale et planifications
* [Un déclencheur pour plusieurs appareils](/kilo-docs-fr/kilo-iot-server/rules-engine/triggers/multiple-devices.md) — sélection des participants et lectures partagées
* [Référence CEL](/kilo-docs-fr/kilo-iot-server/rules-engine/cel-reference.md) — rédigez des expressions pour chaque contexte de démarrage
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://docs.kiloiot.io/kilo-docs-fr/kilo-iot-server/rules-engine/triggers.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
