Belajar

Mengapa delay() memblokir, dan apa yang digunakan sebagai gantinya

Atau lihat semua pelajaran.

  • 526komponen di meja kerja
  • 46board sedang berjalan
  • 1.00xwaktu nyata, di semua board
Arduino Uno: dua laju, tanpa delaylive0.000 s 0.00x
Klik untuk membukanya di editor
Pin 13 berkedip setiap 250 ms, pin 12 setiap 400 ms, dari satu loop yang tidak pernah memanggil delay().

delay(500) melakukan persis yang dikatakannya: menghentikan sketch sepenuhnya selama lima ratus milidetik. Tidak ada hal lain di loop() yang berjalan, tidak ada pin lain yang berubah, tidak ada data serial yang dibaca, sampai penundaan selesai. Itu tidak masalah untuk satu LED berkedip, karena tidak ada hal lain yang perlu dikerjakan sketch sambil menunggu. Semuanya berhenti bekerja begitu ada dua hal yang perlu terjadi dengan jadwalnya masing-masing, karena delay() kedua hanya bisa berjalan setelah yang pertama selesai, artinya dua hal itu tidak akan pernah benar-benar mandiri.

Ini layak dirangkai sekali secara khusus karena kebanyakan tutorial pemula mengajarkan delay() lebih dulu, dengan alasan bagus: itu cara termudah yang mungkin untuk membuat LED berkedip, dan memang benar untuk tugas itu. Masalahnya baru muncul begitu sketch tumbuh melewati LED pertamanya, yang justru saat seorang pemula paling tidak siap menghadapi perubahan cara kerja timing, jadi lebih baik menemui batas ini secara sengaja di sini, pada rangkaian kecil, alih-alih menemuinya untuk pertama kali di tengah proyek yang lebih besar.

The circuit above is the demonstration: two LEDs, one on pin 13 blinking every 250 milliseconds and one on pin 12 blinking every 400 milliseconds, both timed from the same loop with no delay() anywhere in it. Watch them for a few seconds and the two rates visibly drift in and out of phase with each other, because 250 and 400 only line up again every two seconds, which is exactly what two independent rates should do, and exactly what two lamps sharing one delay() call could never manage.

Unduh rencana pelajaran (PDF)

Apa yang sebenarnya dilakukan delay()

Di chip asli, dan di model Mokxi, delay() bukanlah loop sibuk yang memutar CPU tanpa alasan: sketch blink bawaan Uno mengandalkan detikan timer hardware dan membiarkan inti tidur di antara detikan, yang efisien dan benar untuk tepat satu pekerjaan pada satu waktu. Masalahnya tidak pernah karena delay() boros. Masalahnya adalah sifatnya yang total: selama delay berjalan, sketch tidak bisa melakukan hal lain sama sekali, termasuk memeriksa timer kedua yang seharusnya berjalan secara independen.

Bentuk state machine

Perbaikannya adalah berhenti menunggu dan mulai bertanya waktu. Untuk setiap hal yang butuh jadwalnya sendiri, simpan momen terakhir kali itu terjadi, dan pada setiap putaran loop() tanyakan apakah cukup waktu telah berlalu: if (now - lastTime >= INTERVAL) { lastTime = now; ...act... }. loop() itu sendiri tidak pernah berhenti; ia hanya tidak melakukan apa-apa, pada sebagian besar putaran, untuk timer mana pun yang belum waktunya.

Two details in that line are not optional. now and lastTime have to be unsigned long, because that is the type millis() returns and the type the subtraction has to happen in. And the comparison has to be a subtraction, now - lastTime, rather than an addition like lastTime + INTERVAL, because subtracting two unsigned longs comes out correct even across the roll-over that happens roughly every 49.7 days, when millis() wraps back to zero. An addition-based comparison breaks exactly at that boundary; the subtraction never does.

This shape scales past two timers with no change to it at all. The Uno's built-in cpptiming example runs three lamps at three unrelated rates, 200, 330 and 1100 milliseconds, from a small array of little structs, each holding its own pin, interval and last-fired time, and one loop that checks all three the same way this page's two-lamp version checks two. It also prints the longest a single pass through loop() has ever taken, which stays at 2 milliseconds or less as long as nothing in the sketch blocks (2 rather than 1, because millis() itself now and then jumps by 2), and climbs the moment something does. That number is a genuinely useful thing to watch in a sketch you are not sure is blocking anywhere: a loop() that is meant to be instant and suddenly is not has a delay(), or something that behaves like one, hiding in it somewhere.

Dua timer sekaligus

Program bawaan Uno tworates adalah rangkaian di atas, berjalan seperti yang ditampilkan: dua pekerjaan independen, dua interval, satu loop, tanpa delay().

firmware/examples/tworates (program persis yang berjalan di atas)
const int RED_PIN = 13;
const int GREEN_PIN = 12;
const unsigned long RED_MS = 250;
const unsigned long GREEN_MS = 400;

unsigned long lastRed = 0;
unsigned long lastGreen = 0;
bool redOn = false;
bool greenOn = false;

void loop() {
  unsigned long now = millis();

  if (now - lastRed >= RED_MS) {
    lastRed = now;
    redOn = !redOn;
    digitalWrite(RED_PIN, redOn ? HIGH : LOW);
  }

  if (now - lastGreen >= GREEN_MS) {
    lastGreen = now;
    greenOn = !greenOn;
    digitalWrite(GREEN_PIN, greenOn ? HIGH : LOW);
  }
}

Yang akan kamu coba dengan delay(), dan kenapa itu tidak bisa dikembangkan lebih jauh

Membuat dua lampu bergantian hanya dengan delay() itu mungkin, dan program bawaan Uno twoleds melakukan tepat itu: nyalakan lampu merah dan matikan lampu hijau, tunggu, lalu tukar, tunggu lagi. Jika dilihat sendirian, tampak seperti dua laju. Bukan: kedua lampu terkunci pada penantian setengah detik yang sama, karena hanya ada satu penantian di seluruh sketch. Coba beri lampu hijau laju yang tidak membagi habis laju lampu merah, tanpa menyentuh millis(), dan tidak ada cara menuliskannya: panggilan delay() ketiga hanya bisa berjalan setelah dua lainnya selesai, jadi laju independen ketiga bukan satu langkah lebih sulit, tapi mustahil dalam bentuk ini.

Membaca tombol di loop yang sama

Manfaat sesungguhnya dari pola ini muncul begitu sebuah sketch perlu melakukan lebih dari sekadar berkedip. loop() yang dibangun di sekitar delay() tidak bisa memeriksa tombol, mencetak ke serial monitor atau memperbarui tampilan saat sedang menunggu kedipan; loop() yang dibangun di sekitar pemeriksaan millis() menjadikan semuanya hanya blok if lagi yang berjalan di setiap putaran, jadi pembacaan tombol berdampingan nyaman dengan dua timer kedip independen tanpa ada yang berubah dari keduanya. Ini juga bentuk yang dipakai halaman tentang debouncing tombol untuk perbaikannya, dan itu bukan kebetulan: ini masalah yang sama, mengatur waktu sesuatu tanpa memblokir hal lain, dipecahkan dengan cara yang sama.

Buka rangkaian ini di editor. Arduino Uno: dua laju, tanpa delay, dirangkai seperti contoh yang berjalan di bagian atas halaman ini. Ubah komponen atau nilainya dan jalankan lagi.

Pertanyaan

Apa yang terjadi saat millis() roll-over setelah 49,7 hari?

Pengurangan unsigned di now - lastTime membungkus diri dengan benar dan terus menghasilkan interval yang tepat, dan itulah seluruh alasan pola ini ditulis sebagai pengurangan, bukan sebagai lastTime + INTERVAL yang dibandingkan dengan now.

Is delay() ever fine to use?

Boleh, untuk sketch yang benar-benar tidak punya hal lain untuk dikerjakan saat menunggu, atau untuk tunggu yang sangat singkat di setup(). Begitu timer independen kedua, pembacaan tombol atau pemeriksaan serial perlu terjadi selama tunggu itu, delay() adalah alat yang salah.

Bagaimana menambahkan timer ketiga dengan laju ketiga?

Tambahkan variabel lastTime ketiga, interval ketiga dan blok if ketiga, persis bentuk dari dua yang sudah ada. Tidak ada yang berubah dari pola ini saat lebih banyak timer bergabung, dan itulah inti menulis dengan cara ini.

Apakah menggunakan interrupt menggantikan pola ini?

Keduanya menyelesaikan masalah yang berbeda: interrupt bereaksi terhadap suatu peristiwa (sebuah edge, timer overflow) begitu itu terjadi, sedangkan pewaktuan millis() untuk pekerjaan yang hanya perlu terjadi pada jadwal yang bisa diperiksa loop() sendiri. Banyak sketch memakai keduanya.

Kenapa memakai unsigned long, bukan int, untuk variabel pewaktuan?

millis() mengembalikan unsigned long karena hitungannya butuh rentang lebih besar daripada yang diberikan int 16-bit di Uno; menyimpannya di tipe yang lebih kecil atau bertanda akan memotong atau salah membaca nilai jauh sebelum roll-over 49,7 hari menjadi masalah.

Untuk apa micros(), kalau millis() sudah ada?

Resolusi yang lebih halus, dalam mikrodetik bukan milidetik, untuk pewaktuan yang perlu lebih ketat dari satu milidetik, dengan konsekuensi roll-over jauh lebih cepat, kira-kira setiap 71 menit, bukan setiap 49,7 hari. Pola pengurangan yang sama di atas bekerja untuknya tanpa perubahan.

Rakit versi nyatanya

Buka editor, ubah sebuah nilai, dan lihat angkanya ikut berubah. Tidak ada yang perlu dipasang, dan tidak perlu akun.