Arduino Zustandsautomat (State Machine) mit enum und switch-case
Arduino State Machine: Zustände mit enum und switch-case, Übergänge, zeitgesteuerte Zustände mit millis, Ampel, Menü, Waschmaschine und Pico MicroPython.
Ein Arduino Zustandsautomat (State Machine) ist eine Art, Code zu schreiben, bei der du dein Programm in getrennte Zustände aufteilst und dich immer nur in einem davon befindest. Eine Ampel ist im Zustand "rot", "gelb" oder "grün"; eine Waschmaschine "füllt Wasser", "wäscht" oder "schleudert". In jedem Zustand ist klar, was zu tun ist und unter welcher Bedingung es in den nächsten Zustand geht. Am Arduino baust du das mit einem enum, einem switch-case und millis(). Das Ergebnis ist Code, der ohne delay() mehrere Aufgaben gleichzeitig erledigt und sich leicht lesen und erweitern lässt.
In dieser Anleitung sehen wir uns zuerst die Begriffe Zustand, Übergang und Aktion an, wie man ein Zustandsdiagramm zeichnet und den einfachsten Automaten mit zwei Zuständen. Dann schreiben wir eine Ampel mit Fußgängertaster, ein Einstellungsmenü mit zwei Tastern und eine Waschmaschinen-Simulation, die beim Öffnen des Deckels pausiert. Außerdem lernst du, wie mehrere Zustandsautomaten in derselben loop() laufen, was Eintrittsaktionen sind, welche Fehler häufig vorkommen und wie dieselbe Struktur in MicroPython auf dem Raspberry Pi Pico aussieht.
Was ist ein Zustandsautomat?
Ein Zustandsautomat (endlicher Automat, FSM) besteht aus vier Teilen. Zustände sind die begrenzte Anzahl von Lagen, in denen sich das System befinden kann. Übergänge führen von einem Zustand in einen anderen, und Bedingungen oder Ereignisse legen fest, wann das passiert: ein Tastendruck, ein Sensorwert über einer Schwelle oder eine abgelaufene Zeit. Aktionen sind die Arbeiten beim Betreten eines Zustands oder während man in ihm bleibt: eine LED einschalten, einen Motor starten, etwas aufs Display schreiben. Bei jedem Durchlauf von loop() stellt das Programm nur eine Frage: "In welchem Zustand bin ich, und ist die Bedingung zum Verlassen erfüllt?" So wartet es nirgends, und statt verschachtelter ifs und Hunderter Flag-Variablen bekommst du eine aufgeräumte Struktur um eine einzige Zustandsvariable.
| Begriff | Bedeutung | Beispiel Ampel |
|---|---|---|
| Zustand | Die aktuelle Lage des Systems | KIRMIZI (rot), KIRMIZI_SARI (rot-gelb), YESIL (grün), SARI (gelb) |
| Übergang | Wechsel von einem Zustand in einen anderen | Von YESIL nach SARI |
| Bedingung oder Ereignis | Was den Übergang auslöst | 10 Sekunden vorbei oder Fußgängertaster gedrückt |
| Eintrittsaktion | Arbeit, die beim Betreten einmal erledigt wird | Grüne LED an, die anderen aus |
| Aktion im Zustand | Arbeit, die im Zustand laufend erledigt wird | Den Fußgängertaster abfragen |
Warum ein Zustandsautomat statt delay()?
Schreibst du delay(5000), tut der Arduino fünf Sekunden lang nichts: Ein Tastendruck wird nicht bemerkt, Sensoren werden nicht gelesen, das Display nicht aktualisiert. In kleinen Programmen mit nur einer Aufgabe ist das kein Problem, aber sobald eine zweite Aufgabe dazukommt, gerät der Code durcheinander. Ein Zustandsautomat wartet nie; jeder Zustand fragt mit millis() "wie viel Zeit ist vergangen, seit ich ihn betreten habe?" und kehrt sofort zu loop() zurück, wenn die Zeit noch nicht um ist. Da loop tausende Male pro Sekunde läuft, arbeiten Taster, Sensoren und Display ohne Unterbrechung weiter. Die Grundlagen der Zeitsteuerung mit millis() erklären wir ausführlich im Artikel Arduino millis statt delay.
| Eigenschaft | Code mit delay() | Zustandsautomat |
|---|---|---|
| Werden Taster beim Warten gelesen? | Nein | Ja |
| Mehrere Aufgaben gleichzeitig | Schwer, der Code wird unübersichtlich | Einfach, jede Aufgabe in ihrem eigenen Automaten |
| Neuen Zustand hinzufügen | Der ganze Ablauf muss neu geschrieben werden | Ein neuer case kommt dazu |
| Fehlersuche | Unklar, wo das Programm steht | Den Zustandsnamen im Seriellen Monitor auszugeben genügt |
| Speicher | Wenig | Wenig (eine Variable und ein Zeitstempel) |
Der erste Zustandsautomat mit enum und switch-case
Mit einem enum gibst du Zuständen Namen statt Zahlen. Die Zeile enum Durum { YANIK, SONUK }; (an, aus) definiert einen neuen Typ, der für den Compiler die Werte 0 und 1 trägt, für dich aber sprechende Namen hat. Die Zustandsvariable hat diesen Typ, und switch-case führt für jeden Zustand einen eigenen Block aus. Im Beispiel unten leuchtet die Board-LED des Uno (D13) 200 ms und ist dann 1,8 Sekunden aus. Das ginge auch mit delay; in dieser Struktur wartet loop() aber nie, und du kannst am Ende beliebig viele weitere Aufgaben anhängen.
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}Ein Zustandsdiagramm zeichnen
Wenn du den Zustandsautomaten vor dem Programmieren auf Papier zeichnest, verschwinden die meisten Fehler, bevor du überhaupt anfängst. Im Diagramm ist jeder Zustand ein Kreis oder abgerundetes Kästchen und jeder Übergang ein Pfeil. Auf den Pfeil schreibst du die Bedingung des Übergangs und bei Bedarf nach einem Schrägstrich die Aktion, etwa "10 s / Gelb an". Den Startzustand kennzeichnest du mit einem kurzen Pfeil, der aus dem Nichts kommt. Ist das Diagramm fertig, stelle dir für jeden Zustand diese Fragen: Gibt es einen Ausgang aus diesem Zustand? Was gilt zuerst, wenn zwei Bedingungen gleichzeitig wahr sind? Was passiert bei einem unerwarteten Ereignis (Deckel offen, Sensorfehler)? Überträgst du das Diagramm in eine Tabelle, wird das Programmieren zu einer fast mechanischen Aufgabe.
- Liste alle Zustände des Systems auf und gib jedem einen kurzen Namen in Großbuchstaben.
- Wähle den Startzustand; in ihm befindet sich der Arduino nach dem Einschalten oder einem Reset.
- Schreib für jeden Zustand die Austrittsbedingungen auf: Zeit, Taster, Sensor oder ein anderes Ereignis.
- Ergänze für jeden Übergang den Zielzustand und gegebenenfalls die Aktion beim Übergang.
- Leg die Eintrittsaktion jedes Zustands fest: Welche Ausgänge sind an, welche aus?
- Notiere separat gemeinsame Regeln, die in allen Zuständen gelten (Not-Aus, Deckel offen).
- Übertrage das Diagramm in eine Übergangstabelle wie unten und schreibe jede Zeile als if in einem case.
| Zustand | Bedingung | Nächster Zustand | Eintrittsaktion |
|---|---|---|---|
| KIRMIZI | 5 s vorbei | KIRMIZI_SARI | Rot an, Fußgängeranforderung gelöscht |
| KIRMIZI_SARI | 1,5 s vorbei | YESIL | Rot und Gelb an |
| YESIL | 10 s vorbei, bei Anforderung 4 s | SARI | Grün an |
| SARI | 2 s vorbei | KIRMIZI | Gelb an |
Beispiel 1: Ampel mit Fußgängertaster
Die klassische Ampelfolge ist Rot, Rot-Gelb, Grün und Gelb. Fügen wir einen Fußgängertaster hinzu: Drückt ein Fußgänger während der Grünphase, wird Grün verkürzt, sofern es mindestens 4 Sekunden geleuchtet hat, und die Ampel schaltet auf Gelb. Mit delay ist dieses Verhalten fast unmöglich, denn während du auf Grün wartest, kannst du den Taster nicht lesen. Im Zustandsautomaten wird der Taster bei jedem loop-Durchlauf gelesen und die Anforderung in einer Variablen gespeichert. Wenn du die einfache Ampelschaltung noch nie aufgebaut hast, lies zuerst den Artikel Arduino-Ampel.

| Teil | Arduino-Uno-Pin | Hinweis |
|---|---|---|
| Rote LED | D8 | Mit 220-Ω-Widerstand, kurzes Bein an GND |
| Gelbe LED | D9 | Mit 220-Ω-Widerstand |
| Grüne LED | D10 | Mit 220-Ω-Widerstand (PWM-fähiger Pin) |
| Buzzer | D11 | Nur im Waschmaschinenbeispiel |
| Taster 1 | D2 | Anderes Bein an GND, INPUT_PULLUP |
| Taster 2 | D3 | Anderes Bein an 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}Der wichtigste Teil dieses Codes ist die Funktion durumDegistir() (Zustand wechseln). Beim Wechsel in einen Zustand passieren drei Dinge: Die Zustandsvariable wird gesetzt, der Zeitstempel zurückgesetzt und die Eintrittsaktion des Zustands einmal ausgeführt. Laufen alle Übergänge über diese eine Funktion, gibt es keine Fehler der Art "Timer zurücksetzen vergessen" mehr. Die Fußgängeranforderung wird beim Eintritt in KIRMIZI gelöscht, weil die Fußgänger dann ohnehin gehen. Die LED-Vorwiderstände kannst du mit dem LED-Vorwiderstandsrechner berechnen.
Beispiel 2: Einstellungsmenü mit zwei Tastern
Menüs sind die natürlichste Anwendung eines Zustandsautomaten: Die angezeigte Seite ist ein Zustand, die Taster lösen die Übergänge aus. Im Beispiel unten bedeutet der Taster an D2 "weiter" oder "Wert erhöhen", D3 bedeutet "OK". Im Hauptmenü wechselst du zwischen Helligkeit und Geschwindigkeit; mit OK gelangst du in die Einstellseite, änderst den Wert mit D2 und verlässt sie mit OK. Gleichzeitig lässt ein zweiter, unabhängiger Zustandsautomat die LED an D10 mit der gewählten Helligkeit und Geschwindigkeit blinken. Beim Blättern im Menü stockt die LED keinen Moment.

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}Beim Lesen von Tastern musst du auf den Moment des Drückens achten, nicht auf den Pegel. Würden wir handeln, solange digitalRead() LOW liefert, würde das Menü bei einem Druck hunderte Male weiterspringen. Die Funktion basildi() (gedrückt) merkt sich den letzten stabilen Pegel jedes Tasters, entprellt 30 ms lang und liefert nur beim Wechsel von HIGH nach LOW einmal true. Details zum Anschluss und Prellen findest du im Artikel Taster anschließen. Um das Menü statt im Seriellen Monitor auf einem I2C-LCD-Display anzuzeigen, musst du nur die Funktion menuYaz() ändern; der Zustandsautomat bleibt gleich.
| Zustand | D2 (weiter) | D3 (OK) |
|---|---|---|
| MENU_PARLAKLIK | Zu MENU_HIZ wechseln | AYAR_PARLAKLIK öffnen |
| MENU_HIZ | Zu MENU_PARLAKLIK wechseln | AYAR_HIZ öffnen |
| AYAR_PARLAKLIK | Helligkeit um 51 erhöhen (nach 255 wieder 51) | Speichern, zurück zu MENU_PARLAKLIK |
| AYAR_HIZ | Zeit um 100 ms erhöhen (nach 1000 wieder 100) | Speichern, zurück zu MENU_HIZ |
Beispiel 3: Waschmaschine
Echte Geräte arbeiten ein Programm meist Schritt für Schritt ab und reagieren auf unerwartete Ereignisse. In unserer Waschmaschinen-Simulation füllt die Maschine nach einem Druck auf den Starttaster an D2 nacheinander Wasser ein, wäscht, pumpt ab, schleudert und endet mit einem Piepton. Wasserventil, Motor und Pumpe werden durch drei LEDs dargestellt. Im Waschzustand läuft der Motor 2 Sekunden und steht 2 Sekunden; das ist ein kleines zeitabhängiges Muster innerhalb des Zustands. Vor allem aber pausiert die Maschine, egal in welchem Schritt, wenn der Deckelschalter an D3 öffnet, und macht nach dem Schließen mit der verbleibenden Zeit dort weiter, wo sie aufgehört hat.
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}Die Pause zeigt zwei starke Techniken von Zustandsautomaten. Die erste ist eine gemeinsame Regel: Die Deckelprüfung steht an einer Stelle vor dem switch und gilt für alle laufenden Zustände; sie wird nicht in jeden case einzeln geschrieben. Die zweite ist das Merken des vorherigen Zustands: Die Variable oncekiDurum speichert, welcher Schritt verlassen wurde, und kalanGecen, wie viel Zeit darin schon vergangen war. Schließt der Deckel, kehrt die Maschine in denselben Zustand zurück und der Zeitstempel wird um die vergangene Zeit zurückgesetzt, sodass der Schritt nicht von vorn beginnt. In einem echten Gerät steuert ein Relaismodul statt LEDs Ventil, Motor und Pumpe.
Mehrere Zustandsautomaten gleichzeitig betreiben
Wie im Menübeispiel gesehen, kann jede unabhängige Aufgabe ein eigener Zustandsautomat sein. Eine gute Ordnung ist, jeden Automaten in eine eigene Funktion zu legen und in loop() nur diese Funktionen nacheinander aufzurufen: trafikGuncelle(), butonGuncelle(), ekranGuncelle() usw. Da keine Funktion wartet, dreht loop alle paar Mikrosekunden eine Runde, und alle Automaten scheinen gleichzeitig zu laufen. Die Automaten verständigen sich über gemeinsame Variablen: Der Menüautomat ändert hizMs, der LED-Automat liest den Wert. Das ist der einfachste Weg zu Multitasking auf dem Arduino ohne echtes Betriebssystem. Ein Automat sollte den Zustand eines anderen nicht direkt ändern, sondern eine Anforderungsvariable hinterlassen, wie bei der Fußgängeranforderung.
- Nutze pro Automat eine Zustandsvariable und einen Zeitstempel; teile sie nicht zwischen Automaten.
- Die Zustandsvariable static in der Funktion oder in einem eigenen struct zu halten, vermeidet Namenskonflikte.
- Lass den Automaten, der eine Anforderung (wie yayaIstegi) bearbeitet, sie auch löschen.
- Gib beim Debuggen bei jedem Zustandswechsel den Zustandsnamen im Seriellen Monitor aus; so siehst du sofort, wo das Programm hängt.
Zustandsautomaten in MicroPython auf dem Raspberry Pi Pico
MicroPython kennt kein enum; Zustände definierst du als konstante Zahlen oder Texte. Dank Python-Dictionaries lässt sich der Zustandsautomat sehr leicht vollständig tabellengesteuert schreiben: Lampen, Dauer und Folgezustand jedes Zustands stehen in eigenen Dictionaries, und die Schleife entscheidet anhand dieser Tabellen. Für einen neuen Zustand ergänzt du nur eine Zeile in den Tabellen, nicht im Code. Für die Zeitsteuerung nutzt du time.ticks_ms() und time.ticks_diff(); ticks_diff liefert auch beim Überlauf des Zählers die richtige Differenz. Im Code unten hängen die LEDs an GP13 (rot), GP12 (gelb) und GP11 (grün), der Fußgängertaster an GP4. Wenn du neu bei MicroPython bist, beginne mit dem Artikel MicroPython-Grundlagen.
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)Häufige Fehler und Lösungen
| Fehler | Symptom | Lösung |
|---|---|---|
| delay() in einem Zustand | Taster und andere Automaten hängen | Statt zu warten die vergangene Zeit mit millis() prüfen |
| break vergessen | Der Code eines Zustands führt auch den des nächsten aus | Jeden case mit break abschließen |
| Zeitstempel nicht zurückgesetzt | Der neue Zustand endet sofort oder nie | Alle Übergänge über eine einzige Funktion durumDegistir() laufen lassen |
| Auf den Pegel des Tasters schauen | Ein Druck löst mehrere Übergänge aus | Den Moment des Drückens erfassen und entprellen |
| Eintrittsaktion im Zustand ständig wiederholen | Serieller Monitor läuft über, Buzzer piept dauernd | Einmalige Arbeit in die Eintrittsaktion verschieben |
| Zustand ohne Ausgang | Das Programm bleibt für immer in einem Zustand | Prüfen, dass aus jedem Zustand mindestens ein Pfeil führt |
| millis()-Vergleich mit Addition schreiben | Nach 49,7 Tagen stimmt die Zeitsteuerung nicht mehr | Immer die Form millis() - start >= dauer verwenden |
Projektideen mit Zustandsautomaten
- Codeschloss: ein Schloss mit Tastenfeld und Servo und den Zuständen KILITLI (verriegelt), SIFRE_GIRILIYOR (Code-Eingabe), ACIK (offen) und ALARM; bei falschem Code ertönt im Zustand ALARM der Buzzer.
- Simon-Gedächtnisspiel: ein Spiel, das dem Spieler eine LED-Folge zeigt und die Taster abfragt, mit den Zuständen GOSTER (zeigen), BEKLE (warten), KONTROL (prüfen) und KAYBETTIN (verloren).
- Intelligentes Treppenlicht: Beleuchtung mit den Zuständen BOS (Ruhe), YANIYOR (an) und SONUYOR (dimmt ab), die bei Bewegung angeht und nach Ablauf der Zeit langsam ausgeht.
- Reaktionstest: ein Spiel mit den Zuständen HAZIR (bereit), RASTGELE_BEKLE (zufällig warten), OLC (messen) und SONUC (Ergebnis), das die Reaktionszeit in Millisekunden misst.
- Roboter mit seriellen Befehlen: ein Fahrzeug mit den Zuständen DUR (Stopp), ILERI (vorwärts), DON (drehen) und ENGEL (Hindernis), das gleichzeitig auf Sensoren und Befehle reagiert.
Ein Zustandsautomat macht jedes Arduino-Projekt zu Code, der aufgeräumter ist, schneller reagiert und leichter wächst. In der BlueGrays-App findest du Projekte wie eine Ampel, LED-Steuerung per Taster, einen Zähler mit 7-Segment-Anzeige, ein Codeschloss mit Tastenfeld, das Simon-Spiel und eine Ampel mit vier Modi für den Raspberry Pi Pico, jeweils mit Schaltplan und Code Schritt für Schritt; wende die Zustandsautomaten-Struktur aus dieser Anleitung darauf an.
Häufige Fragen
Was ist ein Zustandsautomat beim Arduino?
Ein Zustandsautomat ist eine Codestruktur, die das Programm in eine begrenzte Zahl von Zuständen aufteilt und sich immer nur in einem davon befindet. In jedem Zustand ist klar, was zu tun ist und unter welcher Bedingung es in einen anderen geht. Am Arduino schreibt man ihn meist mit enum, switch-case und millis().
Wie benutzt man enum beim Arduino?
Du definierst es etwa als enum Durum { BEKLE, CALIS, BITTI }; und legst mit Durum durum = BEKLE; eine Variable an. Der Compiler macht aus den Namen Zahlen wie 0, 1, 2, im Code nutzt du aber sprechende Namen. Die enum-Definition gehört an den Anfang der Datei, vor die Funktionen.
Wie schreibt man einen Zustandsautomaten mit switch-case?
Du setzt die Zustandsvariable in switch(durum) und schreibst für jeden Zustand einen case-Block. In jedem Block prüfst du die Austrittsbedingung und wechselst den Zustand, wenn sie erfüllt ist. Vergiss nicht, jeden case mit break zu beenden.
Wie wartet man beim Arduino ohne delay?
Speichere den Moment des Zustandseintritts mit millis() in einer Variablen und prüfe bei jedem loop-Durchlauf die Bedingung millis() - start >= dauer. Ist die Zeit nicht um, läuft loop sofort weiter, und andere Aufgaben werden nicht blockiert. Die Methode funktioniert auch beim Überlauf von millis() korrekt.
Kann ein Arduino mehrere Dinge gleichzeitig tun?
Der Arduino Uno hat nur einen Kern und erledigt Aufgaben nicht wirklich gleichzeitig, aber mit nicht blockierenden Zustandsautomaten führt er sie tausende Male pro Sekunde abwechselnd aus, sodass sie gleichzeitig wirken. Es genügt, jede Aufgabe in eine eigene Funktion zu legen und diese in loop() nacheinander aufzurufen.
Wie schreibt man einen Zustandsautomaten in MicroPython?
MicroPython hat kein enum, daher definiert man Zustände als konstante Zahlen. Sehr praktisch ist eine tabellengesteuerte Struktur, die Dauer, Ausgänge und Folgezustand jedes Zustands in Dictionaries hält. Für die Zeitsteuerung nutzt man time.ticks_ms() und time.ticks_diff().
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Ampel
Eine winzige Nachbildung der Ampel, die du jeden Tag auf der Straße siehst. Rot leuchtet zwei Sekunden, Gelb blitzt kurz auf, Grün leuchtet zwei Sekunden, dann geht es über Gelb wieder zurück zu Rot…

LED mit Taster ein- und ausschalten
Einmal drücken und das Licht geht an, noch einmal drücken und es geht aus, genau wie der Lichtschalter in deinem Zimmer.

ESP32 Ampel
Simulation einer echten Ampel mit 3 rot-gelb-grünen LEDs. Die Zeiten sind nahe an der realen Verkehrslogik: rot lang, gelb kurz, grün lang. Klassisches Beispiel für sequenzielle GPIO-Steuerung.

Raspberry Pi Pico Ampel-Simulator (3 LEDs sequenziell)
Wir simulieren eine echte Ampel mit roten, gelben und grünen LEDs. Grün 4 Sek "gehen", gelb 1,5 Sek "bereit", rot 3 Sek "stopp" und rot+gelb 1 Sek "starten" (europäisches Ampelmuster). Lerne Funktionsdefinition, Zustandsmaschinen-Logik und Multi-GPIO-Synchronisation. Sehr einfache Schaltung: 3 LEDs an GP11/GP12/GP13, jeweils mit 220Ω Widerstand.

Raspberry Pi Pico-Ampel mit 4-Modus-Tastenwahlschalter (Zustandsmaschine)
4 Ampelmodi mit 1 Taster! Jeder Druck wechselt den Modus: normaler Zyklus (rot → gelb → grün), nur Rot (Halt), gelbes Blinklicht (Achtung/Nachtmodus) und Aus (Wartung). Du lernst den Zustandsautomaten kennen (die Variable mode bestimmt, welches Verhalten läuft) und das Durchschalten der Modi mit (mode + 1) % 4.

Zähler mit 7-Segment-Anzeige und Tastern
Ein einfacher Zähler mit drei Knöpfen: Mit dem einen zählt die Ziffer auf der Anzeige um eins hoch, mit dem anderen um eins runter, und der dritte setzt sie auf null zurück.

Passwortschloss mit 4x4-Tastenfeld und LCD
Ein kleines elektronisches Türschloss, das niemanden ohne den richtigen Code hereinlässt.

Arduino Gedächtnisspiel (4 LEDs + 4 Taster + Summer)
Vertraust du deinem Gedächtnis? Vier bunte LEDs leuchten nacheinander auf, jede mit ihrem eigenen Ton, und du wiederholst die Reihenfolge mit den Tastern.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

