Metode Pengaturan Waktu Arduino Dengan Millis (): 4 Langkah

2024 Pengarang: John Day | [email protected]. Terakhir diubah: 2024-01-30 09:56

Dalam artikel ini kami memperkenalkan milis(); fungsi dan menggunakannya untuk membuat berbagai contoh waktu.

milis? Tidak ada hubungannya dengan lip-syncer… semoga Anda mengenali mili sebagai awalan numerik untuk seperseribu; yaitu mengalikan satuan ukuran dengan 0,001 (atau sepuluh pangkat negatif 3).

Menariknya, sistem Arduino kami akan menghitung jumlah milidetik (ribuan detik) dari awal sketsa berjalan hingga penghitungan mencapai jumlah maksimum yang mampu disimpan dalam tipe variabel unsigned long (integer 32-bit [empat byte] – yang berkisar dari nol hingga (2^32)-1.(2^32)-1, atau 4294967295 milidetik dikonversi menjadi 49,71027 hari ganjil.

Penghitung direset ketika Arduino direset, mencapai nilai maksimum atau sketsa baru diunggah. Untuk mendapatkan nilai penghitung pada titik tertentu, panggil saja fungsinya – misalnya:

mulai=milis();

Di mana start adalah variabel panjang yang tidak ditandatangani. Berikut adalah contoh yang sangat sederhana untuk menunjukkan kepada Anda millis() beraksi:

/* milis() demonstrasi */

unsigned mulai lama, selesai, berlalu;

batalkan pengaturan()

{ Serial.begin(9600); }

lingkaran kosong()

{ Serial.println("Mulai…"); mulai=milis(); penundaan (1000); selesai=milis(); Serial.println("Selesai"); berlalu=selesai-mulai; Serial.print(berlalu); Serial.println("milidetik berlalu"); Serial.println(); penundaan (500); }

Sketsa menyimpan jumlah mili saat ini di awal, lalu menunggu satu detik, lalu menyimpan nilai mili lagi di akhir. Akhirnya menghitung waktu yang telah berlalu dari penundaan. Pada screen dump serial monitor berikut, Anda dapat melihat bahwa durasinya tidak selalu tepat 1000 milidetik, seperti yang ditunjukkan pada gambar.

Langkah 1:

Sederhananya, fungsi milis menggunakan penghitung internal di dalam mikrokontroler ATmega di jantung Arduino Anda. Penghitung ini menambah setiap siklus clock – yang terjadi (dalam Arduino standar dan yang kompatibel) pada kecepatan clock 16 Mhz. Kecepatan ini dikendalikan oleh kristal di papan Arduino (benda perak dengan cap T16.000 di atasnya).

Langkah 2:

Akurasi kristal dapat bervariasi tergantung pada suhu eksternal, dan toleransi kristal itu sendiri. Ini pada gilirannya akan mempengaruhi keakuratan hasil milis Anda. Pengalaman anekdotal telah melaporkan penyimpangan dalam akurasi waktu bisa sekitar tiga atau empat detik per periode dua puluh empat jam.

Jika Anda menggunakan papan atau versi Anda sendiri yang menggunakan resonator keramik alih-alih kristal, perhatikan bahwa mereka tidak seakurat dan akan menimbulkan kemungkinan tingkat penyimpangan yang lebih tinggi. Jika Anda membutuhkan tingkat akurasi waktu yang jauh lebih tinggi, pertimbangkan IC pengatur waktu tertentu seperti Maxim DS3231.

Sekarang kita dapat menggunakan mili untuk berbagai fungsi pengaturan waktu. Seperti yang ditunjukkan dalam sketsa contoh sebelumnya, kita dapat menghitung waktu yang telah berlalu. Untuk memajukan ide ini, mari kita buat stopwatch sederhana. Melakukannya bisa sesederhana atau serumit yang diperlukan, tetapi untuk kasus ini kita akan beralih ke yang sederhana.

Pada perspektif perangkat keras, kita akan memiliki dua tombol – Start dan Stop – dengan resistor pull-down 10k ohm terhubung ke pin digital 2 dan 3 masing-masing. Ketika pengguna menekan start sketsa akan mencatat nilai milis – kemudian setelah berhenti ditekan, sketsa akan kembali mencatat nilai milis, menghitung dan menampilkan waktu yang telah berlalu. Pengguna kemudian dapat menekan mulai untuk mengulangi proses, atau berhenti untuk data yang diperbarui. Berikut sketsanya:

/* Stopwatch super dasar menggunakan milis(); */

unsigned mulai lama, selesai, berlalu;

batalkan pengaturan()

{ Serial.begin(9600); pinMode(2, INPUT); // tombol start pinMode(3, INPUT); // tombol stop Serial.println("Tekan 1 untuk Start/reset, 2 untuk waktu yang telah berlalu"); }

batal tampilanHasil()

{ float h, m, s, ms; lama tidak ditandatangani; berlalu=selesai-mulai; h=int(berlalu/3600000); lebih = berlalu%3600000; m=int(lebih dari/60000); lebih = lebih dari% 60000; s=int(lebih/1000); ms=lebih dari%1000; Serial.print("Waktu mentah berlalu: "); Serial.println(berlalu); Serial.print("Waktu yang berlalu: "); Serial.print(h, 0); Serial.print("h"); Serial.print(m, 0); Serial.print("m"); Serial.print(s, 0); Serial.print("s"); Serial.print(ms, 0); Serial.println("ms"); Serial.println(); }

lingkaran kosong()

{ if (digitalRead(2)==HIGH) { start=millis(); penundaan (200); // untuk debounce Serial.println("Mulai…"); } if (digitalRead(3)==HIGH) { selesai=milis(); penundaan (200); // untuk debounce displayResult(); } }

Panggilan ke delay() digunakan untuk mendebounce sakelar – ini opsional dan penggunaannya akan bergantung pada perangkat keras Anda. Gambar adalah contoh output monitor serial sketsa – stopwatch telah dimulai, dan kemudian tombol dua ditekan enam kali selama periode waktu tertentu.

Langkah 3: Speedometer…

Jika Anda memiliki sensor di awal dan akhir jarak tetap, kecepatan dapat dihitung: kecepatan = jarak waktu.

Anda juga bisa membuat speedometer untuk bentuk gerak beroda, misalnya sepeda. Saat ini kami tidak memiliki sepeda untuk dipusingkan, namun kami dapat menjelaskan prosesnya – cukup sederhana. (Penafian – lakukan dengan risiko Anda sendiri, dll.)

Pertama-tama, mari kita tinjau matematika yang diperlukan. Anda perlu mengetahui keliling roda. Perangkat keras – Anda akan membutuhkan sensor. Misalnya – saklar buluh dan magnet. Pertimbangkan sakelar buluh sebagai tombol yang biasanya terbuka, dan sambungkan seperti biasa dengan resistor pull-down 10k ohm.

Orang lain mungkin menggunakan sensor efek hall – masing-masing untuk mereka sendiri). Ingat dari kelas matematika, untuk menghitung keliling – gunakan rumus: keliling = 2πr di mana r adalah jari-jari lingkaran.

Sekarang Anda memiliki lingkar roda, nilai ini dapat dianggap sebagai 'jarak tetap' kami, dan oleh karena itu kecepatan dapat dihitung dengan mengukur waktu yang telah berlalu antara satu putaran penuh.

Sensor Anda – setelah dipasang – harus bekerja dengan metode yang sama seperti tombol yang biasanya terbuka yang ditekan setiap putaran. Sketsa kami akan mengukur waktu yang berlalu antara setiap pulsa dari sensor.

Untuk melakukan ini, contoh kita akan menghubungkan output sensor ke pin digital 2 – karena akan memicu interupsi untuk menghitung kecepatan. Sketsa sebaliknya akan menampilkan kecepatan pada modul LCD antarmuka I2C normal. Antarmuka I2C disarankan karena ini hanya membutuhkan 4 kabel dari papan Arduino ke LCD – semakin sedikit kabel semakin baik.

Berikut adalah sketsa untuk teliti Anda:

/*Spidometer dasar menggunakan milis(); */

#include "Wire.h" // untuk LCD bus I2C

#include "LiquidCrystal_I2C.h" // untuk modul LCD bus I2C - https://bit.ly/m7K5wt LiquidCrystal_I2C lcd (0x27, 16, 2); // atur alamat LCD ke 0x27 untuk tampilan 16 karakter dan 2 baris

mulai mengambang, selesai;

mengapung berlalu, waktu; float circMetric=1.2; // lingkar roda relatif terhadap posisi sensor (dalam meter) float circImperial; // menggunakan 1 kilometer = 0,621371192 mil float speedk, speedm; // menyimpan nilai kecepatan yang dihitung dalam metrik dan imperial

batalkan pengaturan()

{ attachInterrupt(0, speedCalc, RISING); // interupsi dipanggil saat sensor mengirimkan digital 2 high (setiap putaran roda) start=millis(); // setup LCD lcd.init(); // inisialisasi lcd lcd.backlight(); // nyalakan lampu latar LCD lcd.clear(); lcd.println("Pakai helm!"); penundaan(3000); lcd.clear(); Serial.begin(115200); circImperial=circMetric*.62137; // konversi metrik ke imperial untuk penghitungan MPH }

batalkan kecepatanCalc()

{ berlalu=milis()-mulai; mulai=milis(); speedk=(3600*circMetric)/berlalu; // km/j speedm=(3600*circImperial)/berlalu; // Mil per jam }

lingkaran kosong()

{ lcd.setCursor(0, 0); lcd.print(int(speedk)); lcd.print("km/jam"); lcd.print(int(kecepatan)); lcd.print("MPH"); lcd.setCursor(0, 1); lcd.print(int(berlalu)); lcd.print("ms/rev"); penundaan (1000); // sesuaikan preferensi pribadi untuk meminimalkan kedipan }

Tidak banyak yang terjadi – setiap kali roda menyelesaikan satu putaran, sinyal dari sensor akan berubah dari rendah ke tinggi – memicu interupsi yang memanggil fungsi speedCalc().

Ini mengambil pembacaan milis() dan kemudian menghitung perbedaan antara pembacaan saat ini dan pembacaan sebelumnya – nilai ini menjadi waktu untuk menempuh jarak (yang merupakan keliling roda relatif terhadap sensor – disimpan dalam

float circMetric=1.2;

dan diukur dalam meter). Akhirnya menghitung kecepatan dalam km/jam dan MPH. Di antara interupsi, sketsa menampilkan data kecepatan yang diperbarui pada LCD serta nilai waktu mentah untuk setiap putaran demi rasa ingin tahu. Dalam kehidupan nyata saya tidak berpikir siapa pun akan memasang LCD di sepeda, mungkin tampilan LED akan lebih relevan.

Sementara itu, Anda dapat melihat cara kerja contoh ini dalam klip video singkat berikut. Alih-alih kombinasi roda sepeda dan sakelar buluh / magnet, saya telah menghubungkan output gelombang persegi dari generator fungsi ke pin interupsi untuk mensimulasikan pulsa dari sensor, sehingga Anda bisa mendapatkan gambaran tentang cara kerjanya.

Langkah 4:

Itu hanya meringkas penggunaan milis() untuk saat ini. Ada juga mikro(); fungsi yang menghitung mikrodetik.

Jadi begitulah – fungsi praktis lain yang memungkinkan lebih banyak masalah diselesaikan melalui dunia Arduino. Seperti biasa, sekarang terserah Anda dan imajinasi Anda untuk menemukan sesuatu untuk dikendalikan atau bangun untuk kejahatan lainnya.

Posting ini dipersembahkan oleh pmdway.com - semuanya untuk pembuat dan penggemar elektronik, dengan pengiriman gratis ke seluruh dunia.