Dasar · 9 mnt baca

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.

KonsepArtiContoh lampu lalu lintas
StateKeadaan sistem sekarangKIRMIZI (merah), KIRMIZI_SARI (merah-kuning), YESIL (hijau), SARI (kuning)
TransisiPerpindahan dari satu state ke state lainDari YESIL ke SARI
Syarat atau eventPemicu transisi10 detik berlalu atau tombol pejalan kaki ditekan
Aksi masukPekerjaan yang dilakukan sekali ketika masuk ke stateNyalakan LED hijau, matikan yang lain
Aksi di dalam statePekerjaan yang dilakukan terus-menerus selama berada di statePantau 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().

FiturKode dengan delay()State machine
Apakah tombol dibaca selama menunggu?TidakYa
Beberapa pekerjaan sekaligusSulit, kodenya jadi berantakanMudah, setiap pekerjaan punya state machine sendiri
Menambah state baruKamu harus menulis ulang seluruh alurnyaCukup tambah satu case baru
DebuggingTidak jelas program sedang di manaCukup cetak nama state ke Serial Monitor
MemoriSedikitSedikit (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.

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}
Tulis definisi enum di paling atas file, sebelum fungsi-fungsimu. Arduino IDE membuat prototipe fungsi secara otomatis; kalau enum didefinisikan setelah fungsi yang memakainya sebagai parameter, kamu bisa mendapat error “was not declared in this scope”. Jangan lupa juga break di akhir setiap case; kalau tidak, program ikut menjalankan kode state berikutnya.

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.

  1. Daftar semua state sistem dan beri masing-masing nama pendek berhuruf kapital.
  2. Pilih state awal; Arduino akan berada di state ini ketika dinyalakan atau di-reset.
  3. Tulis syarat keluar untuk setiap state: waktu, tombol, sensor, atau event lain.
  4. Tambahkan state tujuan dari setiap transisi dan aksi yang dilakukan selama transisi, kalau ada.
  5. Tentukan aksi masuk setiap state: output mana yang nyala dan mana yang mati?
  6. Catat terpisah aturan bersama yang berlaku di semua state (berhenti darurat, tutup terbuka).
  7. Ubah diagram menjadi tabel transisi seperti di bawah, lalu tulis setiap baris sebagai if di dalam case.
StateSyaratState berikutnyaAksi masuk
KIRMIZI5 dtk berlaluKIRMIZI_SARIMerah menyala, permintaan pejalan kaki dihapus
KIRMIZI_SARI1,5 dtk berlaluYESILMerah dan kuning menyala
YESIL10 dtk berlalu, atau 4 dtk kalau ada permintaanSARIHijau menyala
SARI2 dtk berlaluKIRMIZIKuning 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.

LED merah, kuning, dan hijau
Contoh lampu lalu lintas, menu, dan mesin cuci semuanya memakai tiga LED dan dua tombol yang sama.
KomponenPin Arduino UnoCatatan
LED merahD8Dengan resistor 220 Ω, kaki pendek ke GND
LED kuningD9Dengan resistor 220 Ω
LED hijauD10Dengan resistor 220 Ω (pin yang mendukung PWM)
BuzzerD11Hanya di contoh mesin cuci
Tombol 1D2Kaki lainnya ke GND, INPUT_PULLUP
Tombol 2D3Kaki lainnya ke 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}

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.

Push button
Tombol dihubungkan dengan INPUT_PULLUP; pin terbaca LOW ketika ditekan.
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}

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.

StateD2 (berikutnya)D3 (OK)
MENU_PARLAKLIKPindah ke MENU_HIZMasuk ke AYAR_PARLAKLIK
MENU_HIZPindah ke MENU_PARLAKLIKMasuk ke AYAR_HIZ
AYAR_PARLAKLIKTambah kecerahan sebesar 51 (kembali ke 51 setelah 255)Simpan, kembali ke MENU_PARLAKLIK
AYAR_HIZTambah 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.

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}

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.

Contoh ini hanya simulasi dengan LED. Jangan coba mengganti board kontrol mesin cuci, pemanas, atau pompa sungguhan yang memakai listrik PLN; tegangan listrik PLN (220 V) berbahaya bagi nyawa sekaligus berisiko menimbulkan kebakaran.

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.

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

KesalahanGejalaSolusi
delay() di dalam stateTombol dan state machine lain macetCek waktu yang berlalu dengan millis() alih-alih menunggu
Lupa breakKode satu state ikut menjalankan kode state berikutnyaAkhiri setiap case dengan break
Tidak me-reset timestampState baru langsung selesai atau tidak pernah selesaiLakukan semua transisi lewat satu fungsi durumDegistir()
Melihat level tombolSatu tekanan menyebabkan beberapa transisiTangkap momen penekanan dan terapkan debounce
Menjalankan aksi masuk berulang-ulang di dalam stateSerial Monitor kebanjiran, buzzer berbunyi tanpa hentiPindahkan pekerjaan yang cukup sekali ke aksi masuk
State tanpa jalan keluarProgram terjebak di satu state selamanyaPastikan di diagram setiap state punya minimal satu panah keluar
Menulis perbandingan millis() dengan penjumlahanPengaturan waktu rusak setelah 49,7 hariSelalu pakai bentuk millis() - mulai >= durasi
Kalau jumlah state-mu mulai melewati 8–10, pertimbangkan untuk memecah state machine-nya: misalnya di mesin cuci, “pemilihan program” dan “menjalankan program” bisa menjadi dua state machine terpisah. State machine kecil yang berkomunikasi lewat variabel permintaan jauh lebih mudah dipahami daripada satu state machine raksasa.

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

Lihat semua proyek
Lampu Lalu Lintas
AR-3Pemula

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.

4.8(137)
440
Nyala/Mati LED dengan Tombol (On/Off)
AR-10Pemula

Nyala/Mati LED dengan Tombol (On/Off)

Tekan tombol sekali dan lampu menyala, tekan lagi dan lampu mati, persis seperti sakelar lampu di kamarmu.

4.7(103)
177
Lampu Lalu Lintas ESP32
ES-5Pemula

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.

4.4(22)
45
Simulator Lampu Lalu Lintas Raspberry Pi Pico (3 LED Berurutan)
PI-4Pemula

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.

4.0(1)
12
Lampu Lalu Lintas Raspberry Pi Pico dengan Pemilih 4 Mode lewat Tombol (State Machine)
PI-12Menengah

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

5.0(1)
16
Penghitung dengan Layar 7 Segmen dan Tombol
AR-43Mahir
Premium

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.

4.6(35)
47
Kunci Sandi dengan Keypad 4x4 dan LCD
AR-64Mahir
Premium

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…

4.8(59)
75
Game Memori Arduino (4 LED + 4 Tombol + Buzzer)
AR-93Mahir
Premium

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.

4.8(46)
69