State Machine Arduino: Panduan enum, switch-case, dan millis()
Panduan state machine Arduino: state dengan enum dan switch-case, transisi, state berwaktu dengan millis, lampu lalu lintas, menu, mesin cuci, dan kode Pico.
State machine Arduino, atau mesin keadaan, adalah cara menulis kode dengan membagi programmu menjadi beberapa state (keadaan) yang terpisah, dan pada satu waktu program hanya berada di salah satunya. Lampu lalu lintas berada di state “merah”, “kuning”, atau “hijau”; mesin cuci sedang “mengisi air”, “mencuci”, atau “memeras”. Di setiap state sudah jelas apa yang harus dilakukan dan dengan syarat apa pindah ke state berikutnya. Di Arduino, kamu membangunnya dengan enum, switch-case, dan millis(). Hasilnya adalah kode yang menjalankan beberapa pekerjaan sekaligus tanpa delay(), serta mudah dibaca dan dikembangkan.
Di panduan ini, kita akan melihat dulu konsep state, transisi, dan aksi, cara menggambar diagram state, dan state machine paling sederhana dengan dua state. Lalu kita akan menulis lampu lalu lintas dengan tombol pejalan kaki, menu pengaturan yang dijelajahi dengan dua tombol, dan simulasi mesin cuci yang berhenti sementara ketika tutupnya dibuka. Kamu juga akan belajar cara menjalankan beberapa state machine di loop() yang sama, aksi masuk, kesalahan umum, dan cara menulis struktur yang sama dengan MicroPython di Raspberry Pi Pico.
Apa itu state machine?
State machine (finite state machine, FSM) terdiri dari empat bagian. State adalah sekumpulan terbatas keadaan yang bisa dialami sistem. Transisi memindahkan sistem dari satu state ke state lain, dan syarat atau event menentukan kapan itu terjadi: tombol ditekan, nilai sensor melewati ambang, atau suatu durasi habis. Aksi adalah pekerjaan yang dilakukan ketika masuk ke sebuah state atau selama berada di dalamnya: menyalakan LED, menjalankan motor, menulis ke layar. Di setiap putaran loop(), program hanya menanyakan satu hal: “Aku sedang di state mana, dan apakah syarat untuk keluar dari state ini sudah terpenuhi?” Dengan begitu program tidak pernah menunggu di mana pun, dan alih-alih if bersarang dan ratusan variabel flag, kamu mendapat struktur rapi yang dibangun di sekitar satu variabel state.
| Konsep | Arti | Contoh lampu lalu lintas |
|---|---|---|
| State | Keadaan sistem sekarang | KIRMIZI (merah), KIRMIZI_SARI (merah-kuning), YESIL (hijau), SARI (kuning) |
| Transisi | Perpindahan dari satu state ke state lain | Dari YESIL ke SARI |
| Syarat atau event | Pemicu transisi | 10 detik berlalu atau tombol pejalan kaki ditekan |
| Aksi masuk | Pekerjaan yang dilakukan sekali ketika masuk ke state | Nyalakan LED hijau, matikan yang lain |
| Aksi di dalam state | Pekerjaan yang dilakukan terus-menerus selama berada di state | Pantau tombol pejalan kaki |
Kenapa state machine, bukan delay()?
Ketika kamu menulis delay(5000), Arduino tidak melakukan apa-apa selama lima detik: tombol yang ditekan tidak terdeteksi, sensor tidak dibaca, layar tidak diperbarui. Di program kecil yang hanya melakukan satu pekerjaan, ini tidak masalah, tapi begitu kamu menambahkan pekerjaan kedua, kodenya mulai kacau. State machine tidak pernah menunggu; setiap state bertanya “sudah berapa lama sejak aku masuk?” dengan millis(), dan kalau waktunya belum habis, langsung kembali ke loop(). Karena loop berputar ribuan kali per detik, pekerjaan lain seperti tombol, sensor, dan layar tetap berjalan tanpa terputus. Dasar-dasar pengaturan waktu dengan millis() sudah kami bahas lengkap di artikel Arduino millis() vs delay().
| Fitur | Kode dengan delay() | State machine |
|---|---|---|
| Apakah tombol dibaca selama menunggu? | Tidak | Ya |
| Beberapa pekerjaan sekaligus | Sulit, kodenya jadi berantakan | Mudah, setiap pekerjaan punya state machine sendiri |
| Menambah state baru | Kamu harus menulis ulang seluruh alurnya | Cukup tambah satu case baru |
| Debugging | Tidak jelas program sedang di mana | Cukup cetak nama state ke Serial Monitor |
| Memori | Sedikit | Sedikit (satu variabel dan satu timestamp) |
State machine pertamamu dengan enum dan switch-case
enum dipakai untuk memberi nama pada state, bukan angka. Baris enum Durum { YANIK, SONUK }; (nyala, mati) mendefinisikan tipe baru yang bagi compiler berisi nilai 0 dan 1, tapi bagimu punya nama yang bermakna. Variabel state bertipe ini, dan switch-case menjalankan blok terpisah untuk setiap state. Di contoh di bawah, LED bawaan Uno (D13) menyala 200 ms lalu mati 1,8 detik. Ini juga bisa dibuat dengan delay, tapi dengan struktur ini loop() tidak pernah menunggu, dan kamu bisa menambahkan pekerjaan lain sebanyak yang kamu mau di bagian akhir.
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}Menggambar diagram state
Menggambar state machine di kertas sebelum menulis kode akan menghilangkan sebagian besar bug bahkan sebelum kamu mulai. Di diagram, setiap state berupa lingkaran atau kotak bersudut bulat, dan setiap transisi berupa panah. Di atas panah, kamu tulis syarat transisinya dan, kalau perlu, aksinya setelah garis miring, misalnya “10 dtk / nyalakan kuning”. State awal ditunjukkan dengan panah pendek yang datang dari ruang kosong. Setelah diagram selesai, tanyakan hal-hal ini untuk setiap state: Apakah ada jalan keluar dari state ini? Kalau dua syarat benar bersamaan, mana yang didahulukan? Apa yang terjadi kalau ada event tak terduga (tutup terbuka, error sensor)? Mengubah diagram menjadi tabel membuat penulisan kodenya jadi pekerjaan yang hampir mekanis.
- Daftar semua state sistem dan beri masing-masing nama pendek berhuruf kapital.
- Pilih state awal; Arduino akan berada di state ini ketika dinyalakan atau di-reset.
- Tulis syarat keluar untuk setiap state: waktu, tombol, sensor, atau event lain.
- Tambahkan state tujuan dari setiap transisi dan aksi yang dilakukan selama transisi, kalau ada.
- Tentukan aksi masuk setiap state: output mana yang nyala dan mana yang mati?
- Catat terpisah aturan bersama yang berlaku di semua state (berhenti darurat, tutup terbuka).
- Ubah diagram menjadi tabel transisi seperti di bawah, lalu tulis setiap baris sebagai if di dalam case.
| State | Syarat | State berikutnya | Aksi masuk |
|---|---|---|---|
| KIRMIZI | 5 dtk berlalu | KIRMIZI_SARI | Merah menyala, permintaan pejalan kaki dihapus |
| KIRMIZI_SARI | 1,5 dtk berlalu | YESIL | Merah dan kuning menyala |
| YESIL | 10 dtk berlalu, atau 4 dtk kalau ada permintaan | SARI | Hijau menyala |
| SARI | 2 dtk berlalu | KIRMIZI | Kuning menyala |
Contoh 1: lampu lalu lintas dengan tombol pejalan kaki
Urutan klasik lampu lalu lintas adalah merah, merah-kuning, hijau, dan kuning. Yuk tambahkan tombol pejalan kaki: kalau pejalan kaki menekannya ketika lampu hijau menyala, lampu hijau dipersingkat, asalkan sudah menyala minimal 4 detik, lalu lampu pindah ke kuning. Kalau ditulis dengan delay, perilaku ini hampir mustahil, karena kamu tidak bisa membaca tombol selama menunggu di lampu hijau. Di state machine, tombol dibaca di setiap putaran loop dan permintaannya disimpan di sebuah variabel. Kalau kamu belum pernah merakit rangkaian lampu lalu lintas dasar, lihat dulu artikel Lampu Lalu Lintas Arduino.

| Komponen | Pin Arduino Uno | Catatan |
|---|---|---|
| LED merah | D8 | Dengan resistor 220 Ω, kaki pendek ke GND |
| LED kuning | D9 | Dengan resistor 220 Ω |
| LED hijau | D10 | Dengan resistor 220 Ω (pin yang mendukung PWM) |
| Buzzer | D11 | Hanya di contoh mesin cuci |
| Tombol 1 | D2 | Kaki lainnya ke GND, INPUT_PULLUP |
| Tombol 2 | D3 | Kaki lainnya ke 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}Bagian terpenting dari kode ini adalah fungsi durumDegistir() (ganti state). Ada tiga hal yang terjadi ketika pindah ke sebuah state: variabel state diperbarui, timestamp di-reset, dan aksi masuk state itu dijalankan sekali. Membuat semua transisi lewat satu fungsi ini menghilangkan bug seperti “aku lupa me-reset timer”. Permintaan pejalan kaki dihapus ketika masuk ke state KIRMIZI, karena pada momen itu pejalan kaki memang menyeberang. Kalau kamu ingin menghitung resistor LED, pakai kalkulator resistor LED.
Contoh 2: menu pengaturan dengan dua tombol
Menu adalah penggunaan state machine yang paling alami: halaman yang tampil di layar adalah sebuah state, dan tombol memicu transisinya. Di contoh di bawah, tombol D2 berarti “berikutnya” atau “tambah nilai”, dan D3 berarti “OK”. Di menu utama, kamu berpindah antara opsi kecerahan dan kecepatan; tekan OK untuk masuk ke halaman pengaturan, ubah nilainya dengan D2, lalu keluar dengan OK. Bersamaan dengan itu, state machine kedua yang independen membuat LED di D10 berkedip dengan kecerahan dan kecepatan yang kamu pilih. LED-nya tidak tersendat sedikit pun selama kamu menjelajahi menu.

1// İki butonlu menü + bağımsız LED makinesi / two-button menu + independent LED machine
2// D2: ileri / değer artır, D3: tamam, D10: LED (PWM)
3const int ILERI_PIN = 2, TAMAM_PIN = 3, LED_PIN = 10;
4
5enum MenuDurum { MENU_PARLAKLIK, MENU_HIZ, AYAR_PARLAKLIK, AYAR_HIZ };
6MenuDurum menu = MENU_PARLAKLIK;
7int parlaklik = 153; // 51..255
8int hizMs = 500; // yanıp sönme yarım periyodu / blink half period
9
10struct Buton {
11 uint8_t pin;
12 bool kararli; // kararlı seviye / debounced level
13 bool sonOkuma;
14 unsigned long sonDegisim;
15};
16Buton ileri = {ILERI_PIN, HIGH, HIGH, 0};
17Buton tamam = {TAMAM_PIN, HIGH, HIGH, 0};
18
19// Yalnız basma anında bir kez true döner / true once, on the press edge only
20bool basildi(Buton &b) {
21 bool okuma = digitalRead(b.pin);
22 if (okuma != b.sonOkuma) {
23 b.sonOkuma = okuma;
24 b.sonDegisim = millis();
25 }
26 if (millis() - b.sonDegisim > 30 && okuma != b.kararli) { // 30 ms debounce
27 b.kararli = okuma;
28 return okuma == LOW;
29 }
30 return false;
31}
32
33void menuYaz() {
34 switch (menu) {
35 case MENU_PARLAKLIK: Serial.println(F("> Parlaklik ayari (D3: sec)")); break;
36 case MENU_HIZ: Serial.println(F("> Hiz ayari (D3: sec)")); break;
37 case AYAR_PARLAKLIK: Serial.print(F("Parlaklik: ")); Serial.println(parlaklik); break;
38 case AYAR_HIZ: Serial.print(F("Hiz (ms): ")); Serial.println(hizMs); break;
39 }
40}
41
42void menuGuncelle() { // 1. durum makinesi / machine 1
43 bool i = basildi(ileri);
44 bool t = basildi(tamam);
45 if (!i && !t) return;
46
47 switch (menu) {
48 case MENU_PARLAKLIK:
49 if (t) menu = AYAR_PARLAKLIK;
50 else menu = MENU_HIZ;
51 break;
52 case MENU_HIZ:
53 if (t) menu = AYAR_HIZ;
54 else menu = MENU_PARLAKLIK;
55 break;
56 case AYAR_PARLAKLIK:
57 if (t) menu = MENU_PARLAKLIK; // kaydet ve çık / save and exit
58 else parlaklik = (parlaklik >= 255) ? 51 : parlaklik + 51;
59 break;
60 case AYAR_HIZ:
61 if (t) menu = MENU_HIZ;
62 else hizMs = (hizMs >= 1000) ? 100 : hizMs + 100;
63 break;
64 }
65 menuYaz();
66}
67
68void ledGuncelle() { // 2. durum makinesi / machine 2
69 static bool yanik = false;
70 static unsigned long son = 0;
71 if (millis() - son >= (unsigned long)hizMs) {
72 son = millis();
73 yanik = !yanik;
74 analogWrite(LED_PIN, yanik ? parlaklik : 0);
75 }
76}
77
78void setup() {
79 Serial.begin(9600);
80 pinMode(ILERI_PIN, INPUT_PULLUP);
81 pinMode(TAMAM_PIN, INPUT_PULLUP);
82 pinMode(LED_PIN, OUTPUT);
83 menuYaz();
84}
85
86void loop() {
87 menuGuncelle(); // ikisi de beklemeden sırayla çalışır
88 ledGuncelle(); // both run in turn without blocking
89}Ketika membaca tombol, kamu perlu melihat momen penekanan, bukan levelnya. Kalau kita bertindak selama digitalRead() mengembalikan LOW, menu akan maju ratusan kali dalam satu tekanan. Fungsi basildi() (ditekan) menyimpan level stabil terakhir setiap tombol, menerapkan debounce 30 ms, dan hanya mengembalikan true sekali, yaitu pada perubahan dari HIGH ke LOW. Detail pengkabelan tombol dan pantulan kontak bisa kamu temukan di artikel cara menghubungkan tombol. Untuk menampilkan menu di layar LCD I2C alih-alih Serial Monitor, kamu cukup mengubah fungsi menuYaz(); state machine-nya tetap sama.
| State | D2 (berikutnya) | D3 (OK) |
|---|---|---|
| MENU_PARLAKLIK | Pindah ke MENU_HIZ | Masuk ke AYAR_PARLAKLIK |
| MENU_HIZ | Pindah ke MENU_PARLAKLIK | Masuk ke AYAR_HIZ |
| AYAR_PARLAKLIK | Tambah kecerahan sebesar 51 (kembali ke 51 setelah 255) | Simpan, kembali ke MENU_PARLAKLIK |
| AYAR_HIZ | Tambah durasi sebesar 100 ms (kembali ke 100 setelah 1000) | Simpan, kembali ke MENU_HIZ |
Contoh 3: mesin cuci
Perangkat sungguhan biasanya mengikuti program langkah demi langkah dan bereaksi terhadap event tak terduga. Di simulasi mesin cuci kita, menekan tombol start di D2 membuat mesin berurutan mengisi air, mencuci, membuang air, memeras, dan selesai dengan bunyi bip. Katup air, motor, dan pompa diwakili oleh tiga LED. Di state mencuci, motor berputar 2 detik lalu berhenti 2 detik; itu pola kecil berbasis waktu di dalam state. Yang paling penting, kalau sakelar tutup di D3 terbuka, mesin berhenti sementara di langkah mana pun ia berada, dan ketika tutup ditutup lagi, mesin melanjutkan dari titik terakhir dengan sisa waktunya.
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}Fitur jeda ini menunjukkan dua teknik ampuh state machine. Yang pertama adalah aturan bersama: pengecekan tutup dilakukan di satu tempat, sebelum switch, untuk semua state yang sedang berjalan; tidak ditulis terpisah di setiap case. Yang kedua adalah mengingat state sebelumnya: variabel oncekiDurum (state sebelumnya) menyimpan langkah mana yang ditinggalkan, dan kalanGecen berapa lama waktu yang sudah dihabiskan di langkah itu. Ketika tutup ditutup, mesin kembali ke state yang sama dan timestamp dimundurkan sebesar waktu yang sudah berlalu, sehingga langkahnya tidak mulai dari awal. Di perangkat sungguhan, modul relay menggerakkan katup, motor, dan pompa sebagai pengganti LED.
Menjalankan beberapa state machine sekaligus
Seperti yang kamu lihat di contoh menu, setiap pekerjaan independen bisa menjadi state machine sendiri. Tata letak yang baik adalah menaruh setiap state machine di fungsinya sendiri lalu memanggil fungsi-fungsi itu bergantian di dalam loop(): trafikGuncelle(), butonGuncelle(), ekranGuncelle(), dan seterusnya. Karena tidak ada fungsi yang menunggu, loop berputar setiap beberapa mikrodetik dan semua state machine tampak berjalan bersamaan. State machine saling berkomunikasi lewat variabel bersama: state machine menu mengubah hizMs, dan state machine LED membacanya. Ini cara paling sederhana untuk multitasking di Arduino tanpa sistem operasi sungguhan. Satu state machine sebaiknya tidak mengubah state milik state machine lain secara langsung; sebagai gantinya, ia meninggalkan variabel permintaan, seperti pada permintaan pejalan kaki.
- Pakai satu variabel state dan satu timestamp per state machine; jangan dibagi antar state machine.
- Menyimpan variabel state sebagai static di dalam fungsi atau di dalam struct khusus state machine itu mencegah bentrokan nama.
- Biarkan state machine yang menangani sebuah permintaan (seperti yayaIstegi) yang menghapusnya.
- Ketika debugging, cetak nama state ke Serial Monitor di setiap perubahan state; kamu akan langsung melihat di mana program mentok.
State machine dengan MicroPython di Raspberry Pi Pico
MicroPython tidak punya enum; kamu mendefinisikan state sebagai angka konstan atau string. Berkat dictionary Python, sangat mudah menulis state machine yang sepenuhnya berbasis tabel: lampu, durasi, dan state berikutnya dari setiap state disimpan di dictionary terpisah, lalu perulangan mengambil keputusan dengan melihat tabel-tabel itu. Untuk menambah state baru, kamu menambah satu baris di tabel, bukan di kode. Untuk pengaturan waktu, kamu memakai time.ticks_ms() dan time.ticks_diff(); ticks_diff memberi selisih yang benar bahkan ketika penghitungnya meluap (wrap around). Di kode di bawah, LED ada di GP13 (merah), GP12 (kuning), dan GP11 (hijau), dan tombol pejalan kaki di GP4. Kalau kamu baru mengenal MicroPython, mulailah dari artikel dasar-dasar 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)Kesalahan umum dan solusinya
| Kesalahan | Gejala | Solusi |
|---|---|---|
| delay() di dalam state | Tombol dan state machine lain macet | Cek waktu yang berlalu dengan millis() alih-alih menunggu |
| Lupa break | Kode satu state ikut menjalankan kode state berikutnya | Akhiri setiap case dengan break |
| Tidak me-reset timestamp | State baru langsung selesai atau tidak pernah selesai | Lakukan semua transisi lewat satu fungsi durumDegistir() |
| Melihat level tombol | Satu tekanan menyebabkan beberapa transisi | Tangkap momen penekanan dan terapkan debounce |
| Menjalankan aksi masuk berulang-ulang di dalam state | Serial Monitor kebanjiran, buzzer berbunyi tanpa henti | Pindahkan pekerjaan yang cukup sekali ke aksi masuk |
| State tanpa jalan keluar | Program terjebak di satu state selamanya | Pastikan di diagram setiap state punya minimal satu panah keluar |
| Menulis perbandingan millis() dengan penjumlahan | Pengaturan waktu rusak setelah 49,7 hari | Selalu pakai bentuk millis() - mulai >= durasi |
Ide proyek dengan state machine
- Brankas berkode: kunci dengan keypad dan servo dengan state KILITLI (terkunci), SIFRE_GIRILIYOR (memasukkan kode), ACIK (terbuka), dan ALARM; kode yang salah membunyikan buzzer di state ALARM.
- Game memori Simon: game yang menampilkan urutan LED ke pemain dan memantau tombol, dengan state GOSTER (tampilkan), BEKLE (tunggu), KONTROL (cek), dan KAYBETTIN (kalah).
- Lampu tangga pintar: pencahayaan dengan state BOS (diam), YANIYOR (menyala), dan SONUYOR (meredup) yang menyala ketika ada gerakan dan meredup perlahan ketika waktunya habis.
- Tes reaksi: game dengan state HAZIR (siap), RASTGELE_BEKLE (tunggu acak), OLC (ukur), dan SONUC (hasil) yang mengukur waktu reaksi dalam milidetik.
- Robot yang menerima perintah serial: kendaraan dengan state DUR (berhenti), ILERI (maju), DON (belok), dan ENGEL (rintangan) yang bereaksi terhadap sensor dan perintah bersamaan.
State machine mengubah setiap proyek Arduino yang kamu tulis menjadi kode yang lebih rapi, lebih cepat merespons, dan lebih mudah dikembangkan. Di aplikasi BlueGrays, kamu akan menemukan proyek seperti lampu lalu lintas, kendali LED dengan tombol, penghitung dengan display 7-segmen, kunci password dengan keypad, game Simon, dan lampu lalu lintas empat mode dengan Raspberry Pi Pico, masing-masing dengan skema rangkaian dan kode langkah demi langkah; terapkan struktur state machine dari panduan ini pada proyek-proyek itu.
Pertanyaan umum
Apa itu state machine di Arduino?
State machine adalah struktur kode yang membagi program menjadi sejumlah state terbatas dan pada satu waktu hanya berada di salah satunya. Di setiap state sudah jelas apa yang harus dilakukan dan dengan syarat apa pindah ke state lain. Di Arduino, biasanya ditulis dengan enum, switch-case, dan millis().
Bagaimana cara memakai enum di Arduino?
Kamu mendefinisikannya seperti enum Durum { BEKLE, CALIS, BITTI }; dan membuat variabel dengan Durum durum = BEKLE;. Compiler mengubah nama-nama itu menjadi angka seperti 0, 1, 2, tapi di kode kamu memakai nama yang bermakna. Definisi enum perlu ditulis di bagian atas file, sebelum fungsi-fungsi.
Bagaimana cara menulis state machine dengan switch-case?
Masukkan variabel state ke switch(durum) dan tulis satu blok case untuk setiap state. Di setiap blok, cek syarat keluar state itu dan ganti state kalau syaratnya terpenuhi. Jangan lupa menaruh break di akhir setiap case.
Bagaimana cara menunggu di Arduino tanpa delay?
Simpan momen ketika kamu masuk ke sebuah state di variabel dengan millis(), lalu cek syarat millis() - mulai >= durasi di setiap putaran loop. Kalau waktunya belum habis, loop langsung lanjut, jadi pekerjaan lain tidak tertahan. Cara ini juga tetap benar ketika millis() meluap (overflow).
Apakah Arduino bisa melakukan beberapa hal sekaligus?
Arduino Uno hanya punya satu inti, jadi tidak benar-benar mengerjakan semuanya bersamaan, tapi dengan state machine yang tidak memblokir, ia menjalankan pekerjaan-pekerjaan itu bergantian ribuan kali per detik sehingga tampak bersamaan. Cukup taruh setiap pekerjaan di fungsinya sendiri dan panggil bergantian di dalam loop().
Bagaimana cara menulis state machine di MicroPython?
MicroPython tidak punya enum, jadi state didefinisikan sebagai angka konstan. Struktur berbasis tabel yang menyimpan durasi, output, dan state berikutnya dari setiap state di dictionary sangat praktis. Untuk pengaturan waktu, kamu memakai time.ticks_ms() dan time.ticks_diff().
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
Lampu Lalu Lintas
Tiruan mini lampu lalu lintas yang kamu lihat di jalan setiap hari. Merah menyala dua detik, kuning menyala sebentar, hijau menyala dua detik, lalu kembali ke merah lewat kuning lagi, terus berulang.

Nyala/Mati LED dengan Tombol (On/Off)
Tekan tombol sekali dan lampu menyala, tekan lagi dan lampu mati, persis seperti sakelar lampu di kamarmu.

Lampu Lalu Lintas ESP32
Simulasi lampu lalu lintas sungguhan dengan 3 LED merah-kuning-hijau. Pengaturan waktunya mendekati logika lalu lintas sungguhan: merah lama, kuning singkat, hijau lama. Contoh klasik kendali GPIO berurutan.

Simulator Lampu Lalu Lintas Raspberry Pi Pico (3 LED Berurutan)
Kita menyimulasikan lampu lalu lintas sungguhan dengan LED merah, kuning, dan hijau; proyek 3 LED pertama di seri Pico! Hijau 4 detik "jalan", kuning 1,5 detik "siap", merah 3 detik "berhenti", dan merah+kuning 1 detik "bersiap" (pola Eropa). Pelajari pendefinisian fungsi (def all_off()), logika state machine, dan sinkronisasi beberapa GPIO. 3 LED di GP11 (Hijau), GP12 (Kuning), GP13 (Merah), masing-masing dengan resistor 220Ω, berdampingan di board.

Lampu Lalu Lintas Raspberry Pi Pico dengan Pemilih 4 Mode lewat Tombol (State Machine)
4 mode lampu lalu lintas dengan 1 tombol! Setiap tekanan mengganti mode: Siklus normal (merah → kuning → hijau), Hanya Merah (tanda berhenti), Kuning Berkedip (mode malam), Mati (perawatan). Konsep: state machine (variabel mode menentukan perilaku), perputaran mode dengan modulo ((mode + 1) % 4 → 0→1→2→3→0), waktu non-blocking (fase LED dengan time.ticks_ms() + time.ticks_diff(); jeda debounce singkat tetap memakai sleep_ms).

Penghitung dengan Layar 7 Segmen dan Tombol
Penghitung sederhana dengan tiga tombol: tekan satu dan angka di layar naik satu, tekan yang lain dan turun satu, dan yang ketiga mengembalikannya ke nol.

Kunci Sandi dengan Keypad 4x4 dan LCD
Kunci pintu elektronik kecil yang menahan siapa pun yang tidak tahu kodenya. Kamu menekan tombol pagar lalu mengetik kodenya di keypad; jika benar, layar menulis akses diberikan, LED hijau menyala…

Game Memori Arduino (4 LED + 4 Tombol + Buzzer)
Percaya dengan ingatanmu? Empat LED berwarna menyala berurutan, masing-masing memainkan nadanya sendiri, dan kamu mengulang urutan yang sama dengan menekan tombol.
Artikel lainnya
Aplikasi BlueGrays
Rakit rangkaian ini langkah demi langkah di ponselmu
Skema pengkabelan, kode, dan daftar komponen dalam satu layar. 500+ proyek Arduino, ESP32, dan Pico siap dibuat.
Pindai dengan ponselmu
Arahkan kamera ke kode ini dan toko aplikasi di ponselmu akan terbuka.
atau buka toko aplikasi

