English

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 :

  1. voir une carte se figer, puis corriger ça avec l’horloge,
  2. comprendre pourquoi cette correction tient bon quand l’horloge déborde,
  3. construire une petite alarme qui se souvient de l’état dans lequel elle est.
Le même programme, deux façons d’attendre Deux frises du même programme, clignotement et bouton, sur 4 secondes. En haut, la version delay() : quatre longs blocs gris d’attente d’une seconde chacun ; la DEL est allumée pendant le premier et le troisième. Le bouton n’est regardé que deux fois, à 2 s et à 4 s, en petits repères orange. Un appui vers 0,6 s tombe dans un bloc gris : pas encore entendu, il n’est lu qu’à 2 s, avec 1,4 s de retard, et un appui bref est complètement raté. En bas, la version millis() : loop() est dessinée comme un peigne de passages courts et rapides, chaque passage regarde l’horloge et le bouton. La DEL change à 1, 2 et 3 s, exactement comme avant, et le même appui à 0,6 s reçoit une réponse immédiate : le buzzer sonne. Pas à l’échelle : la vraie loop() tourne plusieurs milliers de fois par seconde. FIG. 1 — FIGÉ OU RÉACTIFaVersion delay()la carte attendDELprogrammebouton ludelay(1000)delay(1000)delay(1000)delay(1000)regarde le bouton : seulement icibouton pressépas encore entendu1,4 s de retard, ou raté si c’était un appui brefbVersion millis()la carte vérifie sans arrêtDELprogrammebouton lumême appuiréponse immédiate : buzzer en marchechaque passage de loop() regarde l’horloge et le boutonPas à l’échelle : la vraie loop() tourne plusieurs milliers de fois par seconde.0 s1 s2 s3 s4 s
Touche le schéma pour l’ouvrir en plein écran.

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] :

  1. Note l’heure du dernier changement (lastBlink).
  2. À chaque passage de loop(), lis l’horloge (now).
  3. Si now - lastBlink atteint au moins l’intervalle voulu, c’est le moment : fais le travail et note la nouvelle heure.
  4. 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 ».

Câblage K4 : buzzer sur 25, DEL sur 26, bouton sur 27 Plaque d’essai vue de dessus, le même câblage que dans la leçon K2. DevKitC à cheval sur la rainure, USB à gauche, broches 25, 26, 27 et GND sur la rangée du haut, colonne j libre. Huit fils numérotés. 1 noir : broche GND vers le rail moins du haut. 2 orange : GPIO 25 vers la rangée 22, patte plus du buzzer actif ; son autre patte est en rangée 25 ; 3 noir : rangée 25 vers le rail moins du haut. 4 vert : GPIO 26 vers la rangée 28 ; la résistance de 220 ohms relie les rangées 28 et 32 ; la patte longue de la DEL est en rangée 32, la courte en rangée 33 ; 5 noir : rangée 33 vers le rail moins du haut. 6 bleu : GPIO 27 vers la rangée 37, une patte du bouton, à cheval sur la rainure sur les rangées 37 et 39 ; 7 noir : la patte opposée, rangée 39 moitié basse, vers le rail moins du bas ; 8 noir : rail moins du bas vers rail moins du haut, pour que les deux rails soient à GND. FIG. 2 — CÂBLAGE, VUE PLAQUE D’ESSAI+−−+jihgfedcba15101522252832373944ENBOOT5VCMDD3D213GND121427262533323534VNVPEN3V3++12435buzzer actif220 ΩDEL678bouton1noir : broche GND → rail − du haut2orange : GPIO 25 → + du buzzer (rangée 22)3noir : − du buzzer (rangée 25) → rail −4vert : GPIO 26 → 220 Ω (rangée 28)5noir : − de la DEL (rangée 33) → rail −6bleu : GPIO 27 → bouton (rangée 37)7noir : bouton, patte opposée → rail − du bas8noir : rail − du bas → rail − du hautMême câblage que la leçon K2. Le bouton n’a pas besoin de résistance : INPUT_PULLUP.
Touche le schéma pour l’ouvrir en plein écran.

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_DELAY est un interrupteur pour l’expérience. Un bool contient true (vrai) ou false (faux).
  • unsigned long now = millis(); lit l’horloge une fois par passage. Le type est unsigned long, car c’est ce que millis() renvoie [1].
  • now - lastBlink >= BLINK_INTERVAL pose 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.

La soustraction résiste au tour d’horloge À gauche, un cadran qui compte de 0 à 99 puis repart à 0, numéroté dans le sens horaire avec 0 en haut. Un repère à 95 porte l’étiquette last, un repère à 3 l’étiquette now. Un arc épais va dans le sens horaire de 95 à 3 en passant par 99 et 0, avec huit points : huit tops se sont écoulés. Sur le papier, 3 moins 95 donne moins 92 ; sur le cercle, moins 92 tombe sur 100 moins 92, soit 8, la bonne réponse. À droite, un cercle plus petit montre la vraie horloge : elle compte de 0 à 4 294 967 295 millisecondes, environ 49,7 jours par tour, puis repart à 0. La règle : des variables unsigned long, et now moins last supérieur ou égal à l’intervalle. FIG. 3 — UNE HORLOGE QUI FAIT LE TOUR01020304050607080908 topslast = 95now = 30 … 99now − lastsur le papier : 3 − 95 = −92unsigned : le calcul fait le tour du cercle−92 → 100 − 92 = 88 tops : la bonne réponsenow ≥ last + 1000 ne marche pas : la somme elle-même fait le tourLa vraie horloge : millis()msaprès 4 294 967 295 vient 0compte de 0 à 4 294 967 295un tour ≈ 49,7 joursmême tour de cercle,avec 4 294 967 296 positionsunsigned long · now − last >= interval
Touche le schéma pour l’ouvrir en plein écran.

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.

Les états de l’alarme, en direct (interactif)
Les états de l’alarme, en direct (interactif) Simulation interactive du croquis d’alarme, pas la vraie carte. Trois bulles d’état : ARMED, ALARM et SILENCED, reliées par des flèches étiquetées capteur, silence et 10 s. L’état actuel s’allume. Maintiens le bouton virtuel Capteur : ARMED passe à ALARM, la DEL et le buzzer pulsent. Maintiens Silence : ALARM passe à SILENCED, la DEL reste allumée et une barre compte les 10 secondes avant le retour à ARMED. Passe en mode figé (delay) : les boutons ne sont lus qu’à la fin de chaque attente, donc un appui rapide est raté et signalé comme bouton non lu. capteursilence10 sARMEDALARMSILENCEDARMEDsimulation, pas la vraie carte

Simulation du croquis, pas la vraie carte.

state = ARMED

DEL éteintebuzzer coupé

pas de minuteur dans cet état

loop() tourne : boutons lus à chaque passage

ARMED : en attente du capteur.

Voici l’état de départ : les commandes ont besoin de JavaScript.

L’alarme en machine à états Trois boîtes arrondies : ARMED en haut à gauche, ALARM en haut à droite, SILENCED en bas. Une flèche de départ entre dans ARMED. Flèche de ARMED vers ALARM : capteur pressé. Flèche de ALARM vers SILENCED : bouton de silence pressé. Flèche de SILENCED vers ARMED : 10 s écoulées. Dans chaque boîte, une bande de 4 secondes montre ce que font la DEL et le buzzer. ARMED : un bref éclair de la DEL environ toutes les 2 secondes, buzzer coupé. ALARM : DEL et buzzer pulsent ensemble. SILENCED : DEL allumée en continu, buzzer coupé. La machine est toujours dans une seule boîte à la fois. FIG. 4 — TROIS ÉTATS, TROIS RÈGLESARMEDDEL : bref éclair toutes les 2 sbuzzer coupéALARMDEL et buzzer pulsent ensembleSILENCEDDEL allumée en continubuzzer coupécapteur pressébouton de silencepressé10 s écouléesdépartPas de delay() : chaque passage de loop() n’exécute que les lignes de l’état actuel.
Touche le schéma pour l’ouvrir en plein écran.

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. state contient l’état actuel.
  • loop() lit les deux boutons une fois, puis le grand if / else if / else choisit 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 -> ARMED sont pour toi seulement, pour regarder la machine bouger.

Fais tes propres modifications

Change une seule chose, téléverse, observe.

  1. Vois le débordement. À la fin de setup() dans l-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 dangereux
    

    Que 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.

  2. Un silence plus long. Mets SILENCE_TIME à 3000. Comment la machine se comporte-t-elle maintenant ?

  3. 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 dans loop(), un nom dans enterState() ?


Quand ça ne marche pas

  • La DEL ne change jamais (version millis). Vérifie que lastBlink = now; est bien dans le if, et que BLINK_INTERVAL n’est ni minuscule ni énorme.
  • Appuyer sur le bouton ne change rien. Vérifie GND sur l’autre patte du bouton et la ligne INPUT_PULLUP. Un bouton se lit LOW quand il est pressé, comme en K2.
  • L’alarme démarre toute seule. La broche du faux capteur se lit LOW trop souvent : un fil mal enfoncé vers GND ou 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.

  1. 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.

  2. Quel type de variable doit recevoir la valeur renvoyée par millis() ?

    • int
    • unsigned long
    • byte
    Voir la réponse

    unsigned long. millis() renvoie un unsigned long, un nombre de 32 bits qui va de 0 à 4 294 967 295 [1][5]. Les types plus petits, comme int, peuvent provoquer des erreurs de logique [1].

  3. 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 ta loop() : 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
  1. 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/
  2. 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/
  3. 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
  4. 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
  5. 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/
  6. 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

Pince ou touche deux fois pour zoomer, glisse pour changer de schéma.Molette avec Ctrl ou double-clic pour zoomer. Les flèches changent de schéma.