Pembelajaran Pengaturcaraan Asas Arduino - Tutorial untuk Pendatang Baru

Dalam tutorial ini kita belajar bagaimana melakukan pengaturcaraan Arduino asas melalui kod contoh dan program contoh. Tutorial ini boleh menjadi kursus yang sangat berharga bagi semua pendatang baru yang ingin memahami asas-asasnya melalui bahasa yang mudah difahami.

Pengenalan

Menurut wikipedia mikrokontroler setara dengan komputer mini yang dibina di dalam satu cip IC, mempunyai pemproses terasnya sendiri, input yang dapat diprogramkan, memori dan output periferal.

Pengawal mikro menjadi sangat berguna bagi pengguna kerana ia menawarkan pemproses, memori dan port input / output terbina dalam (juga disebut GPIO atau pin input / output tujuan umum) yang dapat kita kendalikan oleh pengguna sesuai dengan spesifikasi yang diinginkan.

Dalam tutorial ini kita akan bekerjasama dengan papan Arduino Uno untuk belajar dan menguji program. Untuk menguji dan mengintegrasikan pemasangan perkakasan kami akan menggunakan papan roti.

Sekarang mari kita bergerak dengan cepat dan belajar bagaimana untuk memulakan dengan pengaturcaraan Arduino.

1.2 Memasang Perisian (Windows)

Untuk ini, anda memerlukan akses ke internet, yang pastinya anda miliki di komputer anda. Sila pergi ke pautan berikut dan muat turun perisian IDE:

Fail ZIP Windows untuk pemasangan bukan pentadbir

Selepas memuat turun, anda akan menemui ikon persediaan Arduino di folder muat turun, yang akan kelihatan seperti ini:

Sebaik sahaja anda mendapatkannya, anda hanya boleh mengklik dua kali padanya dan memasang Arduino the Integrated Development Environment (IDE) di komputer anda. Proses lengkap dapat dilihat dalam video berikut:

1.4 Bermula dengan Litar Pertama kami

Sebelum kita mula mempelajari teknik pengaturcaraan yang sebenarnya, untuk pemula mana pun akan berguna untuk memulakan dengan komponen asas seperti LED, dan memahami cara menghubungkannya dengan Arduino.

Seperti yang kita ketahui LED adalah diod pemancar cahaya yang mempunyai kekutuban dan tidak akan menyala jika tidak dihubungkan dengan kutub bekalan yang betul.

Aspek lain dengan LED adalah bahawa peranti ini berfungsi dengan arus rendah dan mungkin akan rosak serta-merta jika perintang yang dihitung dengan tepat tidak disertakan dalam siri dengan salah satu pinnya.

Sebagai peraturan, 330 ohm 1/4 watt sangat sesuai untuk setiap kenaikan input bekalan 5V untuk mengehadkan arus ke tahap selamat yang diperlukan. Oleh itu, untuk 5V mungkin 330 ohm, untuk 10V mungkin 680 ohm dan seterusnya.

Menggunakan Papan Roti untuk Perhimpunan

Pastikan anda tahu bagaimana menggunakan a papan roti sebelum mencuba tutorial yang dijelaskan dalam bab ini, kerana kami akan menggunakan papan roti untuk semua eksperimen di sini.

Penyediaan sambungan LED asas dapat dilihat di bawah:

Anda dapat melihat 3 komponen asas di atas:

1. LED 5mm, 20mA
2. perintang 330 ohm 1/4 watt
3. Seorang Lembaga Arduino

Cukup pasangkan sistem seperti gambar rajah.

Seterusnya, pasangkan 5V dari USB komputer ke Arduino. Sebaik sahaja anda melakukan ini, anda akan melihat LED menyala.

Saya tahu itu cukup asas, tetapi selalu baik bermula dari awal. Yakinlah perkara akan mula menjadi semakin menarik ketika kita terus maju.

1.5 Mengawal LED dengan Arduino

Sekarang kita akan belajar bagaimana mengendalikan LED dengan program Arduino.

Untuk menulis program, kita mesti mempunyai sekurang-kurangnya 2 fungsi dalam setiap program.

Fungsi dapat difahami sebagai rangkaian pernyataan pengaturcaraan yang dapat diberikan dengan nama, seperti yang diberikan di bawah:

1. persediaan () ini dipanggil atau dilaksanakan semasa permulaan program.
2. gelung () ini dipanggil atau dilaksanakan berulang kali sepanjang tempoh operasi Arduino.

Oleh itu, walaupun tidak mempunyai fungsi praktikal, secara teknikal program Arduino sah terpendek dapat ditulis sebagai:

Program Paling Mudah

void setup()
{
}
void loop()
{
}

Anda mungkin menyedari bahawa dalam banyak bahasa pengaturcaraan, sistem ini dimulakan dengan menunjukkan cetakan sederhana, 'Hello, World' di layar paparan

Setara elektronik untuk frasa ini dalam tafsiran mikrokontroler adalah untuk menyalakan dan mematikan LED.

Ini adalah program paling asas yang dapat ditulis dan dilaksanakan oleh seseorang untuk menunjukkan fungsi sistem yang betul.

Kami akan berusaha menerapkan dan memahami prosedur melalui kod berikut:

Penyenaraian 1.2: led1 / led1.pde

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

OK, sekarang mari kita fahami apa maksud setiap baris kod dan bagaimana ia berfungsi untuk melaksanakan fungsi:

const int kPinLed = 13

Ini berfungsi seperti pemalar yang membolehkan kita menggunakannya semasa kursus pengaturcaraan yang lengkap, tanpa perlu menggunakan nilai sebenar yang bertentangan dengannya.

Sesuai dengan peraturan standard, pemalar seperti itu dikenali dengan huruf awal ke . Walaupun ini tidak wajib, ini menjadikan perkara lebih jelas dan mudah difahami setiap kali anda merasa ingin mengetahui perincian kod.

void setup()
{
pinMode(kPinLed, OUTPUT)
}

Kod ini mengkonfigurasi pin tertentu yang disambungkan LED kami. Dengan kata lain, kod tersebut memberitahu Arduino untuk mengawal aspek 'penulisan' pada pin ini, dan bukannya 'membacanya'.

void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

Garis di atas menunjukkan pelaksanaan sebenar aplikasi. Kod ini dimulakan dengan menulis dan mengeluarkan HIGH pada sambungan LED yang berkaitan, menyalakan LED.

Di sini, istilah TINGGI bermaksud mendapatkan + 5V pada pin Arduino yang berkenaan. Istilah pelengkap LOW hanya menunjukkan sifar atau 0V pada pin yang ditentukan.

Seterusnya, kami memanggil delay() yang fungsinya adalah untuk mewujudkan kelewatan melalui milisaat (1/1000 saat). Oleh kerana angka 500 dimasukkan, kelewatan yang dilaksanakan adalah selama 1/2 saat.

Sebaik sahaja 1/2 saat ini habis, baris seterusnya dijalankan yang mematikan LED dengan istilah RENDAH pada pin yang sama.

Garis berikutnya sekali lagi menghasilkan kelewatan 1/2 saat, untuk membolehkan LED kekal MATI selama 1/2 saat.

Dan prosesnya berlanjutan tanpa henti dengan pelaksanaan garis-garis kod, selagi Arduino terus dihidupkan.

Sebelum meneruskan ke tahap seterusnya, saya mengesyorkan agar anda memprogramkan kod di atas dan periksa sama ada anda dapat melaksanakan urutan LED ON / OF dengan betul atau tidak.

Oleh kerana LED lalai di Arduino dihubungkan dengan pin # 13, ia harus segera bertindak balas terhadap program di atas dan mula berkelip. Walau bagaimanapun, jika anda mendapati LED luaran anda tidak berkelip maka mungkin ada kerosakan sambungan dengan LED anda, anda boleh mencuba membalikkan kekutuban LED anda dan mudah-mudahan melihatnya juga berkelip.

Anda boleh bermain dengan masa tunda dengan mengubah angka '500' ke nilai lain dan mendapati LED 'mendengarkan' perintah dan menyebabkannya berkelip mengikut nilai tunda yang ditentukan.

Tetapi ingat, jika anda melihat LED tidak berkelip dengan kadar 1 saat yang tetap, tanpa mengira perubahan masa kelewatan anda, itu mungkin menunjukkan kod tersebut tidak berfungsi kerana terdapat kesilapan. Kerana secara lalai Arduino akan diprogramkan dengan kadar kilat 1 saat. Oleh itu, kadar ini mesti berubah mengikut kod anda untuk mengesahkan cara kerjanya yang betul.

1.7 Komen

Garis kod yang kami fahami di atas ditulis khusus untuk perisian komputer.

Walau bagaimanapun, untuk memastikan bahawa pengguna dapat merujuk makna garis dan memahaminya, selalunya berguna dan masuk akal untuk menulis penjelasan di samping baris kod yang diinginkan.

Ini dipanggil komen yang ditulis untuk rujukan manusia atau pengguna sahaja, dan dikodkan untuk membolehkan komputer mengabaikannya dengan selamat.

Bahasa komen ini ditulis dengan beberapa format:

1. Gaya komen blok, di mana keterangan komen dilampirkan di bawah simbol permulaan / * dan simbol akhir * /
2. Ini tidak perlu dibatasi dalam satu baris sebaliknya dapat diperluas ke baris berikutnya berikutnya bergantung pada panjang komentar atau keterangan, seperti yang ditunjukkan dalam contoh berikut:

/ * Ini komen * /

/ * Begitu juga dengan ini * /

/ * Dan
* ini
* sebagai
* baik * /

Untuk menulis penerangan baris tunggal cepat untuk komen, dua simbol slash // pada permulaannya sudah mencukupi. Ini memberitahu komputer bahawa baris ini tidak ada kaitan dengan kod sebenar, dan mesti diabaikan. Sebagai contoh:

// Ini adalah komen yang tidak akan diabaikan oleh komputer.

Inilah contoh untuk rujukan:

/*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/

/* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

1.8 Penyelesaian Masalah

Sekiranya anda mendapati program anda menunjukkan 'ralat' semasa menyusun, atau masalah lain, petua berikut mungkin akan membantu anda memeriksa semula kod anda untuk menghilangkan rintangan.

1. Bahasa program anda akan peka huruf besar kecil. Contohnya ungkapan myVar tidak boleh ditulis sebagai MyVar.
2. Semua jenis ruang putih yang mungkin dilaksanakan dengan menaip papan kekunci anda, akhirnya diberikan sebagai satu ruang, dan hanya dapat dilihat atau difahami oleh anda sahaja, komputer tidak akan mengambil kira ini. Ringkasnya, ruang bebas dalam bentuk apa pun tidak akan memberi kesan pada hasil kod.
3. Setiap blok kod mesti dilampirkan dengan kurungan keriting kiri dan kanan, '{' dan '}'
4. Angka angka tidak boleh dipisahkan dengan koma. Contohnya, 1000 tidak boleh ditulis sebagai 1,000.
5. Setiap garis kod yang tertutup di antara kurungan keriting mesti diakhiri dengan titik koma

Membuat Urutan Lampu LED Menarik dengan Arduino

Dalam bab sebelumnya, kami belajar bagaimana mengedipkan LED ON / OFF secara berterusan dengan kadar kelewatan tetap.

Sekarang kita akan belajar bagaimana corak kelewatan yang berbeza dapat dilaksanakan pada LED yang sama dengan meningkatkan kod program.

Kami tidak akan menggunakan LED luaran, sebaliknya menggunakan LED lalai yang terpasang di papan Arduino di pin # 13. Anda boleh menemui LED SMD kecil ini tepat di belakang penyambung USB.

2.2 Memahami Penyataan IF

Di bahagian ini kita akan belajar bagaimana struktur kawalan membolehkan kita menjalankan kod individu, dan kadang kala berulang-ulang, seperti yang diperlukan.

Penyataan sekiranya menjadi struktur kawalan ke-1. Pelaksanaan berikut menunjukkan bagaimana ia digunakan:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Kami akan cuba memahami kod di atas secara berperingkat dan mengetahui bagaimana cara ini dapat digunakan untuk pelaksanaan lain yang serupa.

Kod antara baris 1 dan 7 sama dengan program awal kami.

Pengubahsuaian pertama sebenarnya berlaku pada baris ke-8.

int delayTime = 1000

Anda boleh menganggapnya serupa dengan kod pada baris pertama, melarang kenyataan bahawa ia tidak mempunyai istilah penyambung

Ini kerana, kod ini bukan pemalar. Sebaliknya ini ditakrifkan sebagai pemboleh ubah , yang mempunyai sifat nilai berubah semasa pengaturcaraan.

Dalam contoh di atas, anda dapat melihat bahawa pemboleh ubah ini dikaitkan dengan nilai 1000. Ingat, pemboleh ubah seperti yang dilampirkan dalam kurungan keriting harus ditulis dengan ketat hanya dalam pasangan kurungan keriting saja, dan disebut sebagai pemboleh ubah 'tempatan'.

Sebagai alternatif, pemboleh ubah yang seharusnya berada di luar kurungan keriting, seperti yang kita bincangkan sekarang diakui sebagai 'global', dan dapat dilaksanakan hampir di mana saja dalam kod program.

Melangkah ke depan, anda dapat melihat bahawa kod antara baris 9 dan 11 juga serupa dengan program pertama, namun perkara-perkara mulai menarik setelah baris 11. Mari lihat bagaimana!

delayTime = delayTime - 100

Dalam kod ini kita melihat bahawa nilai lalai dari kelewatan Masa sedang diubah suai dengan mengurangkan 100 darinya.

Bermakna 100 dikurangkan dari nilai awalnya 1000, memberikan nilai baru 900.

Melalui gambar berikut, kami akan cuba memahami beberapa pengendali Matematik yang digunakan dalam bahasa Arduino.

Sekarang mari kita menilai kod antara baris 13 dan 15.

if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}

Objektif utama kod di atas adalah untuk memastikan bahawa LED terus berkelip tanpa gangguan.

Kerana fakta bahawa 100 ditolak dari yang asal kelewatan Masa , ia menghalang LED berkelip dari mencapai sifar dan membiarkan berkelip terus berterusan.

Gambar berikut menunjukkan beberapa operator perbandingan yang akan kami gunakan dalam kod kami:

Dalam kod di atas, kita mungkin telah menguji kodnya menjadi if(delayTime == 0).

Tetapi, kerana angka negatif boleh sama buruknya, kita tidak melakukannya, dan ini adalah amalan yang disyorkan.

Fikirkan apa yang akan menjadi hasilnya jika kita cuba mengurangkan 300 daripada 100 daripada delayTime?

Jadi sekarang anda mungkin menyedari bahawa jika delayTime ditulis sebagai kurang atau sama dengan sifar, maka masa kelewatan akan ditetapkan kembali ke angka asal 1000.

digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)

4 baris terakhir kod seperti yang ditunjukkan di atas menjadi bertanggungjawab untuk menghidupkan / mematikan LED, ON / OFF berterusan.

Di sini anda dapat melihat dengan jelas bahawa daripada menggunakan sejumlah angka, kami telah menggunakan pemboleh ubah untuk menetapkan masa kelewatan sehingga kami dapat menyesuaikannya seperti yang kami mahukan selama tempoh operasi kod. Itu sejuk, bukan?

2.3 Penyataan ELSE

Di sini kita akan mengetahui mengapa dan bagaimana sekiranya istilah mungkin mempunyai klausa yang lain sehingga menentukan keadaan sekiranya berlaku sekiranya pernyataan adalah salah.

Saya minta maaf jika kedengarannya terlalu membingungkan, jangan risau, kami akan cuba memahaminya dengan contoh berikut:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Di atas anda dapat melihat bahawa dalam kod baris ke-10 hanya dilaksanakan apabila delayTime kurang atau sama dengan 100, jika tidak maka kod pada baris ke-13 dieksekusi, tetapi keduanya tidak akan pernah terjadi, sama ada baris ke-10 atau kod baris ke-13 akan dilaksanakan, tidak pernah keduanya.

Anda mungkin menyedari bahawa tidak seperti apa yang kita lakukan di bahagian 2.2 sebelumnya, di sini kita tidak membandingkan dengan 0, sebaliknya dibandingkan dengan 100. Ini kerana dalam contoh ini dibandingkan SEBELUM kita mengurangkan 100, sebaliknya di bahagian 2.2, kita membandingkan SELEPAS kita ditolak. Bolehkah anda memberitahu apa yang boleh berlaku sekiranya kita membandingkan 0 dan bukan 100?

2.4 APA penyataan

KE sementara penyataan agak serupa dengan sekiranya pernyataan, kecuali kebenaran bahawa ia menyebabkan pelaksanaan berulang pada sekumpulan kod (yang mungkin berada di antara kurungan keriting) untuk sekian lama syarat itu berlaku, dan ini berfungsi tanpa yang lain penyataan.

Contoh berikut akan membantu anda memahami perkara ini dengan lebih baik

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
}

Bolehkah anda meneka apa yang diprogramkan oleh kod di atas? Nah, ia dirancang untuk mengedipkan LED lebih cepat dan kemudian lebih perlahan.

2.5 Apa yang benar dan salah?

Dalam bahasa pengaturcaraan, salah merujuk kepada sifar (0). Sebenarnya 'benar' tidak digunakan, sebaliknya diandaikan bahawa apabila tidak ada yang salah, maka semua yang disertakan adalah benar.

Ia kelihatan agak pelik namun ia melakukan tugas dengan baik.

Kami akan cuba memahami keadaan melalui contoh berikut.

Anda kadang-kadang mungkin menemui kod seperti yang diberikan di bawah:

while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}

Ini dikodkan seperti pelaksanaan LED akan terus berbasikal selama-lamanya, selagi kuasa tersedia.

Walau bagaimanapun, satu kelemahan kod jenis ini boleh timbul apabila pengguna secara tidak sengaja menggunakan a = bukannya ==.

Saya pasti anda sudah mengetahui bahawa = menandakan tugasan, yang bermaksud ia digunakan untuk menetapkan nilai yang dipilih kepada pemboleh ubah, sementara a == digunakan untuk menegakkan ujian jika nilainya sama.

Sebagai contoh andaikan anda memerlukan LED untuk menyala dengan corak laju secara berurutan dan berulang-ulang, tetapi salah menggunakan = bukannya ==.

Kod kemudian akan muncul seperti ini:

int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}

Kesalahan akan memberikan 0 ke delayTime, dan membawa ke sekiranya pernyataan untuk memeriksa sama ada 0 itu benar atau tidak. Oleh kerana 0 merujuk kepada salah, ia akan menganggapnya tidak benar, dan akan menghentikan pelaksanaan delayTime = 1000, tetapi fungsi delayTime diadakan pada 0 semasa gelung ().

Ini kelihatan sangat tidak diingini !!

Oleh itu, periksa semula program anda untuk memastikan anda tidak melakukan kesalahan bodoh seperti itu.

2.6 Gabungan

Kadang-kadang anda mungkin merasa perlu menguji pelbagai perkara bersama-sama. Seperti, anda mungkin ingin memeriksa apakah pemboleh ubah berada di antara dua nombor. Walaupun ini dapat dilaksanakan menggunakan pernyataan if berkali-kali, mungkin lebih mudah menggunakan kombinasi logik untuk pembacaan yang lebih baik dan lebih mudah.

Melaksanakan kombinasi pada istilah logik dapat dilakukan dengan 3 metode, seperti yang ditunjukkan dalam tabel berikut:

Menarik untuk mengetahui bahawa operator TIDAK boleh berfungsi sebagai pengalih bagi pemboleh ubah yang mungkin ditetapkan untuk menjadi salah satu benar atau salah (atau RENDAH atau TINGGI).

Contoh berikut menggambarkan keadaan:

int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}

Inilah ledState akan menjadi RENDAH, dan seterusnya secepat ledState = !ledState, ia akan berubah menjadi TINGGI. Gelung berikut akan menyebabkan ledState menjadi TINGGI apabila ledState = !ledState adalah RENDAH.

2.7 UNTUK penyataan

Sekarang kita akan cuba memahami mengenai struktur kawalan lain yang merupakan untuk gelung. Ini sangat berguna apabila anda ingin melaksanakan sesuatu beberapa kali.

Mari fahami ini dengan contoh berikut:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}

Anda boleh menemui sesuatu yang unik sesuai dengan untuk.

Ia adalah kodnya saya ++? . Ini berguna untuk pengaturcara yang agak malas dan ingin melaksanakan pengekodan melalui jalan pintas yang mudah

Istilah di atas dikenali sebagai pengendali kompaun, kerana mereka melakukan tugas menggabungkan satu operator penugasan dengan operator penugasan yang lain. Yang paling popular boleh dilihat dalam jadual berikut:

Anda akan mendapati bahawa terdapat 3 sub-pernyataan dalam pernyataan untuk. Ia disusun seperti gambar di bawah:

for (statement1conditionstatement2){
// statements
}

Pernyataan # 1 berlaku tepat pada awal dan sekali sahaja. Keadaan ini diuji setiap kali semasa gelung. Bila-bila masa sahaja benar di dalam kurungan keriting, pernyataan # 2 seterusnya akan dikuatkuasakan. Sekiranya berlaku salah, sistem melompat ke blok kod seterusnya.

Menyambungkan Lebih Banyak LED

OK, sekarang kita akan melihat bagaimana kita dapat menghubungkan lebih banyak bilangan LED untuk mendapatkan kesan yang lebih menarik.

Sambungkan LED dan Arduino seperti gambar di bawah. Kabel merah sebenarnya tidak perlu, tetapi kerana selalu ada idea yang baik untuk memasukkan kedua-dua rel bekalan di papan roti, maka pemasangannya masuk akal.

Sekarang mari kita perbaiki program yang membolehkan kita memeriksa sama ada perkakasan kita dikonfigurasi dengan betul atau tidak.

Selalu disarankan untuk membuat kod dan menjalankan sekumpulan program dengan sedikit langkah untuk memeriksa sama ada perisian masing-masing dikabelkan dengan betul atau tidak.

Ini membantu menyelesaikan masalah yang mungkin berlaku dengan cepat.

Contoh kod di bawah memberikan LED 2 hingga 5 corak tertentu dengan memutarnya satu demi satu secara berkala.

const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}

Seperti yang anda perhatikan, tidak ada yang salah dengan kod tersebut, kecuali kenyataan bahawa ia kelihatan panjang dan oleh itu terdedah kepada kesilapan.

Sudah tentu ada cara yang lebih baik untuk menulis kod di atas, bahagian berikut akan memaparkannya.

2.9 Memperkenalkan Susunan

Susunan boleh menjadi sekumpulan pemboleh ubah yang dapat diindeks dengan nombor indeks. Contoh berikut akan membantu kita untuk memahaminya dengan lebih baik.

const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}
void loop()
{
for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}

OK, sekarang mari kita teliti setiap bahagian dan fahami bagaimana mereka sebenarnya berfungsi.

const int k_numLEDs = 4

Kod di atas menentukan berapa banyak elemen maksimum yang sepatutnya kita miliki dalam tatasusunan. Kod ini membantu kami di bahagian seterusnya untuk memastikan bahawa semuanya ditulis dalam array dan tidak ada apa-apa setelah array berakhir.

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

Pada baris seterusnya ini kita menetapkan struktur array. Nombor di dalam kurungan menunjukkan bilangan elemen dalam larik. Walaupun, kuantiti sebenarnya boleh ditulis, menulis kerana pemalar berfungsi lebih baik. Nilai-nilai biasanya dapat dilihat di dalam kurungan dengan koma dan menetapkan nilai ke array.

Apabila anda menjumpai array yang diindeks dengan nombor 0, ini menunjukkan elemen pertama dalam array, seperti yang ditunjukkan dalam code: k_LEDPins is k_LEDPins[0].

Begitu juga elemen terakhir yang akan ditunjukkan sebagai k_LEDPins[3], kerana kiraan dari 0 hingga 3 adalah 4.

void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}

Kod di atas menunjukkan penggunaan loop untuk meneruskan setiap elemen array dan untuk menetapkannya sebagai OUTPUTS. Kami menerapkan tanda kurung persegi bersama dengan indeks untuk mencapai setiap elemen dalam larik.

jika anda tertanya-tanya adakah mungkin menggunakan pin # 2 untuk pin # 5 tanpa tatasusunan, jawapannya adalah ya, mungkin. Tetapi dalam contoh ini tidak dilakukan kerana kita tidak melakukannya dengan cara itu. Pada bahagian berikut, anda boleh menghilangkan pendekatan array jika pin output yang dipilih tidak sesuai.

Melangkah ke hadapan, mari kita lihat apa yang dilakukan oleh blok kod seterusnya:

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}

Di sini kod diteruskan melalui setiap LED untuk menghidupkannya secara berurutan dengan jurang atau kelewatan 100 milisaat.

for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}

Menggunakan kod di atas menunjukkan bagaimana penerapan untuk gelung dapat digunakan untuk bergerak melalui gelung walaupun dalam urutan terbalik.

Ia bermula dari k_numLEDs - 1 kerana tatasusunan diindeks sifar. Kami tidak bermula dari k_LEDPins[4] kerana itu akan menghasilkan leraian akhir.

Kod menggunakan> = 0 untuk memeriksa supaya elemen pertama pada indeks 0 tidak terlewat atau diabaikan.

Bab 3

Apa itu Input

Oleh itu, adakah kita belajar bagaimana mengendalikan sesuatu menggunakan Arduino. Dalam bab ini kita akan membincangkan bagaimana merasakan dunia nyata dengan menghubungkan input dari parameter luaran.

3.1 Menggunakan Tombol Tekan

Kita semua tahu apa itu butang tekan dan bagaimana ia berfungsi. Ini adalah sejenis suis atau butang yang menghubungkan isyarat dari satu tahap litar ke tahap yang lain sesaat ketika berada dalam keadaan tertekan, dan memecahkan isyarat ketika dilepaskan.

3.1.1 Satu butang dan LED

Kami akan menghubungkan Arduino dengan tombol tekan dengan Arduino seperti perincian yang ditunjukkan di atas dan mempelajari cara kerja dan pelaksanaan dasar.

Butang tekan yang ditunjukkan yang juga disebut tombol tekan suis mikro, memiliki 4 pin total (2 pasang di setiap sisi). Apabila ditolak, setiap pasang pin digabungkan secara dalaman dan membolehkan sambungan atau pengaliran melintasi mereka.

Dalam contoh ini kita hanya menggunakan satu pasang pin atau kenalan ini, pasangan yang lain tidak relevan dan oleh itu diabaikan.

Mari teruskan, gunakan kod berikut dan perhatikan ia berfungsi!

const int kPinButton1 = 2
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Anda mungkin menemui beberapa perkara yang kelihatan tidak biasa di sini. Mari kita tentukan mereka dengan bijak.

void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}

Perkara pertama yang kita lakukan adalah memperbaiki butangPin sebagai MASUKKAN. Saya cukup faham.

Seterusnya, kami menetapkan TINGGI kepada MASUKKAN sematkan. Anda tertanya-tanya, bagaimana mungkin menulis sesuatu di input? Pasti, ini mungkin menarik.

Sebenarnya, pemberian input TINGGI kepada input Arduino menukar perintang penarik Ohm 20k dalaman ON (RENDAH pada pin ini akan mematikannya).

Soalan lain yang anda mungkin adalah apakah perintang penarik. Saya telah merangkumi catatan lengkap mengenai perintang penarik yang anda pelajari di sini .

OK, teruskan, sekarang mari kita lihat kod gelung utama:

void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Apabila anda menekan butang tekan, pin berwayar disambungkan ke tanah, yang menjadikan a RENDAH ke pin itu. Dan semasa dalam keadaan tidak tertekan pin yang sama dipegang di TINGGI atau + 5V melalui perintang penarik dalaman 20K.

Di sini kita ingin Arduino menyalakan LED ketika butang tekan ditekan (RENDAH), oleh itu kita menulis TINGGI untuk output untuk setiap tindak balas RENDAH dari butang tekan, sementara ditekan.

3.1.2 Dua butang dan LED

Anda mungkin tertanya-tanya tindakan yang ditunjukkan di atas boleh dilakukan tanpa Arduino juga. Saya faham, namun ini adalah batu curam untuk belajar bagaimana butang tekan dapat digunakan dengan Arduno.

Sehingga ke tahap ini, kami telah mempelajari menulis kod untuk menghidupkan ON (HIGH) atau mematikan (LOW) LED.

Sekarang mari kita lihat bagaimana kecerahan LED dapat dikendalikan dengan Arduino.

Ia boleh dilakukan dengan menggunakan dua kaedah:

1. Dengan menghadkan jumlah arus ke LED
2. Dengan menggunakan PWM atau modulasi lebar nadi, di mana bekalan ke LED dihidupkan / dimatikan pada kadar yang diinginkan dengan sangat cepat, menghasilkan pencahayaan rata-rata yang intensitasnya bergantung pada PWM.

Dalam papan Arduino, sokongan PWM tersedia pada pin yang ditandai dengan tilde (~), yang merupakan pin 3, 4,5,9,10 dan 11) pada 500Hz (500 kali sesaat). Pengguna dapat memberikan nilai antara 0 dan 255, di mana 0 merujuk kepada tidak HIGH atau tidak + 5V, dan 255 memberitahu Arduino untuk mendapatkan HIGH atau + 5V sepanjang masa. Untuk memulakan perintah ini, anda harus mengakses analogWrite () dengan nilai yang diinginkan.

Anda mungkin menganggap PWM sebagai x / 255 di mana x adalah nilai yang diinginkan yang ingin anda hantar melalui analogWrite().

Siapkan Arduino dan parameter lain seperti yang ditunjukkan di atas.

const int kPinButton1 = 2
const int kPinButton2 = 3
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
pinMode(kPinButton2, INPUT)
pinMode(kPinLed, OUTPUT)
digitalWrite(kPinButton1, HIGH) // turn on pullup resistor
digitalWrite(kPinButton2, HIGH) // turn on pullup resistor
}
int ledBrightness = 128
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness--
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++
}
ledBrightness = constrain(ledBrightness, 0, 255)
analogWrite(kPinLed, ledBrightness)
delay(20)
}

Anda mungkin dapati 3 baris di sini memerlukan penjelasan.

ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)

Garis: ledBrightness = constrain(ledBrightness, 0, 255) menggambarkan fungsi unik di dalam Arduino yang dikenali sebagai batasan ().

Fungsi dalaman ini merangkumi kod yang serupa dengan yang berikut:

int had (nilai int, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Semua kod yang dibincangkan sebelum ini dimulakan dengan batal , yang bermaksud tidak mengembalikan apa-apa (kekosongan). Manakala kod di atas bermula dengan int , yang menunjukkan bahawa ia mengembalikan bilangan bulat. Kami akan membincangkan lebih lanjut mengenai bahagian-bahagian kemudian, buat masa ini ingat bahawa bilangan bulat tidak mempunyai bahagian pecahan.

Betul, jadi ini bermaksud, kod: ledBrightness = constrain(ledBrightness, 0, 255) memberikan ledBrightness to be within the range of 0 and 255.

Baris seterusnya menggunakan analogWrite untuk memerintahkan Arduino untuk menerapkan PWM pada pin yang dipilih dengan nilai yang diinginkan.

Baris seterusnya menimbulkan kelewatan 20 milisaat, ini adalah untuk memastikan bahawa kita tidak menyesuaikan pemakanan lebih cepat daripada 50 Hz atau 50 kali sesaat. Ini kerana manusia boleh menjadi lebih lambat daripada Arduino. Oleh itu, jika kelewatan tidak dibuat, program dapat membuat kita merasa bahawa menekan butang pertama mematikan LED dan menekan butang kedua menghidupkannya (cubalah sendiri untuk mengesahkan).

3.2 Potensiometer

Mari maju dan belajar bagaimana menggunakan potensiometer dengan Arduino.

Untuk mengetahui bagaimana potensiometer atau periuk berfungsi, anda boleh membaca ini artikel .

Sambungkan parameter yang ditunjukkan dengan Arduino anda seperti gambar di atas.

Sebuah periuk akan mempunyai 3 terminal. Terminal tengah akan berhubung dengan ANALOG IN 0 di Arduino. Dua terminal luar yang lain mungkin disambungkan ke rel bekalan + 5V dan 0V.

Mari atur cara dan lihat hasilnya:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinPot, INPUT)
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int ledBrightness
int sensorValue = 0
sensorValue = analogRead(kPinPot)
ledBrightness = map(sensorValue, 0, 1023, 0, 255)
analogWrite(kPinLed, ledBrightness)
}

Anda akan menemui beberapa perkara yang mungkin kelihatan sama sekali baru dan tidak termasuk dalam mana-mana kod kami yang terdahulu.

1. Pemalar kPinPot ditetapkan sebagai A0, di mana A adalah jalan pintas untuk menggambarkan salah satu pin analog. Namun A0 juga merujuk pada pin # 14, A1 hingga pin # 15 dan seterusnya, dan ini membolehkan anda digunakan sebagai input / kelebihan digital sekiranya anda kehabisan pin untuk percubaan. Tetapi ingat anda tidak boleh menggunakan pin digital sebagai pin analog.
2. Garis: ledBrightness = map(sensorValue, 0, 1023, 0, 255) membentangkan fungsi dalaman baru di Arduino yang dikenali sebagai peta (). Ciri ini dikalibrasi semula dari julat tertentu ke yang lain, yang disebut sebagai peta (nilai, fromLow, fromHigh, toLow, toHigh). Ini mungkin menjadi penting kerana analogueRead memberikan nilai dalam julat 0-1023, tetapi analogWrite dapat menerima nilai dari 0-255.

Anda mungkin berfikir, bahawa kerana mungkin untuk mengawal kecerahan LED melalui rintangan yang berubah, hanya periuk yang cukup untuk tujuan tersebut, mengapa penggunaan Arduino. Nah, sekali lagi ini hanyalah landasan, untuk menunjukkan bagaimana periuk dapat dikonfigurasi dengan Arduino.

Tidak ada masalah, sekarang kami akan melakukan sesuatu yang tidak dapat dilakukan tanpa Arduino.

Dalam eksperimen ini, kita akan melihat bagaimana rintangan periuk yang berbeza dapat digunakan untuk mengawal kelajuan atau kecepatan LED yang berkedip.

Inilah programnya:

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
digitalWrite(kPinLed, HIGH)
delay(sensorValue)
digitalWrite(kPinLed, LOW)
delay(sensorValue)
}

3.2.3 Mengelakkan kelewatan ()

Kod di atas kelihatan baik, tetapi LED tidak dapat memeriksa nilai periuk sehingga melalui setiap kitaran penuh. Untuk kelewatan yang lebih lama, proses ini semakin lama pengguna harus menunggu untuk melihat tindak balas pot semasa dia menggerakkannya. Kelewatan ini dapat dielakkan dengan beberapa pengaturcaraan pintar, sehingga memungkinkan pengguna untuk memeriksa nilainya tanpa penundaan minimum. Inilah kodnya.

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
long lastTime = 0
int ledValue = LOW
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
if(millis() > lastTime + sensorValue){
if(ledValue == LOW){
ledValue = HIGH
}
else{
ledValue = LOW
}
lastTime = millis()
digitalWrite(kPinLed, ledValue)
}
}

Jadi apa yang berbeza dalam kod di atas? Ini adalah baris berikut yang membuat perbezaan.

long lastTime = 0

Sehingga bahagian ini, kami telah membincangkan mengenai pemboleh ubah int. Walau bagaimanapun, mungkin terdapat lebih banyak jenis pemboleh ubah yang boleh anda akses. Senarai tersebut boleh dibaca di bawah:

Pada masa ini, sangat penting untuk mengetahui bahawa untuk menyimpan bilangan yang agak besar untuk int pemboleh ubah, anda boleh menggunakan istilah lama atau a int panjang.

Di sini anda dapat melihat satu lagi fungsi menarik yang dipanggil milis ().

Ini menghasilkan jangka masa dalam milisaat yang Arduino bekerja dalam perjalanannya dari awal (ini akan diset semula ke 0 selepas setiap 50 hari). Di sini ia kembali lama kerana jika kembali int , mengira untuk jangka masa panjang mungkin tidak dapat dilakukan. Bolehkah anda menjawab dengan tepat berapa lama? Jawapan adalah 32.767 saat.

Oleh itu, daripada menggunakan kelewatan (), kami memeriksa milisa (), dan sebaik sahaja jumlah milisaat tertentu tamat, kami menukar LED. Akibatnya kita menyimpan masa yang kita ubah pada masa terakhir kali terakhir berubah-ubah, sehingga membolehkan kita memeriksanya semula bila-bila masa yang dikehendaki.

3.3 RGB LED

Setakat ini kami bermain dengan LED warna tunggal. Walaupun warna LED dapat diubah dengan mengganti LED dengan warna lain, tetapi bagaimana dengan menggunakan LED RGB untuk menukar warna LED tanpa menukar LED?

LED RGB pada dasarnya adalah LED yang mempunyai LED merah, hijau, dan biru tertanam dan digabungkan menjadi LED tunggal. Ia mempunyai satu timbal umum yang menuju ke landasan atau rel bekalan 0V sementara 3 petunjuk lain diberi isyarat positif PWM yang pelbagai untuk melaksanakan yang dimaksudkan pencampuran warna .

Anda boleh memasang alat seperti yang ditunjukkan di bawah:

Ia mungkin kelihatan agak rumit, tetapi sebenarnya ini adalah replika reka bentuk kawalan LED terdahulu kami menggunakan PWM.

Berikut adalah kod program latihan:

const int kPinPot1 = A0
const int kPinPot2 = A1
const int kPinPot3 = A2
const int kPinLed_R = 6
const int kPinLed_G = 10
const int kPinLed_B = 11
void setup()
{
pinMode(kPinLed_R, OUTPUT)
pinMode(kPinLed_G, OUTPUT)
pinMode(kPinLed_B, OUTPUT)
}
void loop()
{
int potValue
int ledValue
potValue = analogRead(kPinPot1)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_R, ledValue)
potValue = analogRead(kPinPot2)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_G, ledValue)
potValue = analogRead(kPinPot3)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_B, ledValue)
}

Setelah memuat naik kod ini, lihat saja bagaimana penyesuaian periuk menghasilkan kesan cahaya yang menarik pada RGB, ia boleh menjadi keseronokan.

Anda akan mendapati bahawa apabila ketiga-tiga periuk dipindahkan pada kedudukan maksimum, bukannya warna putih, anda akan melihat warna merah. Ini kerana warna merah adalah yang paling menonjol di antara 3 warna dan oleh itu menjadi dominan dalam keadaan ini. Bagaimanapun anda boleh bereksperimen dengan fungsinya peta () , sebelum melaksanakannya ke bahagian merah LED, untuk mewujudkan keseimbangan yang lebih masuk akal.

Audio dengan Arduino

Di bahagian ini kita akan belajar bagaimana menambahkan suara dan muzik asas pada persediaan Arduino.

Kami akan melihat bagaimana menukar isyarat ke pembesar suara yang disambungkan dengan frekuensi yang diinginkan.

Untuk lebih tepat, nota tengah A akan dicuba, iaitu nota frekuensi 440 Hz.

Untuk melakukan ini, kita hanya memainkan nota tengah A, dan mengoptimumkan isyarat gelombang sinus dengan gelombang persegi.

Juga, kami akan mengira jumlah masa pembesar suara tetap AKTIF dengan menuntut formula:

timeDelay = 1 saat / 2 x nadaKekerapan.

timeDelay = 1 saat / 2 x 440

timeDelay = 1136 mikrodetik

4.1 Mari Sambungkan Dewan Arduino

4.2 Menambah nota Ringkas

Kami telah membincangkan mengenai fungsi tersebut kelewatan () di mana unit berada dalam milisaat (kedua / 1000), namun anda akan menemui fungsi lain delayMicroseconds() di mana unit berada dalam mikrodetik, (milisaat / 1000).

Untuk persediaan sekarang, kami memprogramkan kod untuk menukar + 5V ON / OFF pada pin terpilih yang dihubungkan dengan pembesar suara, pada kadar 440 denyutan sesaat.

Ingat, dalam perbincangan terakhir kami menentukan nilai 1136 mikrodetik untuk nota audio yang dimaksudkan.

Jadi, inilah program untuk ini, yang membolehkan anda mendengar nota audio 440 Hz sebaik sahaja anda memprogramkan arduino dengan pembesar suara disambungkan.

const int kPinSpeaker = 9
const int k_timeDelay = 1136
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
digitalWrite(kPinSpeaker, HIGH)
delayMicroseconds(k_timeDelay)
digitalWrite(kPinSpeaker, LOW)
delayMicroseconds(k_timeDelay)
}

Dengan aplikasi di atas adalah mungkin untuk membuat catatan audio, yang juga berarti kita dapat membuat musik sesuai pilihan kita sendiri.

Dari kod kita memahami bahawa Arduino merangkumi beberapa fungsi bersepadu yang turut menyumbang kepada penciptaan muzik.

Yang pertama adalah nada () yang berfungsi dengan 2 elemen bersama dengan elemen pilihan ke-3, yang ditetapkan sebagai nada (pin, frekuensi, jangka masa). atau nada (pin, kekerapan)

Kedua-duanya ditunjuk untuk melaksanakan masing-masing jangka masa yang anda tetapkan.

Sekiranya tidak ada jangka waktu, muzik akan terus dimainkan sehingga panggilan nada () dijalankan lagi, atau sehingga anda melaksanakannya tiada satu ().

Ini perlu dilakukan dengan menggunakan fungsi kelewatan sekiranya bermain muzik adalah satu-satunya perkara asas yang anda laksanakan.

Tempoh waktunya mungkin sangat penting kerana memungkinkan untuk memberikan masa untuk berapa lama muzik dimainkan, jadi anda juga boleh melakukan perkara lain dengan bebas. Sebaik sahaja lamanya habis, muzik berhenti.

Fungsi seterusnya tiada satu () menangani satu parameter dan menghentikan nada yang dipilih pada pin yang ditentukan.

Amaran pelik: Bila-bila masa bila nada () fungsi dilaksanakan, fungsi PWM pada pin 3 dan 11 akan berhenti beroperasi.

Oleh itu, setiap kali lampiran pembesar suara digunakan dalam program, pastikan untuk tidak menggunakan pin yang disebutkan untuk pembesar suara, sebaliknya cubalah beberapa pin lain untuk lampiran pembesar suara.

OK, jadi inilah program untuk menerapkan muzik pada pembesar suara, walaupun ini bukan muzik sebenar, tetapi nota C skala asas.

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}

Dalam kod di atas, anda mungkin telah melihat sesuatu yang baru dan itu #tentukan .

Istilah ini berfungsi seperti perintah mencari dan menggantikan komputer semasa penyusunan sedang dilakukan.

Apabila ia menemui perkara pertama sebelum spasi, ia menggantinya dengan bahagian garisan yang tersisa (disebut makro).

Jadi dalam contoh ini apabila komputer melihat CATATAN_E4 ia dengan cepat menggantikannya dengan kuantiti 330.

Untuk lebih banyak nota dan penyesuaian, anda boleh merujuk pada fail di stik USB anda yang bernama padang.h , di mana kebanyakan frekuensi boleh didapati untuk pilihan anda.

4.4 Muzik dengan fungsi

Kod di atas kelihatan bagus, tetapi nampaknya mempunyai banyak pengulangan, harus ada beberapa kaedah untuk memendekkan pengulangan ini, bukan?

Sejauh ini kami telah bekerjasama dengan dua fungsi penting yang disertakan bersama Arduino. Sekarang mungkin sudah waktunya kita membuat fungsi kita sendiri.

Setiap fungsi mesti dimulakan dengan jenis pemboleh ubah yang mungkin berkaitan dengannya. Contohnya fungsi batal merujuk kepada jenis yang tidak mengembalikan apa-apa maka namanya tidak sah. Perhatikan, kami telah membincangkan senarai pemboleh ubah di bahagian sebelumnya, anda mungkin ingin merujuknya.

Akibatnya, nama fungsi tertentu mendapat tanda kurung terbuka '(' diikuti dengan senarai parameter yang dipisahkan koma.

Setiap parameter memperoleh jenisnya bersama dengan nama, dan akhirnya penutupan ')' kurungan.

Parameter ini dapat diterapkan dalam fungsi dalam bentuk pemboleh ubah.

Mari lihat contoh di bawah ini di mana kita mengembangkan fungsi yang dipanggil nada kami () dirancang untuk menggabungkan nada () dengan kelewatan () garis, dengan cara fungsi berhenti kembali sehingga nota selesai memainkan nada.

Kami melaksanakan fungsi-fungsi ini dalam kod sebelumnya, dan mendapatkan program di bawah ini, lihat baris terakhir:

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Fungsi sangat berguna untuk menjadikan program lebih mudah difahami.

Berikut adalah contoh di mana kita dapat menentukan pilihan nada yang ingin kita mainkan menggunakan dua tatasusunan. Satu susunan untuk mengekalkan nota, yang lain untuk mengekalkan rentak.

#include 'pitches.h'
int kPinSpeaker = 9
#define NUM_NOTES 15
const int notes[NUM_NOTES] = // a 0 represents a rest
{
NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4,
NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
}
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }
const int beat_length = 300
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
for (int i = 0 i if (notes[i] == 0) {
delay(beats[i] * beat_length) // rest
}
else {
ourTone(notes[i], beats[i] * beat_length)
}
// pause between notes
noTone(kPinSpeaker)
delay(beat_length / 2)
}
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Anda dapat melihat dengan jelas pada baris pertama pengenalan #sertakan penyataan. Tugas penyataan ini adalah untuk mengambil keseluruhan fail antara tanda petikan dan meletakkannya pada kedudukan #sertakan penyataan. Sesuai dengan peraturan standard, peraturan ini diletakkan dengan ketat pada permulaan program.

Bab 5

Mengukur Suhu

Hanya untuk mengingati, ingat, bukannya menulis program besar sama sekali, adalah bijak untuk menulis dan menganalisis bahagian kecil kod, yang membantu dalam mengesan kesalahan dengan cepat.

5.1 Monitor Bersiri

Sehingga kini, kod yang kita bincangkan tidak kelihatan semudah itu untuk membolehkan penyelesaian masalah cepat. Di sini kita akan berusaha menjadikan perkara lebih mudah untuk pemantauan dan penyelesaian masalah yang lebih mudah.

Arduino mempunyai ciri yang membolehkannya 'bercakap kembali' dengan komputer. Anda mungkin diperhatikan bahawa pin0 dan pin1 ditandai sebagai RX dan TX di sebelah satu sama lain. Pin ini sebenarnya dilacak oleh IC berasingan dalam Arduino yang menaikkannya untuk membaca kabel USB semasa dipasang ke PC.

Bahagian di bawah menunjukkan program lengkap, silakan pergi, kita akan belajar mengenai entri baru dalam kod selepas itu. Kod ini sama seperti dinyatakan di bahagian 2.2 kecuali fakta bahawa ia merangkumi beberapa data tambahan untuk membolehkan kita mengenal pasti apa yang dikodkan.

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
Serial.begin(9600)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If it would have been zero or less, reset it.
delayTime = 1000
}
Serial.print('delayTime = ')
Serial.println(delayTime)
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Anda boleh mengenal pasti dua perkara baru di sini, baris baru di persediaan () fungsi.

Serial.begin(9600)

Garis ini hanya menyatakan keperluan menggunakan Bersiri1 kod untuk menegakkannya dengan 9600 baud. (di sini bersiri merujuk bit dihantar satu demi satu, dan baud bermaksud kadar di mana ia dihantar). Nilai baud ini dan nilai di dalam monitor bersiri (kita akan mempelajarinya kemudian) mestilah sama, jika tidak, data dalam monitor bersiri akan menunjukkan sampah. 9600 menjadi standard menjadi lebih senang digunakan.

Entri baru kedua adalah seperti berikut

Serial.print('delayTime = ')
Serial.println(delayTime)

Di sini baris kedua menunjukkan bahawa perkara seterusnya yang keluar dari port bersiri akan bermula pada baris seterusnya. Begitulah perbezaan baris kedua dengan garis penumbuk.

Satu perkara lagi yang dapat anda lihat ialah petikan ('). Ini dikenali sebagai tali, yang hanya akan digunakan seperti pemalar di sini, kerana perbincangan lebih lanjut mengenai topik ini boleh terlalu rumit dan di luar ruang lingkup.

OK, kita sekarang boleh memuat naik kod di atas di Arduino dan melihat apa yang berlaku.

Apa, sepertinya tidak ada yang berlaku, pin Arduino # 13 LED berkedip dan berhenti, sementara LED Tx tetap berkelip.

Ini kerana tetingkap Serial Monitor belum diperbaiki.

Anda perlu mengklik kotak Monitor Serial di IDE anda seperti gambar di atas. Jangan lupa untuk memeriksa kadar baud yang terletak di kanan bawah, secara lalai ia harus 9600, dan akan sesuai dengan kodnya. Sekiranya tidak pastikan memilih 9600.

Klip video berikut menerangkan bagaimana ia dilakukan.

Sekarang mari kita teruskan dan pelajari bagaimana ciri Serial Monitor di atas dapat membantu memprosesnya pengukuran Suhu menggunakan Arduino

Kami akan menggunakan IC TMP36 sebagai sensor suhu, dengan julat -40 hingga 150 darjah Celsius.

Penyediaannya dapat dilihat di bawah:

Kod berikut akan memulakan pengukuran suhu dengan membaca output dari sensor TMP36, dan dengan mengirimkannya ke monitor bersiri ID.

const int kPinTemp = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
float temperatureC = getTemperatureC()
Serial.print(temperatureC)
Serial.println(' degrees C')
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
Serial.print(temperatureF)
Serial.println(' degrees F')
delay(500)
}
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Mari fahami kod dari atas.

float temperatureC = getTemperatureC()

Di sini anda dapat melihat bahawa kami telah memasukkan jenis pemboleh ubah terapung.

Ini adalah satu-satunya jenis pemboleh ubah yang mempunyai ciri menyimpan semuanya kecuali nombor bulat (nombor tanpa bahagian perpuluhan atau pecahan).

Ketepatan dari pemboleh ubah apungan boleh mencapai 6 hingga 7 digit.

Kod bersebelahan getTemperatureC() adalah fungsi kita sendiri yang secara matematik mengira dan menukar perbezaan voltan yang dirasakan dari sensor TMP36 menjadi darjah Celsius.

float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}

Di bahagian seterusnya kod, sejak istilah analogIn() ditugaskan untuk mengembalikan angka antara 1 hingga 1023, menjadi mungkin bagi kita untuk menilai voltan dari sensor dengan mengalikan bacaan kita dengan 5 dan kemudian membaginya dengan 1024.

Sensor TMP36 ditentukan untuk menghasilkan 0.5V pada 0 darjah Celsius, dan seterusnya menghasilkan 10mV untuk setiap kenaikan darjah Celsius.

Inilah perkiraan yang dapat kami hasilkan melalui pengiraan:

Anda boleh menganggapnya sebagai fungsi pertama anda yang mengembalikan nilai (perhatikan bahawa semua fungsi yang tersisa setakat ini tidak mengembalikan nilai kerana mereka sudah jenis ini batal ).

Anda dapat memahami bahawa untuk mendapatkan nilai dari fungsi, anda hanya perlu menambahkan kembali diikuti dengan nombor yang dikehendaki yang anda mahu kembalikan.

Apabila kita berkata kembali itu berarti fungsi mengembalikan respons atau balasan setiap kali dipanggil, yang dapat diterapkan pada variabel.

Apabila ini dihantar ke Monitor Serial, bacaan akan ditukar menjadi Fahrenheit hingga tukarToF ().

float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Fungsi ini mengambil julat Celsius dan mengubahnya menjadi Fahrenheit.

Untuk menukar Fahrenheit ke Celsius kami menerapkan formula Fahrenheit = 9 / 5 (Celsius) + 32.

5.3 Menghadapi LCD

Sekarang mari kita pelajari bagaimana antara muka atau penyambungan Paparan LCD dengan Arduino untuk mendapatkan paparan visual untuk output yang diperlukan.

Dalam aplikasi kita akan menggunakan LCD grafik 84x48, memiliki 84 piksel atau titik secara mendatar, dan resolusi menegak 48 piksel. Oleh kerana pengawal khusus menjadi penting untuk semua LCD, peranti ini juga menggabungkan satu dalam bentuk pengawal PCD8544.

Dalam tutorial ini kita akan menghubungkan modul LCD yang ditentukan di atas dengan Arduino, dan menerapkan rutin tertentu untuk membuat pesanan teks pada paparan.

Pada gambar berikut, anda dapat mencari perincian mengenai antara muka LCD, dan yang kecil Pengatur voltan 3.3V . Pengatur ini diperlukan kerana LCD ditentukan untuk berfungsi dengan bekalan 3.3V.

Anda juga dapat melihat 8 pinout dari modul LCD, spesifikasi pinout dapat dipelajari dari jadual berikut:

Sekarang mari kita lihat bagaimana kita dapat menghubungkan LCD dan parameter yang berkaitan dengan Arduino kami. Perinciannya dapat dilihat dalam ilustrasi yang ditunjukkan di bawah ini:

5.4 Berkomunikasi dengan LCD

Walaupun mungkin untuk menulis bahasa Inggeris yang rumit untuk berinteraksi dengan LCD dari Arduino, kami lebih suka belajar melakukan perkara yang sama menggunakan perpustakaan.

Perpustakaan terdiri daripada pelbagai kod yang dapat digunakan dengan cepat untuk program Arduino yang dipilih.

Ini membolehkan pengguna memanggil fungsi dengan mudah tanpa perlu melalui kerja pengekodan yang kompleks.

5.4.1 Cara Memasang perpustakaan

Untuk ini, anda perlu membuat direktori yang disebut perpustakaan di komputer anda Arduino IDE, seperti yang dijelaskan di sini

5.4.2 Melaksanakan Operasi LCD

Sama seperti pendekatan kami sebelumnya, kami akan memeriksa keseluruhan kod dan kemudian cuba memahami perincian setiap baris.

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

Garis itu merangkumi kod #include

Kod #include memerintahkan PC untuk mengambil fail yang disebutkan dan mengganti elemen #include dengan isi fail semasa penyusunan program.

Elemen #include dapat memiliki tanda kurung sudut yang menunjukkan pencarian di direktori perpustakaan, atau mungkin juga memiliki tanda kutip yang menunjukkan pencarian dalam direktori yang sama di mana program berada.

Baris kod seterusnya menunjukkan pinout LCD, dan kemudian kami menulis bentuk pemboleh ubah baru:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Di sini kita menyatakan pemboleh ubah dengan nama lcd yang memiliki jenis PCD8544 dan memerintahkan PC menyusun semula pinoutnya yang berkaitan dengan Arduino.

Dalam proses ini kami menerangkan pemboleh ubah ke PC dengan mengarahkan bagaimana pin clk, din, dc, dan reset dihubungkan dengan Arduino.

void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}

Garis lcd.init() memulakan operasi LCD. Setelah ini dilaksanakan, baris seterusnya memaksa kursor ke kiri atas paparan. Dan baris seterusnya seterusnya berusaha untuk mencetak mesej 'Hello, World'.

Ini kelihatan sama dengan teknik di mana kami menghantar mesej melalui monitor bersiri. Satu-satunya perbezaan ialah penggunaan kod lcd.print bukannya serial.print.

Blok kod seterusnya sebenarnya disebut berulang-ulang.

void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

Menggunakan baris ini lcd.setCursor(0,1) kami membetulkan kursor ke lajur ke-0 di kiri paling kiri baris 1, di atas paparan LCD.

Baris seterusnya menggunakan jalan pintas: lcd.print(millis())

Sekiranya anda ingat kami telah bekerjasama dengan millis() dalam kod sebelumnya, kita boleh menggunakan yang sama di sini melalui kod:

long numMillis = millis()
lcd.print(numMillis)

Namun kerana hakikat bahawa di sini tidak ada jangka masa dalam milisaat yang terlibat, oleh itu kami mencapainya dengan hanya menghantar millis() berfungsi terus ke lcd.print() .

5.5 Menggabungkan Keseluruhan Perkara

OK, sekarang mari kita gabungkan semua kod yang kita pelajari di atas untuk membuat litar suhu LCD, dan mari lihat bagaimana rupanya:

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
const int kPin_Temp = A0
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(10,0)
lcd.print('Temperature:')
}
void loop()
{
float temperatureC = getTemperatureC()
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
lcd.setCursor(21,1)
lcd.print(temperatureC)
lcd.print(' C')
lcd.setCursor(21,2)
lcd.print(temperatureF)
lcd.print(' F')
delay(100)
}
float getTemperatureC()
{
int reading = analogRead(kPin_Temp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Semuanya kelihatan standard dalam program di atas, kecuali penggunaan fungsinya setCursor () . Ini digunakan untuk menyelaraskan teks sejauh mungkin di sekitar tengah paparan.

Hebat! Dan selamat, anda baru sahaja memprogramkan penunjuk suhu LCD kecil anda sendiri menggunakan Arduino.

Aplikasi Arduino Praktikal

Oleh kerana, pada tahap ini kita telah secara komprehensif membahas berbagai teknik pengaturcaraan secara terperinci, sudah waktunya untuk melakukannya dengan menerapkannya untuk beberapa pelaksanaan praktikal yang berguna.

Kami akan memulakan dengan sensor dan melihat bagaimana peranti sensor dapat digunakan dengan Arduino dengan menjalankan beberapa contoh kod.

7.1 Pengenalan Sensor

Dalam tutorial ini kita akan belajar mengenai berbagai macam sensor yang dapat digunakan dengan Arduino. Ini mungkin termasuk peranti seperti sensor cahaya LDR, sensor kesan ruang magnetik, sensor kecondongan, sensor getaran, sensor tekanan dll.

Kami akan bermula dengan antara muka sensor cahaya LDR dengan Arduino, seperti yang ditunjukkan pada rajah berikut:

Seperti yang kita semua ketahui, LDR adalah alat perintang yang bergantung kepada cahaya yang rintangannya bergantung pada intensiti kejadian persekitaran di permukaannya.

Keamatan cahaya berbanding terbalik dengan bacaan rintangan LDR.

Di sini kita akan belajar bagaimana harta tanah ini dapat disatukan dengan Arduino untuk melaksanakan aplikasi yang berguna:

Kod program yang lengkap dapat dilihat seperti yang diberikan di bawah:

const int kPin_Photocell = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
int value = analogRead(kPin_Photocell)
Serial.print('Analog Reading = ')
Serial.print(value)
if(value <200){
Serial.println(' - Dark')
}else if(value <400){
Serial.println(' - Dim')
}
else if(value <600){
Serial.println(' - Light')
}
else if(value <800){
Serial.println(' - Bright')
}
else{
Serial.println(' - Very Bright')
}
delay(1000)
}

Semua parameter yang digunakan dalam kod telah dibincangkan dalam kursus kami yang telah kami pelajari sejauh ini. Anda boleh memeriksa garis dengan merujuk pada bahagian yang berkaitan.

Nilainya dipilih secara rawak, anda boleh menukar dengan mudah mengikut pilihan anda sendiri.

Sensor kecondongan

Sensor kecondongan adalah alat sederhana yang dapat digunakan untuk mengesan tindakan kemiringan pada objek di mana ia dipasang. Peranti pada dasarnya mempunyai bola logam di dalamnya, yang pada miring berguling di atas sepasang kenalan menyebabkan konduksi melintasi kenalan tersebut. Kontak ini dihentikan sebagai pengarah suis kecondongan, digunakan dengan litar luaran untuk mengesan konduksi akibat tindakan memiringkan dan mengaktifkan aplikasi output yang diinginkan.

Sekarang mari kita lihat bagaimana a sensor kecondongan peranti boleh dihubungkan. Gambar di bawah memberi kami idea mengenai konfigurasi lengkap:

const int kPin_Tilt = 3
const int kPin_LED = 13
void setup()
{
pinMode(kPin_Tilt, INPUT)
digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor
pinMode(kPin_LED, OUTPUT)
}
void loop()
{
if(digitalRead(kPin_Tilt) == HIGH){
digitalWrite(kPin_LED, LOW)
}
else{
digitalWrite(kPin_LED, HIGH)
}
}

Dalam contoh ini, pin pin # 13 lalai digunakan sebagai penunjuk kecondongan.

Anda dapat melihat kemasukan pull-up resistor dengan jelas, sama seperti yang kami lakukan di bahagian 3.1. Oleh itu istilah LOW menunjukkan bahawa fungsi kecondongan tidak dicetuskan.

7.4 Reed Switch Relay (Relay Diaktifkan Magnet Miniatur)

Sekarang mari kita lihat cara menghubungkan suis geganti atau sensor medan magnet dengan Arduino. Relay reed adalah sejenis suis yang mengaktifkan atau melakukan apabila medan magnet atau magnet dibawa berdekatan dengannya. Pada dasarnya ia mempunyai sepasang kenalan feromagnetik di dalam penutup kaca miniatur yang bergabung atau bersentuhan kerana tarikan magnet setiap kali magnet berada di dekatnya. Apabila ini berlaku, terminal kenalan menunjukkan konduksi kerana penutupan kenalan.

Di sini juga kita menggunakan pin # 13 LED untuk menunjukkan tindak balas. Anda boleh menyambungkan LED luaran dari pin ini jika diperlukan seperti penjelasan kami sebelumnya.

const int kPinReedSwitch = 2
const int kPinLed = 13
void setup()
pinMode(kPinReedSwitch, INPUT)
digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinReedSwitch) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

Istilah kod haruslah biasa dan cukup jelas.

7.5 Sensor getaran menggunakan Piezo Transducer

Dalam contoh program seterusnya kita akan melihat bagaimana a transduser piezo boleh digunakan sebagai sensor getaran untuk menerangi LED melalui Arduino.

Elemen piezo sebenarnya adalah peranti yang menghasilkan getaran atau ayunan apabila frekuensi diterapkan di terminalnya. Namun piezo yang sama dapat digunakan dalam proses terbalik untuk menghasilkan denyutan elektrik sebagai tindak balas terhadap getaran yang dikenakan pada badannya. Getaran ini boleh berupa ketukan atau pukulan di permukaan piezo.

Siapkan elemen Arduino dan piezo seperti yang diberikan dalam gambar berikut

const int kPinSensor = A5
const int kPinLed = 13
const int k_threshold = 100
int ledState = LOW // variable used to store the last LED status, to toggle the light
void setup()
{
pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT
}
void loop()
{
int val = analogRead(kPinSensor)
if (val >= k_threshold) {
ledState = !ledState // toggle the value of ledState
digitalWrite(kPinLed, ledState)
delay(20) // for debouncing
}
}

Ambang batas 100 diperkenalkan hanya untuk memastikan bahawa Arduino hanya bertindak balas terhadap getaran asli melalui ketukan, dan bukan getaran lain yang lebih kecil seperti dari suara kuat, atau tanduk.

Pemilihan pin A5 tidak wajib, anda boleh memilih input analog lain mengikut pilihan anda dan dengan memadankannya dalam kod program.

Menggunakan Servo Motor dengan Arduino

Motor servo adalah jenis motor DC yang dapat diputar ke sudut yang tepat sesuai permintaan aplikasi tertentu. Ini dapat dilakukan dengan menerapkan perintah yang dihitung pada input motor yang relevan untuk menghasilkan putaran atau sudut putaran yang tepat dalam jarak 180 darjah pada motor.

Biasanya motor servo mempunyai 3 wayar atau input. Kawat positif biasanya berwarna merah, kawat negatif atau tanah berwarna hitam, yang mana kawat arahan atau kawat isyarat biasanya berwarna putih atau kuning.

Arduino memudahkan kawalan motor servo melalui bahasa sokongan terbina dalam yang menjadikan pengendalian sangat mudah dan sesuai untuk motor servo.

Contoh berikut akan menunjukkan kepada kita program penyediaan asas untuk melaksanakan kawalan motor servo melalui Arduino:

Kodnya diberikan di bawah:

#include
Servo servo1
const int kPinPot = A0
const int kPinServo1 = 9
void setup()
{
servo1.attach(kPinServo1)
}
void loop()
{
int val = analogRead(kPinPot)
val = map(val, 0, 1023, 0, 180)
servo1.write(val)
delay(15)
}

Kami dapat melihat beberapa entri baru di sini. Yang memberitahu kawat servo yang terpasang pada pin apa yang ditugaskannya. Yang lain adalah kod yang memberikan nilai pin antara 0 dan 180, untuk menentukan sudut putaran pada servo.

Kesimpulannya

Subjek Arduino boleh panjang, dan oleh itu di luar ruang lingkup artikel ini. Namun, saya harap tutorial di atas semestinya dapat membantu anda mempelajari asas-asas Arduino dan memahami parameter penting melalui pelbagai contoh kod aplikasi.

Semoga lebih banyak maklumat dapat dikemas kini dari semasa ke semasa di sini, bila ada.

Sementara itu, nikmati kursus pengaturcaraan anda, Selamat Arduino kepada anda !!