Belajar

Overflow Arduino millis(): apa yang terjadi saat pembungkusan, dan satu baris yang selamat darinya

Atau lihat semua pelajaran.

  • 526komponen di meja kerja
  • 46board sedang berjalan
  • 1.00xwaktu nyata, di semua board
Arduino Uno: dua laju, diukur dengan millis()live0.000 s 0.00x
Klik untuk membukanya di editor
Pin 13 berkedip setiap 250 ms dan pin 12 setiap 400 ms, masing-masing diukur dengan now - last >= interval.

millis() menghitung milidetik sejak board menyala, dalam unsigned long. Itu 32 bit di Uno maupun ESP32, jadi hitungannya naik sampai 4294967295 lalu membungkus ke 0 dan lanjut lagi. Ia tidak me-reset board, tidak berhenti, dan tidak melempar error. Ia hanya mulai lagi dari nol, dan sketch mana pun yang membandingkan waktu dengan cara yang salah akan rusak di saat itu.

Perbaikannya satu aturan: selalu kurangkan. Tulis if (millis() - start >= interval), dengan start dan hasilnya sebagai unsigned long, dan perbandingannya benar sebelum pembungkusan, melewatinya, dan sesudahnya. Ditulis if (millis() >= start + interval) ia gagal saat pembungkusan. Bagian halaman ini menunjukkan alasannya, dengan sketch yang berjalan melewati pembungkusan di Uno simulasi dan mencetak setiap nilai.

Rangkaian di atas mengedipkan dua LED pada dua laju dari satu loop tanpa delay(): pin 13 setiap 250 ms dan pin 12 setiap 400 ms. Loop-nya dibangun tepat dari baris itu, sekali untuk tiap LED.

Berapa lama sampai millis() membungkus

Nilai terbesar yang bisa ditampung unsigned long adalah 4294967295. Tambah satu dan kamu dapat 0: di Uno simulasi, Serial.println(4294967295UL + 1) mencetak 0. Sebagai milidetik, 4294967296 adalah 49,71 hari, itulah "49,7 hari" yang dikutip setiap jawaban forum. Board yang berjalan tujuh minggu akan bertemu dengannya.

micros() memakai tipe 32-bit yang sama, tapi menghitung seribu kali lebih cepat, jadi ia membungkus setelah 4294967296 mikrodetik, 71,58 menit. Yang ini bukan sekadar keunikan. Sketch yang mengukur waktu dengan micros() bertemu pembungkusan sedikit lebih dari satu jam setelah menyala, cukup lama untuk lulus semua uji di meja kerja dan cukup singkat untuk gagal di malam pertama pemakaian sungguhan.

Pembungkusan, dijalankan di Uno simulasi

Nobody wants to wait 49.7 days to see a bug, in a simulation or on a desk. So this sketch keeps its own clock: it starts it 296 ms before the wrap, at 4294967000, and steps it forward 100 ms at a time, as millis() would. At each step it asks both questions, "has 1000 ms gone by?" by subtraction and by addition, and prints the answers. The arithmetic is the board’s own: 32-bit unsigned math, run on the simulated ATmega328P.

Ia mencetak "t=0 now=4294967000 now-start=0 subtraction: wait, addition: DUE" di baris pertamanya. Penjumlahan mengatakan interval sudah lewat sebelum satu milidetik pun berlalu. Itu karena start + interval adalah 4294968000, yang tidak muat, jadi terbungkus ke 704, dan setiap nilai now sebelum pembungkusan lebih besar dari 704.

Pengurangan terus menghitung: 100, 200, 300 tepat melewati wrap, saat now berpindah dari 4294967200 ke 4, dan melaporkan "due" untuk pertama kalinya di baris "t=1000 now=704 now-start=1000 subtraction: DUE, addition: DUE". Itu tepat 1000 ms setelah mulai. Penjumlahan, sementara itu, mengatakan "DUE" sampai wrap dan "wait" setelahnya, benar hanya secara kebetulan mulai baris 1000 ms. Jauh dari wrap keduanya setuju, itulah kenapa versi penjumlahan lulus setiap uji singkat.

Kedua perbandingan, dilangkahkan melewati wrap
void setup() {
  Serial.begin(9600);
  unsigned long start = 4294967000UL;  // 296 ms before the wrap
  unsigned long interval = 1000;
  for (unsigned long t = 0; t <= 1200; t += 100) {
    unsigned long now = start + t;     // what millis() would say
    Serial.print("t=");
    Serial.print(t);
    Serial.print(" now=");
    Serial.print(now);
    Serial.print(" now-start=");
    Serial.print(now - start);
    Serial.print(now - start >= interval ? " subtraction: DUE" : " subtraction: wait");
    Serial.println(now >= start + interval ? ", addition: DUE" : ", addition: wait");
  }
}

void loop() {
}

Buka sketch ini di editorKodenya saja: editor menempatkan board dan komponen yang bisa dibacanya dari sketch.

Kenapa pengurangan selalu benar

Unsigned arithmetic in C and C++ is arithmetic modulo 2 to the 32nd: every result wraps the same way the clock does. When now has wrapped to 704 and start is still 4294967000, the true difference is 1000, and 704 minus 4294967000, wrapped, is 1000. The two wraps cancel. As long as the interval you are measuring is shorter than 49.7 days, now - start is the time that has really gone by.

Penjumlahan tidak seberuntung itu. start + interval wrap sendiri, dan now wrap di saat yang berbeda, jadi untuk sementara satu sisi sudah wrap dan yang lain belum, dan perbandingan menjawab pertanyaan yang salah. Memeriksa terhadap tenggat yang disimpan, if (millis() > deadline), adalah kesalahan yang sama dalam bentuk lain.

Cara lain ia salah: tipe yang keliru

Pengurangan hanya berfungsi di unsigned long. Simpan millis() dalam long bertanda dan nilainya jadi negatif setelah 24,86 hari, setengah dari rentangnya: di Uno, (long)4294967000UL mencetak -296. Simpan di int pada Uno, yang di sana 16 bit, dan akan rusak setelah 32,767 detik: (int)40000UL mencetak -25536, jadi sketch yang menyimpan int start = millis(); berperilaku salah dalam menit pertamanya. Pada ESP32, int 32 bit, yang menyembunyikan kesalahan kedua tapi bukan yang pertama.

Gunakan unsigned long untuk setiap variabel yang menyimpan waktu, dan untuk intervalnya juga. const unsigned long INTERVAL = 1000; tidak memakan biaya apa pun dan menjaga seluruh ekspresi dalam tipe yang tepat.

Apakah kamu perlu menangani overflow sama sekali?

Tidak perlu, jika setiap perbandingan berupa pengurangan dalam unsigned long. Tidak perlu mendeteksi wrap, me-reset millis(), atau me-restart board setiap beberapa minggu; sketch yang melakukan hal-hal itu sebenarnya mengakali perbandingan yang ditulis dengan cara yang salah. delay() sudah mengukur waktu tunggunya dengan cara ini, jadi delay() yang melewati wrap tidak masalah.

Satu-satunya batas nyata adalah interval yang lebih panjang dari penghitungnya sendiri. Kamu tidak bisa mengukur 60 hari dengan satu pengurangan millis(). Hitung sesuatu yang lebih lambat: tambahkan satu ke penghitung days setiap kali 86400000 ms berlalu, dengan pengurangan yang sama, atau baca waktu dari modul jam waktu nyata.

Buka rangkaian ini di editor. Arduino Uno: dua laju, dihitung dengan millis(), dirangkai seperti yang berjalan di bagian atas halaman ini. Ubah komponen atau nilainya dan jalankan lagi.

Pertanyaan

Berapa nilai maksimum millis()?

4294967295, unsigned long terbesar. Satu milidetik kemudian nilainya 0. Pada Uno simulasi, 4294967295UL + 1 mencetak 0.

Berapa lama sampai millis() overflow?

Sekitar 49,71 hari, 4294967296 milidetik. micros() overflow setelah sekitar 71,58 menit.

Apakah Arduino me-reset saat millis() overflow?

Tidak. Hitungannya wrap ke 0 dan terus berjalan, dan sketch-nya lanjut. Hanya perbandingan yang ditulis sebagai penjumlahan, atau disimpan dalam tipe yang salah, yang akan salah pada saat itu.

Bagaimana cara menghindari masalah overflow millis()?

Tulis setiap pengecekan sebagai if (millis() - start >= interval), dengan start dan interval dideklarasikan unsigned long. Satu baris itu benar melewati wrap, jadi tidak ada lagi yang perlu ditangani.

Rakit versi nyatanya

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