Belajar Pemrograman Arduino Dasar - Tutorial untuk Pendatang Baru

Dalam tutorial ini kita belajar bagaimana melakukan pemrograman Arduino dasar melalui kode contoh dan program sampel. Tutorial ini bisa menjadi kursus yang sangat berharga bagi semua pendatang baru yang ingin memahami dasar-dasarnya melalui bahasa yang mudah dan dapat dimengerti.

pengantar

Berdasarkan wikipedia mikrokontroler setara dengan komputer mini yang dibangun di dalam chip IC tunggal, memiliki prosesor inti sendiri, input yang dapat diprogram, memori, dan periferal output.

Mikrokontroler menjadi sangat berguna bagi pengguna karena ia menawarkan prosesor bawaan, memori dan port input / output (juga disebut GPIO atau pin input / output tujuan umum) yang dapat dikontrol oleh pengguna sesuai spesifikasi yang diinginkan.

Dalam tutorial ini kita akan bekerja dengan papan Arduino Uno untuk mempelajari dan menguji program. Untuk menguji dan mengintegrasikan perakitan perangkat keras kami akan menggunakan papan tempat memotong roti.

Sekarang mari bergerak cepat dan belajar bagaimana memulai dengan pemrograman Arduino.

1.2 Menginstal Perangkat Lunak (Windows)

Untuk ini, Anda memerlukan akses ke internet, yang jelas Anda miliki di komputer Anda. Silakan buka tautan berikut dan unduh perangkat lunak IDE:

File ZIP Windows untuk penginstalan non admin

Setelah mengunduh, Anda akan menemukan ikon pengaturan Arduino di folder unduhan, yang akan terlihat seperti ini:

Setelah Anda mendapatkan ini, Anda cukup mengklik dua kali dan menginstal Arduino the Integrated Development Environment (IDE) di komputer Anda. Proses lengkapnya dapat divisualisasikan dalam video berikut:

1.4 Memulai Sirkuit Pertama kita

Sebelum kita mulai mempelajari teknik pemrograman yang sebenarnya, bagi setiap pemula, akan berguna untuk memulai dengan komponen dasar seperti LED, dan memahami cara menghubungkannya dengan Arduino.

Seperti yang kita ketahui LED merupakan dioda pemancar cahaya yang memiliki polaritas dan tidak akan menyala jika tidak dihubungkan dengan kutub suplai yang tepat.

Aspek lain dengan LED adalah bahwa perangkat ini bekerja dengan arus rendah dan dapat langsung rusak jika resistor yang dihitung dengan tepat tidak disertakan dalam seri dengan salah satu pinnya.

Sebagai aturan praktis, 330 ohm 1/4 watt cukup ideal untuk setiap kenaikan 5V pada input suplai untuk membatasi arus ke tingkat aman yang diperlukan. Oleh karena itu untuk 5V mungkin 330 ohm, untuk 10V mungkin 680 ohm dan seterusnya.

Menggunakan Breadboard untuk Majelis

Harap pastikan bahwa Anda tahu cara menggunakan file papan tempat memotong roti sebelum mencoba tutorial yang dijelaskan dalam bab ini, karena kami akan menggunakan papan tempat memotong roti untuk semua eksperimen di sini.

Pengaturan koneksi LED dasar dapat disaksikan di bawah ini:

Anda dapat melihat 3 komponen dasar di atas:

1. LED 5mm, 20mA
2. resistor 330 ohm 1/4 watt
3. Sebuah Papan Arduino

Cukup rakit sistem sesuai diagram.

Selanjutnya, colokkan 5V dari USB komputer ke Arduino. Segera setelah Anda melakukan ini, Anda akan melihat LED menyala.

Saya tahu itu cukup mendasar, tetapi selalu bagus untuk memulai dari awal. Yakinlah bahwa hal-hal akan mulai menjadi semakin menarik seiring dengan kemajuan kita.

1.5 Mengontrol LED dengan Arduino

Sekarang kita akan belajar cara mengontrol LED dengan program Arduino.

Untuk menulis program kita harus memiliki minimal 2 fungsi di setiap program.

Suatu fungsi dapat dipahami sebagai rangkaian pernyataan pemrograman yang dapat diberi nama, seperti yang diberikan di bawah ini:

1. mempersiapkan() ini dipanggil atau dijalankan selama memulai program.
2. loop () ini disebut atau dieksekusi berulang-ulang selama seluruh periode operasional Arduino.

Oleh karena itu, meskipun mungkin tidak memiliki fungsi praktis, secara teknis program Arduino sah terpendek dapat ditulis sebagai:

Program Paling Sederhana

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

Anda mungkin telah memperhatikan bahwa dalam banyak bahasa pemrograman, sistem dimulai dengan menampilkan cetakan sederhana, 'Hello, World' pada layar tampilan.

Persamaan elektronik untuk frasa ini dalam interpretasi mikrokontroler adalah dengan mengedipkan LED ON dan OFF.

Ini adalah program paling dasar yang dapat ditulis dan diterapkan seseorang untuk menunjukkan berfungsinya sistem dengan benar.

Kami akan mencoba menerapkan dan memahami prosedur melalui potongan kode berikut:

Daftar 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)
}

Oke, sekarang mari kita pahami arti setiap baris kode dan cara kerjanya untuk menjalankan fungsinya:

const int kPinLed = 13

Ini berfungsi seperti konstanta yang memungkinkan kita untuk menggunakannya selama kursus pemrograman lengkap, tanpa perlu menggunakan nilai aktual yang ditetapkan untuk itu.

Sesuai aturan standar, konstanta tersebut dikenali dengan huruf awal untuk . Meskipun ini tidak wajib, ini membuat segalanya lebih jelas dan mudah dimengerti setiap kali Anda ingin membaca detail kode.

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

Kode ini mengkonfigurasi pin khusus yang dihubungkan dengan LED kita. Dengan kata lain, kode tersebut memberi tahu Arduino untuk mengontrol aspek 'menulis' pada pin ini, alih-alih 'membacanya'.

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

Baris di atas menunjukkan eksekusi aplikasi yang sebenarnya. Kode dimulai dengan menulis dan membuat TINGGI pada koneksi LED yang relevan, menyalakan LED.

Di sini, istilah TINGGI berarti mendapatkan + 5V pada pin Arduino yang bersangkutan. Istilah pelengkap LOW hanya menunjukkan nol atau 0V pada pin yang ditunjuk.

Selanjutnya, kami memanggil delay() yang fungsinya untuk membuat penundaan melalui milidetik (1/1000 detik). Sejak angka 500 dimasukkan, penundaan yang diterapkan akan berlangsung selama 1/2 detik.

Segera setelah 1/2 detik ini habis, baris berikutnya dijalankan yang mematikan LED dengan istilah RENDAH pada pin yang sama.

Baris berikutnya lagi-lagi menghasilkan jeda 1/2 detik, agar LED tetap OFF selama 1/2 detik.

Dan proses berlanjut tanpa batas dengan eksekusi baris kode, selama Arduino tetap bertenaga.

Sebelum melanjutkan ke level berikutnya, saya akan merekomendasikan Anda untuk memprogram kode di atas dan memeriksa apakah Anda dapat mengimplementasikan urutan LED ON / OF dengan benar atau tidak.

Karena LED default di Arduino terhubung dengan pin # 13, itu akan segera merespons program di atas dan mulai berkedip. Namun, jika Anda menemukan LED eksternal Anda tidak berkedip maka mungkin ada kesalahan koneksi dengan LED Anda, Anda dapat mencoba membalikkan polaritas LED Anda dan semoga melihatnya berkedip juga.

Anda dapat bermain dengan waktu tunda dengan mengubah angka '500' menjadi nilai lain dan menemukan LED 'mendengarkan' perintah dan menyebabkannya berkedip sesuai nilai penundaan yang ditentukan.

Tapi ingat, jika Anda melihat LED tidak berkedip dengan kecepatan konstan 1 detik, terlepas dari perubahan waktu tunda Anda, itu mungkin menunjukkan kode tidak berfungsi karena beberapa kesalahan. Karena secara default Arduino akan diprogram dengan kecepatan flashing 1 detik. Oleh karena itu, tarif ini harus bervariasi berdasarkan kode Anda untuk memastikannya berfungsi dengan benar.

1.7 Komentar

Baris kode yang kami pahami di atas secara khusus ditulis untuk perangkat lunak komputer.

Akan tetapi, untuk memastikan bahwa pengguna dapat merujuk arti dari baris-baris tersebut dan memahaminya, seringkali berguna dan masuk akal untuk menulis penjelasan di samping baris kode yang diinginkan.

Ini disebut komentar yang ditulis untuk referensi manusia atau pengguna saja, dan diberi kode untuk memungkinkan komputer mengabaikannya dengan aman.

Bahasa komentar ini ditulis dengan beberapa format:

1. Gaya blok komentar, di mana deskripsi komentar diapit di bawah simbol awal / * dan simbol akhir * /
2. Ini tidak harus dibatasi dalam satu baris melainkan dapat diperpanjang ke baris berikutnya tergantung pada panjang komentar atau deskripsi, seperti yang ditunjukkan pada contoh berikut:

/ * Ini adalah komentar * /

/ * Jadi ini * /

/ * Dan
* ini
* sebagai
* baik * /

Untuk menulis deskripsi baris tunggal yang cepat untuk sebuah komentar, simbol dua garis miring // di awal sudah cukup. Ini memberi tahu komputer bahwa baris ini tidak ada hubungannya dengan kode sebenarnya, dan harus diabaikan. Sebagai contoh:

// Ini adalah komentar yang akan diabaikan oleh komputer.

Berikut contoh referensi:

/*
* 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 Pemecahan Masalah

Jika Anda menemukan program Anda menunjukkan 'kesalahan' saat kompilasi, atau beberapa masalah lainnya, tip berikut mungkin akan membantu Anda untuk memeriksa ulang kode Anda untuk menghilangkan rintangan.

1. Bahasa program Anda akan membedakan huruf besar / kecil. Misalnya ekspresi myVar tidak dapat ditulis sebagai MyVar.
2. Semua jenis ruang putih yang dapat dieksekusi dengan pengetikan keyboard Anda, pada akhirnya ditampilkan sebagai satu spasi, dan hanya terlihat atau dipahami oleh Anda, komputer tidak akan memperhitungkannya. Sederhananya, spasi kosong apa pun tidak akan berpengaruh pada hasil kode.
3. Setiap blok kode harus diapit tanda kurung kurawal kiri dan kanan, '{' dan '}'
4. Digit angka tidak boleh dipisahkan dengan koma. Misalnya, 1000 tidak boleh ditulis sebagai 1.000.
5. Setiap baris kode yang diapit di antara tanda kurung kurawal harus diakhiri dengan titik koma

Membuat Urutan Lampu LED yang Menarik dengan Arduino

Di bab sebelumnya, kita telah mempelajari cara mengedipkan LED ON / OFF terus menerus dengan tingkat penundaan konstan.

Sekarang kita akan belajar bagaimana pola penundaan yang berbeda dapat dijalankan pada LED yang sama dengan meningkatkan kode program.

Kami tidak akan menggunakan LED eksternal, melainkan menggunakan LED default yang terpasang di papan Arduino di pin # 13. Anda dapat menemukan SMD LED kecil ini tepat di belakang konektor USB.

2.2 Memahami Pernyataan IF

Di bagian ini kita akan mempelajari bagaimana struktur kontrol memungkinkan kita menjalankan kode individual, dan terkadang bahkan berulang-ulang, seperti yang diperlukan.

Pernyataan jika menjadi struktur kendali pertama. Implementasi berikut menunjukkan bagaimana itu 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 mencoba memahami kode di atas secara bertahap dan mempelajari bagaimana kode ini dapat digunakan untuk eksekusi serupa lainnya.

Kode antara baris 1 dan 7 sama persis dengan program awal kita.

Modifikasi pertama sebenarnya terjadi pada baris ke-8.

int delayTime = 1000

Anda dapat menemukan ini serupa dengan kode di baris pertama, kecuali fakta bahwa istilah tersebut tidak ada const.

Ini hanya karena, kode ini bukanlah sebuah konstanta. Sebaliknya ini didefinisikan sebagai a variabel , yang memiliki properti nilai variabel selama pemrograman.

Dalam contoh di atas, Anda dapat melihat bahwa variabel ini dikaitkan dengan nilai 1000. Ingat, variabel yang diapit dalam tanda kurung kurawal harus ditulis dengan tepat dalam pasangan tanda kurung kurawal saja, dan disebut sebagai variabel 'lokal'.

Alternatifnya, variabel yang seharusnya berada di luar tanda kurung kurawal, seperti yang kita diskusikan sekarang dikenali sebagai 'global', dan bisa dieksekusi hampir di mana saja dalam kode program.

Ke depan, Anda dapat melihat bahwa kode antara baris 9 dan 11 juga mirip dengan program pertama, namun hal-hal mulai menjadi menarik setelah baris 11. Mari kita lihat caranya!

delayTime = delayTime - 100

Dalam kode ini kita melihat bahwa nilai default dari waktu penundaan sedang dimodifikasi dengan mengurangi 100 darinya.

Artinya 100 dikurangkan dari nilai awal 1000, memberikan nilai baru 900.

Melalui gambar berikut kami akan mencoba memahami beberapa operator Matematika yang digunakan dalam bahasa Arduino.

Sekarang mari kita menilai kode antara baris 13 dan 15.

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

Tujuan utama dari potongan kode di atas adalah untuk memastikan bahwa LED terus berkedip tanpa gangguan.

Karena fakta bahwa 100 dikurangi dari aslinya waktu penundaan , ini mencegah kedipan LED mencapai nol dan memungkinkan kedipan terus menerus.

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

Dalam kode kita di atas, kita bisa menguji kode menjadi if(delayTime == 0).

Namun, karena menjadi sosok negatif bisa sama buruknya, kami tidak melakukannya, dan ini adalah praktik yang disarankan.

Pikirkan apa yang bisa terjadi jika kita mencoba mengurangi 300, bukan 100 dari delayTime?

Jadi sekarang Anda mungkin telah menyadari bahwa delayTime ditulis kurang atau sama dengan nol, maka waktu tunda akan diatur kembali ke angka semula 1000.

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

4 baris terakhir dari kode seperti yang ditunjukkan di atas bertanggung jawab untuk menyalakan / mematikan LED, ON / OFF secara terus menerus.

Di sini Anda dapat melihat dengan jelas bahwa alih-alih menggunakan sejumlah gambar, kami telah menggunakan variabel untuk menetapkan waktu tunda sehingga kami dapat menyesuaikannya sesuai keinginan selama periode operasional kode. Itu keren, bukan?

2.3 Pernyataan ELSE

Di sini kita akan mempelajari mengapa dan bagaimana jika istilah mungkin memiliki klausul lain sehingga memutuskan situasi dalam kasus jika pernyataan itu salah.

Mohon maaf jika kedengarannya terlalu membingungkan, jangan khawatir, kami akan mencoba 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 dengan baik bahwa dalam kode baris ke-10 hanya dieksekusi ketika delayTime kurang dari atau sama dengan 100, jika tidak maka kode di baris ke-13 dijalankan, tetapi keduanya tidak akan pernah terjadi, baik baris ke-10 atau kode baris ke-13 akan diterapkan, tidak pernah keduanya.

Anda mungkin telah memperhatikan bahwa tidak seperti yang kita lakukan di bagian 2.2 sebelumnya, di sini kita tidak membandingkan dengan 0, melainkan dibandingkan dengan 100. Ini karena dalam contoh ini dibandingkan SEBELUM kita mengurangi 100, sebaliknya di bagian 2.2, kita membandingkan SETELAH kita dikurangi. Dapatkah Anda mengetahui apa yang bisa terjadi jika kita membandingkan 0, bukan 100?

2.4 pernyataan WHILE

UNTUK sementara Pernyataan ini sangat mirip dengan jika pernyataan, kecuali kebenaran yang menyebabkan eksekusi berulang ke blok kode (yang mungkin berada di antara tanda kurung kurawal) selama kondisi berlaku, dan ini berfungsi tanpa lain pernyataan.

Contoh berikut akan membantu Anda memahami 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)
}
}

Dapatkah Anda menebak kode di atas diprogram untuk dilakukan? Yah, itu dirancang untuk mengedipkan LED lebih cepat lalu lebih lambat.

2.5 Apa yang benar dan salah?

Dalam bahasa pemrograman, Salah mengacu pada nol (0). Sebenarnya 'benar' tidak digunakan, sebaliknya diasumsikan bahwa jika tidak ada yang salah, maka semua yang disertakan adalah benar.

Kelihatannya sedikit aneh namun itu melakukan pekerjaan dengan cukup baik.

Kami akan mencoba memahami situasinya melalui contoh berikut.

Terkadang Anda mungkin menemukan kode seperti yang diberikan di bawah ini:

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

Ini dikodekan, sepertinya eksekusi LED akan terus berputar selamanya, selama daya tersedia.

Namun, satu kelemahan dari jenis kode ini bisa muncul ketika secara tidak sengaja pengguna menerapkan a = alih-alih ==.

Saya yakin Anda sudah tahu bahwa = menandakan sebuah tugas, artinya ini digunakan untuk menunjuk nilai yang dipilih ke variabel, sementara a == digunakan untuk memaksakan pengujian jika nilainya sama.

Misalnya Anda memerlukan LED untuk berkedip dengan pola kecepatan berurutan dan berulang-ulang, tetapi salah menggunakan = bukannya ==.

Kode 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 menetapkan 0 ke delayTime, dan mengarah ke jika pernyataan untuk memeriksa apakah 0 benar atau tidak. Karena 0 merujuk ke salah, ia akan menganggapnya tidak benar, dan akan menghentikan penerapan delayTime = 1000, melainkan fungsi delayTime ditahan pada 0 selama loop ().

Ini terlihat sangat tidak diinginkan !!

Jadi, selalu periksa ulang program Anda untuk memastikan Anda tidak membuat kesalahan konyol seperti itu.

2.6 Kombinasi

Terkadang Anda mungkin merasa perlu menguji banyak hal secara bersamaan. Misalnya, Anda mungkin ingin memeriksa apakah variabel berada di antara dua angka. Meskipun ini dapat diterapkan dengan menggunakan pernyataan if beberapa kali, mungkin lebih nyaman menggunakan kombinasi logika untuk pembacaan yang lebih baik dan lebih mudah.

Menerapkan kombinasi pada istilah logis dapat dilakukan dengan 3 metode, seperti yang ditunjukkan pada tabel berikut:

Menarik untuk diketahui bahwa operator NOT dapat bekerja sebagai pengalih untuk variabel yang mungkin ditunjuk sebagai salah satu dari keduanya benar atau Salah (atau RENDAH atau TINGGI).

Contoh berikut menggambarkan kondisi tersebut:

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

Di sini ledState akan menjadi RENDAH, dan setelah ledState = !ledState, itu akan menjadi TINGGI. Loop berikut akan menyebabkan ledState menjadi TINGGI saat ledState = !ledState rendah.

2.7 UNTUK pernyataan

Sekarang kita akan mencoba memahami tentang struktur kendali yang lain yaitu a untuk lingkaran. Ini bisa sangat berguna ketika Anda ingin mengimplementasikan sesuatu beberapa kali.

Mari kita pahami 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 dapat menemukan sesuatu yang unik dengan untuk.

Itu adalah kodenya i ++? . Ini berguna untuk programmer yang malas dan ingin mengimplementasikan pengkodean melalui pintasan yang nyaman

Istilah di atas dikenal sebagai operator gabungan, karena mereka melakukan tugas untuk menggabungkan satu operator penugasan dengan operator penugasan lainnya. Yang paling populer di antaranya dapat divisualisasikan dalam tabel berikut:

Anda akan menemukan bahwa ada 3 sub-pernyataan di pernyataan for. Itu terstruktur seperti yang ditunjukkan di bawah ini:

for (statement1conditionstatement2){
// statements
}

Pernyataan # 1 muncul tepat di awal dan hanya sekali. Kondisi ini diuji setiap kali selama pengulangan. Kapanpun itu benar di dalam tanda kurung kurawal, pernyataan # 2 berikutnya akan diterapkan. Dalam kasus a Salah, sistem melompat ke blok kode berikutnya.

Menghubungkan Lebih Banyak LED

Oke, sekarang kita akan melihat bagaimana kita dapat menghubungkan lebih banyak LEds untuk mendapatkan efek yang lebih menarik.

Silakan hubungkan LED dan Arduino seperti yang ditunjukkan di bawah ini. Kabel merah sebenarnya tidak diperlukan, tetapi karena selalu merupakan ide yang baik untuk memiliki kedua rel suplai yang disertakan dalam papan tempat memotong roti, pengaturannya masuk akal.

Sekarang mari kita perbaiki program yang akan memungkinkan kita untuk memeriksa apakah perangkat keras kita dikonfigurasi dengan benar atau tidak.

Selalu disarankan untuk membuat kode dan menjalankan program kecil secara bertahap untuk memeriksa apakah masing-masing perangkat keras terhubung dengan benar atau tidak.

Ini membantu memecahkan kemungkinan kesalahan dengan cepat.

Contoh kode di bawah ini memberikan LED 2 hingga 5 pola tertentu dengan memutarnya satu demi satu secara siklik.

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 mungkin Anda perhatikan, tidak ada yang salah dengan kode tersebut, kecuali fakta bahwa kode tersebut terlihat panjang dan rentan terhadap kesalahan.

Tentu saja ada cara yang lebih baik untuk menulis kode di atas, bagian berikut akan mengungkapkannya.

2.9 Memperkenalkan Array

Array dapat berupa sekelompok variabel yang dapat diindeks dengan nomor 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)
}
}

Oke, sekarang mari kita bahas setiap bagian dan pahami cara kerjanya.

const int k_numLEDs = 4

Kode di atas menentukan berapa banyak elemen maksimum yang seharusnya kita miliki dalam array. Kode ini membantu kita di bagian selanjutnya untuk memastikan bahwa semuanya ditulis dalam array dan tidak ada apa pun setelah array berakhir.

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

Di baris berikutnya ini kami menyiapkan struktur array. Angka di dalam tanda kurung menunjukkan jumlah elemen dalam larik. Meskipun, kuantitas sebenarnya dapat ditulis, menulis sebagai konstanta bekerja lebih baik. Nilai biasanya dapat dilihat di dalam braket dengan koma dan menentukan nilai ke array.

Ketika Anda menemukan sebuah array yang diindeks dengan angka 0, ini menunjukkan elemen pertama dalam array, seperti yang ditunjukkan pada code: k_LEDPins is k_LEDPins[0].

Demikian pula elemen terakhir akan ditampilkan sebagai k_LEDPins[3], karena hitungan dari 0 hingga 3 adalah 4.

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

Kode di atas menunjukkan penggunaan loop untuk melanjutkan melalui setiap elemen array dan untuk mengaturnya sebagai OUTPUT. Kami menerapkan tanda kurung siku bersama dengan indeks untuk menjangkau setiap elemen dalam larik.

jika Anda bertanya-tanya apakah mungkin menggunakan pin # 2 ke pin # 5 tanpa array, jawabannya adalah ya, itu mungkin. Tetapi dalam contoh ini tidak dilakukan karena kami tidak melakukannya dengan cara itu. Pada bagian berikut, Anda dapat menghilangkan pendekatan larik jika pin keluaran yang dipilih tidak sejalan.

Selanjutnya, mari kita lihat apa yang dilakukan blok kode berikutnya:

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

Di sini kode berlanjut melalui masing-masing LED untuk menyalakannya secara berurutan dengan jeda atau penundaan 100 milidetik.

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

Menggunakan kode di atas menunjukkan bagaimana penerapan untuk loop dapat digunakan untuk bergerak melalui loop bahkan dalam urutan terbalik.

Ini dimulai dari k_numLEDs - 1 karena array diindeks nol. Kami tidak mulai dari k_LEDPins[4] karena itu akan mengakibatkan melintasi akhir larik.

Kode menggunakan> = 0 untuk memeriksa agar elemen pertama pada indeks 0 tidak terlewat atau diabaikan.

bagian 3

Apa itu Input

Jadi, apakah kita belajar bagaimana mengoperasikan sesuatu menggunakan Arduino. Dalam bab ini kita akan membahas bagaimana merasakan dunia nyata dengan menghubungkan input dari parameter eksternal.

3.1 Menggunakan Tombol Tekan

Kita semua tahu apa itu tombol tekan dan cara kerjanya. Ini adalah sejenis sakelar atau tombol yang menghubungkan sinyal dari satu tahap rangkaian ke tahap lain untuk sesaat saat berada dalam kondisi tertekan, dan memutus sinyal saat dilepaskan.

3.1.1 Satu tombol dan satu LED

Kami akan menghubungkan Arduino dengan tombol tekan dengan Arduino sesuai detail yang ditunjukkan di atas dan mempelajari kerja dasar dan implementasi pengaturan.

Tombol tekan yang ditunjukkan yang juga disebut tombol tekan saklar mikro, memiliki total 4 pin (2 pasang di setiap sisi). Saat didorong, setiap pasangan pin disambungkan secara internal dan memungkinkan koneksi atau konduksi melewatinya.

Dalam contoh ini kami hanya menggunakan satu pasang pin atau kontak ini, pasangan lainnya tidak relevan dan oleh karena itu diabaikan.

Mari lanjutkan dengan menerapkan kode berikut dan periksa 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 menemukan beberapa hal yang terlihat tidak biasa di sini. Mari kita cari tahu langkah mereka dengan bijak.

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

Hal pertama yang kami lakukan adalah memperbaiki file buttonPin sebagai MEMASUKKAN. Itu cukup mendasar, saya tahu.

Selanjutnya, kami menetapkan TINGGI ke MEMASUKKAN pin. Anda bertanya-tanya, bagaimana mungkin menulis apa pun pada masukan? Tentu, ini mungkin menarik.

Sebenarnya, menetapkan TINGGI ke input Arduino akan mematikan resistor pull-up 20k Ohm internal ON (RENDAH pada pin ini mematikannya).

Pertanyaan lain yang mungkin Anda miliki adalah apa itu resistor pull-up. Saya telah membahas posting komprehensif tentang resistor pull-up yang Anda pelajari di sini .

Oke, lanjutkan, sekarang mari kita lihat kode loop utama:

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

Saat Anda menekan tombol tekan, pin kabel akan terhubung ke ground, yang membuat a RENDAH ke pin itu. Dan saat dalam kondisi tidak tertekan, pin yang sama akan ditahan TINGGI atau + 5V melalui resistor pull-up internal 20K.

Di sini kami ingin Arduino menyalakan LED ketika tombol tekan ditekan (RENDAH), oleh karena itu kami menulis TINGGI untuk output untuk setiap respons RENDAH dari tombol tekan, saat ditekan.

3.1.2 Dua tombol dan satu LED

Nah, Anda mungkin bertanya-tanya tindakan yang ditunjukkan di atas bisa dilakukan tanpa Arduino juga. Saya mengerti, bagaimanapun ini adalah batu loncatan untuk mempelajari bagaimana tombol dapat digunakan dengan Arduno.

Sampai titik ini, kami telah mempelajari penulisan kode untuk menyalakan (TINGGI) atau mematikan (RENDAH) LED.

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

Ini dapat dilakukan dengan dua metode:

1. Dengan membatasi jumlah arus ke LED
2. Dengan menggunakan PWM atau modulasi lebar pulsa, di mana suplai ke LED dinyalakan / dimatikan pada kecepatan yang diinginkan dengan sangat cepat, menghasilkan iluminasi rata-rata yang intensitasnya bergantung pada PWM.

Di papan Arduino dukungan PWM tersedia pada pin yang ditandai dengan tilde (~), yaitu pin 3, 4,5,9,10 dan 11) pada 500Hz (500 kali per detik). Pengguna dapat memberikan nilai apa pun antara 0 dan 255, di mana 0 tidak mengacu pada TINGGI atau tanpa + 5V, dan 255 memberi tahu Arduino untuk mendapatkan TINGGI atau + 5V sepanjang waktu. Untuk memulai perintah ini, Anda harus mengakses analogWrite () dengan nilai yang diinginkan.

Anda dapat mengasumsikan PWM menjadi x / 255 di mana x adalah nilai yang diinginkan yang ingin Anda kirim melalui analogWrite().

Atur Arduino dan parameter lainnya 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 menemukan 3 baris di sini yang membutuhkan penjelasan.

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

Garis: ledBrightness = constrain(ledBrightness, 0, 255) mengilustrasikan fungsi unik di dalam Arduino yang dikenal sebagai kendala ().

Fungsi internal ini terdiri dari kode-kode sebagai berikut:

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

Semua kode yang dibahas sebelumnya dimulai dengan kosong , yang artinya tidak mengembalikan apapun (batal). Padahal kode di atas diawali dengan int , yang menunjukkan bahwa ia mengembalikan bilangan bulat. Kita akan membahas lebih lanjut di bagian selanjutnya, saat ini ingatlah bahwa integer tidak memiliki bagian pecahan.

Benar, jadi ini berarti, kode: ledBrightness = constrain(ledBrightness, 0, 255) menetapkan ledBrightness to be within the range of 0 and 255.

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

Baris berikutnya membuat penundaan selama 20 milidetik, ini untuk memastikan bahwa kita tidak menyesuaikan makan lebih cepat dari 50 Hz atau 50 kali per detik. Ini karena manusia bisa jauh lebih lambat daripada Arduino. Karenanya, jika penundaan tidak dilakukan, program dapat membuat kita merasa bahwa menekan tombol pertama akan mematikan LED dan menekan tombol kedua menyalakannya (coba sendiri untuk konfirmasi).

3.2 Potensiometer

Mari lanjutkan dan pelajari cara menggunakan potensiometer dengan Arduino.

Untuk mengetahui cara kerja potensiometer atau pot, Anda dapat membaca ini artikel .

Hubungkan parameter yang ditunjukkan dengan Arduino Anda seperti yang ditunjukkan di atas.

Pot akan memiliki 3 terminal. Terminal tengah akan terhubung dengan ANALOG IN 0 di Arduino. Dua terminal luar lainnya dapat dihubungkan ke rel suplai + 5V dan 0V.

Mari kita program 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 menemukan beberapa hal yang mungkin terlihat sama sekali baru dan tidak termasuk dalam kode kami sebelumnya.

1. Konstanta kPinPot ditetapkan sebagai A0, di mana A adalah jalan pintas untuk mendeskripsikan salah satu pin analog. Namun A0 juga mengacu pada pin # 14, A1 ke pin # 15 dan seterusnya, dan ini memungkinkan Anda untuk digunakan sebagai input / output digital jika Anda kehabisan pin untuk percobaan. Tapi ingat Anda tidak bisa menggunakan pin digital sebagai pin analog.
2. Garis: ledBrightness = map(sensorValue, 0, 1023, 0, 255) menyajikan fungsi dalam baru di Arduino yang dikenal sebagai peta(). Fitur ini mengkalibrasi ulang dari rentang tertentu ke yang lain, disebut sebagai map (nilai, fromLow, fromHigh, toLow, toHigh). Ini mungkin menjadi penting karena analogueRead memberikan nilai dalam kisaran 0-1023, tetapi analogWrite dapat menerima nilai dari 0-255.

Anda mungkin berpikir, karena dimungkinkan untuk mengontrol kecerahan LED melalui resistansi yang berubah, hanya pot bisa cukup untuk tujuan tersebut, mengapa menggunakan Arduino. Nah, sekali lagi ini hanyalah fondasi, untuk menunjukkan bagaimana pot dapat dikonfigurasi dengan Arduino.

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

Dalam percobaan ini kita akan melihat bagaimana resistansi pot yang bervariasi dapat digunakan untuk mengontrol kecepatan berkedip atau laju LED.

Berikut 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 Mencegah penundaan ()

Kode di atas terlihat bagus, tetapi LED tidak dapat memeriksa nilai pot sampai melewati setiap siklus penuh. Untuk penundaan yang lebih lama, proses ini semakin lama pengguna harus menunggu untuk melihat respons pot saat dia memindahkannya. Penundaan ini dapat dihindari dengan beberapa pemrograman cerdas, sehingga memungkinkan pengguna untuk memeriksa nilai tanpa penundaan minimum. Ini kodenya.

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 bedanya dengan kode di atas? Ini adalah baris berikut yang membuat perbedaan.

long lastTime = 0

Sampai bagian ini, kita telah membahas tentang variabel int. Namun, mungkin ada lebih banyak jenis variabel yang dapat Anda akses. Daftarnya bisa dibaca di bawah ini:

Saat ini, mungkin hanya penting untuk mengetahui bahwa untuk menyimpan jumlah yang relatif besar untuk file int variabel, Anda bisa menggunakan istilah tersebut panjang atau a int panjang.

Di sini Anda dapat melihat fungsi menarik lainnya yang disebut millis().

Ini menghasilkan rentang waktu dalam milidetik Arduino bekerja selama operasinya dari awal (ini akan diatur ulang ke 0 setelah setiap 50 hari). Di sini ia mengembalikan lama karena jika dikembalikan int , menghitung untuk waktu yang lama mungkin tidak dapat dilakukan. Bisakah Anda menjawab dengan tepat berapa lama? Jawabannya adalah 32,767 detik.

Oleh karena itu, alih-alih menggunakan delay (), kami memeriksa milis (), dan segera setelah jumlah milidetik tertentu berlalu, kami mengubah LED. Akibatnya kami menyimpan waktu terakhir kami mengubahnya terakhir kali variabel, sehingga memungkinkan kita untuk memeriksanya lagi kapan pun diinginkan.

3.3 LED RGB

Sejauh ini kami telah bermain dengan satu warna LED. Meskipun warna LED bisa diubah dengan mengganti LED dengan warna lain, tapi bagaimana kalau menggunakan LED RGB untuk mengubah warna LED tanpa mengubah LED?

LED RGB pada dasarnya adalah LED yang memiliki LED merah, hijau, dan biru yang tertanam dan digabungkan menjadi satu LED. Ini memiliki satu kabel yang sama yang menuju ke ground atau rel pasokan 0V sementara 3 kabel lainnya diumpankan dengan sinyal positif PWM yang beragam untuk mengimplementasikan yang dimaksudkan pencampuran warna .

Anda dapat memasang penyiapan seperti yang ditunjukkan di bawah ini:

Ini mungkin terlihat sedikit rumit, tetapi sebenarnya ini adalah replika dari desain kontrol LED kami sebelumnya menggunakan PWM.

Berikut kode 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 mengupload kode ini, lihat saja bagaimana penyesuaian pot menciptakan efek cahaya yang menarik pada RGB, ini bisa sangat menyenangkan.

Anda akan menemukan bahwa ketika semua 3 pot dipindahkan posisi maksimum, alih-alih warna putih, Anda akan melihat warna merah. Ini karena warna merah adalah yang paling menonjol di antara 3 warna dan karenanya mendominasi dalam situasi ini. Bagaimanapun Anda dapat bereksperimen dengan fungsinya peta() , sebelum menjalankannya ke bagian merah LED, untuk menciptakan keseimbangan yang lebih masuk akal.

Audio dengan Arduino

Di bagian ini kita akan belajar bagaimana menambahkan suara dan musik dasar ke pengaturan Arduino.

Kita akan melihat bagaimana cara mengalihkan sinyal ke speaker yang terhubung dengan frekuensi yang diinginkan.

Untuk lebih tepatnya, nada A tengah akan dicoba, yaitu nada frekuensi 440 Hz.

Untuk melakukan ini kita hanya akan memainkan nada A tengah, dan mengoptimalkan sinyal gelombang sinus dengan gelombang persegi.

Selain itu, kami akan menghitung jumlah waktu loudspeaker tetap AKTIF dengan menggunakan rumus:

timeDelay = 1 detik / 2 x toneFrequency.

timeDelay = 1 detik / 2 x 440

timeDelay = 1136 mikrodetik

4.1 Mari Hubungkan Papan Arduino

4.2 Menambahkan catatan Sederhana

Kami sudah membahas tentang fungsinya menunda() di mana satuannya dalam milidetik (detik / 1000), namun Anda akan menemukan fungsi lain delayMicroseconds() dengan satuan dalam mikrodetik, (milidetik / 1000).

Untuk pengaturan saat ini, kami memprogram kode untuk mengaktifkan + 5V ON / OFF pada pin yang dipilih yang terhubung dengan speaker, dengan kecepatan 440 pulsa per detik.

Ingat, dalam diskusi terakhir kami menentukan nilai 1136 mikrodetik untuk catatan audio yang dimaksud.

Jadi, inilah program untuk ini, yang memungkinkan Anda mendengarkan catatan audio 440 Hz segera setelah Anda memprogram arduino dengan pengeras suara yang tersambung.

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 dimungkinkan untuk membuat catatan audio, yang juga berarti kita dapat membuat musik sesuai pilihan kita sendiri.

Dari kode kami memahami bahwa Arduino menyertakan beberapa fungsi terintegrasi yang juga berkontribusi pada penciptaan musik.

Yang pertama adalah nada() yang bekerja dengan 2 elemen bersama dengan elemen opsional ke-3, yang ditetapkan sebagai nada (pin, frekuensi, durasi). atau nada (pin, frekuensi)

Keduanya ditetapkan untuk mengeksekusi masing-masing periode waktu yang ditentukan oleh Anda.

Jika tidak ada jangka waktu, musik akan terus diputar hingga panggilan berlangsung nada() dijalankan lagi, atau sampai Anda mengeksekusi notone().

Ini perlu dilakukan dengan menggunakan fungsi penundaan jika pemutaran musik adalah satu-satunya hal mendasar yang Anda terapkan.

Durasi waktu mungkin penting karena memungkinkan memberikan waktu untuk berapa lama musik dimainkan, sehingga Anda bisa bebas melakukan hal-hal lain. Segera setelah durasinya berakhir, musik berhenti.

Fungsi selanjutnya noTone() menangani satu parameter dan menghentikan nada yang dipilih pada pin tertentu yang ditetapkan.

Peringatan khusus: Kapan saja kapan nada() fungsi diimplementasikan, fungsi PWM pada pin 3 dan 11 akan berhenti beroperasi.

Oleh karena itu, setiap kali sambungan speaker digunakan dalam program ini, pastikan untuk tidak menggunakan pin yang disebutkan untuk speaker, sebagai gantinya coba beberapa pin lain untuk sambungan speaker.

Oke jadi inilah program untuk mengimplementasikan musik pada speaker, meskipun ini bukan musik nyata, melainkan nada dasar skala C.

#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 kode di atas Anda mungkin telah memperhatikan sesuatu yang baru dan itu #menetapkan .

Istilah ini bekerja seperti perintah cari dan ganti untuk komputer saat kompilasi sedang dilakukan.

Setiap kali ia menemukan hal pertama sebelum spasi, ia menggantinya dengan bagian baris yang tersisa (disebut makro).

Jadi dalam contoh ini saat komputer melihat NOTE_E4 itu dengan cepat menggantinya dengan kuantitas 330.

Untuk lebih banyak catatan dan penyesuaian Anda dapat merujuk ke file di stik USB Anda bernama pitches.h , di mana sebagian besar frekuensi dapat ditemukan sesuai keinginan Anda.

4.4 Musik dengan fungsi

Kode diatas kelihatannya bagus, tapi sepertinya banyak pengulangannya, pasti ada cara untuk mempersingkat pengulangan tersebut, bukan?

Sejauh ini kami telah bekerja dengan dua fungsi penting yang disertakan dengan Arduino. Sekarang mungkin saatnya kita membuat fungsi kita sendiri.

Setiap fungsi harus dimulai dengan jenis variabel yang mungkin dikaitkan dengannya. Misalnya fungsinya kosong mengacu pada tipe yang tidak mengembalikan apa-apa maka nama kosong. Catatan, kami telah membahas daftar variabel di bagian sebelumnya, Anda mungkin ingin merujuknya.

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

Masing-masing parameter memperoleh tipenya bersama dengan nama, dan akhirnya tutup ')' kurung.

Parameter ini dapat diterapkan di dalam fungsi dalam bentuk variabel.

Mari kita lihat contoh di bawah ini di mana kita mengembangkan sebuah fungsi bernama ourTone () dirancang untuk menggabungkan nada() dengan menunda() baris, sedemikian rupa sehingga fungsi berhenti kembali sampai not selesai memainkan nada.

Kami menerapkan fungsi-fungsi ini dalam kode kami 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 bisa sangat berguna untuk membuat program lebih mudah dipahami.

Berikut ini adalah contoh di mana kita dapat menentukan pilihan nada yang ingin kita mainkan menggunakan dua array. Satu larik untuk mempertahankan not, yang lainnya untuk mempertahankan ketukan.

#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 dengan jelas melihat pada baris pertama pengantar #include pernyataan. Tugas pernyataan ini adalah mengambil seluruh file di antara tanda kutip dan menempatkannya di posisi #include pernyataan. Sesuai aturan standar, ini secara ketat ditempatkan di awal program.

Bab 5

Mengukur Suhu

Sekadar mengingat, mengingat alih-alih menulis program besar sama sekali, selalu bijaksana untuk menulis dan menganalisis bagian-bagian kecil kode, yang membantu melacak kesalahan dengan cepat.

5.1 Monitor Serial

Hingga saat ini, kode yang kami diskusikan tampaknya tidak semudah itu untuk mengaktifkan pemecahan masalah cepat. Di sini kami akan mencoba untuk mempermudah pemantauan dan penyelesaian masalah yang mungkin lebih mudah.

Arduino memiliki fitur yang memungkinkannya untuk 'berbicara kembali' dengan komputer. Anda dapat mengamati bahwa pin0 dan pin1 ditandai sebagai RX an TX di samping satu sama lain. Pin-pin ini sebenarnya dilacak oleh IC terpisah di dalam Arduino yang meningkatkannya untuk dibaca di kabel USB saat dicolokkan ke PC.

Bagian di bawah ini menunjukkan program lengkap, silakan lanjutkan, kita akan belajar mengenai entri baru dalam kode setelahnya. Kode ini sama dengan yang diekspresikan pada bagian 2.2 kecuali fakta bahwa kode ini menyertakan beberapa data tambahan untuk memungkinkan kita mengidentifikasi untuk apa kode itu dikodekan.

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 dapat mengidentifikasi dua hal baru di sini, baris baru di mempersiapkan() fungsi.

Serial.begin(9600)

Baris ini hanya mengungkapkan perlunya menggunakan file Serial1 kode untuk menegakkannya dengan 9600 baud. (di sini mengacu pada serial bit dikirim satu demi satu, dan baud berarti tingkat pengirimannya). Nilai baud ini dan yang ada di dalam monitor serial (kita akan mempelajarinya nanti) harus sama, atau data di monitor serial akan menunjukkan sampah. 9600 menjadi standar menjadi lebih nyaman digunakan.

Entri baru kedua adalah sebagai berikut

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

Di sini baris kedua menunjukkan bahwa hal berikutnya yang keluar dari port serial akan dimulai di baris berikutnya. Begitulah perbedaan garis kedua dari garis kepalan tangan.

Satu hal lagi yang bisa Anda lihat adalah tanda kutip ('). Ini dikenal sebagai string, yang hanya akan digunakan seperti konstanta di sini, karena diskusi lebih lanjut tentang topik ini bisa jadi terlalu rumit dan di luar cakupan.

Oke, sekarang kita dapat mengunggah kode di atas dalam Arduino dan melihat apa yang terjadi.

Ups, sepertinya tidak ada yang terjadi, LED Arduino pin # 13 berkedip dan berhenti, sementara LED Tx tetap berkedip.

Nah, itu karena jendela Serial Monitor belum diperbaiki.

Anda perlu mengklik kotak Serial Monitor di IDE Anda seperti yang ditunjukkan di atas. Jangan lupa untuk memeriksa baud rate yang terletak di kanan bawah, secara default harus 9600, dan akan cocok dengan kodenya. Jika tidak pastikan untuk memilih 9600.

Klip video berikut menjelaskan cara melakukannya.

Sekarang mari kita lanjutkan dan pelajari bagaimana fitur Serial Monitor di atas dapat membantu memproses file Pengukuran Temperatur menggunakan Arduino

Kami akan menggunakan IC TMP36 sebagai sensor suhu, memiliki kisaran -40 hingga 150 derajat Celcius.

Setup dapat dilihat dibawah ini:

Kode berikut akan memulai pengukuran suhu dengan membaca keluaran dari sensor TMP36, dan dengan mengirimkannya ke monitor serial 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 kita pahami kode dari atas.

float temperatureC = getTemperatureC()

Di sini Anda dapat melihat bahwa kami telah memasukkan tipe variabel mengapung.

Ini adalah satu-satunya tipe variabel yang menyimpan segala sesuatu kecuali bilangan bulat (angka tanpa desimal atau bagian pecahan).

Akurasi dari variabel float dapat mencapai 6 hingga 7 digit.

Kode yang berdampingan getTemperatureC() adalah fungsi kita sendiri yang secara matematis menghitung dan mengubah perbedaan tegangan yang dirasakan dari sensor TMP36 menjadi derajat Celcius.

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 bagian selanjutnya dari kode, karena istilah analogIn() ditugaskan untuk mengembalikan angka antara 1 hingga 1023, menjadi mungkin bagi kami untuk menilai tegangan dari sensor dengan mengalikan pembacaan kami dengan 5 dan kemudian membaginya dengan 1024.

Sensor TMP36 ditentukan untuk menghasilkan 0,5V pada 0 derajat Celcius, dan kemudian menghasilkan 10mV untuk setiap kenaikan derajat Celcius.

Berikut perkiraan yang dapat kami hasilkan melalui perhitungan:

Anda dapat mempertimbangkan untuk menjadi fungsi pertama Anda yang mengembalikan beberapa nilai (perhatikan bahwa semua fungsi yang tersisa sejauh ini tidak mengembalikan nilai apa pun karena mereka termasuk dalam tipe kosong ).

Anda dapat memahami bahwa untuk mendapatkan nilai dari suatu fungsi, Anda hanya perlu menambahkan kembali diikuti dengan nomor yang diinginkan yang ingin Anda kembalikan.

Saat kami berkata kembali itu berarti fungsi mengembalikan respons atau balasan setiap kali dipanggil, yang bisa diterapkan ke variabel.

Ketika ini dikirim ke Serial Monitor, pembacaan akan dikonversi ke Fahrenheit melalui convertToF ().

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

Fungsi ini mengambil kisaran Celsius dan mengubahnya menjadi Fahrenheit.

Untuk mengubah Fahrenheit ke Celsius kami menerapkan rumusnya Fahrenheit = 9 / 5 (Celcius) + 32.

5.3 Antarmuka LCD

Sekarang mari kita pelajari cara menghubungkan atau menghubungkan layar LCD dengan Arduino untuk mendapatkan tampilan visual untuk keluaran yang dibutuhkan.

Dalam aplikasi kami, kami akan menggunakan LCD grafis 84x48, memiliki 84 piksel atau titik secara horizontal, dan resolusi vertikal 48 piksel. Karena pengontrol khusus menjadi keharusan untuk semua LCD, perangkat saat ini juga menyertakan satu pengontrol dalam bentuk PCD8544.

Dalam tutorial ini kita akan menghubungkan modul LCD yang ditentukan di atas dengan Arduino, dan menerapkan rutinitas tertentu untuk membuat pesan teks pada tampilan.

Pada gambar berikut, Anda dapat menemukan detail tentang antarmuka LCD, beserta yang kecil Pengatur tegangan 3.3V . Regulator ini diperlukan karena LCD ditentukan untuk bekerja dengan suplai 3,3V.

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

Sekarang mari kita lihat bagaimana kita dapat menghubungkan LCD dan parameter yang relevan dengan Arduino kita. Detailnya dapat divisualisasikan dalam ilustrasi yang ditunjukkan di bawah ini:

5.4 Berkomunikasi ke LCD

Meskipun dimungkinkan untuk menulis mahasiswi yang rumit untuk berinteraksi dengan LCD dari Arduino, kita lebih suka belajar bagaimana melakukan hal yang sama menggunakan perpustakaan.

Perpustakaan terdiri dari bermacam-macam kode yang dapat dengan cepat diterapkan untuk program Arduino yang dipilih.

Hal ini memungkinkan pengguna untuk memanggil suatu fungsi dengan mudah tanpa harus melalui pekerjaan pengkodean yang rumit.

5.4.1 Bagaimana Menginstal perpustakaan

Untuk ini, Anda harus membuat direktori yang disebut perpustakaan di komputer Anda Arduino IDE, seperti yang dijelaskan sini

5.4.2 Menerapkan Operasi LCD

Sama seperti pendekatan kami sebelumnya, pertama-tama kami akan memeriksa seluruh kode dan kemudian mencoba memahami detail baris individu.

#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())
}

Baris tersebut menyertakan kode #include

Kode #include memerintahkan PC untuk mengambil file yang disebutkan dan mengganti elemen #include dengan konten file selama proses kompilasi program.

Elemen #include dapat memiliki tanda kurung siku yang menunjukkan pencarian di direktori perpustakaan, atau juga dapat memiliki tanda kutip yang menunjukkan pencarian di dalam direktori yang sama dengan tempat program berada.

Baris kode berikutnya mengekspresikan pinout LCD, dan kemudian kami menulis bentuk variabel baru:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Di sini kami mengekspresikan variabel dengan nama lcd yang memiliki tipe PCD8544 dan menginstruksikan PC menyesali pinoutnya yang terkait dengan Arduino.

Dalam proses ini kami menggambarkan variabel ke PC dengan menginstruksikan 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() menginisialisasi operasi LCD. Setelah ini dijalankan, baris berikutnya memaksa kursor ke kiri atas tampilan. Dan baris berikutnya berusaha mencetak pesan 'Halo, Dunia'.

Ini terlihat sangat identik dengan teknik di mana kami mengirim pesan melalui monitor serial. Satu-satunya perbedaan adalah penggunaan kode lcd.print bukan serial.print.

Blok kode berikutnya sebenarnya dipanggil berulang-ulang.

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

Menggunakan baris ini lcd.setCursor(0,1) kami memperbaiki kursor ke kolom ke-0 di paling kiri dari baris ke-1, di atas layar LCD.

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

Jika Anda ingat kami pernah bekerja dengan millis() dalam kode kami sebelumnya, kami dapat menerapkan hal yang sama di sini juga melalui kode:

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

Namun karena fakta bahwa di sini tidak ada periode waktu dalam milidetik yang terlibat, oleh karena itu kami menyelesaikannya hanya dengan mengirim millis() berfungsi langsung ke lcd.print() .

5.5 Menggabungkan Keseluruhan

Oke, sekarang mari kita gabungkan semua kode yang kita pelajari di atas untuk membuat rangkaian suhu LCD, dan mari kita lihat tampilannya:

#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 terlihat standar pada program di atas, kecuali penggunaan fungsinya setCursor () . Ini digunakan untuk meratakan teks sejauh mungkin di sekitar tengah tampilan.

Bagus! Dan selamat, Anda baru saja memprogram indikator suhu LCD kecil Anda sendiri menggunakan Arduino.

Aplikasi Arduino Praktis

Karena, pada titik ini kita telah secara komprehensif membahas berbagai teknik pemrograman secara mendetail, inilah saatnya untuk memahaminya dengan menerapkannya untuk beberapa implementasi praktis yang berguna.

Kami akan mulai dengan sensor dan melihat bagaimana perangkat sensor dapat digunakan dengan Arduino dengan menjalankan beberapa kode sampel.

7.1 Pengantar Sensor

Dalam tutorial ini kita akan belajar tentang berbagai macam sensor yang dapat digunakan dengan Arduino. Ini mungkin termasuk perangkat seperti sensor cahaya LDR, sensor efek hall magnetik, sensor kemiringan, sensor getaran, sensor tekanan, dll.

Kami akan mulai dengan antarmuka sensor cahaya LDR dengan Arduino, seperti yang ditunjukkan pada diagram berikut:

Seperti yang kita ketahui bersama, LDR adalah perangkat resistor yang bergantung pada cahaya yang resistansinya bergantung pada intensitas kejadian sekitar di permukaannya.

Intensitas cahaya berbanding terbalik dengan pembacaan resistansi LDR.

Di sini kita akan mempelajari bagaimana properti ini dapat diintegrasikan dengan Arduino untuk menjalankan aplikasi yang berguna:

Kode program lengkap dapat divisualisasikan seperti yang diberikan di bawah ini:

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 kode telah dibahas dalam kursus kita yang telah kita pelajari sejauh ini. Anda dapat memeriksa baris dengan mengacu pada bagian yang relevan.

Nilai dipilih secara acak, Anda dapat dengan mudah mengubahnya sesuai preferensi Anda sendiri.

Sensor Kemiringan

Sensor kemiringan adalah perangkat sederhana yang dapat digunakan untuk mendeteksi tindakan kemiringan pada objek apa pun yang dipasang. Perangkat pada dasarnya memiliki bola logam di dalamnya, yang saat dimiringkan menggulung sepasang kontak yang menyebabkan konduksi di seluruh kontak tersebut. Kontak ini diakhiri sebagai ujung sakelar kemiringan, digunakan dengan sirkuit eksternal untuk mendeteksi konduksi karena aksi miring dan mengaktifkan aplikasi keluaran yang diinginkan.

Sekarang mari kita lihat bagaimana a sensor kemiringan perangkat dapat disambungkan. Gambar di bawah ini memberi kita gambaran tentang konfigurasi lengkapnya:

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, LED pin # 13 default digunakan sebagai indikator kemiringan.

Anda dapat dengan jelas melihat penyertaan resistor pull-up di sini, sangat mirip dengan yang kami lakukan di bagian 3.1. Oleh karena itu istilah LOW menunjukkan bahwa fungsi kemiringan tidak dipicu.

7.4 Relai Sakelar Buluh (Relai Aktif Magnet Miniatur)

Sekarang mari kita lihat cara menghubungkan sakelar relai atau sensor medan magnet dengan Arduino. Relai buluh adalah sejenis sakelar yang aktif atau berjalan ketika medan magnet atau magnet didekatinya. Pada dasarnya ia memiliki sepasang kontak feromagnetik di dalam selungkup kaca miniatur yang bergabung atau melakukan kontak karena tarikan magnet setiap kali magnet berada di dekatnya. Ketika ini terjadi, terminal kontak menunjukkan konduksi karena penutupan kontak.

Di sini juga kami menggunakan LED pin # 13 untuk menunjukkan respons. Anda dapat menghubungkan LED eksternal dari pin ini jika diperlukan sesuai 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 kode harus familiar dan cukup jelas.

7.5 Sensor getaran menggunakan Piezo Transducer

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

Elemen piezo sebenarnya adalah perangkat yang menghasilkan getaran atau osilasi ketika frekuensi diterapkan di terminalnya. Namun piezo yang sama dapat digunakan dalam proses sebaliknya menghasilkan pulsa listrik sebagai respons terhadap getaran yang diterapkan pada tubuhnya. Getaran ini bisa berupa ketukan atau pukulan pada permukaan piezo.

Atur Arduino dan elemen piezo seperti yang diberikan pada 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 100 diperkenalkan hanya untuk memastikan bahwa Arduino hanya merespons getaran asli melalui ketukan, dan bukan getaran kecil lainnya seperti dari suara keras, atau klakson.

Pemilihan pin A5 tidak wajib, Anda dapat memilih input analog lainnya sesuai preferensi Anda dan dengan mencocokkannya di kode 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 ke input motor yang relevan untuk menghasilkan sudut putar atau belok yang akurat dalam rentang 180 derajat pada motor.

Biasanya motor servo memiliki 3 kabel atau input. Kabel positif biasanya berwarna merah, negatif atau kabel ground berwarna hitam, dimana kabel perintah atau kabel sinyal biasanya berwarna putih atau kuning.

Arduino memfasilitasi kontrol motor servo melalui bahasa pendukung bawaan yang membuat pengendalian menjadi sangat nyaman dan ideal untuk motor servo.

Contoh berikut akan menunjukkan kepada kita program pengaturan dasar untuk mengimplementasikan kontrol motor servo melalui Arduino:

Kode diberikan di bawah ini:

#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 memberi tahu kabel servo yang terpasang ke pin apa yang ditetapkan. Yang lainnya adalah kode yang memberikan pin nilai antara 0 dan 180, untuk menentukan sudut rotasi pada servo.

Kesimpulan

Subjek Arduino bisa sangat panjang, dan karena itu di luar cakupan artikel ini. Namun, saya harap tutorial di atas pasti membantu Anda mempelajari dasar-dasar Arduino, dan memahami parameter penting melalui berbagai contoh kode aplikasi.

Semoga informasi lebih lanjut dapat diperbarui dari waktu ke waktu di sini, kapan pun tersedia.

Sementara itu, nikmati kursus pemrograman Anda, Selamat Arduinoing untuk Anda !!