Bases · 11 min de lecture

Machine à états Arduino : enum, switch-case et millis()

Machine à états Arduino : états avec enum et switch-case, transitions, états temporisés avec millis, feu tricolore, menu, lave-linge et code Pico MicroPython.

Une machine à états Arduino (state machine) est une façon d'écrire du code où tu découpes ton programme en états distincts et où tu n'es jamais que dans un seul à la fois. Un feu tricolore est dans l'état « rouge », « orange » ou « vert » ; un lave-linge « prend l'eau », « lave » ou « essore ». Dans chaque état, on sait clairement quoi faire et à quelle condition passer au suivant. Sur Arduino, tu construis cela avec un enum, un switch-case et millis(). Le résultat : un code qui mène plusieurs tâches à la fois sans delay(), facile à lire et à faire évoluer.

Dans ce guide, on voit d'abord les notions d'état, de transition et d'action, le dessin d'un diagramme d'états et la machine la plus simple à deux états. Ensuite, on écrit un feu tricolore avec bouton piéton, un menu de réglages piloté par deux boutons et la simulation d'un lave-linge qui se met en pause quand on ouvre le hublot. Tu apprendras aussi à faire tourner plusieurs machines à états dans le même loop(), les actions d'entrée, les erreurs fréquentes et la façon d'écrire la même structure en MicroPython sur le Raspberry Pi Pico.

Qu'est-ce qu'une machine à états ?

Une machine à états (automate fini, FSM) comporte quatre éléments. Les états sont les situations, en nombre limité, dans lesquelles le système peut se trouver. Les transitions font passer d'un état à un autre, et les conditions ou événements décident du moment : un appui sur un bouton, une valeur de capteur qui dépasse un seuil ou une durée écoulée. Les actions sont le travail effectué en entrant dans un état ou tant qu'on y reste : allumer une LED, lancer un moteur, écrire sur un écran. À chaque tour de loop(), le programme ne se pose qu'une question : « Dans quel état suis-je, et la condition pour en sortir est-elle remplie ? » Il n'attend donc jamais nulle part, et au lieu de if imbriqués et de dizaines de drapeaux, tu obtiens une structure propre autour d'une seule variable d'état.

NotionSignificationExemple du feu tricolore
ÉtatLa situation actuelle du systèmeKIRMIZI (rouge), KIRMIZI_SARI (rouge-orange), YESIL (vert), SARI (orange)
TransitionPassage d'un état à un autreDe YESIL à SARI
Condition ou événementCe qui déclenche la transition10 secondes écoulées ou bouton piéton appuyé
Action d'entréeTravail fait une fois en entrantAllumer la LED verte, éteindre les autres
Action dans l'étatTravail fait en continu dans l'étatSurveiller le bouton piéton

Pourquoi une machine à états plutôt que delay() ?

Quand tu écris delay(5000), l'Arduino ne fait rien pendant cinq secondes : il ne voit pas l'appui sur un bouton, ne lit pas les capteurs, ne met pas l'écran à jour. Dans un petit programme à une seule tâche, ce n'est pas grave, mais dès que tu ajoutes une deuxième tâche, le code se dégrade. Une machine à états n'attend jamais ; chaque état demande avec millis() « combien de temps s'est écoulé depuis que j'y suis entré ? » et, si ce n'est pas fini, revient aussitôt à loop(). Comme loop tourne des milliers de fois par seconde, les autres tâches comme les boutons, les capteurs et l'écran continuent sans interruption. On a expliqué en détail la temporisation avec millis() dans l'article millis ou delay sur Arduino.

CaractéristiqueCode avec delay()Machine à états
Les boutons sont-ils lus pendant l'attente ?NonOui
Plusieurs tâches à la foisDifficile, le code s'emmêleFacile, chaque tâche dans sa machine
Ajouter un étatIl faut réécrire tout le déroulementOn ajoute un case
DébogageOn ne sait pas où en est le programmeAfficher le nom de l'état dans le moniteur série suffit
MémoirePeuPeu (une variable et un horodatage)

Première machine à états avec enum et switch-case

Un enum permet de nommer les états au lieu de leur donner des numéros. La ligne enum Durum { YANIK, SONUK }; (allumé, éteint) définit un nouveau type qui vaut 0 et 1 pour le compilateur mais porte des noms parlants pour toi. La variable d'état est de ce type, et switch-case exécute un bloc distinct pour chaque état. Dans l'exemple ci-dessous, la LED intégrée de l'Uno (D13) s'allume 200 ms puis s'éteint 1,8 seconde. On pourrait le faire avec delay, mais avec cette structure loop() n'attend jamais et tu peux ajouter à la fin autant d'autres tâches que tu veux.

C++ (Arduino IDE)
1// En basit durum makinesi: farklı sürelerde yanıp sönen LED
2// Simplest state machine: an LED with different on/off times
3const int LED_PIN = 13;
4
5enum Durum { YANIK, SONUK };            // durumlar / states
6Durum durum = SONUK;
7unsigned long durumBaslangic = 0;        // duruma giriş zamanı / time the state began
8
9void setup() {
10  pinMode(LED_PIN, OUTPUT);
11}
12
13void loop() {
14  unsigned long gecen = millis() - durumBaslangic;   // durumda geçen süre / time in state
15
16  switch (durum) {
17    case YANIK:
18      if (gecen >= 200) {                // 200 ms yandıktan sonra / after 200 ms on
19        digitalWrite(LED_PIN, LOW);
20        durum = SONUK;
21        durumBaslangic = millis();
22      }
23      break;
24    case SONUK:
25      if (gecen >= 1800) {               // 1,8 sn söndükten sonra / after 1.8 s off
26        digitalWrite(LED_PIN, HIGH);
27        durum = YANIK;
28        durumBaslangic = millis();
29      }
30      break;
31  }
32  // loop asla beklemez; buraya başka işler eklenebilir
33  // loop never blocks; other tasks can be added here
34}
Place la définition de l'enum tout en haut du fichier, avant tes fonctions. L'IDE Arduino génère automatiquement les prototypes de fonctions ; si l'enum est défini après une fonction qui l'utilise comme paramètre, tu peux obtenir l'erreur « was not declared in this scope ». N'oublie pas non plus le break à la fin de chaque case ; sinon le programme exécute aussi le code de l'état suivant.

Dessiner un diagramme d'états

Dessiner la machine à états sur papier avant de coder élimine la plupart des bugs avant même de commencer. Dans le diagramme, chaque état est un cercle ou un rectangle arrondi, et chaque transition une flèche. Sur la flèche, tu écris la condition de la transition et, si besoin, l'action après une barre oblique, par exemple « 10 s / allumer l'orange ». L'état initial est signalé par une petite flèche qui ne part de nulle part. Une fois le diagramme terminé, pose-toi ces questions pour chaque état : y a-t-il une sortie ? Si deux conditions sont vraies en même temps, laquelle passe en premier ? Que se passe-t-il en cas d'événement imprévu (hublot ouvert, capteur en panne) ? Transformer le diagramme en tableau rend l'écriture du code presque mécanique.

  1. Liste tous les états du système et donne à chacun un nom court en majuscules.
  2. Choisis l'état initial ; l'Arduino s'y trouvera à la mise sous tension ou après un reset.
  3. Écris les conditions de sortie de chaque état : durée, bouton, capteur ou autre événement.
  4. Ajoute l'état cible de chaque transition et l'action éventuelle à réaliser pendant celle-ci.
  5. Définis l'action d'entrée de chaque état : quelles sorties seront actives, lesquelles éteintes ?
  6. Note à part les règles communes valables dans tous les états (arrêt d'urgence, ouverture du hublot).
  7. Transforme le diagramme en tableau de transitions comme celui ci-dessous et écris chaque ligne sous forme de if dans un case.
ÉtatConditionÉtat suivantAction d'entrée
KIRMIZI5 s écouléesKIRMIZI_SARIRouge allumé, demande piéton effacée
KIRMIZI_SARI1,5 s écouléeYESILRouge et orange allumés
YESIL10 s écoulées, ou 4 s s'il y a une demandeSARIVert allumé
SARI2 s écouléesKIRMIZIOrange allumé

Exemple 1 : feu tricolore avec bouton piéton

La séquence classique d'un feu est rouge, rouge-orange, vert et orange. Ajoutons un bouton piéton : si un piéton appuie pendant le vert, celui-ci est écourté, à condition d'avoir duré au moins 4 secondes, et le feu passe à l'orange. Écrit avec delay, ce comportement est presque impossible, car tu ne peux pas lire le bouton pendant que tu attends sur le vert. Dans une machine à états, le bouton est lu à chaque tour de loop et la demande est mémorisée dans une variable. Si tu n'as jamais monté le circuit de base du feu tricolore, lis d'abord l'article feu tricolore Arduino.

LED rouge, orange et verte
Les exemples du feu, du menu et du lave-linge utilisent les trois mêmes LED et deux boutons.
ÉlémentBroche Arduino UnoRemarque
LED rougeD8Avec une résistance de 220 Ω, patte courte au GND
LED orangeD9Avec une résistance de 220 Ω
LED verteD10Avec une résistance de 220 Ω (broche PWM)
BuzzerD11Seulement dans l'exemple du lave-linge
Bouton 1D2Autre patte au GND, INPUT_PULLUP
Bouton 2D3Autre patte au GND, INPUT_PULLUP
C++ (Arduino IDE)
1// Yaya butonlu trafik lambası durum makinesi / traffic light with pedestrian button
2const int KIRMIZI_LED = 8, SARI_LED = 9, YESIL_LED = 10, YAYA_BUTON = 2;
3
4enum Durum { KIRMIZI, KIRMIZI_SARI, YESIL, SARI };
5Durum durum = KIRMIZI;
6unsigned long durumBaslangic = 0;
7bool yayaIstegi = false;
8
9void lambalar(bool k, bool s, bool y) {
10  digitalWrite(KIRMIZI_LED, k);
11  digitalWrite(SARI_LED, s);
12  digitalWrite(YESIL_LED, y);
13}
14
15// Durum değiştir + giriş eylemi / change state + entry action
16void durumDegistir(Durum yeni) {
17  durum = yeni;
18  durumBaslangic = millis();
19  switch (yeni) {
20    case KIRMIZI:      lambalar(1, 0, 0); yayaIstegi = false; break;  // yayalar geçer / pedestrians cross
21    case KIRMIZI_SARI: lambalar(1, 1, 0); break;
22    case YESIL:        lambalar(0, 0, 1); break;
23    case SARI:         lambalar(0, 1, 0); break;
24  }
25}
26
27void setup() {
28  pinMode(KIRMIZI_LED, OUTPUT);
29  pinMode(SARI_LED, OUTPUT);
30  pinMode(YESIL_LED, OUTPUT);
31  pinMode(YAYA_BUTON, INPUT_PULLUP);
32  durumDegistir(KIRMIZI);
33}
34
35void loop() {
36  if (digitalRead(YAYA_BUTON) == LOW) yayaIstegi = true;   // isteği hatırla / remember the request
37
38  unsigned long gecen = millis() - durumBaslangic;
39  switch (durum) {
40    case KIRMIZI:
41      if (gecen >= 5000) durumDegistir(KIRMIZI_SARI);
42      break;
43    case KIRMIZI_SARI:
44      if (gecen >= 1500) durumDegistir(YESIL);
45      break;
46    case YESIL:
47      // En az 4 sn yeşil; yaya isterse kısalır, yoksa 10 sn
48      // At least 4 s green; shortened on request, otherwise 10 s
49      if ((yayaIstegi && gecen >= 4000) || gecen >= 10000) durumDegistir(SARI);
50      break;
51    case SARI:
52      if (gecen >= 2000) durumDegistir(KIRMIZI);
53      break;
54  }
55}

La partie la plus importante de ce code est la fonction durumDegistir() (changer d'état). En passant dans un état, trois choses se produisent : la variable d'état est mise à jour, l'horodatage est remis à zéro et l'action d'entrée de l'état est exécutée une fois. Faire passer toutes les transitions par cette seule fonction élimine les bugs du genre « j'ai oublié de réinitialiser le minuteur ». La demande piéton est effacée en entrant dans KIRMIZI, puisque les piétons traversent à ce moment-là de toute façon. Pour calculer les résistances des LED, utilise le calculateur de résistance pour LED.

Exemple 2 : menu de réglages à deux boutons

Les menus sont l'usage le plus naturel d'une machine à états : la page affichée est un état et les boutons déclenchent les transitions. Dans l'exemple ci-dessous, le bouton D2 signifie « suivant » ou « augmenter la valeur » et D3 signifie « OK ». Dans le menu principal, tu passes de l'option luminosité à l'option vitesse ; OK ouvre la page de réglage, D2 change la valeur et OK te fait sortir. En même temps, une deuxième machine à états indépendante fait clignoter la LED de D10 avec la luminosité et la vitesse choisies. La LED ne se fige pas une seule fois pendant que tu navigues dans le menu.

Bouton-poussoir
Les boutons sont câblés en INPUT_PULLUP ; quand on appuie, la broche lit LOW.
C++ (Arduino IDE)
1// İki butonlu menü + bağımsız LED makinesi / two-button menu + independent LED machine
2// D2: ileri / değer artır, D3: tamam, D10: LED (PWM)
3const int ILERI_PIN = 2, TAMAM_PIN = 3, LED_PIN = 10;
4
5enum MenuDurum { MENU_PARLAKLIK, MENU_HIZ, AYAR_PARLAKLIK, AYAR_HIZ };
6MenuDurum menu = MENU_PARLAKLIK;
7int parlaklik = 153;    // 51..255
8int hizMs = 500;        // yanıp sönme yarım periyodu / blink half period
9
10struct Buton {
11  uint8_t pin;
12  bool kararli;               // kararlı seviye / debounced level
13  bool sonOkuma;
14  unsigned long sonDegisim;
15};
16Buton ileri = {ILERI_PIN, HIGH, HIGH, 0};
17Buton tamam = {TAMAM_PIN, HIGH, HIGH, 0};
18
19// Yalnız basma anında bir kez true döner / true once, on the press edge only
20bool basildi(Buton &b) {
21  bool okuma = digitalRead(b.pin);
22  if (okuma != b.sonOkuma) {
23    b.sonOkuma = okuma;
24    b.sonDegisim = millis();
25  }
26  if (millis() - b.sonDegisim > 30 && okuma != b.kararli) {   // 30 ms debounce
27    b.kararli = okuma;
28    return okuma == LOW;
29  }
30  return false;
31}
32
33void menuYaz() {
34  switch (menu) {
35    case MENU_PARLAKLIK: Serial.println(F("> Parlaklik ayari (D3: sec)")); break;
36    case MENU_HIZ:       Serial.println(F("> Hiz ayari (D3: sec)")); break;
37    case AYAR_PARLAKLIK: Serial.print(F("Parlaklik: ")); Serial.println(parlaklik); break;
38    case AYAR_HIZ:       Serial.print(F("Hiz (ms): ")); Serial.println(hizMs); break;
39  }
40}
41
42void menuGuncelle() {                       // 1. durum makinesi / machine 1
43  bool i = basildi(ileri);
44  bool t = basildi(tamam);
45  if (!i && !t) return;
46
47  switch (menu) {
48    case MENU_PARLAKLIK:
49      if (t) menu = AYAR_PARLAKLIK;
50      else menu = MENU_HIZ;
51      break;
52    case MENU_HIZ:
53      if (t) menu = AYAR_HIZ;
54      else menu = MENU_PARLAKLIK;
55      break;
56    case AYAR_PARLAKLIK:
57      if (t) menu = MENU_PARLAKLIK;          // kaydet ve çık / save and exit
58      else parlaklik = (parlaklik >= 255) ? 51 : parlaklik + 51;
59      break;
60    case AYAR_HIZ:
61      if (t) menu = MENU_HIZ;
62      else hizMs = (hizMs >= 1000) ? 100 : hizMs + 100;
63      break;
64  }
65  menuYaz();
66}
67
68void ledGuncelle() {                         // 2. durum makinesi / machine 2
69  static bool yanik = false;
70  static unsigned long son = 0;
71  if (millis() - son >= (unsigned long)hizMs) {
72    son = millis();
73    yanik = !yanik;
74    analogWrite(LED_PIN, yanik ? parlaklik : 0);
75  }
76}
77
78void setup() {
79  Serial.begin(9600);
80  pinMode(ILERI_PIN, INPUT_PULLUP);
81  pinMode(TAMAM_PIN, INPUT_PULLUP);
82  pinMode(LED_PIN, OUTPUT);
83  menuYaz();
84}
85
86void loop() {
87  menuGuncelle();      // ikisi de beklemeden sırayla çalışır
88  ledGuncelle();       // both run in turn without blocking
89}

Pour lire un bouton, il faut regarder le moment de l'appui, pas le niveau. Si on agissait tant que digitalRead() renvoie LOW, le menu avancerait des centaines de fois pour un seul appui. La fonction basildi() (appuyé) garde le dernier niveau stable de chaque bouton, applique un anti-rebond de 30 ms et ne renvoie true qu'une fois, au passage de HIGH à LOW. Tu trouveras les détails du câblage et des rebonds dans l'article brancher un bouton-poussoir. Pour afficher le menu sur un écran LCD I2C plutôt que dans le moniteur série, il suffit de modifier la fonction menuYaz() ; la machine à états reste la même.

ÉtatD2 (suivant)D3 (OK)
MENU_PARLAKLIKPasser à MENU_HIZEntrer dans AYAR_PARLAKLIK
MENU_HIZPasser à MENU_PARLAKLIKEntrer dans AYAR_HIZ
AYAR_PARLAKLIKAugmenter la luminosité de 51 (retour à 51 après 255)Enregistrer, revenir à MENU_PARLAKLIK
AYAR_HIZAugmenter la durée de 100 ms (retour à 100 après 1000)Enregistrer, revenir à MENU_HIZ

Exemple 3 : un lave-linge

Les vrais appareils suivent souvent un programme étape par étape et réagissent aux événements imprévus. Dans notre simulation de lave-linge, un appui sur le bouton de démarrage en D2 fait successivement prendre l'eau, laver, vidanger, essorer, puis finir par un bip. La vanne d'eau, le moteur et la pompe sont représentés par trois LED. Pendant le lavage, le moteur tourne 2 secondes puis s'arrête 2 secondes ; c'est un petit motif temporisé à l'intérieur de l'état. Surtout, si l'interrupteur du hublot en D3 s'ouvre, la machine se met en pause quelle que soit l'étape, puis reprend là où elle s'était arrêtée, avec le temps restant, quand le hublot se referme.

C++ (Arduino IDE)
1// Çamaşır makinesi durum makinesi (LED'lerle benzetim) / washing machine simulation
2// D8: su vanası, D9: motor, D10: pompa, D11: buzzer, D2: başlat, D3: kapak anahtarı
3const int VANA = 8, MOTOR = 9, POMPA = 10, BUZZER = 11, BASLA = 2, KAPAK = 3;
4
5enum Program { BEKLEME, SU_ALMA, YIKAMA, BOSALTMA, SIKMA, BITTI, DURAKLATILDI };
6const char *const adlar[] = {"BEKLEME", "SU ALMA", "YIKAMA", "BOSALTMA", "SIKMA", "BITTI", "DURAKLATILDI"};
7
8Program durum = BEKLEME;
9Program oncekiDurum = BEKLEME;       // duraklatmadan dönmek için / to resume after pause
10unsigned long durumBaslangic = 0;
11unsigned long kalanGecen = 0;        // duraklatıldığında geçen süre / time spent before pause
12
13const unsigned long SURE_SU = 5000, SURE_YIKAMA = 12000, SURE_BOSALTMA = 4000, SURE_SIKMA = 6000;
14
15void cikislar(bool vana, bool motor, bool pompa) {
16  digitalWrite(VANA, vana);
17  digitalWrite(MOTOR, motor);
18  digitalWrite(POMPA, pompa);
19}
20
21void gir(Program yeni) {                             // giriş eylemleri / entry actions
22  durum = yeni;
23  durumBaslangic = millis();
24  Serial.print(F("Durum: "));
25  Serial.println(adlar[yeni]);
26  switch (yeni) {
27    case BEKLEME:      cikislar(0, 0, 0); break;
28    case SU_ALMA:      cikislar(1, 0, 0); break;
29    case YIKAMA:       cikislar(0, 1, 0); break;
30    case BOSALTMA:     cikislar(0, 0, 1); break;
31    case SIKMA:        cikislar(0, 1, 1); break;
32    case BITTI:        cikislar(0, 0, 0); tone(BUZZER, 2000, 800); break;
33    case DURAKLATILDI: cikislar(0, 0, 0); break;
34  }
35}
36
37bool calisiyor() {
38  return durum == SU_ALMA || durum == YIKAMA || durum == BOSALTMA || durum == SIKMA;
39}
40
41void setup() {
42  Serial.begin(9600);
43  pinMode(VANA, OUTPUT);
44  pinMode(MOTOR, OUTPUT);
45  pinMode(POMPA, OUTPUT);
46  pinMode(BUZZER, OUTPUT);
47  pinMode(BASLA, INPUT_PULLUP);
48  pinMode(KAPAK, INPUT_PULLUP);      // kapak kapalı = LOW / lid closed = LOW
49  gir(BEKLEME);
50}
51
52void loop() {
53  static bool oncekiBasla = HIGH;
54  bool basla = digitalRead(BASLA);
55  bool baslaBasildi = (oncekiBasla == HIGH && basla == LOW);   // basma anı / press edge
56  oncekiBasla = basla;
57  bool kapakAcik = digitalRead(KAPAK) == HIGH;
58
59  // Her çalışma durumu için ortak kural: kapak açılırsa duraklat
60  // Common rule for every running state: pause if the lid opens
61  if (calisiyor() && kapakAcik) {
62    oncekiDurum = durum;
63    kalanGecen = millis() - durumBaslangic;
64    gir(DURAKLATILDI);
65    return;
66  }
67
68  unsigned long gecen = millis() - durumBaslangic;
69  switch (durum) {
70    case BEKLEME:
71      if (baslaBasildi && !kapakAcik) gir(SU_ALMA);
72      break;
73    case SU_ALMA:
74      if (gecen >= SURE_SU) gir(YIKAMA);
75      break;
76    case YIKAMA:
77      digitalWrite(MOTOR, (gecen / 2000) % 2 == 0);  // 2 sn çalış, 2 sn dur / 2 s on, 2 s off
78      if (gecen >= SURE_YIKAMA) gir(BOSALTMA);
79      break;
80    case BOSALTMA:
81      if (gecen >= SURE_BOSALTMA) gir(SIKMA);
82      break;
83    case SIKMA:
84      if (gecen >= SURE_SIKMA) gir(BITTI);
85      break;
86    case BITTI:
87      if (gecen >= 3000) gir(BEKLEME);
88      break;
89    case DURAKLATILDI:
90      if (!kapakAcik) {
91        gir(oncekiDurum);                            // kaldığı yere dön / resume
92        durumBaslangic = millis() - kalanGecen;      // kalan süreyi koru / keep remaining time
93      }
94      break;
95  }
96}

La pause illustre deux techniques puissantes des machines à états. La première est une règle commune : le contrôle du hublot est fait à un seul endroit, avant le switch, pour tous les états en marche ; on ne l'écrit pas dans chaque case. La seconde consiste à mémoriser l'état précédent : la variable oncekiDurum garde l'étape quittée et kalanGecen le temps déjà passé dedans. Quand le hublot se referme, la machine revient dans le même état et l'horodatage est reculé du temps écoulé, si bien que l'étape ne recommence pas de zéro. Dans un vrai appareil, un module relais commande la vanne, le moteur et la pompe à la place des LED.

Cet exemple n'est qu'une simulation avec des LED. N'essaie pas de remplacer la carte de commande d'un vrai lave-linge, d'un chauffage ou d'une pompe alimentés sur le secteur ; la tension secteur présente un danger de mort et un risque d'incendie.

Faire tourner plusieurs machines à états en même temps

Comme dans l'exemple du menu, chaque tâche indépendante peut être sa propre machine à états. Une bonne organisation consiste à placer chaque machine dans sa propre fonction et à simplement appeler ces fonctions à tour de rôle dans loop() : trafikGuncelle(), butonGuncelle(), ekranGuncelle(), etc. Comme aucune fonction n'attend, loop fait un tour toutes les quelques microsecondes et toutes les machines semblent tourner en même temps. Les machines communiquent par des variables partagées : la machine du menu modifie hizMs et celle de la LED la lit. C'est la façon la plus simple de faire du multitâche sur Arduino sans vrai système d'exploitation. Une machine ne devrait pas changer directement l'état d'une autre ; elle doit plutôt laisser une variable de demande, comme pour la demande piéton.

  • Utilise une variable d'état et un horodatage par machine ; ne les partage pas entre machines.
  • Garder la variable d'état en static dans la fonction ou dans un struct propre à la machine évite les conflits de noms.
  • Laisse la machine qui traite une demande (comme yayaIstegi) l'effacer elle-même.
  • Pendant le débogage, affiche le nom de l'état dans le moniteur série à chaque changement ; tu verras tout de suite où le programme bloque.

Machine à états en MicroPython sur le Raspberry Pi Pico

MicroPython n'a pas d'enum ; tu définis les états comme des nombres constants ou des chaînes. Grâce aux dictionnaires de Python, il est très facile d'écrire la machine à états entièrement pilotée par des tables : les feux, la durée et l'état suivant de chaque état sont rangés dans des dictionnaires, et la boucle décide en consultant ces tables. Pour ajouter un état, tu ajoutes une ligne aux tables, pas au code. Pour la temporisation, on utilise time.ticks_ms() et time.ticks_diff() ; ticks_diff donne la bonne différence même quand le compteur déborde. Dans le code ci-dessous, les LED sont sur GP13 (rouge), GP12 (orange) et GP11 (vert), et le bouton piéton sur GP4. Si tu débutes en MicroPython, commence par l'article les bases de MicroPython.

MicroPython
1# Raspberry Pi Pico MicroPython: tablo tabanlı trafik lambası durum makinesi
2# Table-driven traffic light state machine
3from machine import Pin
4import time
5
6kirmizi = Pin(13, Pin.OUT)
7sari = Pin(12, Pin.OUT)
8yesil = Pin(11, Pin.OUT)
9buton = Pin(4, Pin.IN, Pin.PULL_UP)
10
11KIRMIZI, KIRMIZI_SARI, YESIL, SARI = 0, 1, 2, 3      # durumlar / states
12ADLAR = ("KIRMIZI", "KIRMIZI_SARI", "YESIL", "SARI")
13LAMBALAR = {KIRMIZI: (1, 0, 0), KIRMIZI_SARI: (1, 1, 0), YESIL: (0, 0, 1), SARI: (0, 1, 0)}
14SURE = {KIRMIZI: 5000, KIRMIZI_SARI: 1500, YESIL: 10000, SARI: 2000}
15SONRAKI = {KIRMIZI: KIRMIZI_SARI, KIRMIZI_SARI: YESIL, YESIL: SARI, SARI: KIRMIZI}
16
17durum = KIRMIZI
18baslangic = time.ticks_ms()
19yaya_istegi = False
20
21def gir(yeni):
22    global durum, baslangic, yaya_istegi
23    durum = yeni
24    baslangic = time.ticks_ms()
25    k, s, y = LAMBALAR[yeni]
26    kirmizi.value(k)
27    sari.value(s)
28    yesil.value(y)
29    if yeni == KIRMIZI:
30        yaya_istegi = False          # yayalar geçer / pedestrians cross
31    print("durum:", ADLAR[yeni])
32
33gir(KIRMIZI)
34while True:
35    if buton.value() == 0:
36        yaya_istegi = True
37    gecen = time.ticks_diff(time.ticks_ms(), baslangic)   # taşmaya dayanıklı / overflow safe
38    sure = SURE[durum]
39    if durum == YESIL and yaya_istegi:
40        sure = 4000
41    if gecen >= sure:
42        gir(SONRAKI[durum])
43    time.sleep_ms(10)

Erreurs fréquentes et solutions

ErreurSymptômeSolution
delay() dans un étatLes boutons et les autres machines se figentVérifie le temps écoulé avec millis() au lieu d'attendre
Oublier le breakLe code d'un état exécute aussi celui du suivantTermine chaque case par break
Ne pas réinitialiser l'horodatageLe nouvel état se termine aussitôt ou jamaisFais toutes les transitions via une seule fonction durumDegistir()
Regarder le niveau du boutonUn appui provoque plusieurs transitionsDétecte le moment de l'appui et applique un anti-rebond
Répéter l'action d'entrée dans l'étatLe moniteur série déborde, le buzzer sonne sans arrêtDéplace le travail ponctuel dans l'action d'entrée
Un état sans sortieLe programme reste bloqué pour toujours dans un étatVérifie qu'au moins une flèche sort de chaque état
Écrire la comparaison millis() avec une additionLa temporisation se dérègle au bout de 49,7 joursUtilise toujours la forme millis() - debut >= duree
Si ton nombre d'états dépasse 8 à 10, pense à découper la machine : pour le lave-linge, « choix du programme » et « exécution du programme » pourraient être deux machines distinctes. De petites machines qui communiquent par des variables de demande sont bien plus faciles à comprendre qu'une seule machine géante.

Idées de projets avec des machines à états

  • Coffre à code : une serrure avec clavier et servo et les états KILITLI (verrouillé), SIFRE_GIRILIYOR (saisie du code), ACIK (ouvert) et ALARM ; un mauvais code déclenche le buzzer dans l'état ALARM.
  • Jeu de mémoire Simon : un jeu qui montre une séquence de LED au joueur et lit les boutons, avec les états GOSTER (montrer), BEKLE (attendre), KONTROL (vérifier) et KAYBETTIN (perdu).
  • Éclairage d'escalier intelligent : une lumière avec les états BOS (repos), YANIYOR (allumée) et SONUYOR (en extinction) qui s'allume à la détection d'un mouvement et s'éteint doucement à la fin du délai.
  • Test de réaction : un jeu avec les états HAZIR (prêt), RASTGELE_BEKLE (attente aléatoire), OLC (mesure) et SONUC (résultat) qui mesure le temps de réaction en millisecondes.
  • Robot piloté par liaison série : un véhicule avec les états DUR (arrêt), ILERI (avance), DON (virage) et ENGEL (obstacle) qui réagit à la fois aux capteurs et aux commandes.

Une machine à états transforme chacun de tes projets Arduino en un code plus ordonné, plus réactif et plus facile à faire grandir. Dans l'application BlueGrays, tu trouveras des projets comme un feu tricolore, la commande d'une LED avec un bouton, un compteur sur afficheur 7 segments, une serrure à code avec clavier, le jeu Simon et un feu tricolore à quatre modes avec le Raspberry Pi Pico, chacun avec schéma et code pas à pas ; applique-leur la structure de machine à états de ce guide.

Questions fréquentes

Qu'est-ce qu'une machine à états sur Arduino ?

Une machine à états est une structure de code qui découpe le programme en un nombre limité d'états et ne se trouve que dans un seul à la fois. Dans chaque état, on sait quoi faire et à quelle condition passer à un autre. Sur Arduino, on l'écrit en général avec enum, switch-case et millis().

Comment utiliser enum sur Arduino ?

On le définit par exemple avec enum Durum { BEKLE, CALIS, BITTI }; et on crée une variable avec Durum durum = BEKLE;. Le compilateur transforme les noms en nombres comme 0, 1 et 2, mais dans le code tu utilises des noms parlants. La définition de l'enum doit se trouver en haut du fichier, avant les fonctions.

Comment écrire une machine à états avec switch-case ?

Tu places la variable d'état dans switch(durum) et tu écris un bloc case pour chaque état. Dans chaque bloc, tu testes la condition de sortie de l'état et tu changes d'état si elle est remplie. N'oublie pas de terminer chaque case par break.

Comment attendre sans delay sur Arduino ?

Enregistre avec millis() l'instant où tu entres dans un état et teste à chaque tour de loop la condition millis() - debut >= duree. Si le temps n'est pas écoulé, loop continue aussitôt et les autres tâches ne sont pas bloquées. Cette méthode reste correcte même quand millis() déborde.

Un Arduino peut-il faire plusieurs choses à la fois ?

L'Arduino Uno n'a qu'un cœur, il ne fait donc pas vraiment plusieurs choses en même temps, mais avec des machines à états non bloquantes il les exécute à tour de rôle des milliers de fois par seconde et elles paraissent simultanées. Il suffit de mettre chaque tâche dans sa propre fonction et de les appeler à tour de rôle dans loop().

Comment écrire une machine à états en MicroPython ?

MicroPython n'a pas d'enum, les états sont donc définis par des nombres constants. Une structure pilotée par des tables, qui range dans des dictionnaires la durée, les sorties et l'état suivant de chaque état, est très pratique. Pour la temporisation, on utilise time.ticks_ms() et time.ticks_diff().

Voir tous les projets
Feu de circulation
AR-3Débutant

Feu de circulation

Une copie miniature du feu tricolore que tu vois chaque jour dans la rue. Le rouge reste allumé deux secondes, l'orange brille un court instant, le vert reste deux secondes, puis on revient au rouge…

4.8(137)
440
Allumer et éteindre une LED avec un bouton
AR-10Débutant

Allumer et éteindre une LED avec un bouton

Un appui et la lumière s'allume, un deuxième et elle s'éteint, exactement comme l'interrupteur de ta chambre.

4.7(103)
177
Feu de circulation ESP32
ES-5Débutant

Feu de circulation ESP32

Simulation d'un vrai feu de circulation avec 3 LED rouge-jaune-vert. Les temps sont proches de la logique du trafic réel : rouge long, jaune court, vert long. Exemple classique de contrôle séquentiel GPIO.

4.4(22)
45
Simulateur de Feu de Circulation Raspberry Pi Pico (3 LEDs séquentielles)
PI-4Débutant

Simulateur de Feu de Circulation Raspberry Pi Pico (3 LEDs séquentielles)

Nous simulons un vrai feu de circulation avec des LEDs rouge, jaune et verte. Vert 4 sec "passez", jaune 1,5 sec "préparez", rouge 3 sec "arrêtez" et rouge+jaune 1 sec "départ" (motif européen). Apprends la définition de fonction, la logique de machine à états et la synchronisation multi-GPIO. Circuit simple : 3 LEDs sur GP11/GP12/GP13, chacune avec 220Ω.

4.0(1)
12
Feu de signalisation Raspberry Pi Pico avec sélecteur à 4 modes (machine à états)
PI-12Intermédiaire

Feu de signalisation Raspberry Pi Pico avec sélecteur à 4 modes (machine à états)

4 modes de feu tricolore avec 1 bouton ! Chaque appui change de mode : cycle normal (rouge → jaune → vert), rouge seul (arrêt), jaune clignotant (prudence/mode nuit) et éteint (maintenance). Tu apprends la machine à états (la variable mode décide du comportement exécuté) et le passage d'un mode à l'autre avec (mode + 1) % 4.

5.0(1)
16
Compteur avec afficheur 7 segments et boutons
AR-43Avancé
Premium

Compteur avec afficheur 7 segments et boutons

Un compteur tout simple à trois boutons : avec l'un, le chiffre affiché monte d'un cran, avec l'autre il descend d'un cran, et le troisième le remet à zéro.

4.6(35)
47
Serrure à code avec clavier 4x4 et écran LCD
AR-64Avancé
Premium

Serrure à code avec clavier 4x4 et écran LCD

Une petite serrure électronique qui ne laisse entrer que ceux qui connaissent le code.

4.8(59)
75
Jeu de mémoire avec Arduino (4 LED + 4 boutons + buzzer)
AR-93Avancé
Premium

Jeu de mémoire avec Arduino (4 LED + 4 boutons + buzzer)

Tu as confiance en ta mémoire ? Quatre LED de couleur s'allument dans un certain ordre, chacune avec sa propre note, et tu dois refaire la même suite en appuyant sur les boutons.

4.8(46)
69