famosa studio arduino starter kit manual-v1.0
DESCRIPTION
MANUAL STARTER KIT FAMOSATRANSCRIPT
Famosa Studio Arduino Starter Kit - V1.0
Tutorial dibawah ini adalah dokumen versi PDF dari tutorial untuk Starter Kit yang sudah kami
sediakan di halaman blog dari Famosa Studio di blog.famosastudio.com
Semua tutorial mengenai Starter Kit dapat dilihat pada link ini: Starter Kit
Mudah-mudahan tutorial yang kami sediakan ini dapat membantu anda dalam menguasai
penggunaan board Arduino dan cara pemrogramannya. Apabila ada hal-hal yang kurang
berkenan dapat disampai kepada kami melalui email: [email protected]. Semua
masukan anda akan kami pergunakan untuk terus melakukan perbaikan dalam memberikan
pelayan yang terbaik bagi semua pelanggan Toko Online Famosa Studio
http://www.famosastudio.com.
Daftar Isi 1. Memulai Menggunakan Arduino dengan Windows ................................................................................. 2
2. Tutorial Breadboard untuk Arduino .......................................................................................................... 6
3. Tutorial Singkat Bahasa Pemrograman Arduino ..................................................................................... 11
4. Tutorial Arduino - Blinking LED ............................................................................................................... 15
5. Tutorial Arduino - Multiple LEDs ............................................................................................................. 20
6. Tutorial Arduino – Servo ......................................................................................................................... 27
7. Tutorial Arduino – Buzzer ....................................................................................................................... 32
8. Tutorial Arduino - Push Buttons .............................................................................................................. 36
9. Tutorial Arduino - Potentiometers .......................................................................................................... 44
1. Memulai Menggunakan Arduino dengan
Windows
Posting ini disadur dari "Getting Started w/ Arduino on Windows"
Dokumen ini akan menjelaskan bagaimana caranya menghubungkan board Arduino dengan komputer
dan meng-upload program (sketch) pertama anda.
1. Dapatkan board Arduino dan kabel USB
Pada tutorial ini, kami mengasumsikan anda menggunakan sebuah Arduino Uno, Arduino Duemilanove,
Nano atau Diecimila.
Anda juga membutuhkan sebuah kabel USB standar (A - B), sama dengan kabel yang anda gunakan untuk
printer USB.
Anda bisa mendapatkan board Arduino Uno di Famosa Studio.
2. Download Software Arduino
Dapatkan versi terakhir dari halaman download Arduino.
Setelah download selesai, ekstrak file yang telah di-download tadi. Pastikan anda tidak merubah struktur
folder. Klik dua kali pada folder untuk membukanya. Terdapat beberapa file dan sub-folder di dalamnya.
3. Hubungkan Board
Arduino Uno, Mega, Deumilanove dan Arduino Nano akan menarik sumber daya dari port USB atau
power supply eksternal.
Hubungkan board Arduino dengan komputer menggunakan kabel USB. LED berwarna hijau
(berlabel PWR) akan hidup.
4. Instalasi Drivers
Instalasi driver untuk Arduino Uno dengan Windows 7, Vista atau XP:
Hubungkan board anda dan tunggu Windows untuk memulai proses instalasi driver. Setelah
beberapa saat, proses ini akan gagal, walaupun sudah melakukan yang terbaik.
Klik pada Start Menu dan buka Control Panel
Di dalam Control Panel, masuk ke menu System and Security. Kemudian klik pada System.
Setelah tampilan System muncul, buka Device Manager.
Lihat pada bagian Ports (COM & LPT). Anda akan melihat sebuah port terbuka dengan nama
"Arduino Uno (COMxx)"
Klik kanan pada port "Arduino Uno (COMxx)" dan pilih opsi "Update Driver Software".
Kemudian, pilih opsi "Browse my computer for Driver software".
Terakhir, masuk dan pilih file driver Uno, dengan nama "ArduinoUNO.inf", terletak di dalam
folder "Drivers" pada Software Arduino yang telah di-download tadi.
Windows akan meneruskan instalasi driver.
Instalasi driver untuk Arduino Duemilanove, Nano atau Diecimila dengan Windows 7,
Vista dan XP:
Ketika anda menghubungkan board, Windows seharusnya memulai proses instalasi driver (ini apabila
anda belum pernah menggunakan komputer tersebut dengan board Arduino sebelumnya).
Pada Windows Vista, driver akan otomatis di-download dan diinstalasi.
Pada Windows XP, wizard Add New Hardware akan muncul:
Ketika ditanya Can Windows connect to Windows Update to search for
software? pilih No, not this time. Klik next.
Pilih Install from a list or specific location (Advanced) dan klik next.
Pastikan bahwa Search for the best driver in these location dicentang; Seach removable
media jangan dicentang;Include this location in the search dicentang dan masuk ke
direktori drivers/FTDI USB Drivers pada folder software Arduino. (Versi terakhir dari driver
ini dapat ditemukan pada situs FTDI). Klik next.
Wizard akan mencari driver dan kemudian memberitahu bahwa sebuah "USB Serial Converter"
telah ditemukan. Klik finish.
Wizard hardware baru akan muncul kembali. Ulangi langkah yang sama seperti sebelumnya
dengan pilihan yang sama dan lokasi folder yang sama. Kali ini sebuah " USB Port Serial" akan
ditemukan.
Anda dapat memastikan apakah driver sudah ter-install dengan membuka Windows Device Manager (di
tab Hardware pada Control Panel - System). Cari "USB Serial Port" pada bagian Ports, itulah board
Arduino.
5. Jalankan Aplikasi Arduino
Klik dua kali pada aplikasi Arduino (arduino.exe).
6. Buka contoh Blink
Buka contoh program LED Blink: File > Examples > 1.Basics > Blink.
7. Pilih board anda
Anda perlu memilih opsi pada menu Tools > Board yang sesuai dengan board Arduino yang dipakai.
8. Pilih serial port anda
Pilih port serial yang digunakan oleh board Arduino anda pada menu Tools > Serial Port. Biasanya ini
adalah COM3 atau yang lebih tinggi (COM1 dan COM2 biasanya sudah direservasi untuk serial port
hardware). Untuk mencari tahu, anda dapat melepaskan koneksi ke board Arduino dan buka kembali
menu tadi; pilihan yang menghilang harusnya adalah board Arduino anda. Koneksikan kembali board-
nya dan pilih serial port yang sesuai.
9. Upload program
Nah, sekarang hanya tinggal klik tombol "Upload" pada software. Tunggu beberapa saat - anda dapat
melihat led TX dan RX pada board berkelap-kelip. Bila upload berhasil akan ada pesan "Done uploading."
yang muncul pada status bar.
Beberapa saat setelah upload selesai, anda dapat melihat pin 13 (L) LED pada board mulai berkelap-kelip
(warna oranye). Jika benar, selamat! Anda sudah berhasil menjalankan Arduino dan program-nya dengan
sukses.
2. Tutorial Breadboard untuk Arduino
Apa itu breadboard?
Breadboard adalah board yang digunakan untuk membuat rangkaian elektronik sementara dengan tujuan
uji coba atau prototipe tanpa harus menyolder. Dengan memanfaatkan breadboard, komponen-
komponen elektronik yang dipakai tidak akan rusak dan dapat digunakan kembali untuk membuat
rangkaian yang lain. Breadboard umumnya terbuat dari plastik dengan banyak lubang-lubang diatasnya.
Lubang-lubang pada breadboard diatur sedemikian rupa membentuk pola sesuai dengan pola jaringan
koneksi di dalamnya.
Breadboard yang tersedia di pasaran umumnya terbagi atas 3 ukuran: mini breadboard, medium
breadboard atau large breadboard. Mini breadboard memiliki 170 titik koneksi (bisa juga lebih).
Kemudian medium breaboard memiliki 400 titik koneksi. Dan large breadboard memiliki 830 titik
koneksi.
Mini Breadboard dan Layout Koneksi
Perhatikan gambar diatas, sebuah mini breadboard dengan 200 titik koneksi. Pada bagian kanan dapat
dilihat pola layout koneksi yang digambar dengan garis berwarna biru. Pada breadboard tersebut dapat
dilihat penulisan huruf A, B, C, D, E, F, G, H, I dan J. Kemudian ada angka 1, 5, 10, 15 dan 20. Huruf dan
angka ini membentuk semacam koordinat. A1, B1, C1, D1 dan E1 saling berhubungan sesuai pola
koneksinya (lihat kembali garis berwarna biru). Begitu juga A2 --> E2, A3 --> E3, F1 --> J1, F2 --> J2 dan
seterusnya. Dengan memahami pola koneksi ini kita sudah bisa memakai breadboard untuk keperluan
prototipe rangkaian sehingga dapat menempatkan komponen elektronik secara tepat sesuai gambar
rangkaian yang dimaksud.
Medium Breadboard dengan 400 titik
Layout Koneksi Medium Breadboard
Gambar diatas adalah medium breadboard dengan 400 titik koneksi. Medium breadboard ini biasa juga
disebut half (setengah) breadboard. Karena ukurannya kurang lebih setengah dari ukuran large / full
breadboard dengan 830 titik koneksi.
Setelah mengetahui dasar-dasar tentang breadboard, kita coba menggunakannya dengan Arduino.
Rangkaian dasar yang biasa dipakai untuk belajar Arduino adalah Blinking LED.
Skema rangkaian untuk Blinking LED
Setelah kita mengetahui rangkaian apa yang akan dibuat, selanjutnya adalah penerapannya
menggunakan breadboard dan Arduino.
Blinking LED menggunakan Arduino
Gambar diatas adalah simulasi rangkaian Blinking LED dengan memakai software Fritzing. Berikut
adalah gambar asli dari rangkaian tersebut menggunakan Arduino Starter Kit.
Blinking LED menggunakan Arduino Starter Kit
Bagaimana, mudah bukan?
Nah berikut ini kami tampilkan schematic untuk motor driver menggunakan IC L293D (Quadruple Half-
H Drivers).
Motor Driver dengan L293D
Simulasi rangkaian pada breadboard menggunakan Fritzing untuk motor driver tersebut dapat dilihat
pada gambar dibawah ini.
Simulasi Motor Driver dengan L293D pada breadboard
Demikianlah tutorial singkat mengenai penggunaan breadboard bersama dengan Arduino. Semoga
tutorial ini ada manfaatnya. Selamat mencoba :)
3. Tutorial Singkat Bahasa Pemrograman Arduino
Arduino menggunakan pemrograman dengan bahasa C. Berikut ini adalah sedikit penjelasan yang
ditujukan kepada anda yang hanya mempunyai sedikit pengalaman pemrograman dan membutuhkan
penjelasan singkat mengenai karakter bahasa C dan software Arduino. Untuk penjelasan yang lebih
mendalam, web Arduino.cc adalah sumber yang lengkap.
Struktur
Setiap program Arduino (biasa disebut sketch) mempunyai dua buah fungsi yang harus ada.
void setup( ) { }
o Semua kode didalam kurung kurawal akan dijalankan hanya satu kali ketika program
Arduino dijalankan untuk pertama kalinya.
void loop( ) { }
o Fungsi ini akan dijalankan setelah setup (fungsi void setup) selesai. Setelah dijalankan
satu kali fungsi ini akan dijalankan lagi, dan lagi secara terus menerus sampai catu daya
(power) dilepaskan.
Syntax
Berikut ini adalah elemen bahasa C yang dibutuhkan untuk format penulisan.
//(komentar satu baris)
o Kadang diperlukan untuk memberi catatan pada diri sendiri apa arti dari kode-kode yang
dituliskan. Cukup menuliskan dua buah garis miring dan apapun yang kita ketikkan
dibelakangnya akan diabaikan oleh program.
/* */(komentar banyak baris)
o Jika anda punya banyak catatan, maka hal itu dapat dituliskan pada beberapa baris
sebagai komentar. Semua hal yang terletak di antara dua simbol tersebut akan diabaikan
oleh program.
{ }(kurung kurawal)
o Digunakan untuk mendefinisikan kapan blok program mulai dan berakhir (digunakan
juga pada fungsi dan pengulangan).
;(titk koma)
o Setiap baris kode harus diakhiri dengan tanda titik koma (jika ada titik koma yang hilang
maka program tidak akan bisa dijalankan).
Variabel
Sebuah program secara garis besar dapat didefinisikan sebagai instruksi untuk memindahkan angka
dengan cara yang cerdas. Variabel inilah yang digunakan untuk memindahkannya.
int (integer)
o Digunakan untuk menyimpan angka dalam 2 byte (16 bit). Tidak mempunyai angka
desimal dan menyimpan nilai dari -32,768 dan 32,767.
long (long)
o Digunakan ketika integer tidak mencukupi lagi. Memakai 4 byte (32 bit) dari memori
(RAM) dan mempunyai rentang dari -2,147,483,648 dan 2,147,483,647.
boolean (boolean)
o Variabel sederhana yang digunakan untuk menyimpan nilai TRUE (benar)
atau FALSE (salah). Sangat berguna karena hanya menggunakan 1 bit dari RAM.
float (float)
o Digunakan untuk angka desimal (floating point). Memakai 4 byte (32 bit) dari RAM dan
mempunyai rentang dari -3.4028235E+38 dan 3.4028235E+38.
char (character)
o Menyimpan 1 karakter menggunakan kode ASCII (misalnya 'A' = 65). Hanya memakai 1
byte (8 bit) dari RAM.
Operator Matematika
Operator yang digunakan untuk memanipulasi angka (bekerja seperti matematika yang sederhana).
=
o Membuat sesuatu menjadi sama dengan nilai yang lain (misalnya: x = 10 * 2, x sekarang
sama dengan 20).
%
o Menghasilkan sisa dari hasil pembagian suatu angka dengan angka yang lain (misalnya:
12 % 10, ini akan menghasilkan angka 2).
+
o Penjumlahan
-
o Pengurangan
*
o Perkalian
/
o Pembagian
Operator Pembanding
Digunakan untuk membandingkan nilai logika.
==
o Sama dengan (misalnya: 12 == 10 adalah FALSE (salah) atau 12 == 12 adalah TRUE
(benar))
!=
o Tidak sama dengan (misalnya: 12 != 10 adalah TRUE (benar) atau 12 != 12 adalah FALSE
(salah))
<
o Lebih kecil dari (misalnya: 12 < 10 adalah FALSE (salah) atau 12 < 12 adalah FALSE
(salah) atau 12 < 14 adalah TRUE (benar))
>
o Lebih besar dari (misalnya: 12 > 10 adalah TRUE (benar) atau 12 > 12 adalah FALSE
(salah) atau 12 > 14 adalah FALSE (salah))
Struktur Pengaturan
Program sangat tergantung pada pengaturan apa yang akan dijalankan berikutnya, berikut ini adalah
elemen dasar pengaturan (banyak lagi yang lain dan bisa dicari di internet).
1. if..else, dengan format seperti berikut ini:
if (kondisi) { }
else if (kondisi) { }
else { }
Dengan struktur seperti diatas program akan menjalankan kode yang ada di dalam kurung kurawal jika
kondisinya TRUE, dan jika tidak (FALSE) maka akan diperiksa apakah kondisi pada else if dan jika
kondisinya FALSE maka kode pada else yang akan dijalankan.
2. for, dengan format seperti berikut ini:
for (int i = 0; i < #pengulangan; i++) { }
Digunakan bila anda ingin melakukan pengulangan kode di dalam kurung kurawal beberapa kali, ganti
#pengulangan dengan jumlah pengulangan yang diinginkan. Melakukan penghitungan ke atas
dengan i++ atau ke bawah dengan i--.
Digital
1. pinMode(pin, mode)
Digunakan untuk menetapkan mode dari suatu pin, pin adalah nomor pin yang akan digunakan dari 0-19
(pin analog 0-5 adalah 14-19). Mode yang bisa digunakan adalah INPUT atau OUTPUT.
2. digitalWrite(pin, value)
Ketika sebuah pin ditetapkan sebagai OUTPUT, pin tersebut dapat dijadikan HIGH (ditarik menjadi 5
volts) atau LOW(diturunkan menjadi ground).
3. digitalRead(pin)
Ketika sebuah pin ditetapkan sebagai INPUT maka anda dapat menggunakan kode ini untuk
mendapatkan nilai pin tersebut apakah HIGH (ditarik menjadi 5 volts) atau LOW (diturunkan menjadi
ground).
Analog
Arduino adalah mesin digital tetapi mempunyai kemampuan untuk beroperasi di dalam alam analog
(menggunakan trik). Berikut ini cara untuk menghadapi hal yang bukan digital.
1. analogWrite(pin, value)
Beberapa pin pada Arduino mendukung PWM (pulse width modulation) yaitu pin 3, 5, 6, 9, 10, 11. Ini
dapat merubah pin hidup (on)atau mati (off) dengan sangat cepat sehingga membuatnya dapat berfungsi
layaknya keluaran analog. Value (nilai) pada format kode tersebut adalah angka antara 0 ( 0% duty cycle
~ 0V) dan 255 (100% duty cycle ~ 5V).
2. analogRead(pin)
Ketika pin analog ditetapkan sebagai INPUT anda dapat membaca keluaran voltase-nya. Keluarannya
berupa angka antara 0 (untuk 0 volts) dan 1024 (untuk 5 volts).
Demikianlah tutorial singkat mengenai bahasa pemrograman pada Arduino. Selamat mencoba!
4. Tutorial Arduino - Blinking LED
Setelah pada tutorial sebelumnya dijelaskan secara singkat tentang bahasa pemrograman Arduino, maka
sekarang kita coba penerapannya. Pada pelajaran pertama pemrograman dengan bahasa apapun (html,
php, dll) biasanya kita kenal program "Hello world". Nah pada Arduino, program "Hello world" ini adalah
"Blinking LED".
Ide Dasar
LED (light emitting diode) adalah komponen dasar yang sering digunakan pada rangkaian elektronik.
Karena bentuknya berupa lampu kecil maka kita dapat segera dapat melihat hasil program kita secara
visual. LED pada program kali ini akan dibuat menjadi berkelap-kelip (blinking) dengan durasi waktu
yang tertentu dan dilakukan berulang terus menerus.
Untuk memulai, segera siapkan komponen yang dibutuhkan seperti tertera di bawah ini dan pasang pada
breadboard. Setelah semua komponen terpasang maka kita akan meng-upload programnya. Hubungkan
Arduino anda ke komputer dengan kabel USB. Kemudian pilih port yang sesuai pada software Arduino di
menu Tools > Serial Port > COMXX (sesuai dengan comm port Arduino anda). Lalu upload program
tersebut dengan menggunakan menu File > Upload I/O Board (ctrl+U). Lihat hasilnya!
Rangkaian
Komponen yang diperlukan:
1 buah LED
1 buah resistor 330 ohm
Kabel jumper
Skema rangkaian dapat dilihat pada gambar berikut:
Skema rangkaian untuk Blinking LED
Berikut ini adalah gambar simulasi penempatan komponen pada breadboard dan board Arduino. Gambar
simulasi ini menggunakan software Fritzing yang bisa didapat di sini.
Blinking LED using Arduino
Kode Pemrograman
Di bawah ini adalah kode pemrograman yang digunakan untuk blinking LED. Tidak perlu mengetiknya
karena sudah tersedia pada software Arduino. Klik menu File > Examples > 1.Basic > Blink.
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
This example code is in the public domain.
*/
void setup() {
// initialize the digital pin as an output.
// Pin 13 has an LED connected on most Arduino boards:
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH); // set the LED on
delay(1000); // wait for a second
digitalWrite(13, LOW); // set the LED off
delay(1000); // wait for a second
}
Membuat Perubahan
Bila tidak terdapat kesalahan, maka rangkaian anda akan berupa LED yang berkelap-kelip dengan durasi
hidup 1 detik dan mati 1 detik yang dilakukan berulang-ulang. Sudah puas? Hehehe rasanya pasti belum.
Bagaimana kalau kita melakukan beberapa perubahan pada program agar kita dapat lebih memahami
cara kerjanya.
Beberapa perubahan yang bisa kita lakukan, antara lain:
Mengganti pin
Pada program diatas, LED kita terhubung pada pin 13, tetapi kita bisa menggunakan pin Arduino yang
lain. Untuk menggantinya, ambil kabel jumper yang terpasang pada pin 13 dan pindahkan pada pin lain
sesuai yang anda inginkan (dari 0-13) (anda juga bisa menggunakan pin analog 0-5, pin 0 analog adalah
pin 14, dst).
Kemudian rubah baris kode program, ganti angka 13 dengan pin baru yang sudah dipilih.
Lalu upload sketch-nya (ctrl+U)
Merubah durasi kelap-kelip
Kalau anda kurang puas dengan kelap-kelip berdurasi 1 detik, berikut caranya:
Rubah baris kode program:
digitalWrite(13, HIGH);
delay(durasi hidup); // (detik * 1000)
digitalWrite(13, LOW);
delay(durasi mati); // (detik * 1000)
Ganti durasi hidup/mati dengan durasi yang anda inginkan. Misalnya untuk 5 detik, tuliskan angka 5000
(5 * 1000).
Merubah cerahnya LED (brightness)
Selain pengaturan digital yang hidup atau mati, Arduino dapat juga melakukan pengaturan beberapa pin
digital seperti layaknya analog yang akan kita gunakan untuk mengatur cerahnya LED. Untuk
mencobanya, lakukan langkah berikut ini:
Rubah pin LED menjadi pin 9 (jangan lupa rubah juga kabel jumpernya). Rubah baris kode program,
ganti 13 menjadi angka 9.
Rubah kode dalam { } pada bagian loop() dengan kode berikut:
void loop() {
analogWrite(9,angka baru);
}
angka baru = angka antara 0 - 255. 0 = mati, 255 = hidup, angka diantaranya = perbedaan tingkat
kecerahan
Fading
Kita akan menggunakan contoh program Fading yang sudah disediakan oleh software Arduino.
Menu: File > Examples > 3.Analog > Fading. Program ini akan mengatur memudarnya LED dari
mati ke hidup dan sebaliknya.
/*
Fade
This example shows how to fade an LED on pin 9
using the analogWrite() function.
This example code is in the public domain.
*/
int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by
void setup() {
// declare pin 9 to be an output:
pinMode(9, OUTPUT);
}
void loop() {
// set the brightness of pin 9:
analogWrite(9, brightness);
// change the brightness for next time through the loop:
brightness = brightness + fadeAmount;
// reverse the direction of the fading at the ends of the fade:
if (brightness == 0 || brightness == 255) {
fadeAmount = -fadeAmount ;
}
// wait for 30 milliseconds to see the dimming effect
delay(30);
}
Kemudian upload program dan lihat hasilnya!
Baiklah itu tutorial Arduino kita kali ini. Selamat mencoba!
5. Tutorial Arduino - Multiple LEDs
Ide Dasar
Kalau pada tutorial sebelumnya kita sudah bisa membuat 1 buah LED berkelap-kelip, maka pada tutorial
kali ini kita akan menggunakan banyak LED. Kita akan menggunakan 8 buah LED. Tutorial kali ini akan
memberikan kesempatan pada anda untuk ber-eksperimen menulis kode pemrograman untuk Arduino.
Catatan: Tutorial dan kode yang digunakan di sini disadur dari kode yang tercantum pada link
berikut: http://ardx.org/CODE02
Sejalan dengan pengaturan LED kita akan mencoba untuk membuat kode pemrograman lebih sederhana
dengan beberapa metode.
for () loops - digunakan ketika kita ingin menjalankan sejumlah baris kode berulang-ulang.
arrays[] - digunakan untuk mengatur penggunaan variabel dengan lebih mudah (array = grup dari
variabel).
Rangkaian
Komponen yang diperlukan:
8 buah LED
8 buah resistor 330 ohm
Kabel jumper
Skema rangkaian dapat dilihat pada gambar berikut:
Skema rangkaian untuk banyak LED
Berikut ini adalah gambar simulasi penempatan komponen pada breadboard dan board Arduino. Gambar
simulasi ini menggunakan software Fritzing yang bisa didapat di sini.
Multiple LEDs using Arduino
Kode Pemrograman
Di bawah ini adalah kode pemrograman yang digunakan untuk Multiple LED.
//LED Pin Variables
int ledPins[] = {2,3,4,5,6,7,8,9}; //An array to hold the pin each LED is connected to
//i.e. LED #0 is connected to pin 2, LED #1, 3 and so on
//to address an array use ledPins[0] this would equal 2
//and ledPins[7] would equal 9
/*
* setup() - this function runs once when you turn your Arduino on
* We the three control pins to outputs
*/
void setup()
{
//Set each pin connected to an LED to output mode (pulling high (on) or low (off)
for(int i = 0; i < 8; i++){ //this is a loop and will repeat eight times
pinMode(ledPins[i],OUTPUT); //we use this to set each LED pin to output
} //the code this replaces is below
/* (commented code will not run)
* these are the lines replaced by the for loop above they do exactly the
* same thing the one above just uses less typing
pinMode(ledPins[0],OUTPUT);
pinMode(ledPins[1],OUTPUT);
pinMode(ledPins[2],OUTPUT);
pinMode(ledPins[3],OUTPUT);
pinMode(ledPins[4],OUTPUT);
pinMode(ledPins[5],OUTPUT);
pinMode(ledPins[6],OUTPUT);
pinMode(ledPins[7],OUTPUT);
(end of commented code)*/
}
/*
* loop() - this function will start after setup finishes and then repeat
* we call a function called oneAfterAnother(). if you would like a different behaviour
* uncomment (delete the two slashes) one of the other lines
*/
void loop() // run over and over again
{
oneAfterAnotherNoLoop(); //this will turn on each LED one by one then turn each off
//oneAfterAnotherLoop(); //does the same as oneAfterAnotherNoLoop but with
//much less typing
//oneOnAtATime(); //this will turn one LED on then turn the next one
//on turning the
//former off (one LED will look like it is scrolling
//along the line
//inAndOut(); //lights the two middle LEDs then moves them out then back
//in again
}
/*
* oneAfterAnotherNoLoop() - Will light one LED then delay for delayTime then light
* the next LED until all LEDs are on it will then turn them off one after another
*
* this does it without using a loop which makes for a lot of typing.
* oneOnAtATimeLoop() does exactly the same thing with less typing
*/
void oneAfterAnotherNoLoop(){
int delayTime = 100; //the time (in milliseconds) to pause between LEDs
//make smaller for quicker switching and larger for slower
digitalWrite(ledPins[0], HIGH); //Turns on LED #0 (connected to pin 2 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[1], HIGH); //Turns on LED #1 (connected to pin 3 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[2], HIGH); //Turns on LED #2 (connected to pin 4 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[3], HIGH); //Turns on LED #3 (connected to pin 5 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[4], HIGH); //Turns on LED #4 (connected to pin 6 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[5], HIGH); //Turns on LED #5 (connected to pin 7 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[6], HIGH); //Turns on LED #6 (connected to pin 8 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[7], HIGH); //Turns on LED #7 (connected to pin 9 )
delay(delayTime); //waits delayTime milliseconds
//Turns Each LED Off
digitalWrite(ledPins[7], LOW); //Turns on LED #0 (connected to pin 2 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[6], LOW); //Turns on LED #1 (connected to pin 3 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[5], LOW); //Turns on LED #2 (connected to pin 4 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[4], LOW); //Turns on LED #3 (connected to pin 5 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[3], LOW); //Turns on LED #4 (connected to pin 6 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[2], LOW); //Turns on LED #5 (connected to pin 7 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[1], LOW); //Turns on LED #6 (connected to pin 8 )
delay(delayTime); //waits delayTime milliseconds
digitalWrite(ledPins[0], LOW); //Turns on LED #7 (connected to pin 9 )
delay(delayTime); //waits delayTime milliseconds
}
/*
* oneAfterAnotherLoop() - Will light one LED then delay for delayTime then light
* the next LED until all LEDs are on it will then turn them off one after another
*
* this does it using a loop which makes for a lot less typing.
* than oneOnAtATimeNoLoop() does exactly the same thing with less typing
*/
void oneAfterAnotherLoop(){
int delayTime = 100; //the time (in milliseconds) to pause between LEDs
//make smaller for quicker switching and larger for slower
//Turn Each LED on one after another
for(int i = 0; i <= 7; i++){
digitalWrite(ledPins[i], HIGH); //Turns on LED #i each time this runs i
delay(delayTime); //gets one added to it so this will repeat
} //8 times the first time i will = 0 the final
//time i will equal 7;
//Turn Each LED off one after another
for(int i = 7; i >= 0; i--){ //same as above but rather than starting at 0 and counting up
//we start at seven and count down
digitalWrite(ledPins[i], LOW); //Turns off LED #i each time this runs i
delay(delayTime); //gets one subtracted from it so this will repeat
} //8 times the first time i will = 7 the final
//time it will equal 0
}
/*
* oneOnAtATime() - Will light one LED then the next turning off all the others
*/
void oneOnAtATime(){
int delayTime = 100; //the time (in milliseconds) to pause between LEDs
//make smaller for quicker switching and larger for slower
for(int i = 0; i <= 7; i++){
int offLED = i - 1; //Calculate which LED was turned on last time through
if(i == 0) { //for i = 1 to 7 this is i minus 1 (i.e. if i = 2 we will
offLED = 7; //turn on LED 2 and off LED 1)
} //however if i = 0 we don't want to turn of led -1 (doesn't exist)
//instead we turn off LED 7, (looping around)
digitalWrite(ledPins[i], HIGH); //turn on LED #i
digitalWrite(ledPins[offLED], LOW); //turn off the LED we turned on last time
delay(delayTime);
}
}
/*
* inAndOut() - This will turn on the two middle LEDs then the next two out
* making an in and out look
*/
void inAndOut(){
int delayTime = 100; //the time (in milliseconds) to pause between LEDs
//make smaller for quicker switching and larger for slower
//runs the LEDs out from the middle
for(int i = 0; i <= 3; i++){
int offLED = i - 1; //Calculate which LED was turned on last time through
if(i == 0) { //for i = 1 to 7 this is i minus 1 (i.e. if i = 2 we will
offLED = 3; //turn on LED 2 and off LED 1)
} //however if i = 0 we don't want to turn of led -1 (doesn't exist)
//instead we turn off LED 7, (looping around)
int onLED1 = 3 - i; //this is the first LED to go on ie. LED #3 when i = 0 and LED
//#0 when i = 3
int onLED2 = 4 + i; //this is the first LED to go on ie. LED #4 when i = 0 and LED
//#7 when i = 3
int offLED1 = 3 - offLED; //turns off the LED we turned on last time
int offLED2 = 4 + offLED; //turns off the LED we turned on last time
digitalWrite(ledPins[onLED1], HIGH);
digitalWrite(ledPins[onLED2], HIGH);
digitalWrite(ledPins[offLED1], LOW);
digitalWrite(ledPins[offLED2], LOW);
delay(delayTime);
}
//runs the LEDs into the middle
for(int i = 3; i >= 0; i--){
int offLED = i + 1; //Calculate which LED was turned on last time through
if(i == 3) { //for i = 1 to 7 this is i minus 1 (i.e. if i = 2 we will
offLED = 0; //turn on LED 2 and off LED 1)
} //however if i = 0 we don't want to turn of led -1 (doesn't exist)
//instead we turn off LED 7, (looping around)
int onLED1 = 3 - i; //this is the first LED to go on ie. LED #3 when i = 0 and LED
//#0 when i = 3
int onLED2 = 4 + i; //this is the first LED to go on ie. LED #4 when i = 0 and LED
//#7 when i = 3
int offLED1 = 3 - offLED; //turns off the LED we turned on last time
int offLED2 = 4 + offLED; //turns off the LED we turned on last time
digitalWrite(ledPins[onLED1], HIGH);
digitalWrite(ledPins[onLED2], HIGH);
digitalWrite(ledPins[offLED1], LOW);
digitalWrite(ledPins[offLED2], LOW);
delay(delayTime);
}
}
Melakukan Perubahan
Menggunakan loop
Perhatikan kode pada baris void loop(), di dalamnya terdapat 4 baris kode. 3 baris kode dimulai dengan
karakter //. Ini artinya baris kode tersebut dianggap sebagai komentar (comment) dan tidak akan
dijalakan oleh program. Untuk merubah program agar menjalankan baris kedua, rubah kode program
menjadi seperti berikut ini:
void loop() // run over and over again
{
//oneAfterAnotherNoLoop(); //this will turn on each LED one by one then turn each off
oneAfterAnotherLoop(); //does the same as oneAfterAnotherNoLoop but with
//much less typing
//oneOnAtATime(); //this will turn one LED on then turn the next one
//on turning the
//former off (one LED will look like it is scrolling
//along the line
//inAndOut(); //lights the two middle LEDs then moves them out then back
//in again
}
Upload program-nya dan perhatikan bahwa tidak terdapat perubahan. Kalau anda perhatikan kedua
fungsi tersebut, masing-masing melakukan hal yang sama, tetapi dengan pendekatan yang berbeda
(fungsi kedua menggunakan loop).
Animasi yang lain
Bosan dengan animasi yang sekarang sedang berjalan? Cobalah 2 contoh animasi yang lain. Hilangkan //
pada baris fungsi yang ke 3, kemudian upload program-nya. Maka animasi LED yang berbeda akan kita
lihat. Ulangi hal yang sama pada baris ke 4.
Buat animasi sendiri
Masukkan perubahan sesuai imaginasi anda untuk mendapatkan kreasi animasi anda sendiri. Hal utama
yang perlu diperhatikan adalah menghidupkan LED dengan kode digitalWrite(pinNumber,
HIGH); dan mematikan LED dengan kode digitalWrite(pinNumber, LOW);.
Jangan khawatir, pengetikkan kode program yang salah tidak akan mengakibatkan kerusakan.
Selamat mencoba dan berkreasi!
6. Tutorial Arduino – Servo
Ide Dasar
Kali ini kita akan mencoba untuk menggunakan servo dengan Arduino. Servo yang akan digunakan
adalah servo mikro yang banyak dijual pada toko hobi atau bisa juga di sini.
Di dalam servo terdapat gearbox yang kecil (untuk membuat gerakan yang lebih bertenaga) dan
rangkaian elektronik (untuk memudahkan pengaturan). Sebuah servo standard dapat diatur posisinya
dari 0 sampai dengan 180 derajat. Pengaturan posisi diatur menggunakan timed pulse, antara
1.25 milliseconds (0 derajat) dan 1.75 milliseconds (180 derajat) 1.5 milliseconds untuk 90 derajat).
Waktu yang digunakan ini bervariasi dari tiap manufaktur servo. Apabila pulse yang digunakan dikirim
setiap 25-50 milliseconds maka servo akan bergerak dengan sangat halus. Salah satu kelebihan Arduino
adalah disediakannya software library yang memungkinkan untuk menggerakkan beberapa servo dengan
kode yang sederhana.
Rangkaian
Komponen yang diperlukan:
1 buah servo mikro
Kabel jumper
Skema rangkaian dapat dilihat pada gambar berikut:
Skema rangkaian Servo dengan Arduino
Berikut ini adalah gambar simulasi penempatan komponen dan board Arduino. Gambar simulasi ini
menggunakan software Fritzing yang bisa didapat di sini.
Servo connection using Arduino
Kode Pemrograman
Di bawah ini adalah kode pemrograman yang digunakan untuk menggerakkan servo. Tidak perlu
mengetiknya karena sudah tersedia pada software Arduino. Klik menu File > Examples > Servo >
Sweep.
// Sweep
// by BARRAGAN <http://barraganstudio.com>
// This example code is in the public domain.
#include <Servo.h>
Servo myservo; // create servo object to control a servo
// a maximum of eight servo objects can be created
int pos = 0; // variable to store the servo position
void setup()
{
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}
void loop()
{
for(pos = 0; pos < 180; pos += 1) // goes from 0 degrees to 180 degrees
{ // in steps of 1 degree
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
for(pos = 180; pos>=1; pos-=1) // goes from 180 degrees to 0 degrees
{
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
}
Membuat Perubahan
Membuat timing sendiri
Menggunakan library servo yang sudah disediakan oleh Arduino memang sangat memudahkan untuk
menggerakkan servo. Tetapi kadang kita perlu mengetahui cara memprogram sesuatu secara mandiri.
Contoh dibawah ini adalah cara mengaturpulse yang digunakan untuk menggerakkan servo secara
langsung (tanpa library servo). Dengan cara ini kita dapat menggerakkan servo pada 20 pin yang tersedia
pada Arduino (pin digital & analog). Tetapi anda perlu merubah beberapa baris kode agar dapat
mengoptimalkan hasilnya. Berikut ini adalah kode dasar yang akan dipergunakan.
int servoPin = 9;
int pulseTime;
void setup()
{
Serial.begin(9600);
pinMode(servoPin,OUTPUT);
}
void loop()
{
pulseTime = 2100; //(the number of microseconds
//to pause for (1500 90 degrees
// 900 0 degrees 2100 180 degrees)
digitalWrite(servoPin, HIGH);
delayMicroseconds(pulseTime);
digitalWrite(servoPin, LOW);
delay(25);
}
Upload dan coba lihat hasilnya. Servo akan bergerak ke arah 180 derajat. Timing 2100 microseconds akan
membuat servo bergerak ke arah 180 derajat. Tapi seperti sudah diutarakan pada awal tutorial ini, timing
tiap servo berbeda antara manufaktur. Jadi anda harus menemukan timing yang sesuai untuk servo yang
anda gunakan karena bisa jadi timing 2100 microseconds belum membuat servo bergerak mencapai 180
derajat. Untuk mencoba menemukan timing yang sesuai dengan servo yang anda pakai, gunakan kode
program dibawah ini yang merupakan variasi dari kode sebelumnya.
int servoPin = 9;
int pulseTime;
void setup()
{
Serial.begin(9600);
pinMode(servoPin,OUTPUT);
}
void loop()
{
for(pulseTime = 900; pulseTime <= 2100; pulseTime += 50) {
Serial.println(pulseTime);
digitalWrite(servoPin, HIGH);
delayMicroseconds(pulseTime);
digitalWrite(servoPin, LOW);
delay(25);
}
for(pulseTime = 2100; pulseTime >= 900; pulseTime -= 50) {
Serial.println(pulseTime);
digitalWrite(servoPin, HIGH);
delayMicroseconds(pulseTime);
digitalWrite(servoPin, LOW);
delay(25);
}
}
Upload dan coba lihat kembali hasilnya. Servo akan bergerak ke 180 derajat dan 0 derajat berulang-ulang
seperti pada program Sweep tadi. Tetapi hasilnya mungkin kurang maksimal, sudut 180 derajat dan 0
derajat-nya masih belum maksimal. Artinya servo sebenarnya belum menyentuh sudut 180 derajat atau 0
derajat. Coba rubah angka pada pulseTime, untuk yg 900 coba diperkecil dan untuk yang 2100 coba
diperbesar. Anda harus menemukan angka pulseTime yang pada angka tersebut servo sudah pada posisi
maksimumnya (servo tidak bergerak lagi, mencapai sudut 180/0 derajat). Pada mikro servo yang saya
gunakan, kebetulan angkanya ditemukan pada posisi 600 dan 2650, sehingga programnya menjadi
seperti ini.
int servoPin = 9;
int pulseTime;
void setup()
{
Serial.begin(9600);
pinMode(servoPin,OUTPUT);
}
void loop()
{
for(pulseTime = 600; pulseTime <= 2650; pulseTime += 50) {
Serial.println(pulseTime);
digitalWrite(servoPin, HIGH);
delayMicroseconds(pulseTime);
digitalWrite(servoPin, LOW);
delay(25);
}
for(pulseTime = 2650; pulseTime >= 600; pulseTime -= 50) {
Serial.println(pulseTime);
digitalWrite(servoPin, HIGH);
delayMicroseconds(pulseTime);
digitalWrite(servoPin, LOW);
delay(25);
}
}
Silahkan bereksperimen sampai menemukan angka yang sesuai. Agar mempermudah melihat angka
pulseTime, coba gunakan Serial Monitor (Menu: Tools > Serial Monitor). Seperti terlihat pada
tampilan berikut ini. Dan agar angka pulseTime yang digunakan tidak bergerak terlalu cepat, ganti
kode delay(25); menjadi delay(500);.
Tampilan Serial Monitor pada saat program dijalankan
Setelah anda mengerti dan memahami cara menggerakkan servo menggunakan Arduino, cobalah
praktekkan untuk menggerakkan sesuatu, misalnya menggerakkan kepala dari mainan boneka yang
sudah tidak dipergunakan lagi. Atau gunakan untuk membuka atau menutup sesuatu. Gunakan daya
kreasi anda!
Selamat bereksperimen!
7. Tutorial Arduino – Buzzer
Ide Dasar
Setelah dengan tutorial sebelumnya kita sudah mencoba mengatur LED dan servo, kali ini kita coba
untuk mengontrol suara. Suara adalah fenomena analog, bagaimana caranya Arduino menanganinya?
Sekali lagi kita akan meniru perilaku analog menggunakan Arduino dengan kecepatannya yang luar biasa.
Untuk ini kita akan menghubungkan buzzer/piezo elements ke salah satu pin digital Arduino. Sebuah
buzzer akan menghasilkan suara ketukan setiap kali dialiri gelombang (pulse) arus listrik. Jika kita
menggunakan gelombang arus listrik dengan frekuensi yang tepat (misalnya 440 kali per detik untuk
menghasilkan nada A) maka suara ketukan secara bersama-sama ini akan menghasil nada musik. Mari
kita coba bereksperimen dan mebuat Arduino menyanyikan lagu "Twinkle Twinkle Little Star".
Catatan: Ide tutorial dan kode yang digunakan didapat dari link berikut: http://ardx.org/CODE06.
Rangkaian
Komponen yang diperlukan:
1 buah buzzer
Kabel jumper
Skema rangkaian dapat dilihat pada gambar berikut:
Skema rangkaian untuk Buzzer dan Arduino
Berikut ini adalah gambar simulasi penempatan komponen pada breadboard dan board Arduino. Gambar
simulasi ini menggunakan software Fritzing yang bisa didapat di sini.
Buzzer using Arduino
Pada saat menempatkan buzzer, perhatikan polaritas-nya (tanda +) jangan terbalik. Kaki dengan tanda +
dihubungkan dengan pin 9 Arduino.
Kode Pemrograman
Di bawah ini adalah kode pemrograman yang digunakan untuk Buzzer.
/* Melody
* (cleft) 2005 D. Cuartielles for K3
*
* This example uses a piezo speaker to play melodies. It sends
* a square wave of the appropriate frequency to the piezo, generating
* the corresponding tone.
*
* The calculation of the tones is made following the mathematical
* operation:
*
* timeHigh = period / 2 = 1 / (2 * toneFrequency)
*
* where the different tones are described as in the table:
*
* note frequency period timeHigh
* c 261 Hz 3830 1915
* d 294 Hz 3400 1700
* e 329 Hz 3038 1519
* f 349 Hz 2864 1432
* g 392 Hz 2550 1275
* a 440 Hz 2272 1136
* b 493 Hz 2028 1014
* C 523 Hz 1912 956
*
* http://www.arduino.cc/en/Tutorial/Melody
*/
int speakerPin = 9;
int length = 15; // the number of notes
char notes[] = "ccggaagffeeddc "; // a space represents a rest
int beats[] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 };
int tempo = 300;
void playTone(int tone, int duration) {
for (long i = 0; i < duration * 1000L; i += tone * 2) {
digitalWrite(speakerPin, HIGH);
delayMicroseconds(tone);
digitalWrite(speakerPin, LOW);
delayMicroseconds(tone);
}
}
void playNote(char note, int duration) {
char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };
// play the tone corresponding to the note name
for (int i = 0; i < 8; i++) {
if (names[i] == note) {
playTone(tones[i], duration);
}
}
}
void setup() {
pinMode(speakerPin, OUTPUT);
}
void loop() {
for (int i = 0; i < length; i++) {
if (notes[i] == ' ') {
delay(beats[i] * tempo); // rest
} else {
playNote(notes[i], beats[i] * tempo);
}
// pause between notes
delay(tempo / 2);
}
}
Melakukan Perubahan
Bermain dengan tempo
Waktu pada tiap nada didasarkan pada beberapa variabel, sehingga kita dapat merubah suara tiap nada
atau tempo-nya. Untuk merubah tempo nada kita dapat merubah satu baris. int tempo = 300; ---> int
tempo = angka baru; Merubah angka baru dengan nilai yang lebih besar akan melambatkan tempo
atau dengan nilai lebih kecil untuk mempercepatnya.
Menyesuaikan nada
Kalau anda rasa nadanya masih kurang tepat, hal ini dapat diperbaiki. Nada yang dipergunakan pada
program ini telah diperhitungkan sesuai dengan catatan pada bagian atas kode pemrograman tadi. Untuk
menyesuaikan nada, sesuaikan nilai pada array tones [] ke atas atau ke bawah sampai nadanya dirasa
sudah sesuai. Tiap nada dicocokkan dengan nama yang terdapat pada array names [], misalnya c =
1915.
char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };
Membuat melodi sendiri
Kode program di atas diset untuk memainkan lagu "Twinkle Twinkle Little Star", namun dengan cara
pemrograman yang telah dibuat dimungkinkan untuk merubah lagu dengan cukup mudah. Tiap lagu
didefinisikan dengan sebuah int dan dua array, int length menentukan jumlah
nada, array pertama notes [] mendefinisikan nada, dan yang kedua beats [] menentukan berapa lama
nada itu dimainkan.
Seperti contoh ini:
Twinkle Twinkle Little Star
int length = 15;
char notes [] = {"ccggaagffeeddc "};
int beats [] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 };
Happy Birthday (baris pertama)
int length = 13;
char notes [] = {"ccdcfeccdcgf "};
int beats [] = { 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 4 };
Silahkan mencoba membuat lagu yang lain!
8. Tutorial Arduino - Push Buttons
Ide Dasar
Tutorial Arduino terakhir yang kita posting adalah tutorial menggunakan buzzer, yang bisa dilihat di sini.
Tutorial tersebut menjelaskan bagaimana membuat 'musik' dengan Arduino. Posting-posting tutorial
sebelumnya lebih mengutamakan dalam menghasilkan keluaran (output), jadi posting kali ini akan
membuat Arduino untuk menerima masukan (input). Arduino akan 'mendengarkan', 'melihat' dan
'merasakan'.
Kita akan mulai dengan tombol (push buttons) yang sederhana. Koneksi untuk penggunaan tombol juga
sangat mudah. Ada tambahan komponen yaitu resistor, yang bisa berfungsi sebagai pull-up atau pull-
down, tergantung penempatannya. Kenapa diperlukan resistor? Karena Arduino berbeda dengan kita
yang tahu kapan tombol ditekan atau tidak. Arduino 'merasakan' bahwa tombol ditekan atau tidak dari
arus yang melewatinya, apakah HIGH atau LOW.
Ada dua skenario penggunaan tombol yang akan kita bahas. Pertama, ketika tombol ditekan pin Arduino
akan menjadi LOW dan menjadi HIGH kalau dilepas. Skenario yang kedua adalah ketika tombol ditekan,
pin Arduino akan menjadi HIGH dan LOW kalau tombol dilepas.
Rangkaian
Komponen yang diperlukan:
2 buah push button
2 buah resistor 10K ohm
1 buah resistor 330 ohm
1 buah LED
Kabel jumper
Untuk skenario pertama, berarti pin Arduino akan dihubungkan dengan GND (ground) melalui tombol.
Ketika tombol ditekan, pin akan menjadi LOW, tetapi pada saat dilepas maka kondisi pin akan
mengambang (float) (hal ini kadang bisa menimbulkan kesalahan). Nah di sini fungsi resistor akan
menjadi hal yang penting. Resistor akan dipasangkan antara pin Arduino dan +5V, sehingga ketika
tombol dilepas maka pin akan terhubung dengan +5V melalui resistor dan pin menjadi HIGH. Ini yang
dinamakan resistor menjadi pull-up, karena resistor menarik pin ke atas pada +5V. Oh ya, kita memakai
resistor dengan nilai 10K ohm. Perhatikan pada skematik berikut.
Skema rangkaian push button dengan pull-up resistor
Pada skenario kedua, pin Arduino akan dihubungkan dengan dengan +5V melalui tombol. Ketika tombol
ditekan, pin akan menjadi HIGH dan agar pada saat dilepas pin menjadi LOW kita gunakan resistor 10K
ohm. Resistor seperti ini dinamakan pull-down, karena resistor menarik pin ke bawah pada GND
(ground). Perhatikan juga skematik berikut.
Skema rangkaian push button dengan pull-down resistor
Berikut ini adalah gambar simulasi penempatan komponen pada breadboard dan board Arduino. Gambar
simulasi ini menggunakan software Fritzing yang bisa didapat di sini.
Push buttor for Arduino - Pull-up Resistor
Push button for Arduino - Pull-down Resistor
Kode Pemrograman
Di bawah ini adalah kode pemrograman yang digunakan untuk push button. Tidak perlu mengetiknya
karena sudah tersedia pada software Arduino. Klik menu File > Examples > 2.Digital > Button.
/*
Button
Turns on and off a light emitting diode(LED) connected to digital
pin 13, when pressing a pushbutton attached to pin 2.
The circuit:
* LED attached from pin 13 to ground
* pushbutton attached to pin 2 from +5V
* 10K resistor attached to pin 2 from ground
* Note: on most Arduinos there is already an LED on the board
attached to pin 13.
created 2005
by DojoDave <http://www.0j0.org>
modified 28 Oct 2010
by Tom Igoe
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/Button
*/
// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 13; // the number of the LED pin
// variables will change:
int buttonState = 0; // variable for reading the pushbutton status
void setup() {
// initialize the LED pin as an output:
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
}
void loop(){
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);
// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (buttonState == HIGH) {
// turn LED on:
digitalWrite(ledPin, HIGH);
}
else {
// turn LED off:
digitalWrite(ledPin, LOW);
}
}
Program di atas dapat berfungsi untuk 2 skenario kita tadi.
Membuat Perubahan
Mungkin ada yang merasa kalau contoh di atas terlalu gampang. Ok, kita akan melakukan beberapa
perubahan:
1 tombol untuk On dan 1 lagi tombol untuk Off
Kita akan membuat perubahan sehingga On dan Off dari LED ditentukan dari 1 buah tombol, 1
menghidupkan dan 1 lagi untuk mematikan.
Ok, kita pilih rangkaian push button dengan pull-up resistor. Tambahkan rangkaian untuk tombol kedua
dengan kondisi yang sama pada breadboard anda. Bedanya tombol kedua ini menggunaan pin 3 dari
Arduino. Bagaimana, bisa kan? Hasilnya kurang lebih seperti ini.
2 Push buttons for Arduino - Pull-up Resistors
Kemudian rubah kode programnya menjadi seperti ini:
const int buttonPin1 = 2; // the number of the pushbutton pin
const int buttonPin2 = 3; // the number of the pushbutton pin
const int ledPin = 13; // the number of the LED pin
// variables will change:
int buttonState = 0; // variable for reading the pushbutton status
void setup() {
// initialize the LED pin as an output:
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin1, INPUT);
pinMode(buttonPin2, INPUT);
}
void loop(){
// read the state of the pushbutton value:
if (digitalRead(buttonPin1) == LOW) {
digitalWrite(ledPin, LOW); //turn LED off
} else if (digitalRead(buttonPin2) == LOW) {
digitalWrite(ledPin, HIGH); //turn LED on
}
}
Upload programnya dan mulailah mencoba tombol On dan tombol Off-nya. Seru kan! Nah coba sekarang
gunakan rangkaian push button dengan pull-down resistor. Tambahkan tombol kedua dan sesuaikan
programnya, kemudian upload dan lihat hasilnya.
Fading naik dan turun
Kita akan gunakan tombol untuk mengatur sinyal analog dan melakukan pengaturan LED agar memudar
(fading) naik atau turun sesuai tombol yang ditekan. Rubah kabel jumper untuk LED yang tadinya di pin
13 menjadi pin 9. Rubah juga di kode program: const int ledPin = 13; --> const int ledPin = 9;
Kemudian rubah kode program pada bagian loop() menjadi:
[cc lang="c" escaped="true" first_line="8"]int value = 0;
void loop(){
if (digitalRead(inputPin1) == LOW) {
value--;
} else if (digitalRead(inputPin2) == LOW) {
value++; }
value = constrain(value, 0, 255);
analogWrite(ledPin, value);
delay(10);
}[/cc]
Merubah kecepatan fading
Jika anda ingin agar LED memudar (fading) lebih cepat atau lebih lambat, hanya perlu merubah kode 1
baris saja:
delay(10); --> delay(nilai baru);
Agar memudar lebih cepat, ganti nilai baru dengan angka yang lebih kecil, untuk memudar lebih lambat,
ganti nilai baru dengan angka yan glebih besar.
Baiklah, itu tadi tutorial Arduino mengenai push button atau tombol. Semoga bermanfaat dan selamat
mencoba!
9. Tutorial Arduino - Potentiometers
Ide Dasar
Pada Tutorial Arduino - Push Buttons, kita belajar menggunakan Arduino untuk membaca input. Tutorial
kali ini akan menjelaskan cara membaca input dari pin analog Arduino. Arduino mempunya 6 pin analog
yang dapat membaca input berupa voltase (dari 0 sampai 5 volts) dan mengkonversikannya ke angka
digital antara 0 (0 volts) dan 1024 (5 volts), yaitu pembacaaan dengan resolusi 10 bit. Salah satu
komponen yang dapat mengeksploitasi tegangan input ini adalah potentiometer atau biasa disebut juga
variable resistor. Potentiometer yang terhubung dengan tegangan 5 volts akan memberikan keluaran
tegangan antara 0 dan 5 volts pada pin bagian tengahnya, tergantung pada sudut diputarnya
potentiometer tersebut. Kita kemudian dapat menggunakan tegangan keluaran ini sebagai sebuah
variabel di dalam program kita.
Rangkaian
Komponen yang diperlukan:
1 buah potentiometer 10K ohm
1 buah resistor 330 ohm
1 buah LED
Kabel jumper
Skema rangkaian dapat dilihat pada gambar berikut:
Skema rangkaian potentiometer dengan Arduino
Berikut ini adalah gambar simulasi penempatan komponen pada breadboard dan board Arduino. Gambar
simulasi ini menggunakan software Fritzing yang bisa didapat di sini.
Potentiometer for Arduino
Kode Pemrograman
Di bawah ini adalah kode pemrograman yang digunakan untuk potentiometer. Tidak perlu mengetiknya
karena sudah tersedia pada software Arduino. Klik menu File > Examples > 3.Analog >
AnalogInput.
/*
Analog Input
Demonstrates analog input by reading an analog sensor on analog pin 0 and
turning on and off a light emitting diode(LED) connected to digital pin 13.
The amount of time the LED will be on and off depends on
the value obtained by analogRead().
The circuit:
* Potentiometer attached to analog input 0
* center pin of the potentiometer to the analog pin
* one side pin (either one) to ground
* the other side pin to +5V
* LED anode (long leg) attached to digital output 13
* LED cathode (short leg) attached to ground
* Note: because most Arduinos have a built-in LED attached
to pin 13 on the board, the LED is optional.
Created by David Cuartielles
Modified 4 Sep 2010
By Tom Igoe
This example code is in the public domain.
http://arduino.cc/en/Tutorial/AnalogInput
*/
int sensorPin = A0; // select the input pin for the potentiometer
int ledPin = 13; // select the pin for the LED
int sensorValue = 0; // variable to store the value coming from the sensor
void setup() {
// declare the ledPin as an OUTPUT:
pinMode(ledPin, OUTPUT);
}
void loop() {
// read the value from the sensor:
sensorValue = analogRead(sensorPin);
// turn the ledPin on
digitalWrite(ledPin, HIGH);
// stop the program for <sensorValue> milliseconds:
delay(sensorValue);
// turn the ledPin off:
digitalWrite(ledPin, LOW);
// stop the program for for <sensorValue> milliseconds:
delay(sensorValue);
}
Membuat Perubahan
Beberapa perubahan yang dapat kita lakukan pada program di atas:
Memicu keluaran pada saat ambang batas terlewati
Kadang kita agar program kita dapat memicu suatu keluaran pada saat nilai masukan melewati suatu
ambang batas yang telah kita tentukan sebelumnya. Untuk melakukan ini dengan potentiometer, rubah
kode pada loop () menjadi seperti berikut:
void loop() {
int threshold = 512;
if(analogRead(sensorPin) > threshold) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
}
Perubahan pada seperti kode di atas akan menyebabkan LED hidup apabila nilai masukan dari
potentiometer melewati 512, kira-kira pertengahan antara nilai minimum dan maksimum. Anda dapat
merubah sensitivitas dengan merubah nilai ambang batas yang dipakai.
Fading
Tingkat kecerahan dari LED dapat dikendalikan langsung dari potentiometer. Untuk melakukan hal ini,
pertama kita harus merubah pin yang terhubung pada LED. Pindahkan kabel jumper yang terhubung
pada pin 13 ke pin 9, rubah juga pada baris kode-nya.
int ledPin = 13; ----> int ledPin = 9;
Kemudian rubah kode pada loop () menjadi seperti berikut:
void loop() {
int value = analogRead(sensorPin) / 4;
analogWrite(ledPin, value);
}
Upload kode setelah dirubah dan perhatikan bahwa LED akan berubah tingkat kecerahannya sesuai
perubahan pada putaran potentiometer.
Catatan: Kita membagi nilai masukan dari pin sensor dengan 4 karena fungsi analogRead()
menghasilkan nilai dari 0 sampai 1024 (10 bit), sedangkan fungsi analogWrite() menerima nilai dari 0
sampai 255 (8 bit).
Mengendalikan Servo
Berikut ini adalah contoh aplikasi yang cukup menarik tentang memakai beberapa komponen secara
bersamaan. Hubungkan servo mikro dengan Arduino seperti yang telah dijelaskan pada tutorial dengan
servo di sini. Kemudian buka program Knob (File > Examples > Servo > Knob).
Upload kode dan perhatikan servo mikro yang sekarang akan ikut berputar ketika potentiometer diputar.
Hmm...tambah seru nih tutorialnya. Selamat mencoba dan berkreasi!