Basis · 10 min leestijd

Arduino-state machine: gids voor enum, switch-case en millis()

Gids voor de Arduino-state machine: toestanden met enum en switch-case, overgangen, getimede toestanden met millis, een stoplicht, een menu, een wasmachine en Pico-code.

Een Arduino-state machine is een manier van code schrijven waarbij je je programma opdeelt in aparte toestanden en er altijd maar in één tegelijk zit. Een stoplicht staat op "rood", "geel" of "groen"; een wasmachine is aan het "vullen", "wassen" of "centrifugeren". In elke toestand is duidelijk wat er moet gebeuren en onder welke voorwaarde je naar de volgende toestand gaat. Op Arduino bouw je dit met een enum, een switch-case en millis(). Het resultaat is code die meerdere taken tegelijk uitvoert zonder delay() en die makkelijk te lezen en uit te breiden is.

In deze gids kijken we eerst naar de begrippen toestand, overgang en actie, hoe je een toestandsdiagram tekent en de eenvoudigste state machine met twee toestanden. Daarna schrijven we een stoplicht met voetgangersknop, een instellingenmenu dat je met twee knoppen bedient en een wasmachinesimulatie die pauzeert als het deksel opengaat. Ook leer je hoe je meerdere state machines in dezelfde loop() draait, wat entry-acties zijn, welke veelgemaakte fouten er zijn en hoe dezelfde structuur in MicroPython op de Raspberry Pi Pico wordt geschreven.

Wat is een state machine?

Een state machine (eindige toestandsmachine, FSM) heeft vier onderdelen. Toestanden zijn de beperkte set situaties waarin het systeem kan zijn. Overgangen gaan van de ene toestand naar de andere, en voorwaarden of gebeurtenissen bepalen wanneer dat gebeurt: een druk op een knop, een sensorwaarde die een drempel passeert of een verstreken tijdsduur. Acties zijn het werk dat je doet bij het binnengaan van een toestand of terwijl je erin blijft: een led aansteken, een motor laten draaien, naar een display schrijven. Bij elke ronde van loop() stelt het programma maar één vraag: "In welke toestand zit ik, en is de voorwaarde om eruit te gaan vervuld?" Zo wacht het nergens op, en in plaats van geneste if's en honderden vlagvariabelen krijg je een nette structuur rond één toestandsvariabele.

BegripBetekenisVoorbeeld stoplicht
ToestandDe huidige situatie van het systeemKIRMIZI (rood), KIRMIZI_SARI (rood-geel), YESIL (groen), SARI (geel)
OvergangVan de ene toestand naar de andere gaanVan YESIL naar SARI
Voorwaarde of gebeurtenisWat de overgang activeert10 seconden voorbij of de voetgangersknop is ingedrukt
Entry-actieWerk dat één keer wordt gedaan bij het binnengaan van een toestandDe groene led aanzetten, de andere uitzetten
Actie binnen een toestandWerk dat continu wordt gedaan zolang je in een toestand zitDe voetgangersknop in de gaten houden

Waarom een state machine in plaats van delay()?

Als je delay(5000) schrijft, doet de Arduino vijf seconden niets: een druk op een knop wordt niet opgemerkt, sensoren worden niet gelezen, het display wordt niet bijgewerkt. In kleine programma's met één taak is dat prima, maar zodra je een tweede taak toevoegt, begint de code te haperen. Een state machine wacht nooit; elke toestand vraagt met millis() "hoeveel tijd is er verstreken sinds ik binnenkwam?" en keert, als de tijd nog niet om is, meteen terug naar loop(). Omdat loop duizenden keren per seconde draait, blijven andere taken zoals knoppen, sensoren en displays ononderbroken werken. De basis van timing met millis() hebben we uitgebreid behandeld in het artikel Arduino millis vs delay.

KenmerkCode met delay()State machine
Worden knoppen gelezen tijdens het wachten?NeeJa
Meerdere taken tegelijkMoeilijk, de code wordt rommeligMakkelijk, elke taak in een eigen machine
Een nieuwe toestand toevoegenJe schrijft de hele flow omJe voegt een nieuwe case toe
DebuggenOnduidelijk waar het programma zitDe naam van de toestand naar de Serial Monitor printen is genoeg
GeheugenWeinigWeinig (één variabele en een tijdstempel)

Je eerste state machine met enum en switch-case

Met een enum geef je toestanden namen in plaats van nummers. De regel enum Durum { YANIK, SONUK }; (aan, uit) definieert een nieuw type dat voor de compiler de waarden 0 en 1 heeft, maar voor jou betekenisvolle namen. De toestandsvariabele is van dit type en switch-case voert voor elke toestand een apart blok uit. In het voorbeeld hieronder is de ingebouwde led van de Uno (D13) 200 ms aan en 1,8 seconden uit. Dat kan ook met delay, maar in deze structuur wacht loop() nooit en kun je aan het eind zoveel andere taken toevoegen als je wilt.

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}
Zet de enum-definitie helemaal bovenaan het bestand, vóór je functies. De Arduino IDE genereert automatisch functieprototypes; als de enum wordt gedefinieerd na een functie die hem als parameter gebruikt, kun je de foutmelding "was not declared in this scope" krijgen. Vergeet ook de break aan het eind van elke case niet; anders voert het programma ook de code van de volgende toestand uit.

Een toestandsdiagram tekenen

Als je de state machine op papier tekent voordat je code schrijft, verdwijnen de meeste bugs nog voor je begint. In het diagram is elke toestand een cirkel of afgeronde doos en elke overgang een pijl. Op de pijl schrijf je de voorwaarde van de overgang en, indien nodig, de actie na een schuine streep, zoals "10 s / geel aan". De beginstoestand geef je aan met een korte pijl die uit het niets komt. Stel bij een klaar diagram voor elke toestand deze vragen: is er een weg uit deze toestand? Als twee voorwaarden tegelijk waar zijn, welke gaat voor? Wat gebeurt er bij een onverwachte gebeurtenis (het deksel gaat open, een sensorfout)? Als je het diagram in een tabel omzet, wordt het schrijven van de code bijna mechanisch werk.

  1. Maak een lijst van alle toestanden van het systeem en geef elk een korte naam in hoofdletters.
  2. Kies de beginstoestand; de Arduino zit in deze toestand wanneer hij wordt ingeschakeld of gereset.
  3. Schrijf voor elke toestand de uitgangsvoorwaarden op: tijd, knop, sensor of een andere gebeurtenis.
  4. Voeg de doeltoestand van elke overgang toe en eventuele acties die daarbij horen.
  5. Bepaal de entry-actie van elke toestand: welke uitgangen gaan aan en welke uit?
  6. Noteer apart de gemeenschappelijke regels die in elke toestand gelden (noodstop, deksel open).
  7. Zet het diagram om in een overgangstabel zoals hieronder en schrijf elke rij als een if binnen een case.
ToestandVoorwaardeVolgende toestandEntry-actie
KIRMIZI5 s voorbijKIRMIZI_SARIRood aan, voetgangersverzoek gewist
KIRMIZI_SARI1,5 s voorbijYESILRood en geel aan
YESIL10 s voorbij, of 4 s bij een verzoekSARIGroen aan
SARI2 s voorbijKIRMIZIGeel aan

Voorbeeld 1: stoplicht met voetgangersknop

De klassieke stoplichtvolgorde is rood, rood-geel, groen en geel. Laten we een voetgangersknop toevoegen: als een voetganger er tijdens groen op drukt, wordt het groen ingekort, mits het minstens 4 seconden aan is geweest, en gaat het licht naar geel. Met delay is dit gedrag bijna onmogelijk, omdat je de knop niet kunt lezen terwijl je op groen wacht. In een state machine wordt de knop bij elke ronde van loop gelezen en wordt het verzoek in een variabele bewaard. Heb je de basisschakeling van het stoplicht nog nooit gebouwd, bekijk dan eerst het artikel Arduino-stoplicht.

Rode, gele en groene leds
De voorbeelden met het stoplicht, het menu en de wasmachine gebruiken allemaal dezelfde drie leds en twee knoppen.
OnderdeelPin op Arduino UnoOpmerking
Rode ledD8Met een weerstand van 220 Ω, kort pootje naar GND
Gele ledD9Met een weerstand van 220 Ω
Groene ledD10Met een weerstand van 220 Ω (pin met PWM)
BuzzerD11Alleen in het wasmachinevoorbeeld
Knop 1D2Andere pootje naar GND, INPUT_PULLUP
Knop 2D3Andere pootje naar 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}

Het belangrijkste deel van deze code is de functie durumDegistir() (toestand wijzigen). Bij het overgaan naar een toestand gebeuren drie dingen: de toestandsvariabele wordt bijgewerkt, de tijdstempel wordt gereset en de entry-actie van die toestand wordt één keer uitgevoerd. Doordat elke overgang via deze ene functie loopt, verdwijnen fouten als "ik vergat de timer te resetten". Het voetgangersverzoek wordt gewist bij het binnengaan van de toestand KIRMIZI, omdat voetgangers dan toch oversteken. Wil je de ledweerstanden berekenen, gebruik dan de tool ledweerstandcalculator.

Voorbeeld 2: een instellingenmenu met twee knoppen

Menu's zijn het meest natuurlijke gebruik van een state machine: de pagina op het scherm is een toestand en de knoppen activeren de overgangen. In het voorbeeld hieronder betekent de knop op D2 "volgende" of "waarde verhogen" en D3 "OK". In het hoofdmenu schakel je tussen de opties helderheid en snelheid; druk op OK om de instellingenpagina te openen, verander de waarde met D2 en verlaat de pagina met OK. Tegelijk laat een tweede, onafhankelijke state machine de led op D10 knipperen met de gekozen helderheid en snelheid. De led stottert geen moment terwijl je door het menu bladert.

Drukknop
De knoppen zijn aangesloten met INPUT_PULLUP; de pin leest LOW als je erop drukt.
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}

Bij het lezen van knoppen moet je kijken naar het moment van indrukken, niet naar het niveau. Als we handelden zolang digitalRead() LOW teruggeeft, zou het menu bij één druk honderden keren doorschuiven. De functie basildi() (ingedrukt) onthoudt het laatste stabiele niveau van elke knop, past een contactdender van 30 ms toe en geeft maar één keer true terug, bij de wissel van HIGH naar LOW. De details over het aansluiten van een knop en contactdender vind je in het artikel hoe sluit je een knop aan. Als je het menu wilt tonen op een I2C-lcd-display in plaats van in de Serial Monitor, hoef je alleen de functie menuYaz() aan te passen; de state machine blijft hetzelfde.

ToestandD2 (volgende)D3 (OK)
MENU_PARLAKLIKGa naar MENU_HIZGa naar AYAR_PARLAKLIK
MENU_HIZGa naar MENU_PARLAKLIKGa naar AYAR_HIZ
AYAR_PARLAKLIKHelderheid met 51 verhogen (na 255 terug naar 51)Opslaan, terug naar MENU_PARLAKLIK
AYAR_HIZDe tijd met 100 ms verhogen (na 1000 terug naar 100)Opslaan, terug naar MENU_HIZ

Voorbeeld 3: een wasmachine

Echte apparaten volgen meestal stap voor stap een programma en reageren op onverwachte gebeurtenissen. In onze wasmachinesimulatie vult de machine zich na een druk op de startknop op D2 met water, wast, pompt leeg, centrifugeert en eindigt met een piep, in die volgorde. De waterklep, de motor en de pomp worden voorgesteld door drie leds. In de wastoestand draait de motor 2 seconden en staat hij 2 seconden stil; dat is een klein tijdgebonden patroon binnen de toestand. Het belangrijkste: als de deksPelschakelaar op D3 opengaat, pauzeert de machine de stap waar hij mee bezig is, en als het deksel dicht gaat, gaat hij verder waar hij was gebleven met de resterende tijd.

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}

De pauze toont twee krachtige state-machinetechnieken. De eerste is een gemeenschappelijke regel: de dekselcontrole gebeurt op één plek, vóór de switch, voor alle lopende toestanden; ze wordt niet in elke case apart geschreven. De tweede is het onthouden van de vorige toestand: de variabele oncekiDurum bewaart welke stap is verlaten en kalanGecen hoeveel tijd erin was doorgebracht. Als het deksel sluit, keert de machine terug naar dezelfde toestand en wordt de tijdstempel met de verstreken tijd teruggezet, zodat de stap niet opnieuw begint. In een echt apparaat sturen een relaismodule de klep, motor en pomp aan in plaats van leds.

Dit voorbeeld is slechts een simulatie met leds. Probeer niet het besturingsbord van een echte wasmachine, verwarming of pomp op netspanning te vervangen; netspanning is zowel levensgevaarlijk als een brandrisico.

Meerdere state machines tegelijk draaien

Zoals je in het menuvoorbeeld zag, kan elke onafhankelijke taak een eigen state machine zijn. Een goede opzet is om elke machine in een eigen functie te zetten en die functies binnen loop() gewoon na elkaar aan te roepen: trafikGuncelle(), butonGuncelle(), ekranGuncelle() enzovoort. Omdat geen enkele functie wacht, gaat loop om de paar microseconden rond en lijken alle machines tegelijk te draaien. De machines praten met elkaar via gedeelde variabelen: de menumachine verandert hizMs en de ledmachine leest die. Dit is de eenvoudigste manier om op een Arduino te multitasken zonder echt besturingssysteem. Een machine mag de toestand van een andere niet rechtstreeks veranderen; laat in plaats daarvan een verzoekvariabele achter, zoals bij het voetgangersverzoek.

  • Gebruik per machine één toestandsvariabele en één tijdstempel; deel ze niet tussen machines.
  • Als je de toestandsvariabele static in de functie houdt of in een struct voor die machine, voorkom je naamconflicten.
  • Laat de machine die een verzoek afhandelt (zoals yayaIstegi) het verzoek ook wissen.
  • Print bij het debuggen bij elke toestandswijziging de naam van de toestand naar de Serial Monitor; dan zie je meteen waar het programma vastloopt.

State machines in MicroPython op de Raspberry Pi Pico

MicroPython heeft geen enum; je definieert toestanden als constante getallen of strings. Dankzij Python-dictionaries is het heel eenvoudig om de state machine volledig tabelgestuurd te schrijven: de lichten, duur en volgende toestand van elke toestand staan in aparte dictionaries en de lus beslist aan de hand van die tabellen. Om een nieuwe toestand toe te voegen, voeg je een regel toe aan de tabellen, niet aan de code. Voor timing gebruik je time.ticks_ms() en time.ticks_diff(); ticks_diff geeft het juiste verschil, ook als de teller rondgaat. In de onderstaande code zitten de leds op GP13 (rood), GP12 (geel) en GP11 (groen) en de voetgangersknop op GP4. Ben je nieuw met MicroPython, begin dan met het artikel MicroPython-basis.

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)

Veelgemaakte fouten en oplossingen

FoutSymptoomOplossing
delay() binnen een toestandKnoppen en andere machines bevriezenControleer de verstreken tijd met millis() in plaats van te wachten
break vergetenDe code van de ene toestand voert ook die van de volgende uitSluit elke case af met break
De tijdstempel niet resettenDe nieuwe toestand eindigt meteen of nooitLaat elke overgang via één functie durumDegistir() lopen
Naar het niveau van de knop kijkenEén druk veroorzaakt meerdere overgangenVang het moment van indrukken af en pas ontdendering toe
De entry-actie steeds opnieuw uitvoeren binnen de toestandDe Serial Monitor loopt vol, de buzzer piept non-stopVerplaats eenmalig werk naar de entry-actie
Een toestand zonder uitgangHet programma blijft eeuwig in één toestandControleer of er in het diagram minstens één pijl uit elke toestand vertrekt
De millis()-vergelijking met een optelling schrijvenDe timing gaat na 49,7 dagen misGebruik altijd de vorm millis() - start >= duur
Als het aantal toestanden boven de 8–10 begint uit te komen, overweeg dan om de machine te splitsen: in de wasmachine kunnen "programmakeuze" en "programma uitvoeren" bijvoorbeeld twee aparte machines zijn. Kleine machines die via verzoekvariabelen met elkaar praten, zijn veel makkelijker te begrijpen dan één gigantische machine.

Projectideeën met state machines

  • Codekluis: een slot met keypad en servo met de toestanden KILITLI (op slot), SIFRE_GIRILIYOR (code wordt ingevoerd), ACIK (open) en ALARM; bij een foute code gaat de buzzer af in de toestand ALARM.
  • Simon-geheugenspel: een spel dat de speler een ledreeks toont en naar de knoppen luistert, met de toestanden GOSTER (tonen), BEKLE (wachten), KONTROL (controleren) en KAYBETTIN (verloren).
  • Slim trappenlicht: verlichting met de toestanden BOS (rust), YANIYOR (aan) en SONUYOR (dimt uit) die aangaat bij bewegingsdetectie en langzaam dooft als de tijd om is.
  • Reactietest: een spel met de toestanden HAZIR (klaar), RASTGELE_BEKLE (willekeurig wachten), OLC (meten) en SONUC (resultaat) dat de reactietijd in milliseconden meet.
  • Robot die seriële commando's opvolgt: een voertuig met de toestanden DUR (stop), ILERI (vooruit), DON (draaien) en ENGEL (obstakel) dat tegelijk op sensoren en commando's reageert.

Een state machine maakt van elk Arduino-project dat je schrijft code die netter is, sneller reageert en makkelijker groeit. In de BlueGrays-app vind je projecten zoals een stoplicht, een led bedienen met een knop, een teller met een 7-segmentdisplay, een codeslot met keypad, het Simon-spel en een stoplicht met vier standen op de Raspberry Pi Pico, elk met een stap-voor-stapschakelschema en code; pas de state-machinestructuur uit deze gids erop toe.

Veelgestelde vragen

Wat is een state machine in Arduino?

Een state machine is een codestructuur die het programma opdeelt in een beperkt aantal toestanden en er altijd maar in één tegelijk zit. In elke toestand is duidelijk wat er moet gebeuren en onder welke voorwaarde je naar een andere toestand gaat. Op Arduino schrijf je hem meestal met enum, switch-case en millis().

Hoe gebruik je enum in Arduino?

Je definieert hem als enum Durum { BEKLE, CALIS, BITTI }; en maakt een variabele met Durum durum = BEKLE;. De compiler zet de namen om in getallen als 0, 1, 2, maar in de code gebruik je betekenisvolle namen. De enum-definitie moet bovenaan het bestand staan, vóór de functies.

Hoe schrijf je een state machine met switch-case?

Zet de toestandsvariabele in switch(durum) en schrijf voor elke toestand één case-blok. Controleer in elk blok de uitgangsvoorwaarde van die toestand en wijzig de toestand als die is vervuld. Vergeet niet een break aan het eind van elke case te zetten.

Hoe wacht je in Arduino zonder delay?

Bewaar het moment waarop je een toestand binnengaat in een variabele met millis() en controleer bij elke ronde van loop de voorwaarde millis() - start >= duur. Is de tijd nog niet om, dan gaat loop meteen door, zodat andere taken niet worden opgehouden. Deze methode werkt ook correct wanneer millis() overloopt.

Kan een Arduino meerdere dingen tegelijk doen?

De Arduino Uno heeft één kern, dus hij doet niet echt dingen tegelijk, maar met niet-blokkerende state machines voert hij ze duizenden keren per seconde om de beurt uit, zodat ze gelijktijdig lijken. Het is genoeg om elke taak in een eigen functie te zetten en die binnen loop() na elkaar aan te roepen.

Hoe schrijf je een state machine in MicroPython?

MicroPython heeft geen enum, dus toestanden definieer je als constante getallen. Een tabelgestuurde structuur die de duur, uitgangen en volgende toestand van elke toestand in dictionaries bewaart, is erg praktisch. Voor timing gebruik je time.ticks_ms() en time.ticks_diff().

Alle projecten bekijken
Verkeerslicht
AR-3Beginner

Verkeerslicht

Een kleine kopie van het verkeerslicht dat je elke dag op straat ziet. Rood brandt twee seconden, geel knippert even, groen brandt twee seconden en daarna gaat het via geel weer naar rood, steeds…

4.8(135)
438
LED schakelen met een knop (aan/uit)
AR-10Beginner

LED schakelen met een knop (aan/uit)

Druk één keer op de knop en het licht gaat aan, druk nog een keer en het gaat uit, net als de lichtschakelaar in je kamer. De Arduino merkt elke druk op en zet de led in de tegenovergestelde toestand.

4.7(103)
177
ESP32-stoplicht
ES-5Beginner

ESP32-stoplicht

Een echt stoplicht nabootsen met 3 leds: rood, geel en groen. De tijden lijken op de echte verkeerslogica: rood lang, geel kort, groen lang. Een klassiek voorbeeld van sequentiële GPIO-besturing.

4.4(21)
44
Raspberry Pi Pico-stoplicht (3 leds na elkaar)
PI-4Beginner

Raspberry Pi Pico-stoplicht (3 leds na elkaar)

We bouwen de logica van een echt stoplicht na met een rode, gele en groene led, het eerste Pico-project met 3 leds! Groen zegt 4 seconden "rijden", geel 1,5 seconde "maak je klaar", rood 3 seconden "stop" en rood+geel 1 seconde "optrekken" (het Europese stoplichtpatroon). Je leert functies definiëren (def all_off()), toestandsmachinelogica en het synchroniseren van meerdere GPIO's.

4.0(1)
12
Raspberry Pi Pico-stoplicht met knop voor 4 standen (state machine)
PI-12Gemiddeld

Raspberry Pi Pico-stoplicht met knop voor 4 standen (state machine)

4 stoplichtstanden met 1 knop! Elke druk schakelt de stand om: normale cyclus (rood → geel → groen), alleen rood (stop), knipperend geel (waarschuwing/nachtstand) en uit (onderhoud). Je leert de state machine (de variabele mode bepaalt welk gedrag draait) en het doorlopen van de standen met (mode + 1) % 4.

5.0(1)
15
Teller met 7-segmentdisplay en knoppen
AR-43Gevorderd
Premium

Teller met 7-segmentdisplay en knoppen

Een eenvoudige teller met drie knoppen: met de ene knop gaat het cijfer op het display er één omhoog, met de andere één omlaag en de derde zet het terug op nul.

4.6(35)
47
Codeslot met 4x4-keypad en LCD
AR-64Gevorderd
Premium

Codeslot met 4x4-keypad en LCD

Een klein elektronisch deurslot dat iedereen buiten houdt die de code niet kent.

4.8(59)
75
Arduino-geheugenspel (4 leds + 4 knoppen + buzzer)
AR-93Gevorderd
Premium

Arduino-geheugenspel (4 leds + 4 knoppen + buzzer)

Vertrouw je op je geheugen? Vier gekleurde leds lichten na elkaar op en spelen elk hun eigen toon; jij herhaalt dezelfde volgorde door op de knoppen te drukken.

4.8(46)
69