Leçons · Leçon K4 · Les bases du code · 30 min
Le temps et les états
Empêche la carte de se figer pendant une attente, mesure le temps avec millis(), puis construis une petite alarme sous forme de machine à états. Environ 30 minutes, avec un schéma sur lequel tu peux appuyer.
Le feu qui n’entend rien
Imagine un feu de circulation qui change de couleur toutes les quelques secondes. Un piéton arrive et appuie sur le bouton du passage. Rien ne se passe, parce que le contrôleur est occupé à « attendre » le prochain changement et ne regarde pas le bouton avant la fin de l’attente. Un vrai passage piéton doit faire les deux en même temps : garder le cycle en route et rester attentif.
Tu peux faire cette erreur avec delay(). Sur les cartes Arduino classiques, c’est une attente active : le processeur reste dessus et ne fait rien d’autre [3]. L’ESP32 est un peu différent : pendant un delay(), les tâches de fond de la puce continuent de tourner. Mais cela ne t’aide pas, car ta loop() reste bloquée sur cette ligne et ne peut pas lire le bouton. Pendant l’attente, ton code ne peut ni lire une entrée, ni traiter des données, ni changer une sortie [2][3]. La référence Arduino dit la même chose : aucune lecture de capteur, aucun calcul, aucun changement de broche ne peut avoir lieu pendant un delay(), donc presque toute l’activité s’arrête [2]. (Quelques tâches de fond continuent, comme l’enregistrement des caractères qui arrivent sur la liaison série [2]. Ton propre code, lui, ne tourne pas.)
Pour une DEL qui clignote, ça ne gêne pas. Pour une alarme qui doit réagir à un bouton, ça gêne beaucoup.
Dans cette leçon, tu vas :
- voir une carte se figer, puis corriger ça avec l’horloge,
- comprendre pourquoi cette correction tient bon quand l’horloge déborde,
- construire une petite alarme qui se souvient de l’état dans lequel elle est.
Regarde l’horloge à la place
Au lieu de t’arrêter une seconde, tu peux regarder l’heure de temps en temps. La carte a une horloge intégrée : millis() renvoie le nombre de millisecondes écoulées depuis le début du programme [1]. (Une milliseconde est un millième de seconde : il en faut 1000 pour faire une seconde.)
L’idée, c’est un emploi du temps et un œil sur l’horloge [4] :
- Note l’heure du dernier changement (
lastBlink). - À chaque passage de
loop(), lis l’horloge (now). - Si
now - lastBlinkatteint au moins l’intervalle voulu, c’est le moment : fais le travail et note la nouvelle heure. - Sinon, ne fais rien et continue. Les autres tâches, comme la lecture d’un bouton, tournent dans le même passage.
loop() tourne maintenant très vite et vérifie l’horloge à chaque fois, au lieu d’attendre. La documentation Arduino cite cette méthode comme l’alternative aux longues attentes [2]. Le programme d’exemple fourni avec l’IDE s’appelle BlinkWithoutDelay [4].
Là où l’image s’arrête. Une horloge murale continue de tourner pendant que tu lis un livre. millis() continue aussi, mais ton code ne la regarde que quand loop() revient. Si une partie de la boucle prend du temps, la vérification arrive en retard. La règle est donc simple : pas de delay() dans un programme qui doit rester réactif, et pas de longs travaux dans loop().
Clignote et reste à l’écoute
Branche les pièces de la leçon K2 : le bouton sur la GPIO 27 (l’autre patte à GND), la DEL sur la GPIO 26 à travers 220 Ω, le buzzer actif sur la GPIO 25. La DEL est notre « feu de circulation », et le buzzer est le « signal sonore pour piétons ».
Téléverse ce programme et ouvre le moniteur série à 115200 baud :
// Tinker Mission, leçon K4 : clignoter sans se figer (millis) et entendre quand même un bouton
// Câblage (les mêmes pièces que dans la leçon K2) :
// Bouton : une patte à la GPIO 27, la patte diagonalement opposée à GND (pas de résistance nécessaire)
// DEL : GPIO 26 -> résistance de 220 ohms -> patte longue de la DEL ; patte courte de la DEL -> GND
// Buzzer actif : patte + à la GPIO 25, autre patte à GND (module à 3 broches : VCC à 3V3, GND à GND, I/O à la GPIO 25)
// La DEL est le « feu de circulation » : elle change toutes les secondes.
// Le buzzer est le « signal sonore pour piétons » : il sonne tant que tu tiens le bouton.
// Ouvre le moniteur série à 115200 baud : il indique combien de fois loop() a tourné pendant la dernière seconde.
// À toi : mets USE_DELAY à true, téléverse, et tiens le bouton. Puis remets-le à false.
const int BUTTON_PIN = 27;
const int LED_PIN = 26;
const int BUZZER_PIN = 25;
const bool USE_DELAY = false; // false = version millis(), true = version delay()
const unsigned long BLINK_INTERVAL = 1000; // la DEL change toutes les 1000 ms
const unsigned long REPORT_INTERVAL = 1000; // un compte rendu toutes les 1000 ms
unsigned long lastBlink = 0; // l’heure (en ms) du dernier changement de la DEL
unsigned long lastReport = 0; // l’heure du dernier compte rendu
unsigned long loopCount = 0; // combien de fois loop() a tourné depuis le dernier compte rendu
int ledState = LOW;
void setup() {
Serial.begin(115200);
pinMode(BUTTON_PIN, INPUT_PULLUP);
pinMode(LED_PIN, OUTPUT);
pinMode(BUZZER_PIN, OUTPUT);
}
void loop() {
unsigned long now = millis(); // l’horloge de la carte : les millisecondes depuis son démarrage
loopCount = loopCount + 1;
// Tâche 1 : la lente, changer la DEL toutes les secondes.
if (USE_DELAY) {
digitalWrite(LED_PIN, HIGH);
delay(1000); // toute la carte attend ici
digitalWrite(LED_PIN, LOW);
delay(1000); // et ici
} else {
if (now - lastBlink >= BLINK_INTERVAL) {
lastBlink = now; // note l’heure de ce changement
if (ledState == LOW) {
ledState = HIGH;
} else {
ledState = LOW;
}
digitalWrite(LED_PIN, ledState);
}
}
// Tâche 2 : la rapide, faire sonner le buzzer tant que le bouton est tenu.
if (digitalRead(BUTTON_PIN) == LOW) {
digitalWrite(BUZZER_PIN, HIGH);
} else {
digitalWrite(BUZZER_PIN, LOW);
}
// Tâche 3 : une fois par seconde, dire combien de fois loop() a tourné.
if (now - lastReport >= REPORT_INTERVAL) {
lastReport = now;
Serial.print("loop() ran ");
Serial.print(loopCount);
Serial.println(" times in the last second");
loopCount = 0;
}
}
Télécharger le dossier du croquis (.zip)
La DEL change une fois par seconde. Appuie sur le bouton à n’importe quel moment : le buzzer répond tout de suite. Le moniteur série affiche un très grand nombre de passages de loop() par seconde. Lis le tien : la carte n’est pas au repos, elle surveille tout, tout le temps.
Maintenant, l’expérience. Mets USE_DELAY à true, téléverse de nouveau, et appuie sur le bouton par petites touches. La DEL clignote toujours, mais le buzzer répond en retard, rate complètement ta touche, ou continue de sonner après que tu as lâché le bouton, parce que la carte est coincée dans un delay(). La ligne de compte rendu n’affiche plus que 1 passage de loop(), et elle apparaît une fois toutes les deux secondes (elle dit toujours « in the last second », mais chaque passage prend maintenant deux secondes). Remets false quand tu as fini.
Ce que font les nouvelles lignes :
const bool USE_DELAYest un interrupteur pour l’expérience. Unboolcontienttrue(vrai) oufalse(faux).unsigned long now = millis();lit l’horloge une fois par passage. Le type estunsigned long, car c’est ce quemillis()renvoie [1].now - lastBlink >= BLINK_INTERVALpose la question : « 1000 ms se sont-elles écoulées depuis le dernier changement ? »lastBlink = now;note l’heure de ce changement, pour que la prochaine attente parte de là.
Quand l’horloge déborde
millis() ne peut pas compter indéfiniment. C’est un unsigned long, un nombre de 32 bits qui va de 0 à 4 294 967 295 [5]. Au bout d’environ 50 jours, il déborde et repart à zéro [1]. (Fais le calcul : 4 294 967 296 ms font environ 49,7 jours.)
Est-ce que le clignotement se casse ce jour-là ? Non, si tu compares comme le fait le programme : soustraire, puis comparer.
Une petite horloge. Imagine une horloge qui compte de 0 à 99, puis repart à 0. Tu as noté l’heure 95. Un instant plus tard, l’horloge indique 3. Huit tops se sont écoulés (96, 97, 98, 99, 0, 1, 2, 3). Sur le papier, la soustraction 3 - 95 donne -92. Un nombre unsigned ne peut pas être négatif : il fonctionne en cercle, comme cette horloge, et -92 fait le tour pour devenir 100 - 92 = 8. La bonne réponse.
La vraie horloge fait pareil avec 4 294 967 296 positions au lieu de 100. Disons que lastBlink vaut 4 294 967 000 et que now a fait le tour jusqu’à 200. Le calcul now - lastBlink donne 496, soit exactement le nombre de millisecondes écoulées (296 pour revenir à zéro, puis 200 de plus). Tu peux le vérifier sur ta propre carte dans « Fais tes propres modifications ».
Ce qui casse tout. Écrire if (now >= lastBlink + 1000) a l’air équivalent, mais ne l’est pas. Avec lastBlink à 4 294 967 000, la somme lastBlink + 1000 fait elle-même le tour et vaut 704 : le test réussit tout de suite, bien avant la fin de l’intervalle. Ranger l’heure dans un int ne vaut pas mieux : les types plus petits mènent à des erreurs de logique, et même un long signé ne monte qu’à la moitié [1].
L’habitude à retenir : des variables unsigned long, et now - last >= interval. L’attente que tu mesures peut durer aussi longtemps que l’horloge le permet, environ 49 jours, bien plus que ce qu’il faut pour un clignotement ou une alarme.
Les états : une mémoire pour la carte
Maintenant, un travail plus gros : une alarme qui a des humeurs. Elle est armée et elle attend. Quand quelque chose est détecté, elle passe en alarme. Quand tu appuies sur le bouton de silence, elle passe en silence pendant un moment, puis elle est de nouveau armée.
L’outil adapté s’appelle une machine à états. L’idée ne demande que trois choses :
- une liste d’états, les situations dans lesquelles la machine peut se trouver (ici : ARMED, ALARM, SILENCED),
- une variable qui se souvient de l’état actuel (
state), - des règles : dans chaque état, ce qu’il faut faire, et quel événement fait passer à un autre état.
Pense à un jeu de plateau. Tu es sur une seule case à la fois. La case te dit ce que tu peux faire, et un certain tirage de dé t’envoie sur une autre case. La machine est toujours sur exactement une case.
Nos trois cases :
- ARMED (armée) : la DEL fait un bref éclair environ toutes les deux secondes, un discret « je surveille ». Si le capteur se déclenche, on va en ALARM.
- ALARM (alarme) : la DEL et le buzzer pulsent ensemble. Si le bouton de silence est pressé, on va en SILENCED.
- SILENCED (silence) : DEL allumée en continu, buzzer éteint. Au bout de 10 secondes, retour en ARMED.
Remarque ce dont tu n’as pas besoin : aucun delay(). Chaque état a ses propres quelques lignes, et chaque passage de loop() n’exécute que les lignes de l’état actuel. Les éclairs utilisent la même astuce d’horloge que tout à l’heure. Les 10 secondes de silence, c’est simplement now - stateStart >= SILENCE_TIME.
Appuie sur les boutons virtuels du schéma ci-dessous : l’état actuel s’allume, et les flèches montrent où mène chaque événement. Puis bascule l’interrupteur sur « figé » pour voir ce que fait la même machine quand elle utilise delay() pour attendre.
Simulation du croquis, pas la vraie carte.
state = ARMED
pas de minuteur dans cet état
loop() tourne : boutons lus à chaque passage
Bouton non lu : tu as relâché pendant l’attente.
ARMED : en attente du capteur.
Voici l’état de départ : les commandes ont besoin de JavaScript.
L’alarme, en code
Ajoute un second bouton comme faux capteur, entre la GPIO 33 et GND (même câblage que le premier bouton). Dans les leçons suivantes, tu le remplaceras par un vrai capteur. Les deux boutons utilisent INPUT_PULLUP, la résistance de rappel intégrée à la carte, comme dans la leçon K2. La fiche technique indique que la plupart des GPIO numériques peuvent être configurées avec une résistance de rappel interne [6].
// Tinker Mission, leçon K4 : une petite alarme construite comme une machine à états (ARMED, ALARM, SILENCED)
// Câblage :
// Bouton de silence : une patte à la GPIO 27, la patte diagonalement opposée à GND (pas de résistance nécessaire)
// Faux capteur : un second bouton, une patte à la GPIO 33, la patte diagonalement opposée à GND
// (pressé = « quelque chose a été détecté » ; les leçons suivantes le remplacent par de vrais capteurs)
// DEL : GPIO 26 -> résistance de 220 ohms -> patte longue de la DEL ; patte courte de la DEL -> GND
// Buzzer actif : patte + à la GPIO 25, autre patte à GND (module à 3 broches : VCC à 3V3, GND à GND, I/O à la GPIO 25)
// ARMED : la DEL fait un bref éclair environ toutes les 2 secondes. Appuyer sur le bouton capteur déclenche l’alarme.
// ALARM : la DEL et le buzzer pulsent ensemble. Appuyer sur le bouton de silence coupe le bruit.
// SILENCED : la DEL reste allumée, le buzzer est éteint. Au bout de 10 secondes, l’alarme est de nouveau armée.
// Aucun delay() nulle part : chaque état surveille ses boutons en permanence.
const int BUTTON_PIN = 27; // bouton de silence, pressé = LOW
const int SENSOR_PIN = 33; // faux capteur, pressé = LOW
const int LED_PIN = 26;
const int BUZZER_PIN = 25;
// Les trois états, sous forme de nombres qui ont un nom.
const int STATE_ARMED = 0;
const int STATE_ALARM = 1;
const int STATE_SILENCED = 2;
const unsigned long HEARTBEAT_ON = 100; // armée : DEL allumée 100 ms ...
const unsigned long HEARTBEAT_OFF = 1900; // ... puis éteinte 1900 ms
const unsigned long ALARM_HALF = 200; // alarme : allumée 200 ms, éteinte 200 ms
const unsigned long SILENCE_TIME = 10000; // silence : 10 secondes
int state = STATE_ARMED; // la mémoire de la machine : dans quel état sommes-nous ?
unsigned long stateStart = 0; // l’heure à laquelle nous sommes entrés dans cet état
unsigned long lastToggle = 0; // l’heure du dernier changement de l’impulsion
int pulse = LOW; // le niveau actuel de l’impulsion (HIGH = allumé)
// Passer à un nouvel état et remettre ses horloges à zéro.
void enterState(int newState, unsigned long now) {
state = newState;
stateStart = now;
lastToggle = now;
pulse = HIGH; // chaque état commence avec son impulsion allumée
if (state == STATE_ARMED) {
Serial.println("-> ARMED");
} else if (state == STATE_ALARM) {
Serial.println("-> ALARM");
} else {
Serial.println("-> SILENCED");
}
}
// Inverser l’impulsion quand elle a duré assez longtemps, sans attendre.
void updatePulse(unsigned long now, unsigned long onTime, unsigned long offTime) {
unsigned long needed = offTime;
if (pulse == HIGH) {
needed = onTime;
}
if (now - lastToggle >= needed) {
lastToggle = now;
if (pulse == HIGH) {
pulse = LOW;
} else {
pulse = HIGH;
}
}
}
void setup() {
Serial.begin(115200);
pinMode(BUTTON_PIN, INPUT_PULLUP);
pinMode(SENSOR_PIN, INPUT_PULLUP);
pinMode(LED_PIN, OUTPUT);
pinMode(BUZZER_PIN, OUTPUT);
enterState(STATE_ARMED, millis());
}
void loop() {
unsigned long now = millis();
bool buttonPressed = (digitalRead(BUTTON_PIN) == LOW);
bool sensorTriggered = (digitalRead(SENSOR_PIN) == LOW);
if (state == STATE_ARMED) {
updatePulse(now, HEARTBEAT_ON, HEARTBEAT_OFF);
digitalWrite(LED_PIN, pulse);
digitalWrite(BUZZER_PIN, LOW);
if (sensorTriggered) {
enterState(STATE_ALARM, now);
}
} else if (state == STATE_ALARM) {
updatePulse(now, ALARM_HALF, ALARM_HALF);
digitalWrite(LED_PIN, pulse);
digitalWrite(BUZZER_PIN, pulse);
if (buttonPressed) {
enterState(STATE_SILENCED, now);
}
} else {
// STATE_SILENCED
digitalWrite(LED_PIN, HIGH);
digitalWrite(BUZZER_PIN, LOW);
if (now - stateStart >= SILENCE_TIME) {
enterState(STATE_ARMED, now);
}
}
}
Télécharger le dossier du croquis (.zip)
Ouvre le moniteur série : il affiche une ligne à chaque changement d’état. Appuie sur le bouton capteur, puis sur le bouton de silence, puis attends.
Comment le lire :
- Les trois lignes
const int STATE_...donnent un nom à chaque état.statecontient l’état actuel. loop()lit les deux boutons une fois, puis le grandif / else if / elsechoisit les lignes de l’état actuel. Une seule branche s’exécute par passage.enterState()est le seul endroit où l’état change. Elle note aussi l’heure (stateStart), pour que chaque état puisse mesurer depuis combien de temps il dure.updatePulse()reprend l’astuce du clignotement de l’écran 3, écrite une seule fois et réutilisée pour l’éclair lent de l’état armé et pour l’alarme rapide.- Les messages
-> ARMEDsont pour toi seulement, pour regarder la machine bouger.
Fais tes propres modifications
Change une seule chose, téléverse, observe.
-
Vois le débordement. À la fin de
setup()dansl-k4-millis, ajoute ces lignes, téléverse et lis le moniteur série :unsigned long last = 4294967000UL; // les lettres UL signifient « unsigned long » unsigned long before = 4294967001UL; // 1 ms plus tard unsigned long after = 200; // l’horloge a fait le tour du cercle Serial.println(after - last); // temps écoulé à travers le débordement Serial.println(before - last >= 1000); // le test sûr : 1 veut dire « c’est l’heure » Serial.println(before >= last + 1000); // le test dangereuxQue disent les trois nombres, et quel test se trompe ? (Si rien ne s’affiche, appuie sur le bouton EN de la carte : il redémarre le programme et relance setup().) Retire ces lignes ensuite.
-
Un silence plus long. Mets
SILENCE_TIMEà 3000. Comment la machine se comporte-t-elle maintenant ? -
Un nouvel état. Ajoute un quatrième état,
STATE_TEST, déclenché en tenant le bouton de silence dans ARMED, qui allume la DEL en continu pendant 2 secondes. Quelles lignes ajoutes-tu : la constante, une branche dansloop(), un nom dansenterState()?
Quand ça ne marche pas
- La DEL ne change jamais (version millis). Vérifie que
lastBlink = now;est bien dans leif, et queBLINK_INTERVALn’est ni minuscule ni énorme. - Appuyer sur le bouton ne change rien. Vérifie
GNDsur l’autre patte du bouton et la ligneINPUT_PULLUP. Un bouton se litLOWquand il est pressé, comme en K2. - L’alarme démarre toute seule. La broche du faux capteur se lit
LOWtrop souvent : un fil mal enfoncé versGNDou un bouton mal placé. N’appuie sur rien et regarde le moniteur série. - Le bouton de silence ne fait rien. C’est voulu : il ne marche qu’en ALARM. En ARMED et en SILENCED, il est ignoré.
- ALARM revient juste après SILENCED. Le bouton capteur est toujours tenu (voir la question 3 du quiz).
- Les durées sont un peu en retard. Cherche un
delay()ou un travail lent caché dans tes modifications. - Rien dans le moniteur série. Règle-le sur 115200 baud, comme
Serial.begin(115200).
Vérifie-toi
Trois petites questions. Rien n’est enregistré, prends ton temps.
Pendant que delay(1000) s’exécute, que peut faire la carte ?
- Continuer à lire le bouton, car delay() ne met en pause que la DEL
- Presque rien : elle ne peut ni lire une entrée ni changer une sortie avant la fin de l’attente
- Faire tourner deux programmes à la fois
Voir la réponse
Presque rien : elle ne peut ni lire une entrée ni changer une sortie avant la fin de l’attente. delay() met le programme en pause. Aucune lecture de capteur, aucun calcul, aucun changement de broche ne peut avoir lieu pendant ce temps : presque toute l’activité s’arrête [2][3]. C’est pourquoi un bouton pressé pendant l’attente peut recevoir sa réponse en retard, ou pas du tout.
Quel type de variable doit recevoir la valeur renvoyée par millis() ?
- int
- unsigned long
- byte
Dans le programme de l’alarme, les 10 secondes de SILENCED se terminent alors que le faux bouton-capteur est toujours enfoncé. Que se passe-t-il ensuite ?
- L’alarme reste armée et silencieuse jusqu’à ce que tu relâches le bouton
- L’état repasse à ARMED, puis part aussitôt en ALARM
- La carte redémarre
Voir la réponse
L’état repasse à ARMED, puis part aussitôt en ALARM. Quand le temps de silence est écoulé, la machine entre dans ARMED. Dans ARMED, le programme vérifie le capteur à chaque passage de loop(), voit qu’il est toujours pressé, et passe à ALARM. C’est le bon comportement pour une porte qui est restée ouverte.
En bref
delay()bloque taloop(): pendant qu’il dure, ton code ne peut ni lire des entrées ni changer des sorties, même si les tâches de fond de l’ESP32 continuent [2][3].millis()est l’horloge de la carte, en millisecondes, depuis le début du programme [1].- Le schéma : note la dernière heure, et à chaque passage demande
now - last >= interval. Si oui, agis et note la nouvelle heure. - Utilise
unsigned long. La soustraction continue de fonctionner quand l’horloge déborde, au bout d’environ 50 jours [1][5]. - Une machine à états, c’est une liste d’états, une variable qui se souvient de l’état actuel, et des règles pour passer de l’un à l’autre. Chaque passage de
loop()n’exécute que l’état actuel.
Prochaines étapes : un capteur câblé à la place du faux bouton, puis K5 pour les modules qui parlent à la carte.
Sources
Voir les 6 sources
- Arduino, Language Reference, « millis() » (renvoie le nombre de millisecondes écoulées depuis que la carte exécute le programme en cours ; ce nombre déborde, c’est-à-dire repart à zéro, au bout d’environ 50 jours ; type de retour unsigned long ; l’arithmétique avec des types plus petits comme int peut causer des erreurs de logique, et un long signé a la moitié du maximum d’un non signé) — https://docs.arduino.cc/language-reference/en/functions/time/millis/
- Arduino, Language Reference, « delay() » (met le programme en pause pendant le nombre de millisecondes indiqué ; aucune lecture de capteur, aucun calcul, aucune manipulation de broche ne peut avoir lieu pendant l’attente, qui arrête donc presque toute autre activité ; le programme Blink Without Delay interroge millis() comme alternative ; les données série qui arrivent sur RX sont quand même enregistrées) — https://docs.arduino.cc/language-reference/en/functions/time/delay/
- Adafruit, « Multi-tasking the Arduino - Part 1 », « Ditch the delay() » (sur les cartes Arduino classiques, delay() est une attente active qui monopolise le processeur ; pendant un appel à delay(), on ne peut ni répondre aux entrées, ni traiter des données, ni changer des sorties) — https://learn.adafruit.com/multi-tasking-the-arduino-part-1/ditch-the-delay
- Adafruit, « Multi-tasking the Arduino - Part 1 », « Using millis() for timing » (établir un emploi du temps et surveiller l’horloge au lieu d’une attente qui arrête tout ; l’exemple BlinkWithoutDelay fourni avec l’IDE) — https://learn.adafruit.com/multi-tasking-the-arduino-part-1/using-millis-for-timing
- Arduino, Language Reference, « unsigned long » (stocke 32 bits, plage de 0 à 4 294 967 295, soit 2^32 - 1 ; pas de nombres négatifs) — https://docs.arduino.cc/language-reference/en/variables/data-types/unsignedLong/
- Espressif, ESP32 Series Datasheet v5.3 (la plupart des GPIO numériques peuvent être configurées avec une résistance de rappel ou d’abaissement interne, ou mises en haute impédance) — https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf