Macchina a stati con Arduino: enum, switch-case e millis()
Macchina a stati con Arduino: stati con enum e switch-case, transizioni, stati temporizzati con millis, semaforo, menu, lavatrice e versione per Pico.
Una macchina a stati con Arduino (state machine) è un modo di scrivere codice in cui dividi il programma in stati separati e ti trovi sempre in uno solo di essi. Un semaforo è nello stato "rosso", "giallo" o "verde"; una lavatrice sta "caricando acqua", "lavando" o "centrifugando". In ogni stato è chiaro cosa fare e a quale condizione passare al successivo. Con Arduino la costruisci con un enum, uno switch-case e millis(). Il risultato è un codice che svolge più compiti insieme senza delay() ed è facile da leggere e da ampliare.
In questa guida vedremo prima i concetti di stato, transizione e azione, come disegnare un diagramma degli stati e la macchina più semplice a due stati. Poi scriveremo un semaforo con pulsante pedonale, un menu di impostazioni che si scorre con due pulsanti e la simulazione di una lavatrice che si mette in pausa quando si apre lo sportello. Imparerai anche a far girare più macchine a stati nello stesso loop(), le azioni di ingresso, gli errori più comuni e come si scrive la stessa struttura in MicroPython sul Raspberry Pi Pico.
Cos'è una macchina a stati?
Una macchina a stati (macchina a stati finiti, FSM) ha quattro parti. Gli stati sono le situazioni, in numero limitato, in cui può trovarsi il sistema. Le transizioni portano da uno stato all'altro, e le condizioni o eventi decidono quando succede: la pressione di un pulsante, un sensore che supera una soglia o un tempo che scade. Le azioni sono il lavoro fatto entrando in uno stato o restandoci: accendere un LED, avviare un motore, scrivere su un display. A ogni giro di loop() il programma si chiede solo: "In che stato sono e la condizione per uscirne si è verificata?" Così non aspetta mai e, al posto di if annidati e decine di variabili flag, ottieni una struttura ordinata attorno a una sola variabile di stato.
| Concetto | Significato | Esempio del semaforo |
|---|---|---|
| Stato | La situazione attuale del sistema | KIRMIZI (rosso), KIRMIZI_SARI (rosso-giallo), YESIL (verde), SARI (giallo) |
| Transizione | Passaggio da uno stato a un altro | Da YESIL a SARI |
| Condizione o evento | Ciò che fa scattare la transizione | Sono passati 10 secondi o è stato premuto il pulsante pedonale |
| Azione di ingresso | Lavoro fatto una volta entrando | Accendere il LED verde, spegnere gli altri |
| Azione nello stato | Lavoro fatto di continuo nello stato | Controllare il pulsante pedonale |
Perché una macchina a stati invece di delay()?
Quando scrivi delay(5000), Arduino non fa nulla per cinque secondi: non si accorge della pressione di un pulsante, non legge i sensori, non aggiorna il display. Nei programmi piccoli con un solo compito va bene, ma appena aggiungi un secondo compito il codice inizia a rompersi. In una macchina a stati non si aspetta mai; ogni stato chiede con millis() "quanto tempo è passato da quando sono entrato?" e, se il tempo non è scaduto, torna subito a loop(). Dato che loop gira migliaia di volte al secondo, gli altri compiti come pulsanti, sensori e display continuano senza interruzioni. Abbiamo spiegato a fondo la temporizzazione con millis() nell'articolo millis e delay con Arduino.
| Caratteristica | Codice con delay() | Macchina a stati |
|---|---|---|
| I pulsanti vengono letti durante l'attesa? | No | Sì |
| Più compiti insieme | Difficile, il codice si ingarbuglia | Facile, ogni compito nella sua macchina |
| Aggiungere uno stato | Va riscritto tutto il flusso | Si aggiunge un case |
| Debug | Non si sa dove sia il programma | Basta stampare il nome dello stato nel Monitor seriale |
| Memoria | Poca | Poca (una variabile e un timestamp) |
La prima macchina a stati con enum e switch-case
Un enum serve a dare nomi agli stati invece di numeri. La riga enum Durum { YANIK, SONUK }; (acceso, spento) definisce un nuovo tipo che per il compilatore vale 0 e 1, ma per te ha nomi significativi. La variabile di stato è di questo tipo e lo switch-case esegue un blocco diverso per ogni stato. Nell'esempio qui sotto il LED integrato dell'Uno (D13) resta acceso 200 ms e spento 1,8 secondi. Si potrebbe fare anche con delay, ma con questa struttura loop() non aspetta mai e alla fine puoi aggiungere tutti gli altri compiti che vuoi.
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}Disegnare il diagramma degli stati
Disegnare la macchina a stati su carta prima di programmare elimina la maggior parte degli errori prima ancora di iniziare. Nel diagramma ogni stato è un cerchio o un riquadro arrotondato e ogni transizione è una freccia. Sulla freccia scrivi la condizione della transizione e, se serve, l'azione dopo una barra, per esempio "10 s / accendi il giallo". Lo stato iniziale si indica con una piccola freccia che non parte da nessuno stato. Finito il diagramma, poniti queste domande per ogni stato: c'è un'uscita da questo stato? Se due condizioni sono vere insieme, quale viene prima? Cosa succede con un evento imprevisto (sportello aperto, sensore guasto)? Trasformare il diagramma in una tabella rende la scrittura del codice quasi meccanica.
- Elenca tutti gli stati del sistema e dai a ciascuno un nome breve in maiuscolo.
- Scegli lo stato iniziale; Arduino sarà in questo stato all'accensione o dopo un reset.
- Scrivi le condizioni di uscita di ogni stato: tempo, pulsante, sensore o altro evento.
- Aggiungi lo stato di destinazione di ogni transizione e l'eventuale azione da compiere durante la transizione.
- Decidi l'azione di ingresso di ogni stato: quali uscite saranno accese e quali spente?
- Annota a parte le regole comuni valide in tutti gli stati (arresto di emergenza, apertura dello sportello).
- Trasforma il diagramma in una tabella delle transizioni come quella qui sotto e scrivi ogni riga come un if dentro un case.
| Stato | Condizione | Stato successivo | Azione di ingresso |
|---|---|---|---|
| KIRMIZI | Passati 5 s | KIRMIZI_SARI | Rosso acceso, richiesta pedonale cancellata |
| KIRMIZI_SARI | Passati 1,5 s | YESIL | Rosso e giallo accesi |
| YESIL | Passati 10 s, o 4 s se c'è una richiesta | SARI | Verde acceso |
| SARI | Passati 2 s | KIRMIZI | Giallo acceso |
Esempio 1: semaforo con pulsante pedonale
La sequenza classica del semaforo è rosso, rosso-giallo, verde e giallo. Aggiungiamo un pulsante pedonale: se un pedone lo preme mentre è verde, il verde si accorcia, purché sia rimasto acceso almeno 4 secondi, e il semaforo passa al giallo. Scritto con delay, questo comportamento è quasi impossibile, perché non puoi leggere il pulsante mentre aspetti sul verde. In una macchina a stati il pulsante viene letto a ogni giro di loop e la richiesta viene memorizzata in una variabile. Se non hai mai montato il circuito base del semaforo, guarda prima l'articolo semaforo con Arduino.

| Parte | Pin di Arduino Uno | Nota |
|---|---|---|
| LED rosso | D8 | Con resistenza da 220 Ω, gamba corta a GND |
| LED giallo | D9 | Con resistenza da 220 Ω |
| LED verde | D10 | Con resistenza da 220 Ω (pin con PWM) |
| Buzzer | D11 | Solo nell'esempio della lavatrice |
| Pulsante 1 | D2 | L'altro piedino a GND, INPUT_PULLUP |
| Pulsante 2 | D3 | L'altro piedino a 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 parte più importante di questo codice è la funzione durumDegistir() (cambia stato). Passando a uno stato succedono tre cose: si aggiorna la variabile di stato, si azzera il timestamp e si esegue una volta l'azione di ingresso dello stato. Far passare tutte le transizioni da questa unica funzione elimina errori del tipo "ho dimenticato di azzerare il timer". La richiesta pedonale viene cancellata entrando in KIRMIZI, perché in quel momento i pedoni attraversano comunque. Per calcolare le resistenze dei LED puoi usare il calcolatore della resistenza per LED.
Esempio 2: menu di impostazioni a due pulsanti
I menu sono l'uso più naturale di una macchina a stati: la pagina mostrata è uno stato e i pulsanti fanno scattare le transizioni. Nell'esempio qui sotto il pulsante D2 significa "avanti" o "aumenta il valore" e D3 significa "OK". Nel menu principale passi tra luminosità e velocità; con OK entri nella pagina di impostazione, cambi il valore con D2 ed esci con OK. Nello stesso tempo una seconda macchina a stati indipendente fa lampeggiare il LED su D10 con la luminosità e la velocità scelte. Mentre navighi nel menu il LED non si blocca nemmeno per un attimo.

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}Leggendo i pulsanti bisogna guardare il momento della pressione, non il livello. Se agissimo finché digitalRead() restituisce LOW, il menu avanzerebbe centinaia di volte con una sola pressione. La funzione basildi() (premuto) ricorda l'ultimo livello stabile di ogni pulsante, applica un antirimbalzo di 30 ms e restituisce true una sola volta, al passaggio da HIGH a LOW. Trovi i dettagli del collegamento e dei rimbalzi nell'articolo come collegare un pulsante. Per mostrare il menu su un display LCD I2C invece che nel Monitor seriale basta cambiare la funzione menuYaz(); la macchina a stati resta la stessa.
| Stato | D2 (avanti) | D3 (OK) |
|---|---|---|
| MENU_PARLAKLIK | Vai a MENU_HIZ | Entra in AYAR_PARLAKLIK |
| MENU_HIZ | Vai a MENU_PARLAKLIK | Entra in AYAR_HIZ |
| AYAR_PARLAKLIK | Aumenta la luminosità di 51 (dopo 255 torna a 51) | Salva, torna a MENU_PARLAKLIK |
| AYAR_HIZ | Aumenta il tempo di 100 ms (dopo 1000 torna a 100) | Salva, torna a MENU_HIZ |
Esempio 3: una lavatrice
Gli apparecchi reali di solito seguono un programma passo per passo e reagiscono agli eventi imprevisti. Nella nostra simulazione di lavatrice, premendo il pulsante di avvio su D2 la macchina carica l'acqua, lava, scarica, centrifuga e termina con un bip, in quest'ordine. La valvola dell'acqua, il motore e la pompa sono rappresentati da tre LED. Nello stato di lavaggio il motore gira 2 secondi e si ferma 2 secondi; è un piccolo schema temporizzato dentro lo stato. Soprattutto, se l'interruttore dello sportello su D3 si apre, la macchina va in pausa in qualsiasi fase si trovi e, quando lo sportello si richiude, riprende da dove si era fermata con il tempo rimanente.
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 pausa mostra due tecniche potenti delle macchine a stati. La prima è una regola comune: il controllo dello sportello è fatto in un solo punto, prima dello switch, per tutti gli stati in funzione; non va scritto in ogni case. La seconda è ricordare lo stato precedente: la variabile oncekiDurum memorizza da quale fase si è usciti e kalanGecen quanto tempo vi era già trascorso. Quando lo sportello si chiude la macchina torna nello stesso stato e il timestamp viene arretrato del tempo trascorso, così la fase non ricomincia da capo. In un apparecchio reale un modulo relè comanda valvola, motore e pompa al posto dei LED.
Far girare più macchine a stati insieme
Come hai visto nell'esempio del menu, ogni compito indipendente può essere una propria macchina a stati. Una buona organizzazione è mettere ogni macchina in una sua funzione e chiamare queste funzioni a turno dentro loop(): trafikGuncelle(), butonGuncelle(), ekranGuncelle() e così via. Dato che nessuna funzione aspetta, loop compie un giro ogni pochi microsecondi e tutte le macchine sembrano funzionare insieme. Le macchine comunicano tramite variabili condivise: la macchina del menu cambia hizMs e quella del LED la legge. È il modo più semplice di fare multitasking su Arduino senza un vero sistema operativo. Una macchina non dovrebbe cambiare direttamente lo stato di un'altra; dovrebbe invece lasciare una variabile di richiesta, come per la richiesta pedonale.
- Usa una variabile di stato e un timestamp per ogni macchina; non condividerli tra macchine.
- Tenere la variabile di stato static dentro la funzione o in uno struct dedicato evita conflitti di nomi.
- Fai cancellare una richiesta (come yayaIstegi) alla macchina che la gestisce.
- Durante il debug stampa il nome dello stato nel Monitor seriale a ogni cambio; vedrai subito dove si blocca il programma.
Macchina a stati in MicroPython sul Raspberry Pi Pico
MicroPython non ha enum; definisci gli stati come numeri costanti o stringhe. Grazie ai dizionari di Python è molto facile scrivere la macchina a stati completamente guidata da tabelle: luci, durata e stato successivo di ogni stato stanno in dizionari separati e il ciclo decide consultando queste tabelle. Per aggiungere uno stato aggiungi una riga alle tabelle, non al codice. Per la temporizzazione si usano time.ticks_ms() e time.ticks_diff(); ticks_diff dà la differenza corretta anche quando il contatore va in overflow. Nel codice qui sotto i LED sono su GP13 (rosso), GP12 (giallo) e GP11 (verde) e il pulsante pedonale su GP4. Se sei alle prime armi con MicroPython, parti dall'articolo basi di 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)Errori comuni e soluzioni
| Errore | Sintomo | Soluzione |
|---|---|---|
| delay() dentro uno stato | Pulsanti e altre macchine si bloccano | Invece di aspettare controlla il tempo trascorso con millis() |
| Dimenticare il break | Il codice di uno stato esegue anche quello del successivo | Chiudi ogni case con break |
| Non azzerare il timestamp | Il nuovo stato finisce subito o mai | Fai tutte le transizioni con un'unica funzione durumDegistir() |
| Guardare il livello del pulsante | Una pressione provoca più transizioni | Rileva il momento della pressione e applica l'antirimbalzo |
| Ripetere l'azione di ingresso dentro lo stato | Il Monitor seriale si riempie, il buzzer suona di continuo | Sposta il lavoro da fare una volta nell'azione di ingresso |
| Uno stato senza uscita | Il programma resta per sempre in uno stato | Controlla che da ogni stato esca almeno una freccia |
| Scrivere il confronto di millis() con una somma | La temporizzazione si guasta dopo 49,7 giorni | Usa sempre la forma millis() - inizio >= durata |
Idee di progetto con le macchine a stati
- Cassaforte con codice: una serratura con tastierino e servo e gli stati KILITLI (chiusa), SIFRE_GIRILIYOR (inserimento codice), ACIK (aperta) e ALARM; con un codice sbagliato il buzzer suona nello stato ALARM.
- Gioco di memoria Simon: un gioco che mostra al giocatore una sequenza di LED e legge i pulsanti, con gli stati GOSTER (mostra), BEKLE (attendi), KONTROL (controlla) e KAYBETTIN (hai perso).
- Luce intelligente per le scale: un'illuminazione con gli stati BOS (riposo), YANIYOR (accesa) e SONUYOR (in spegnimento) che si accende quando rileva un movimento e si spegne lentamente allo scadere del tempo.
- Test dei riflessi: un gioco con gli stati HAZIR (pronto), RASTGELE_BEKLE (attesa casuale), OLC (misura) e SONUC (risultato) che misura il tempo di reazione in millisecondi.
- Robot comandato via seriale: un veicolo con gli stati DUR (fermo), ILERI (avanti), DON (svolta) ed ENGEL (ostacolo) che reagisce insieme a sensori e comandi.
Una macchina a stati trasforma ogni tuo progetto Arduino in codice più ordinato, più reattivo e più facile da far crescere. Nell'app BlueGrays trovi progetti come un semaforo, il controllo di un LED con un pulsante, un contatore con display a 7 segmenti, una serratura a codice con tastierino, il gioco Simon e un semaforo a quattro modalità con il Raspberry Pi Pico, ognuno con schema e codice passo per passo; applica a questi progetti la struttura a stati di questa guida.
Domande frequenti
Cos'è una macchina a stati con Arduino?
Una macchina a stati è una struttura di codice che divide il programma in un numero limitato di stati e si trova sempre in uno solo di essi. In ogni stato è chiaro cosa fare e a quale condizione passare a un altro. Con Arduino di solito si scrive con enum, switch-case e millis().
Come si usa enum con Arduino?
Si definisce come enum Durum { BEKLE, CALIS, BITTI }; e si crea una variabile con Durum durum = BEKLE;. Il compilatore trasforma i nomi in numeri come 0, 1 e 2, ma nel codice usi nomi significativi. La definizione dell'enum va messa all'inizio del file, prima delle funzioni.
Come si scrive una macchina a stati con switch-case?
Metti la variabile di stato in switch(durum) e scrivi un blocco case per ogni stato. In ogni blocco controlli la condizione di uscita di quello stato e, se è vera, cambi stato. Non dimenticare il break alla fine di ogni case.
Come si aspetta con Arduino senza delay?
Salva con millis() il momento in cui entri in uno stato e controlla a ogni giro di loop la condizione millis() - inizio >= durata. Se il tempo non è scaduto, loop prosegue subito e gli altri compiti non si bloccano. Il metodo funziona correttamente anche quando millis() va in overflow.
Arduino può fare più cose contemporaneamente?
L'Arduino Uno ha un solo core, quindi non fa davvero più cose insieme, ma con macchine a stati non bloccanti le esegue a turno migliaia di volte al secondo e sembrano simultanee. Basta mettere ogni compito in una sua funzione e chiamarle a turno dentro loop().
Come si scrive una macchina a stati in MicroPython?
MicroPython non ha enum, quindi gli stati si definiscono come numeri costanti. È molto pratica una struttura guidata da tabelle che tiene in dizionari durata, uscite e stato successivo di ogni stato. Per la temporizzazione si usano time.ticks_ms() e time.ticks_diff().
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Semaforo
Una copia in miniatura del semaforo che vedi ogni giorno per strada. Il rosso resta acceso due secondi, il giallo brilla per un attimo, il verde resta due secondi, poi si torna al rosso passando di…

Accendere e spegnere un LED con un pulsante
Premi il pulsante una volta e la luce si accende, premilo di nuovo e si spegne, proprio come l'interruttore della tua stanza.

Semaforo ESP32
Simulazione di un vero semaforo con 3 LED rosso-giallo-verde. I tempi si avvicinano alla logica del traffico reale: rosso lungo, giallo corto, verde lungo. Classico esempio di controllo GPIO sequenziale.

Simulatore Semaforo Raspberry Pi Pico (3 LED Sequenziali)
Simuliamo un vero semaforo con LED rosso, giallo e verde. Verde 4 sec "vai", giallo 1,5 sec "preparati", rosso 3 sec "fermati" e rosso+giallo 1 sec "partenza" (pattern europeo). Impara la definizione di funzione, la logica della macchina a stati e la sincronizzazione multi-GPIO. Circuito semplice: 3 LED su GP11/GP12/GP13.

Semaforo Raspberry Pi Pico con selettore a 4 posizioni (macchina a stati)
4 modalità del semaforo con 1 pulsante! A ogni pressione cambia modalità: ciclo normale (rosso → giallo → verde), solo rosso (stop), giallo lampeggiante (attenzione/modalità notte) e spento (manutenzione). Impari la macchina a stati (la variabile mode decide quale comportamento eseguire) e a scorrere le modalità con (mode + 1) % 4.

Contatore con display a 7 segmenti e pulsanti
Un contatore semplice con tre pulsanti: con uno la cifra sul display sale di uno, con un altro scende di uno, e il terzo la riporta a zero.

Serratura con password, tastierino 4x4 e LCD
Una piccola serratura elettronica che non fa entrare chi non conosce il codice. Premi il tasto cancelletto e digiti il codice sul tastierino; se è giusto, lo schermo indica accesso consentito, si…

Gioco di memoria con Arduino (4 LED + 4 pulsanti + buzzer)
Ti fidi della tua memoria? Quattro LED colorati si accendono in sequenza, ognuno con la sua nota, e tu ripeti lo stesso ordine premendo i pulsanti.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

