DRAFT

MODUL PEMROGRAMAN DASAR

ARDUINO
MATA KULIAH MEKATRONIKA

JURUSAN TEKNIK MESIN

FAKULTAS TEKNOLOGI INDUSTRI
INSTITUT TEKNOLOGI SEPULUH NOPEMBER
SURABAYA 2016
 DAFTAR ISI

DAFTAR ISI...................................................................................................1
1. PENDAHULUAN.......................................................................................2
A. Tujuan Praktikum..................................................................................2
B. Dasar Teori..........................................................................................2
1) Perangkat Keras Arduino..............................................................2
2) Perangkat Lunak Arduino...............................................................4
3) Pemrograman Arduino..................................................................5
C. Tugas Awal..........................................................................................7
2. PRAKTIKUM..............................................................................................8
A. Alat dan bahan....................................................................................8
B. Hello Computer.................................................................................8
C. Hello World Berulang......................................................................10
D. Konstanta dan Keluaran Digital.....................................................11
E. Variabel dan Masukan Digital.........................................................13
F. Tipe Data dan Operator..................................................................15
G. Pengulangan...................................................................................17
H. Pencabangan..................................................................................19
I. Fungsi..............................................................................................20
J. Pemilihan.........................................................................................22
K. Array.................................................................................................23
3. Referensi............................................................................................25

Modul Praktikum Pemrograman Arduino 1

 1. PENDAHULUAN

A. Tujuan Praktikum
Pada praktikum ini anda diminta untuk dapat menguasai beberapa
kompetensi khusus yang berhubungan dengan mikroprosesor berbasis
Arduino. Beberapa kompetensi khusus tersebut antara lain,
Mengenal arsitektur perangkat keras Arduino.
Mampu melakukan pemrograman mikroprosesor Arduino dengan
memanfaatkan fungsi- fungsi standar bahasa pemrograman C.
Melakukan proses debuging (metode yang dilakukan programmer
untuk melakukan analisa dan evaluasi) terhadap program arduino
yang telah dirancang

B. Dasar Teori
Arduino merupakan suatu projek open-source yang diinisiasi oleh
Massimo Banzi, David Cuartielles, David Mellis, dan Nicholas
Zambetti. Arduino terdiri dari dua perangkat, yaitu perangkat keras
(hardware) dan perangkat lunak (software). Sifat open-source ini
memperbolehkan pengguna untuk mengakses informasi sumber seperti
skematik rangkaian listrik untuk perangkat keras dan kode pemrograman
untuk perangkat lunak. Perangkat keras Arduino dapat kita beli dengan
harga yang relatif murah bila dibandingkan dengan development board
sejenis. Selain itu perangkat lunak yang ada dapat kita gunakan secara
gratis dan dapat berjalan di sistem operasi Windows, Linux, maupun
Macintosh.

1) Perangkat Keras Arduino

Hingga saat ini sudah terdapat beberapa jenis perangkat keras
Arduino yang dapat kita pilih sesuai dengan kebutuhan. Perangkat
keras yang digunakan di praktikum ini adalah Arduino Uno atau
Duemilanove, seperti tampak pada Gambar 1.

Modul Praktikum Pemrograman Arduino 2

 Gambar 1. Perangkat Keras Arduino

Inti dari sistem ini adalah mikroprosesor ATMega328, yang

dilengkapi dengan beberapa rangkaian tambahan. Pada diagram blok
Gambar 1, terlihat bahwa Arduino memiliki berbagai fitur berikut:
CPU adalah otak yang menjalankan perangkat lunak.
Ada tiga memori utama yakni:
1. EEPROM (Erasable Programmable Read Only Memory)
sebesar 1KB, digunakan untuk menyimpan firmware
(perangkat lunak paling dasar).
2. FPM (Flash Program Memory) sebesar 32KB, digunakan
untuk menyimpan software yang di-upload ke Arduino,
berupa program dan data-data utama.
3. SRAM (Stack Random Access Memory) sebesar 2KB, adalah
memori untuk stack(data dan informasi pemanggilan
subrutin) selama program berjalan.
Timer, adalah komponen untuk membantu pewaktuan dalam
program, misalnya untuk penundaan (delay) atau interupsi
secara periodik.
Digital Input output, adalah antarmuka dengan sinyal yang
bersifat digital, hanya bisa bernilai HIGH (sekitar 3 5 Volt) atau
LOW (sekitar 0 - 2 Volt). Secara total ada 14 pin DI/O. Yang
istimewa, ke-14 port ini bisa dikonfigurasi untuk berbagai mode:
1. Digital input biasa, misalnya untuk menerima masukan dari
tombol.
2. Digital output biasa, misalnya untuk luaran ke LED.
3. PWM (pulse width modulation) output, adalah luaran
berupa pulsa periodic dengan lebar pulsa yang bisa diatur.
Biasanya ini digunakan untuk luaran motor servo yang bisa
diatur kecepatannya.
4. Int (Interrupt), adalah masukan yang dapat memicu
perubahan jalannya program secara langsung, berguna
untuk masukan yang sifatnya penting dan mendesak,
misalnya sinyal alarm.
5. SI (serial interface), untuk komunikasi serial.
Analog Input, untuk menerima masukan sinyal yang harganya
bisa banyak (antara 0 5 Volt). Ada 6 pin AI, yang bisa
digunakan dalam mode:
1. Analog Input 10 bit, bisa menerima tegangan 0-5 volt dan
akan dikonversi menjadi data digital bernilai 0 1023.
Umumnya digunakan untuk menerima masukan dari
sensor.
Modul Praktikum Pemrograman Arduino 3
 2. Digital input biasa, sama seperti antarmuka DI.
3. SPI (Serial Program Interface), bisa digunakan untuk
komunikasi antar Arduino.
Rekomendasi tegangan masukan: 7-12 Volt
USB (Universal Serial Bus), guna berkomunikasi dengan
komputer, dan juga menerima daya listrik dari komputer.
PSU (Power Suply Unit), dapat menerima catu daya listrik 6
20 Volt, dan akan diregulasi menjadi 5 Volt.

Terlihat bahwa Arduino dapat menggunakan dua macam catu

daya, yaitu: catu daya yang berasal dari kanal USB dan catu daya
eksternal. Ketika anda menghubungkan kabel USB dari komputer ke
Arduino, maka Arduino akan secara otomatis menyerap daya yang
berasal dari kanal USB. Daya dari kanal USB ini sangat terbatas,
hanya mempunyai tegangan 5 volt dan arus maksimal 500 mA. Jika
terjadi kelebihan beban (overload), maka kanal USB akan mengalami
kerusakan. Jika Arduino akan digunakan untuk mengontrol beban
dengan daya yang besar, maka anda wajib menggunakan catu daya
eksternal seperti adaptor. Perangkat keras Arduino sudah
mempunyai regulator tegangan 5 volt, sehingga rekomendasi
tegangan masukan ketika menggunakan catu daya eksternal adalah 7
volt sampai dengan 12 volt.

2) Perangkat Lunak Arduino

Untuk melakukan pemrograman Arduino, ada perangkat lunak
Arduino IDE (integrated development environment) yang mudah
dipakai. Perangkat lunak ini bisa dijalankan disuatu komputer, dengan
sistem operasi Linux, Windows maupun MacOS. Seperti terlihat pada
Gambar 2, program ini cukup sederhana. Ada sebuah editor utama
dimana kita bisa menulis program dalam bahasa Arduino. Di bagian
atas ada baris tombol-tombol menu. Dua yang penting adalah untuk
mengkompilasi program, kemudian meng-upload-nya ke
mikroprosesor. Di bagian bawah, ada jendela hitam yang akan
menampilkan pesan-pesan saat proses kompilasi maupun upload.

Modul Praktikum Pemrograman Arduino 4

 2. Perangkat Lunak Arduino

Paling atas ada baris menu guna mengaktifkan berbagai fitur

layanan dari File hingga Help. Untuk belajar, ada dua menu yang
berguna yaitu:
Menu File > Examples : menyediakan berbagai contoh kode
sumber.
Menu Help > Reference : menampilkan referensi bahasa
Arduino pada suatu web browser.
Selama belajar ini, sangat dianjurkan untuk membuka referensi
ini saat anda bertemu berbagai perintah-perintah baru.

3) Pemrograman Arduino
Ada tiga langkah utama yang dilakukan dalam melakukan
pemrograman mikroprosesor di dalam environment Arduino yaitu,
1. Penulisan kode program
2. Melakukan kompilasi (compilation) pada kode program
yang telah ditulis.
3. Program yang telah dikompilasi akan di-upload ke dalam
mikroprosesor
Dalam menulis program, arduino memakai bahasa C++ yang
telah disederhanakan dan disesuaikan untuk mikroprosesor. Dalam
bahasa C atau C++, program selalu memiliki satu fungsi utama yakni
main(). Demi mempermudah pemrograman mikroprosesor, bahasa
arduino menetapkan adanya dua fungsi utama yaitu loop() dan
setup(). Struktur standar program Arduino ditunjukkan di bawah
ini.

//Struktur Standar Kode Program Arduino

//Nama File: *.pde

// Deklarasi Konstanta

// Deklarasi Variabel Global

void setup(){
Modul Praktikum Pemrograman Arduino 5
 //Inisialisasi Variabel
//Inisialisasi mode pinpin pada mikroprosesor
//Perintah inisialisasi lainnya
}

void loop(){
//Perintah 1
//Perintah 2
}

Gambar 3. Flowchart setup() dan loop()

Diagram alir pada Gambar 3 memperlihatkan bagaimana kedua
fungsi utama tersebut akan dijalankan. Begitu mikroprosesor
dihidupkan (demikian pula saat tombol reset ditekan, atau
program baru di-upload) maka fungsi loop() akan dijalankan sekali
saja, lalu disusul dengan fungsi loop(). Ketika fungsi loop selesai,
maka sistem Arduino akan melakukan pengulangan sehingga fungsi
loop() akan dijalankan kembali. Demikian seterusnya hingga
mikroprosesor di matikan.
Dengan algoritma standar ini, maka fungsi setup() harus
digunakan untuk proses inisialisasi seperti memberi nilai awal pada
variabel global dan mengatur mode perangkat keras. sementara itu
fungsi loop() adalah mengandung perintah-perintah yang memang
akan dijalankan terus menerus sampai mikroprosesor dimatikan.
Setelah kode program selesai ditulis maka kode sumber arduino harus
disimpan menjadi file dengan extensi pde. Langkah selanjutnya, kode
biner harus dikompilasi menjadi kode biner.
Dalam kompilasi ini, kode sumber mungkin mengandung
kesalahan tulis (syntax error). Arduino akan menampilkan kesalahan
Modul Praktikum Pemrograman Arduino 6
 tersebut pada kotak pesan (di bagian bawah). Baca baik-baik pesan
tersebut, lalu benarkan kode sumber, dan kompilasi kembali sampai
sukses.
Setelah kompilasi selesai, maka kode biner dapat diupload ke
mikroprosesor. Untuk itu ada tiga hal yang harus dipastikan, yaitu:
Mikroprosesor Arduino sudah harus terkoneksi ke komputer
melalui jalur USB, dan nampak bahwa lampunya yang merah
menyala.
Pada Arduino IDE, pilih jalur komunikasi serial antara
komputer dengan mikroprosesor dari menu Tools > Serial
Port. Di sistem operasi Linux, untuk arduino dengan tipe
selain Arduino Uno, port serial yang digunakan adalah
/dev/ttyUSB*, sedangkan untuk tipe Arduino Uno port serial
yang digunakan adalah /dev/ttyACM*. Pada sistem operasi
Windows biasanya menggunakan COM*.
Pada Arduino IDE, pilih jenis perangkat keras Arduino yang
sesuai melalui menu Tools > Boards. Pilih sesuai board
yang anda gunakan, Arduino Uno atau Arduino
Duemilanove.

Setelah ketiga hal tersebut siap, maka tinggal klik tombol

upload. Tunggu sejenak hingga pada kotak pesan muncul pesan
bahwa proses upload sudah selesai (done). Sekecap kemudian,
program akan mulai dijalankan di perangkat keras arduino.

C. Tugas Awal
Sebelum mulai praktikum, harap sadari bahwa arduino ini akan
rusak jika penggunaannya salah, dan bila rusak maka regu anda wajib
menggantinya. Karena itu mohon baca dan pahami:
10 Ways to Destroy an Arduino,
http://ruggedcircuits.com/html/ancp01.html

!!!!! PENTING !!!!

Modul Praktikum Pemrograman Arduino 7

Modul Praktikum Pemrograman Arduino 8
 2. PRAKTIKUM

A Alat dan bahan

Pada pelaksanaan praktikum ini, diperlukan alat dan bahan sebagai
berikut:

No Nama Banyak Keterangan

1 Komputer / Laptop 1
2 Arduino 1
3 Kabel USB 1
4 Protoboard 1
5 Push button 2
6 LED 4
7 Resistor 330 Ohm 4
8 Resistor 10K 2

D.Hello Computer
Sebagai langkah pertama untuk memprogram arduino jalankan perintah
berikut ini:
1. Menghidupkan komputer
2. Koneksikan arduino ke komputer dengan kabel USB
3. Pada komputer, jalankan program Arduino. Amati bahwa LED
power pada Arduino akan langsung menyala, karena sudah mendapat
catu daya dari computer.
Setelah itu, coba ketikkan program berikut.

void setup(){
Serial.begin(9600);
delay(10000); // tunda 10 detik
Serial.println(Hello computer);
}
void loop() {} // kosong saja

Kode 1. Dasar komunikasi mikrokontroler Arduino

Program ini berfungsi mengirim data dari arduino ke komputer,
melalui kabel yang sama untuk meng-upload program dari komputer ke
arduino. Setelah selesai diketik, simpan dulu program yang sudah diketik
tadi dengan menekan tombol Save. Kemudian tekan tombol upload
untuk mengkompilasi dan langsung mengupload program. Begitu

Modul Pemrograman Arduino 9

terdengar nada beep (tanda program sudah selesai di-upload), segera
tekan icon Serial Monitor pada perangkat lunak Arduino (cepat, anda
hanya punya 10 detik !) sehingga muncul jendela seperti Gambar 4.
Setelah 10 detik, mestinya jendela tersebut akan menampilkan kalimat
"Hello computer".

Gambar 4. Jendela monitor Serial

Dengan adanya fasilitas komunikasi serial tersebut, Arduino mudah

berbicara ke komputer. Salah satu manfaatnya praktisnya adalah untuk
debugging (mencari kesalahan program). Setelah selesai melihat-lihat
tampilan, jangan lupa menutup layar monitor serial tersebut karena jika
masih terbuka, arduino IDE tak bisa meng-upload program ke
mikroprosesor.

Modul Pemrograman Arduino 10

 E. Hello World Berulang
Pada latihan sebelumnya, tampilan Hello computer hanya terjadi
sekali saja, dan setelah itu tak Arduino akan membisu. Namun
sebenarnya, arduino tidak mati. Dia terus bekerja, hanya saja tak
melakukan apa-apa karena fungsi loop-nya kosong. Sekarang coba ubah
program sebelumnya menjadi seperti berikut. Perhatikan bahwa ada dua
baris perintah yang dipindah dari setup() ke loop(). Jangan lupa
mengubah delay menjadi 1000 mili detik.

void setup(){
Serial.begin(9600);
}

void loop() {
delay(1000); // tunda 1 detik
Serial.println(Hello computer);
}

Kode 2. Dasar komunikasi mikrokontroler Arduino

Upload program tersebut, dan jalankan serial monitor. Amati
keluaran program sekarang, bandingkan dengan sebelumnya. Apa
kesimpulan anda tentang subrutin setup() dan loop() ?

Modul Pemrograman Arduino 11

 F. Konstanta dan Keluaran Digital
Kini kita mencoba antarmuka luaran digital ke rangkaian elektronik.
Salah satu contoh komponen elektronik yang dapat dipasangkan
langsung ke jalur keluaran digital Arduino adalah LED. Susunlah
rangkaian LED pada protoboard seperti tampak pada Gambar 5.

// konstanta
#defne LED0 4
#defne LED1 5
#defne LED2 6
#defne LED2 7

#defne DELAY 1000

void setup()
{
Serial.begin(9600);
pinMode(LED0, OUTPUT);
}
void loop()
{Serial.println(HIGH);
digitalWrite(LED0, HIGH);
delay(DELAY);
Serial.println(LOW);
digitalWrite(LED0, LOW);
delay(DELAY);
}

Gambar 5. Skema Rangkaian LED Kode 3. Program

keluaran digital

Gambar 5. Rangkaian LED

Modul Pemrograman Arduino 12

 Perhatikan polaritas kaki-kaki LED, jangan sampai terbalik.
Hubungkan katoda masing-masing LED ke ground (GND), dan anoda ke
resistor lalu ke pin keluaran digital Arduino yang sesuai (pin nomor 9
hingga 12). Resistor di sini berfungsi sebagai pembatas arus. Dengan
luaran digital dari arduino adalah 5V dan resistor 330 ohm, berapa arus
yang akan mengalir ke LED (asumsi tahanan dalam LED adalah 0) ? Jika
tak ada resistor, berapa arus yang akan mengalir dan apa akibatnya ?
Setelah rangkaian siap, tulislah kode 3 di perangkat lunak Arduino.
Perhatikan pada awal program ada definisi konstanta LED0 sesuai nomor
pin yang digunakan dan DELAY. Hal ini demi memperjelas penulisan
program, dan akan mudah jika kelak harus mengubah koneksi perangkat
keras. Selanjutnya baru tuliskan fungsi setup dan loop dengan perintah-
perintah sesuai dengan cara kerja yang diinginkan. Pada bagian setup,
mula-mula perangkat keras disiapkan dengan perintah pinMode.
Selanjutnya pada bagian loop(), LED bisa dinyalakan/dimatikan dengan
perintah digitalWrite().
Setelah selesai diketik, upload program ke Arduino. Amati peristiwa
yang terjadi pada LED0, kemudian analisa program yang baru saja
dibuat. Coba ubah konstanta DELAY dari 1000 menjadi 250 dan upload
lagi. Perubahan apa yang terjadi di LED0 ?

Tugas 1 :
Buatlah program sehingga ke-empat LED menyala bergantian
dengan selang waktu 250 ms sehingga nampak berjalan. Isi program
kira-kira seperti ini, lengkapi lalu jalankan !

void loop(){
Serial.println("LED0 Nyala");
digitalWrite(LED0,HIGH);
delay(100);
digitalWrite(LED0,LOW);
delay(100);

Serial.println("LED1 Nyala");
digitalWrite(LED1,HIGH);
delay(100);
digitalWrite(LED1,LOW);
delay(100);

// dan seterusnya sampai LED3

........
}
Kode 4: Program Lampu Berjalan
Modul Pemrograman Arduino 13
Modul Pemrograman Arduino 14
 G.Variabel dan Masukan Digital
Pertahankan rangkaian LED gambar 6, tambahkan rangkaian
tombol di protoboard seperti pada Gambar 7. Perhatikan bahwa push
button S1 dipasang dengan menggunakan resistor pull-down sedangkan
push-button S2 dipasang dengan menggunakan resistor pull-up. Coba
analisis, berapa tegangan yang akan masuk ke pin 2 saat tombol S1
terbuka atau tertutup? Demikian pula berapa tegangan pada Pin 3 saat
tombol S2 terbuka atau tertutup?

// konstanta
#defne LED0 4
#defne LED1 5
#defne BUTTON1 2
#defne BUTTON2 3

// variabel
int val1, val2;

void setup(){
pinMode(LED0,OUTPUT);
pinMode(LED1,.....);
pinMode(BUTTON1,INPUT);
pinMode(BUTTON2,.....);
Serial......(9600);
}
Gambar 7. Rangkaian tombol
void loop(){
val1 = digitalRead(BUTTON1);
val2 = ...........(BUTTON2);
digitalWrite(LED0,val1);
............(LED1,val2);
Serial.print(Button1 = );
Serial.println(val1);
Serial.print(Button2 = );
Serial.println(val2);
delay(1000);

Modul Pemrograman Arduino 15

 }

Kode 5. Dasar masukan digital

Kini kita ingin membuat program agar LED0 menyala jika tombol S1
ditekan, demikian pula LED1 menyala jika tombol S2 ditekan. Untuk itu
kita perlu membaca masukan digital dengan perintah digitalRead().
Hasil pembacaan ini harus disimpan, untuk itulah kita perlu variabel.
Tugas 2.
Perhatikan dan ketik kode 2 pada perangkat lunak Arduino,
lengkapi bagian yang masih titik-titik. Setelah siap, upload program
di atas dan jalankan serial monitor. Coba amati kondisi LED-0 pada
saat push button di PIN2 ditekan dan dilepaskan, demikian pula
kondisi LED-1 sesuai penekanan push button di PIN3. Cocokkan
dengan informasi yang nampak diserial monitor. Mestinya, jika
tombol S1 ditekan maka LED0 akan menyala (pull-down), dan
sebaliknya LED1 menyala justru ketika tombol S2 sedang tidak
ditekan (karena pull-up).
 H.Tipe Data dan Operator
Kini kita ingin agar LED0 menyala jika S1 diteken, demikian pula LED1
menyala jika 2 ditekan. Untuk itu, setelah masukan dibaca kita
memerlukan pemrosesan data dulu sebelum dikeluarkan. Coba amati
program berikut:

#defne LED0 9
#defne LED1 10
#defne BUTTON1 2
#defne BUTTON2 3

int val1, val2; // variabel tipe integer boolean

d1, d2; // variabel tipe boolean

void setup(){
pinMode(LED0,OUTPUT);
pinMode(LED1,OUTPUT);
pinMode(BUTTON1,INPUT);
pinMode(BUTTON2,INPUT);
Serial.begin(9600);
}

void loop(){
// Proses input
val1 = digitalRead(BUTTON1);
val2 = digitalRead(BUTTON2);

// Proses pengolahan data

// operator logika, menjadi data bertipe boolean
d1 = (val1 == HIGH);
d2 = (val2 != HIGH);

// Proses output
digitalWrite(LED0,d1);
digitalWrite(LED1,d2);

// Pelaporan
Serial.print("Led0 = ");
Serial.println(d1);
Serial.print("Led1 = ");
Serial.println(d2);
delay(1000);
}

Kode 6. Tipe Data dan Operator

Program tersebut memperlihatkan algoritma umum pengontrolan berbasis
komputer yakni looping terus menerus untuk melakukan:
 1. Pembacaan piranti masukan ke variabel masukan
2. Mengolah variabel masukan menjadi variabel luaran
3. Menulis variabel luaran ke piranti luaran
Dalam rangka tahap 2 inilah, kita harus memperhatikan tipe data dan
operator. Pada contoh, terlihat bahwa variabel masukan (val1, val2)
bertipe int karena begitulah tipe data yang akan dikembalikan oleh fungsi
digitalRead(). Setelah itu, kita perlu mengolahnya dengan aljabar boolean.
Oleh karena itu tipe data int tersebut dioperasikan dengan operator
pembandingan (==, !=) sehingga dapat dimasukkan ke variabel luaran
(d1, d2) yang bertipe boolean. Barulah data tersebut dikeluarkan
menggunakan fungsi digitalWrite().
Cobalah modifikasi program anda sebelumnya menjadi seperti kode
3, lalu jalankan. Apa sekarang LED0 dan LED1 akan menyala sesuai
harapan ?

Tugas 3:
Buatlah program sehingga LED0 hanya akan menyala bila
tombol S1 dan S2 ditekan bersamaan. Petunjuk: olah data dengan
operator logika seperti and (&&), or (||) dan not (!).
 I. Pengulangan
Pada tugas 1 kita telah membuat program lampu berjalan sesuai
Kode 4. Program tersebut akan berjalan dengan benar, namun rasakan
bahwa selama menulis anda harus melakukan salin-tempel, kemudian
mengubah sedikit variabel. Itu membosankan dan rentan salah.
Bayangkan jika ada 100 LED yang harus dijalankan. Rasanya kurang
cerdas kalau kita harus menulis 100 kode yang sama. Untuk itulah bahasa
pemrograman menyediakan jurus pengulangan, yaitu fitur yang
memungkinkan satu blok perintah dilaksanakan berkali-kali sesuai kondisi
tertentu. Arduino menyediakan perintah pengulangan FOR, WHILE dan
DO-WHILE yang sebaiknya digunakan dengan tepat, agar algoritma
menjadi efisien. Untuk menggunakan pengulangan, kita harus bisa
mengamati empat hal:
1. Apa variabel yang berubah (contoh pada tugas 1, variabel nomor
pin).
2. Berapa nilai awalnya (pada contoh adalah LED0 = 9).
3. Berapa besar perubahannya (pada contoh adalah 1).
4. Berapa nilai akhirnya (pada contoh adalah LED3 = 12).
Bila hal-hal tersebut telah ditentukan, maka kita bisa menulis program
lebih ringkas sebagai berikut:

// konstanta
#defne LED0 4
#defne LED3 7

// contoh setup dengan pengulangan

void setup() {
int pin; // variabel yang akan berubah
for (pin=LED0; // nilai awal
pin <= LED3; // syarat terus, sesuai nilai akhir
pin++) // perubahan
{
pinMode(pin,OUTPUT); // bagian yang diulang
}
Serial.begin(9600);
}

// nyala dari LED0 hingga LED3 dengan pengulangan

void loop(){
int pin; // variabel yang akan berubah
for(pin=LED0; // nilai awal
pin <= LED3; // syarat terus, sesuai nilai akhir
pin++) // perubahan
 {
// blok perintah yang diulang
Serial.print("Nyala pin ");
Serial.println(pin);
digitalWrite(pin,HIGH);
delay(DELAY);
digitalWrite(pin,LOW);
}
}

Kode 7. Program lampu berjalan pakai pengulangan

Tugas 4:
Modifikasilah kode 7 sehingga LED menyala dari LED3 ke LED0
(terbalik arah dari contoh kode 7) dengan metode pengulangan.
 J. Pencabangan
Kini kita akan membuat program LED berjalan yang bisa berbalik
arah, yaitu jika tombol S1 ditekan maka LED menyala berurutan dari
LED0 ke LED3, sedangkan jika tombol S1 dilepas LED menyala dari LED3
ke LED0. Pada masalah ini, program punya dua kemungkinan operasi
dan harus memilih salah satu berdasar satu kondisi tertentu. Untuk itu,
bahasa pemrograman menyediakan fitur pencabangan. Ada dua bentuk
dasar pencabangan yaitu IF dan IFELSE. Berikut ini kerangka
program lampu berjalan dengan konstruksi if - else.
// konstanta
............
#defne DELAY 250

void setup(){
// siapkan mode pin dan serial
pinMode(LED0,OUTPUT);
....................
}

void loop(){
int val1; // variabel
val1 = digitalRead(BUTTON1);
// pencabangan sesuai bacaan tombol
if (val1 == HIGH) {
// nyala dari LED0 hingga LED3
// pakai pengulangan sesuai kode 7
......
}
else {
// nyala dari LED3 hingga LED0
// pakai pengulangan sesuai tugas 4
.......................;
}
// Pelaporan
Serial.print("Button1 = ");
Serial.print(val1);
}

Kode 8. Pencabangan if-else

Tugas 5:
Lengkapi kerangka Kode 8 (dengan memasukkan potongan dari kode
7 dan latihan 4). Setelah diupload dan berjalan, coba tekan
tombol S1, tahan beberapa saat, lalu lepas kembali. Amati
jalannya LED.
 K. Fungsi
Fungsi adalah fitur bahasa pemrograman agar keseluruhan program
menjadi modular, sekaligus bisa lebih singkat. Sejak awal, kita sudah
menggunakan fungsi setup() dan loop(). Selanjutnya kita bisa membuat
fungsi lainnya sesuai keperluan yang akan dipanggil oleh setup() maupun
loop(). Sebagai contoh, ini adalah fungsi untuk lampu berjalan yang
fleksibel bisa dari kiri ke kanan maupun dari kanan ke kiri.
Gambar 6. Rangkaian tombol
// definisi konstanta
....
// fungsi tambahan dengan nama led_run
// tidak mengembalikan apaapa (void) dan menerima 2 parameter
// awal = pin awal yang akan dinyalakan
// akhir = pin akhir yang akan dinyalakan
void led_run(int awal, int akhir){
int delta;
// hitung perubahan
if (awal < akhir)
delta=1;
else
delta=1;
// nyala dari pin1 hingga pin2
for(int pin=awal; // nilai awal
... .. ...........; // syarat terus
pin = pin+delta) // perubahan
{
// blok perintah yang diulang
digitalWrite(pin,HIGH);
delay(DELAY);
digitalWrite(pin,LOW);
}
}
// fungsi utama setup
void setup() {....}

// fungsi utama loop

void loop(){
int val1;
val1 = digitalRead(BUTTON1);
if (val1 == HIGH) {
// nyala dari LED0 hingga LED3, panggil fungsi
led_run(LED0, LED3);
}
 else {
// nyala dari LED3 hingga LED0, panggil fungsi
...................;}
// Pelaporan
Serial.println("Button1 = ");
Serial.println(val1);
}
Kode 9: Program lampu berjalan pakai pengulangan

Tugas 6:
Tentukan syarat terus pada fungsi led_run tersebut, lalu lengkapi
kerangka Kode 9 agar bisa dikompilasi dan di-upload. Setelah itu
coba dengan menekan dan melepas tombol S1.
 L. Pemilihan
Pemilihan adalah fitur yang mirip dengan pencabangan, namun
kondisi pemilihannya bisa banyak. Dalam bahasa arduino, perintah yang
tersedia adalah switch-case. Sebagai contoh, misal kita ingin membuat
lampu LED menyala secara berurut dari mati semua, lalu menyala satu
(LED0 saja), menyala 2 (LED0 dan LED1), demikian seterusnya hingga
menyala semua (LED0 - LED3). Setelah itu semua LED mati dan siklus
berulang. Ini dia contoh programnya:

// definisi konstanta
....
// fungsi led_off, mematikan semua LED pakai pengulangan
void led_off() {
int pin;
for (pin=LED0; ... .. ....; pin++)
{
digitalWrite(pin, LOW);
}
}
// fungsi led_on, dengan satu parameter
// banyak = jumlah LED yang akan dinyalakan
void led_on(int banyak)
switch (banyak) {
case 0 : break; // berhenti
case 4 : digitalWrite(LED3, HIGH); // terus
case 3 : digitalWrite(LED2, ....); // terus
case 2 : digitalWrite(...., ....); // terus
case 1 : .................. .....;
}
}
// fungsi setup
void setup() { .... }
int banyak = 1;
void loop(){
Serial.println("Banyak = ");
Serial.println(banyak);
led_on(banyak);
delay(DELAY);
led_off();
// naikkan banyak, kembali ke 0 setelah mencapai 4
banyak = (banyak + 1) % 5;
}

Kode 10: Program lampu menyala banyak dengan pemilihan

Tugas 7: Lengkapi kerangka Kode 10, lalu jalankan. Amati
nyalanya LED.
 M. Array
Sebagai contoh, kini kita akan membuat program yang bisa
menampilkan deret angka secara berurut, misalkan 13312432. Tiap
angka ditampilkan dengan sejumlah LED yang menyala selama 750 mili
detik, lalu mati selama 250 mili detik. Karena deret angka tersebut tidak
ada aturannya, teknik pengulangan biasa tak bisa digunakan, sehingga
programnya menjadi sebagai berikut:

// definisi konstanta
....
// fungsi led_off dan led_on seperti kode 10
void led_off() {...}
void led_on(int banyak) {...}

// fungsi setup
void setup() {...}

// loop utama menampilkan deretan angka 13312234

void loop(){
// angka ke1
Serial.println("Angka 1");
led_on(1);
delay(750);
led_off();
delay(250);

// angka ke2
Serial.println("Angka 3");
led_on(3);
delay(750);
led_off();
delay(250);

// angka ke3 dan seterusnya

.........
}

Kode 11. LED menyala sesuai deretan angka

Bagaimana supaya program tersebut lebih sederhana? Salah satu
jawabnya adalah memakai array. Fitur ini memungkinkan kita memesan
suatu variabel yang punya banyak elemen, masing-masing elemen bisa
diakses dengan index. Solusi dengan array untuk masalah deret angka
adalah sebagai berikut:
 // definisi konstanta
....

// variabel deret angka pakai array

int deret[] = {1, 3, 3, 1, 2, 2, 3, 4};

// fungsi fungsi
void led_off() {...}
void led_on(int banyak) {...}
void setup() {...}

// loop utama menampilkan array deret

void loop(){
// nilai angka dalam elemen array tidak teratur
// namun index array teratur
// karena itu bisa pakai pengulangan
// variabel pengulangan: index (i)
// nilai awal : 0
// nilai akhir : panjang array 1
// perubahan : 1
for (int i=0; i<deret.length; i++) {
Serial.print("Angka ke");
Serial.println(i);
led_on(deret[i]);
delay(750);
led_off();
delay(250);
}
// delay setelah deret selesai delay(1000);
}

Kode 12: LED menyala sesuai deretan angka dengan teknik array
Wow, jadi sangat sederhana dibanding kode 11 bukan ???

Tugas 8:
Lengkapi kerangka Kode 10 lalu jalankan. Amati apakah LED akan
menyala berturutan sesuai deret yang diharapkan ?
 3. REFERENSI

http://arduino.cc/en/Reference/HomePage
http://arduino.cc/en/Tutorial/HomePage
http://arduino.cc/en/Main/Hardware
http://www.makeuseof.com/tag/10-great-arduino-projects-for-beginners/
http://blog.startingelectronics.com/arduino-projects-for-beginners/