Basi · 11 min di lettura

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.

ConcettoSignificatoEsempio del semaforo
StatoLa situazione attuale del sistemaKIRMIZI (rosso), KIRMIZI_SARI (rosso-giallo), YESIL (verde), SARI (giallo)
TransizionePassaggio da uno stato a un altroDa YESIL a SARI
Condizione o eventoCiò che fa scattare la transizioneSono passati 10 secondi o è stato premuto il pulsante pedonale
Azione di ingressoLavoro fatto una volta entrandoAccendere il LED verde, spegnere gli altri
Azione nello statoLavoro fatto di continuo nello statoControllare 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.

CaratteristicaCodice con delay()Macchina a stati
I pulsanti vengono letti durante l'attesa?NoSì
Più compiti insiemeDifficile, il codice si ingarbugliaFacile, ogni compito nella sua macchina
Aggiungere uno statoVa riscritto tutto il flussoSi aggiunge un case
DebugNon si sa dove sia il programmaBasta stampare il nome dello stato nel Monitor seriale
MemoriaPocaPoca (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.

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}
Scrivi la definizione dell'enum in cima al file, prima delle funzioni. L'IDE Arduino genera automaticamente i prototipi delle funzioni; se l'enum è definito dopo una funzione che lo usa come parametro, puoi ottenere l'errore "was not declared in this scope". Non dimenticare nemmeno il break alla fine di ogni case; altrimenti il programma esegue anche il codice dello stato successivo.

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.

  1. Elenca tutti gli stati del sistema e dai a ciascuno un nome breve in maiuscolo.
  2. Scegli lo stato iniziale; Arduino sarà in questo stato all'accensione o dopo un reset.
  3. Scrivi le condizioni di uscita di ogni stato: tempo, pulsante, sensore o altro evento.
  4. Aggiungi lo stato di destinazione di ogni transizione e l'eventuale azione da compiere durante la transizione.
  5. Decidi l'azione di ingresso di ogni stato: quali uscite saranno accese e quali spente?
  6. Annota a parte le regole comuni valide in tutti gli stati (arresto di emergenza, apertura dello sportello).
  7. Trasforma il diagramma in una tabella delle transizioni come quella qui sotto e scrivi ogni riga come un if dentro un case.
StatoCondizioneStato successivoAzione di ingresso
KIRMIZIPassati 5 sKIRMIZI_SARIRosso acceso, richiesta pedonale cancellata
KIRMIZI_SARIPassati 1,5 sYESILRosso e giallo accesi
YESILPassati 10 s, o 4 s se c'è una richiestaSARIVerde acceso
SARIPassati 2 sKIRMIZIGiallo 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.

LED rosso, giallo e verde
Gli esempi del semaforo, del menu e della lavatrice usano gli stessi tre LED e due pulsanti.
PartePin di Arduino UnoNota
LED rossoD8Con resistenza da 220 Ω, gamba corta a GND
LED gialloD9Con resistenza da 220 Ω
LED verdeD10Con resistenza da 220 Ω (pin con PWM)
BuzzerD11Solo nell'esempio della lavatrice
Pulsante 1D2L'altro piedino a GND, INPUT_PULLUP
Pulsante 2D3L'altro piedino a 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 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.

Pulsante
I pulsanti sono collegati con INPUT_PULLUP; quando si premono il pin legge 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}

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.

StatoD2 (avanti)D3 (OK)
MENU_PARLAKLIKVai a MENU_HIZEntra in AYAR_PARLAKLIK
MENU_HIZVai a MENU_PARLAKLIKEntra in AYAR_HIZ
AYAR_PARLAKLIKAumenta la luminosità di 51 (dopo 255 torna a 51)Salva, torna a MENU_PARLAKLIK
AYAR_HIZAumenta 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.

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

Questo esempio è solo una simulazione con LED. Non provare a sostituire la scheda di controllo di una vera lavatrice, di uno scaldabagno o di una pompa alimentati dalla rete; la tensione di rete è pericolosa per la vita e comporta rischio d'incendio.

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.

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

ErroreSintomoSoluzione
delay() dentro uno statoPulsanti e altre macchine si bloccanoInvece di aspettare controlla il tempo trascorso con millis()
Dimenticare il breakIl codice di uno stato esegue anche quello del successivoChiudi ogni case con break
Non azzerare il timestampIl nuovo stato finisce subito o maiFai tutte le transizioni con un'unica funzione durumDegistir()
Guardare il livello del pulsanteUna pressione provoca più transizioniRileva il momento della pressione e applica l'antirimbalzo
Ripetere l'azione di ingresso dentro lo statoIl Monitor seriale si riempie, il buzzer suona di continuoSposta il lavoro da fare una volta nell'azione di ingresso
Uno stato senza uscitaIl programma resta per sempre in uno statoControlla che da ogni stato esca almeno una freccia
Scrivere il confronto di millis() con una sommaLa temporizzazione si guasta dopo 49,7 giorniUsa sempre la forma millis() - inizio >= durata
Se il numero di stati comincia a superare 8–10, valuta di dividere la macchina: per esempio, nella lavatrice "scelta del programma" ed "esecuzione del programma" potrebbero essere due macchine separate. Più macchine piccole che comunicano con variabili di richiesta si capiscono molto meglio di una sola macchina gigante.

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().

Vedi tutti i progetti
Semaforo
AR-3Principiante

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…

4.8(137)
440
Accendere e spegnere un LED con un pulsante
AR-10Principiante

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.

4.7(103)
177
Semaforo ESP32
ES-5Principiante

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.

4.4(22)
45
Simulatore Semaforo Raspberry Pi Pico (3 LED Sequenziali)
PI-4Principiante

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.

4.0(1)
12
Semaforo Raspberry Pi Pico con selettore a 4 posizioni (macchina a stati)
PI-12Intermedio

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.

5.0(1)
16
Contatore con display a 7 segmenti e pulsanti
AR-43Avanzato
Premium

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.

4.6(35)
47
Serratura con password, tastierino 4x4 e LCD
AR-64Avanzato
Premium

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…

4.8(59)
75
Gioco di memoria con Arduino (4 LED + 4 pulsanti + buzzer)
AR-93Avanzato
Premium

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.

4.8(46)
69