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.
| Notion | Signification | Exemple du feu tricolore |
|---|---|---|
| État | La situation actuelle du système | KIRMIZI (rouge), KIRMIZI_SARI (rouge-orange), YESIL (vert), SARI (orange) |
| Transition | Passage d'un état à un autre | De YESIL à SARI |
| Condition ou événement | Ce qui déclenche la transition | 10 secondes écoulées ou bouton piéton appuyé |
| Action d'entrée | Travail fait une fois en entrant | Allumer la LED verte, éteindre les autres |
| Action dans l'état | Travail fait en continu dans l'état | Surveiller 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éristique | Code avec delay() | Machine à états |
|---|---|---|
| Les boutons sont-ils lus pendant l'attente ? | Non | Oui |
| Plusieurs tâches à la fois | Difficile, le code s'emmêle | Facile, chaque tâche dans sa machine |
| Ajouter un état | Il faut réécrire tout le déroulement | On ajoute un case |
| Débogage | On ne sait pas où en est le programme | Afficher le nom de l'état dans le moniteur série suffit |
| Mémoire | Peu | Peu (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.
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}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.
- Liste tous les états du système et donne à chacun un nom court en majuscules.
- Choisis l'état initial ; l'Arduino s'y trouvera à la mise sous tension ou après un reset.
- Écris les conditions de sortie de chaque état : durée, bouton, capteur ou autre événement.
- Ajoute l'état cible de chaque transition et l'action éventuelle à réaliser pendant celle-ci.
- Définis l'action d'entrée de chaque état : quelles sorties seront actives, lesquelles éteintes ?
- Note à part les règles communes valables dans tous les états (arrêt d'urgence, ouverture du hublot).
- Transforme le diagramme en tableau de transitions comme celui ci-dessous et écris chaque ligne sous forme de if dans un case.
| État | Condition | État suivant | Action d'entrée |
|---|---|---|---|
| KIRMIZI | 5 s écoulées | KIRMIZI_SARI | Rouge allumé, demande piéton effacée |
| KIRMIZI_SARI | 1,5 s écoulée | YESIL | Rouge et orange allumés |
| YESIL | 10 s écoulées, ou 4 s s'il y a une demande | SARI | Vert allumé |
| SARI | 2 s écoulées | KIRMIZI | Orange 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.

| Élément | Broche Arduino Uno | Remarque |
|---|---|---|
| LED rouge | D8 | Avec une résistance de 220 Ω, patte courte au GND |
| LED orange | D9 | Avec une résistance de 220 Ω |
| LED verte | D10 | Avec une résistance de 220 Ω (broche PWM) |
| Buzzer | D11 | Seulement dans l'exemple du lave-linge |
| Bouton 1 | D2 | Autre patte au GND, INPUT_PULLUP |
| Bouton 2 | D3 | Autre patte au GND, INPUT_PULLUP |
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.

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.
| État | D2 (suivant) | D3 (OK) |
|---|---|---|
| MENU_PARLAKLIK | Passer à MENU_HIZ | Entrer dans AYAR_PARLAKLIK |
| MENU_HIZ | Passer à MENU_PARLAKLIK | Entrer dans AYAR_HIZ |
| AYAR_PARLAKLIK | Augmenter la luminosité de 51 (retour à 51 après 255) | Enregistrer, revenir à MENU_PARLAKLIK |
| AYAR_HIZ | Augmenter 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.
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.
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.
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
| Erreur | Symptôme | Solution |
|---|---|---|
| delay() dans un état | Les boutons et les autres machines se figent | Vérifie le temps écoulé avec millis() au lieu d'attendre |
| Oublier le break | Le code d'un état exécute aussi celui du suivant | Termine chaque case par break |
| Ne pas réinitialiser l'horodatage | Le nouvel état se termine aussitôt ou jamais | Fais toutes les transitions via une seule fonction durumDegistir() |
| Regarder le niveau du bouton | Un appui provoque plusieurs transitions | Détecte le moment de l'appui et applique un anti-rebond |
| Répéter l'action d'entrée dans l'état | Le moniteur série déborde, le buzzer sonne sans arrêt | Déplace le travail ponctuel dans l'action d'entrée |
| Un état sans sortie | Le programme reste bloqué pour toujours dans un état | Vérifie qu'au moins une flèche sort de chaque état |
| Écrire la comparaison millis() avec une addition | La temporisation se dérègle au bout de 49,7 jours | Utilise toujours la forme millis() - debut >= duree |
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().
Projets à réaliser après cet article
Voir tous les projets
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…

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.

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.

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

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.

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.

Serrure à code avec clavier 4x4 et écran LCD
Une petite serrure électronique qui ne laisse entrer que ceux qui connaissent le code.

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.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

