09 - 65151010 - PR Pengenalan Mikrokontroler - Arduino

VEHICLE CONTROL SYSTEM
DASAR SISTEM KONTROL OTOMOTIF
Pengenalan Mikrokontroler (Prakterk)
TUJUAN PEMBELAJARAN :
 Mengenal, mengerti, dan memahami Mikrokontroler.
ALAT BAHAN WAKTU

 AVO Meter  Modul Perangkat Praktikum  Instruksi : jam
 Personal Downloader dan Minimum Sistem  Latihan : jam
Komputer (PC) Mikrokontroler
 Kabel-kabel Penghubung
PERCOBAAN 01 - Menyiapkan kit yang diperlukan untuk memasukkan program ke chip

ATMega328 yang ada pada board UNO
A. Instal software Arduino IDE.

1. Software bisa diunduh dari website https://www.arduino.cc/en/Main/Software atau dari file
yang disiapkan oleh instruktur.
2. Silahkan instal Software Arduino IDE ke komputer anda sesuai paltform yang anda
gunakan. Software Arduino IDE tersedia untuk berbagai platform, seperti windows, Linux,
Mac, dan bahkan Arm. Bukalah software tersebut dan hubungkan board UNO ke komputer
dengan menggunakan kabel USB yang telah disediakan.
3. Pilih Menu “File > Examples > 01.Basics > BareMinimum”
Program Studi : Dikeluarkan oleh : Tanggal :

Halaman :
OTOTRONIK Trigas 26-07-19
Nama : 1-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Pada jendela tersebut anda bisa mengetikkan perintah-perintah yang akan anda upload ke
board UNO.
(Langkah-langkah pada jobseheet ini menggunakan platform windows 7 64 bit. Tampilan
software akan sedikit berbeda jika menggunakan platform yang lain tetapi masih
mempunyai struktur menu yang sama.)
4. Hal yang harus diperhatikan sebelum memulai membuat baris-baris perintah adalah memilih
board yang akan digunakan pada software Arduino IDE dan pada port serial berapa board
tersebut terhubung.
a. Pilih board “Arduino/Geneino Uno” melalui menu Tools > Board: “Arduino/Geneino
Uno” > Arduino/Genuino Uno
b. Pilih port dimana board Uno anda terhubung dengan komputer, melalui menu Tools >
Port > COMxx(Arduino/Genuino Uno)

Halaman :
Nama : 2-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
- Board Uno yang ada pada kit tidak memerlukan driver khusus. Setelah anda
menginstal software Arduino IDE (pada langkah di atas) secara otomatis akan
mendeteksi board saat board dihubungkan ke komputer melalui kabel USB.
- Pemilihan board dan port cukup sekali dilakukan, kecuali anda mengganti board atau
port usb. Software Arduino IDE ini bisa digunakan untuk semua board berbasis
Arduino seperti board Uno, Mega2560, ProMini, Nano, Lilypad, Pro Mikro, dan
board lainnya yang support dengan Arduino.
5. Penjelasan ringkas mengenai fungsi-fungsi pada software Arduino IDE
 Tombol “New” untuk membuat file baru.

 Tombol “Open” untuk membuka file yang telah dibuat dan disimpan sebelumnya.
 Tombol “Save” untuk menyimpan file yang telah dibuat.
 Tombol “Compile” untuk melakukan proses compile. Proses compile ini akan
menterjemahkan perintah-perintah (disebut sketch) yang ditulis pada editor teks
menjadi bahasa yang yang dipahami oleh mesin (*.hex). Pada saat proses compile

Halaman :
Nama : 3-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
dilakukan pemeriksaan terhadap perintah yang anda buat. Jika ada kesalahan, maka
proses compile akan dihentikan dan kesalahan akan ditampilkan.
 Tombol “Upload” untuk melakukan proses upload file *.hex ke board Uno. Kode-kode
perintah (sketch) yang tercompile sebelumnya diterjemahkan ke dalam bahasa mesin
(file *.hex). Dan pada proses upload ini file *.hex tersebut dituliskan ke dalam memori
chip ATMega328 yang terdapat pada board Uno, yang selanjutnya disebut dengan
program atau perintah.
 Setelah proses Upload selesai chip akan terus mengeksekusi program atau perintah
selama ada arus listrik yang diberikan ke dalam board Uno. Meskipun hubungan
dengan komputer diputus dengan melepas kabel usb (terdapat sumber tegangan 5
Volt), program atau perintah tersebut akan terus dijalankan jika board Uno masih
diberi sumber catu daya lain, misal baterai atau sumber arus lainnya.
 Program pada chip ATMega328 akan selalu ada dalam chip tersebut dan akan selalu
dieksekusi selama ada catudaya dalam board Uno. Program akan tergantikan (replace)
jika anda meng-upload sketch (perintah) yang lain.

Halaman :
Nama : 4-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
B. Membuat program (sketch), Meng-compile, Memasukkan program ke chip ATMega328
yang ada pada board Uno
1. Buat program (sketch) sederhana melalui EDITOR pada software “Arduino IDE” – Ikuti
petunjuk pengajar!
Contoh program/sketch TUTORIAL_led_1.ino:

-------------------------------------------------------------------------------------------------------------------------------------
/*
Pinout pada shield :
D4 -> Led Merah
D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/
#define pinLed 4 //definisikan pinLed adalah 4, led merah ada pada D4
void setup()
{
pinMode(pinLed, OUTPUT); //set menjadi output
}
void loop()
{
digitalWrite(pinLed, HIGH); //menyalakan led (memberi tegangan 5V)
delay(1000); //jeda waktu 1 detik, akan tetap menyala selama 1 detik
digitalWrite(pinLed, LOW); //mematikan led (memberi tegangan 0V)
delay(1000); //jeda waktu 1 detik, akan tetap mati selama 1 detik
}
-------------------------------------------------------------------------------------------------------------------------------------
Penjelasan program/sketch:
Pada sketch tersebut, dapat dilihat ada 4 bagian besar. Bagian awal adalah bagian comment,
yang diawali dengan /* dan diakhiri dengan */
Setiap bagian baris program yang di apit oleh /* dan */ tidak akan di eksekusi, sehingga
bisa kita gunakan untuk menulis komentar atau petunjuk untuk program tersebut, misal
dalam contoh di atas adalah:
/*
Pinout pada shield :
D4 -> Led Merah
D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/
Bagian kedua adalah area sebelum void setup(). Di area ini biasa digunakan untuk
menyimpan parameter atau variabel yang di definisikan di muka. Misal dalam contoh diatas:
#define pinLed 4 //definisikan pinLed adalah 4, led merah ada pada D4

Halaman :
Nama : 5-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
kita mendefinisikan kata pinLed adalah 4, sehingga setiap kata pinLed yang ada dalam
program akan diartikan sebagai 4. Kalimat setelah tanda // juga adalah comment, yang
tidak akan dieksekusi.
Bagian selanjutnya adalah bagian setup(). Bagian ini adalah bagian yang wajib dalam
setiap program/sketch Arduino. Ada 2 bagian wajib, bagian setup() dan bagian loop().
Kedua bagian tersebut harus ada, walaupun misalnya tidak diisi apapun.
Bagian setup() adalah bagian yang akan di eksekusi sekali saja setiap kali board Arduino
di nyalakan, sedangkan pada bagian loop() akan selalu di-eksekusi ber ulang-ulang
setelah bagian setup() selesai dikerjakan.
void setup()
{
}
Dalam bagian setup() tersebut, hanya terdapat 1 perintah yaitu pinMode. Perintah
pinMode adalah perintah untuk memberitahukan mikrokontroller bahwa pin I/O yang
bersangkutan akan diperlakukan sebagai input atau sebagai output. Pada contoh diatas kita
akan membuat pin 4 (dimana kutub positif led merah terhubung ke pin digital 4 dan kutub
negatif ke ground) menjadi output, karena kita akan memberikan tegangan ke pin tersebut,
bukan menangkap nilai tegangan, sehingga perintah nya adalah pinMode(4, OUTPUT);
Syntax perintah pinMode adalah :
pinMode(pin,value)
dimana pin adalah nomer pin yang akan digunakan, value adalah sebagai INPUT atau
OUTPUT.
Karena kita telah mendefinisikan kata pinLed adalah 4, sehingga kita bisa juga menulis
menjadi
Mengapa menggunakan #define ? Hal ini biasa digunakan dalam pemrograman untuk
mempermudah penulisan, dan terutama untuk mempermudah dalam trial and error dan
debugging. Perhatikan program diatas, jika semua kata pinLed diganti dengan 4, maka
program akan tetap berjalan dengan benar. Namun jika anda akan mengganti pin, misalnya
akan menyalakan led kuning yang terhubung ke pin 7, akan lebih mudah mengganti 1 baris

Halaman :
Nama : 6-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
saja yaitu #define pinLed 7 daripada mengganti baris berisi angka 4 menjadi 7.
Bagian selanjutnya adalah bagian loop(). Bagian ini akan selalu dieksekusi ber ulang-
ulang dari atas kebawah dan keatas lagi, seterus nya hingga terjadi reset atau restart. Mari
kita bahas isi dari bagian loop().
Baris pertama dalam bagian loop adalah
Baris tersebut berisi perintah digitalWrite(), yang syntax nya adalah :
digitalWrite(pin,value);
dimana pin adalah nomer pin yang akan digunakan, dan value adalah HIGH atau LOW
Ketika kita memberikan nilai HIGH, maka pada pin tersebut akan mengalir tegangan 5V.
Ketika kita beri nilai LOW, maka pada pin tersebut akan memiliki teganan 0V, atau
terhubung dengan GND (ground).
Perintah digitalWrite(pinLed, HIGH); berarti memerintahkan untuk mengalirkan 5V

ke pinLed atau pin digital 4 dalam hal ini (karena pinLed adalah sama dengan 4 yang kita
definisikan sebelumnya). Karena pin 4 terhubung ke kutub positif led merah dan kutub
negatifnya terhubung ke GND, maka led merah akan menyala. Sampai baris ini kita baru
sampai ke memerintahkan led merah di pin 4 menyala, dan led akan menyala.
Baris berikutnya adalah delay(1000);.
Pada baris ini mikrokontroller akan menunggu selama 1000 mili detik atau 1 detik, sehingga
perintah sebelum nya yaitu yang menyalakan led merah akan tampak tetap menyala selama
1 detik, karena mikrokontroller sedang ‘sibuk’ mengerjakan perintah delay(1000);
sebelum mengerjakan baris berikut nya. Setelah 1000 milli seconds berakhir maka perintah
selanjutnya akan dieksekusi.
Perintah selanjutkan adalah mirip dengan perintah baris sebelum nya yang menyalakan led
merah, namun kali ini memerintahkan untuk mematikan dengan mengirim 0V ke pin 4
Nilai LOW memerintahkan untuk memberikan tegangan 0V atau sama dengan pin tersebut

Halaman :
Nama : 7-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
terhubung ke GND. Seperti yang telah disebutkan sebelum nya, kutub positif led merah
terhubung ke pin 4 dan kutub negatif nya ke GND. Ketika pin 4 terhubung ke GND juga
maka kedua kutub led merah terhubung ke GND sehingga led merah tidak akan menyala.
Perintah selanjutnya yang akan di jalankan adalah
delay(1000); //jeda waktu 1 detik, akan tetap mati selama 1 detik
maka kedua kutub led
Seperti delay(1000); sebelumnya, di baris ini pun mikrokontroller akan ‘sibuk’ menunggu
hingga 1 detik. Pada titik ini, led sedang dalam kondisi tidak menyala, sehingga akan
tampak led tidak menyala selama 1 detik.
Baris tersebut adalah baris terakhir dari bagian loop(), dan karena bagian loop() akan
selalu diulang, maka perintah yang akan dilaksanakan adalah perintah awal loop() lagi
yaitu perintah menyalakan led. Demikian seterusnya akan dijalankan terus menerus,
sehingga yang tampak oleh mata kita adalah led merah berkedip dengan selang waktu nyala
dan mati 1 detik.
Silahkan ber eksperimen dengan mencoba nilai-nilai delay yang berbeda. Cobalah 500, 150,
2000 atau kreasi anda dan lihat bagaimana perubahan nya. Anda pun dapat mencoba
mengganti pinLed selain 4. Pada shield, led merah terhunbung ke pin 4, led kuning ke pin 7,
led hijau ke pin 5 dan led biru ke pin 6.
2. Selanjutnya masukkan program ke chip ATMega328 yang ada pada board Uno, dengan
meng-klik tombol upload pada Arduino IDE. Amati dan analisis yang terjadi pada board
Uno setelah program selesai di-upload.

Halaman :
Nama : 8-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
3. Uji cobakan tombol Compile, Upload, New, Open, dan Save pada software Arduino IDE
untuk mengetahui fungsinya lebih jauh. Tanyakan ke pengajar jika ada yang masih belum
dipahami.
PERCOBAAN 02 - Contoh Program Aplikasi pada Led
A. Blink Multiple Led

Tutorial ini adalah mengembangan dari Tutorial_Led_1 di atas dimana kali ini kita akan
mencoba sketch led berkedip namun untuk beberapa led yang menghasilkan efek cahaya
tertentu.
Buatlah program (sketch) sederhana melalui EDITOR pada software “Arduino IDE” dan beri
nama dengan TUTORIAL_led_2.ino, dan upload program/sketch tersebut ke board UNO.
Anda akan melihat bahwa led akan menyala dan mati secara bergantian sehingga memberikan
efek led nyala berjalan (running led). Konsep yang sama (namun tentunya lebih kompleks)
yang digunakan pada running text yang biasa anda lihat di tempat-tempat umum.
Mari kita perhatikan isi program/sketch nya :

---------------------------------------------------------------------------------------------------------------------------------------------
/*
TUTORIAL LED BERKEDIP BERGANTIAN
D4 -> Led Merah
D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/
#define merah 4

Halaman :
Nama : 9-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
#define hijau 5
#define biru 6
#define kuning 7
void setup()
{
pinMode(merah, OUTPUT); //set menjadi output
pinMode(hijau, OUTPUT); //set menjadi output
pinMode(biru, OUTPUT); //set menjadi output
pinMode(kuning, OUTPUT); //set menjadi output
}
void loop()
{
digitalWrite(kuning, HIGH);//menyalakan led kuning (memberi tegangan 5V)
digitalWrite(biru, LOW); //mematikan led biru(memberi tegangan 0V)
digitalWrite(hijau, LOW); //mematikan led hijau(memberi tegangan 0V)
digitalWrite(merah, LOW); //mematikan led merah(memberi tegangan 0V)
delay(500); //jeda waktu 1/2 detik, kuning akan tetap
//menyala dan sisanya akan tetap mati selama
//1/2 detik
digitalWrite(kuning, LOW); //mematikan led kuning (memberi tegangan 0V)

digitalWrite(biru, HIGH); //menyalakan led biru(memberi tegangan 5V)
delay(500); //jeda waktu 1/2 detik, biru akan tetap
//1/2 detik

digitalWrite(hijau, HIGH); //menyalakan led hijau(memberi tegangan 5V)
//1/2 detik

digitalWrite(merah, HIGH); //menyalakan led merah(memberi tegangan 5V)
//1/2 detik
}
---------------------------------------------------------------------------------------------------------------------------------------------
Pada sektch tersebut, kali ini kita membuat definisi untuk 4 led, sehingga kita memiliki 4 baris
definisi untuk mempermudah penulisan program
#define merah 4
#define hijau 5
#define biru 6
#define kuning 7
Pada shield, led merah terhubung ke pin digital 4, led hijau ke pin 5, led biru ke pin 6 dan led
kuning ke pin 7. Jika pada tutorial sebelum nya kita menggunakan kata pinLed untuk

Halaman :
Nama : 10-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
mewakili nomer pin 4, kali ini kita menggunakan kata merah untuk 4, hijau untuk 5, biru untuk
6 dan kata kuning untuk 7, sehingga akan lebih mudah dipahami dalam alur program.
void setup()
{
}
Bagian setup() berisi perintah yang serupa dengan tutorial sebelum nya, hanya saja
sekarang kita akan menggunakan 4 led yang terhubung di 4 pin I/O sehingga kita harus
memberitahukan microcontroller mode dari setiap pin yang akan kita gunakan.
Pada bagian loop(), meskipun cukup panjang, tapi jika anda perhatikan, sebenarnya terdapat
sebuah pola yang mirip. Perhatikan bagian pertama pola tersebut :
delay(500); //jeda waktu 1/2 detik, kuning akan tetap
//1/2 detik
Jika anda perhatikan, 5 baris tersebut bertujuan untuk membuat led kuning menyala dan led
biru, hijau, dan merah mati, dan biarkan kondisi tersebut selama 500 milisecond atau 0.5
detik. Selanjutnya setelah 0.5 detik berselang, akan melaksanakan bagian selanjutnya :
//1/2 detik
dimana pada bagian ini adalah giliran led biru yang diberi HIGH dan led lain nya diberi LOW
sehingga hanya led biru yang menyala dan led sisa nya mati. Karena ada delay(500) maka
kondisi tersebut akan bertahan selama 0.5 detik.
Bagian selanjutnya adalah menyalakan led hijau dan mematikan led lain nya.
//1/2 detik

Halaman :
Nama : 11-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
dan terakhir giliran led merah menyala dan led lainnya mati :
//1/2 detik
setelah selesai menjalankan baris terakhir bagian loop(), akan kembali lagi ke baris pertama
bagian loop(), sehingga akan tampak efek running led dari ke 4 led tersebut.
Silahkan ber eksperimen dengan mengganti nilai delay() dari sketch tersebut. Nilai
delay() akan mempengaruhi kecepatan pergantian nyala led.
Cobalah juga menggunakan #define untuk mengganti angka delay(), misal dengan
#define JEDA 300 dan ganti semua angka 500 pada sketch tersebut dengan kata JEDA

Halaman :
Nama : 12-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
B. Blink Multiple Led dan Konsep Sub Program
Tutorial ini adalah mengembangan dari Tutorial_Led_2 yang membuat efek running led,
namun kali ini kita akan mencoba membuat sketch yang dipecah ke beberapa sub program
yang akan memudahkan penulisan dan pembacaan program, terutama program-program yang
panjang.
nama dengan TUTORIAL_led_3.ino, dan upload program/sketch tersebut ke board UNO.
Anda akan melihat bahwa led akan menyala dan mati secara bergantian sehingga memberikan
efek led nyala berjalan (running led). Konsep yang sama (namun tentunya lebih kompleks)
yang digunakan pada running text yang biasa anda lihat di tempat-tempat umum.
---------------------------------------------------------------------------------------------------------------------------------------------
/*
TUTORIAL LED BERKEDIP BERGANTIAN PADA ARDUINO
PENGENALAN SUB PROGRAM
D4 -> Led Merah
D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/
#define merah 4
#define hijau 5
#define biru 6
#define kuning 7
#define jeda 200
void setup()
{
}
void loop()
{
nyalaKuning();
nyalaBiru();
nyalaHijau();
nyalaMerah();
}
//membuat sub-sub program
void nyalaKuning()
{
digitalWrite(kuning, HIGH); //menyalakan led kuning (memberi tegangan 5V)

Halaman :
Nama : 13-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
delay(jeda);
}
void nyalaBiru()
{
delay(jeda);
}
void nyalaHijau()
{
delay(jeda);
}
void nyalaMerah()
{
delay(jeda);
}
---------------------------------------------------------------------------------------------------------------------------------------------
Perhatikan pada sketch tersebut, perbedaan dengan sketch TUTORIAL_led_2.ino adalah
terdapat bagian-bagian lain setelah bagian loop(). Bagian-bagian tersebut adalah sub
program untuk mempermudah menyusun dan melihat alur program. Bagian void
nyalaKuning() berisi baris program untuk menyalakan led kuning dan mematikan led sisa
nya. Bagian sub program void nyalaBiru() berisi baris program untuk menyalakan led
biru. Begitupun dengan nyalaHijau() dan nyalaMerah().
Sub program tersebut dipanggil di bagian loop() dengan menuliskan nama nya. Untuk
memanggil dan mengeksekusi sub program nyalaMerah(), tinggal tulis baris
nyalaMerah() pada bagian loop().
void loop()
{
nyalaKuning();
nyalaBiru();
nyalaHijau();
nyalaMerah();
}
Pada badan loop() tersebut, perintah nyalaKuning() di laksanakan dulu sampai selesai,
lalu nyalaBiru(), kemudian nyalaHijau(), dan lalu nyalaMerah() untuk kemudian

Halaman :
Nama : 14-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
mulai lagi ke atas ke nyalaKuning() dan seterus-nya.
Dengan penggunaan sub program tersebut, penelusuran alur program pada bagian loop
menjadi lebih mudah dilihat. Hal ini sangat berguna pada program-program / sketch yang
cukup panjang dan rumit.

Halaman :
Nama : 15-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 03 - Pengenalan Serial Monitor dan Input I/O
Pada tutorial kali ini kita akan berkenalan dengan Serial Monitor. Sesuai nama nya, Serial
Monitor adalah sebuah feature yang dimiliki oleh software Arduino IDE untuk memonitor atau
memantau data yang tersedia atau dikeluarkan oleh microcontroller via komunikasi serial. Dengan
Serial Monitor kita bisa mengetahui apa yang dituliskan di port serial dan ditampilkan pada
jendela Serial Monitor.
Komunikasi serial pada board UNO dilakukan pada port serial yang terletak pada pin 0 dan pin 1,
atau melalui USB. Board UNO, Nano, ProMini, Lilypad memiliki hanya 1 buah serial yang
terletak pada pin 0 dan 1 dan digunakan juga sebagai komunikasi melalui USB
Untuk mencoba Serial Monitor, buatlah program (sketch) sederhana melalui EDITOR pada
software “Arduino IDE” dan beri nama dengan TUTORIAL_Serial_Monitor_1.ino, dan upload
program/sketch tersebut ke board UNO. Setelah di upload, tidak akan tampak apa-apa karena
pada saat ini kita tidak mengontrol hardware apapun.
Untuk memunculkan jendela Serial Monitor, klik icon yang berada di pojok kanan atas jendela
Arduino IDE. Pastikan juga board Arduino sudah terkoneksi ke komputer melalui kabel USB.
Jendela Serial Monitor akan ditampilkan dengan meng-klik tombol yang ditunjukkan anak panah
seperti pada gambar di bawah ini.

Halaman :
Nama : 16-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Mari kita bahas sketch TUTORIAL_Serial_Monitor_1:
---------------------------------------------------------------------------------------------------------------------------------------------
/*
TUTORIAL SERIAL MONITOR ARDUINO
MENAMPILKAN NILAI DARI SEBUAH PIN
*/
void setup()
{
Serial.begin(115200); //memulai inisiasi komunikasi serial dengan baud
//rate 115200 bps
Serial.println("Mencoba Serial Monitor 2");
pinMode(A5,INPUT); //set pin Analog 5 atau A5 menjadi input
}
void loop()
{
int nilai = analogRead(A5);
Serial.print("Nilai dari A5 :");
Serial.println(nilai);
delay(1000);
}
---------------------------------------------------------------------------------------------------------------------------------------------
Pada bagian setup(), untuk bisa menggunakan komunikasi serial seperti menampilkan data pada
serial Monitor, gunakan perintah Serial.begin(115200); Syntax dari
Serial.begin() adalah
Serial.begin(baud_rate);
Dimana baud rate adalah nilai kecepatan baud rate serial yang akan kita gunakan. Nilai yang bisa
digunakan adalah ada cukup banyak pilihan, yang bisa dilihat pada jendela Serial Monitor di
bagian pojok kanan bawah, namun nilai yang biasa digunakan adalah 9600 untuk kecepatan
transfer data yang agak lambat dan 115200 untuk kecepatan cukup tinggi.
Perintah selanjutnya adalah Serial.println(). Serial.println() kita gunakan untuk

menuliskan data yang akan muncul di jendela Serial Monitor.
Pada baris perintah diatas, kita akan memunculkan tulisan Mencoba Serial Monitor 2 pada jendela
Serial Monitor. Tulisan tersebut hanya akan muncul sekali saat board dinyalakan, karena perintah
ditulis di bagian setup().
Selanjutnya terdapat baris perintah untuk memberi intruksi ke mikrokontroller bahwa kita akan
mengambil nilai dari sebuah pin, atau memberlakukan sebuah pin sebagai INPUT.
pinMode(A5,INPUT); //set pin Analog 5 atau A5 menjadi input

Halaman :
Nama : 17-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Berbeda dengan tutorial led sebelum nya, dimana kita memperlakukan pin-pin yang terhubung
dengan led-led sebagai OUTPUT (karena kita akan memberikan tegangan 5V saat HIGH atau 0V
saat LOW), pada pin kali ini kita memerintahkan sebagai INPUT, karena kita akan mengambil
nilai tegangan yang ada di pin tersebut. Di contoh ini kita akan mengambil nilai tegangan dari pin
analog 5 (A5), yang walaupun pada pin tersebut tidak terhubung ke alat apapun namun akan
terdapat tegangan yang berubah-ubah saking sensitif nya mikrokontroller, sehingga bisa kita ambil
untuk di tampilkan.
Pin analog bisa memberikan nilai antara 0 sampai 1023, tergantung tegangan yang di terima oleh
pin tersebut. Pin digital hanya akan memberikan nilai 0 (LOW) atau 1 (HIGH), tergantung
tegangan yang diterima pin digital tersebut. Jika pin digital menerima tegangan diatas 3V maka
akan dianggap 1 atau HIGH. Begitupun dengan jika menerima tegangan dibawah 3V akan
dianggap 0 atau LOW. Pada board UNO terdapat 14 pin (pin 0 s/d pin 13) digital dan 5 buah pin
analog (A0 s/d A5).
Pada tutorial ini pin yang kita gunakan adalah pin A5 yang merupakan pin analog sehingga nilai
yang akan muncul antara 0 sampai 1023.
Baris perintah berikutnya adalah di bagian loop().
int nilai = analogRead(A5);
Pada baris tersebut kita memerintahkan untuk menangkap nilai dari A5 dengan perintah
analogRead() dan menyimpan nya di variabel nilai yang memiliki jenis data integers (int)
Nilai yang tertangkap tersebut dan telah disimpan ke variabel nilai, kemudian akan ditampilkan
pada baris berikut nya :
Serial.print("Nilai dari A5 :");

Serial.println(nilai);
Apa perbedaan Serial.print() dengan Serial.println()? Perbedaan nya adalah setelah

perintah Serial.print(), tulisan selanjutnya setelah Serial.print() akan ditampiilkan
pada posisi langsung sebelah data terakhir. Sedangkan pada Serial.println(), data akan
ditampilkan pada baris baru setelah data pada Serial.println() di tampilkan.
Pada serial monitor, sketch tersebut akan memunculkan tampilan seperti berikut :

Halaman :
Nama : 18-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Halaman :
Nama : 19-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 04 - Pengenalan Potensiometer Sebagai Simulasi Sensor
Pada tutorial kali ini kita akan belajar bagaimana konsep membaca nilai dari sensor pada Arduino,
dengan menggunakan potensiometer sebagai alat yang mensimulasikan sensor, sebelum kita
menggunakan sensor yang sebenarnya.
Mengapa kita menggunakan potensiometer? Sebelum nya mari kita berkenalan lebih dalam dulu
dengan potensiometer.
Potensiometer adalah sebuah resistor atau hambatan yang bersifat variabel atau dapat kita ubah
nilai hambatan nya dengan memutar lengan nya.
Potensiometer umum nya memiliki 3 kaki, seperti pada gambar diatas. Setiap potensio memiliki
nilai hambatan maksimum nya, misal potensio 10K berarti memiliki hambatan antara 0 sampai
10K ohm. Hambatan tersebut berubah tergantung posisi lengan potensio. Misal pada simbol
diatas, hambatan antara AB berbeda dengan antara BC, tergantung posisi lengan potensio (kaki
B). Jika kaki B mendekati A maka hambatan AB akan lebih kecil dan hambatan BC lebih besar.
Demikian pula jika sebalik nya.
Bagaimana potensio bisa dijadikan sebagai simulasi sensor? Dengan menggunakan nya sebagai
pengubah tegangan yang akan di tangkap oleh pin I/O Arduino. Kaki A dihubungkan ke GND,
kaki B ke pin I/O Arduino dan kaki C ke 5V, maka seiring dengan perubahan posisi lengan
potensio, maka tegangan yang akan diterima pin I/O pun akan berubah dengan nilai antara 0 s/d

Halaman :
Nama : 20-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
5V.
Sekarang mari kita coba rangkaian tersebut. Pada shield telah dirangkai potensiometer dengan
kaki B terhubung ke A0. Buatlah program (sketch) sederhana melalui EDITOR pada software
“Arduino IDE” dan beri nama dengan TUTORIAL_POTENSIO_1.ino dan upload ke board
UNO.
Program / sketch nya dalah sebagai berikut :

---------------------------------------------------------------------------------------------------------------------------------------------
/*
* TUTORIAL POTENSIOMETER PADA ARDUINO
*
* Pinout (dari kiri ke kanan potensiometer) :
* GND,A0,VCC

Halaman :
Nama : 21-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
*
* Untuk membaca nilai dari pin analog (nilai 0 - 1023)
*/
void setup()
{
pinMode(A0,INPUT); //set A0 menjadi input
Serial.begin(115200); //memulai komunikasi serial pada baud rate 115200
Serial.println("Mencoba potensiometer pada Arduino");
}
void loop()
{
int hasil = analogRead(A0); //ambil data nilai A0 dan simpan ke variabel
//hasil
Serial.println("Nilai dari potensio : " + String(hasil)); //tampilkan
//pada serial monitor
delay(500); //jeda waktu 500 mS
}
---------------------------------------------------------------------------------------------------------------------------------------------
Sketch tersebut mirip dengan sketch pada tutorial sebelum nya yaitu
TUTORIAL_Serial_Monitor_1.ino dengan perbedaan bahwa kali ini nilai analog diperoleh dari
nilai yang tergantung pada putaran lengan potensio.
Setelah upload sketch tersebut, bukalah jendela Serial Monitor dan perhatikan nilai yang tampil.
Nilai tersebut akan berkisar antara 0 hingga 1023 tergantung pada putaran anda pada
potensiometer yang ada pada shield.
Setiap perubahan yang anda lakukan dengan memutar lengan potensio berarti merubah nilai
tegangan yang di terima pin A0 sehingga merubah nilai analogRead() yang ditangkap dan
ditampilkan pada layar Serial Monitor.
Konsep ini lah yang digunakan untuk mengambil nilai dari sensor, konsep perubahan tegangan

Halaman :
Nama : 22-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
yang mirip potensiometer. Beda nya, pada sensor perubahan tegangan bukan karena pemutaran
manual potensio oleh anda, tapi oleh situasi yang merubah nya. Misal pada sensor suhu, sensor
suhu memiliki komponen yang akan berubah hambatan nya seiring dengan perubahan suhu.
Perubahan tegangan akibat perubahan hambatan itulah yang nantinya ditangkap oleh I/O arduino
untuk kita tampilkan sebagai data.

Halaman :
Nama : 23-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 05 - Potensiometer dan LED
Di tutorial ini kita akan belajar menggabungkan konsep potensiometer dengan beberapa led yang
telah dipelajari pada Tutorial_Led_3 yang telah dipelajari sebelumnya. Buatlah program (sketch)
sederhana melalui EDITOR pada software “Arduino IDE” dan beri nama dengan
TUTORIAL_Led_4.ino dan upload ke board Uno. Akan tampak efek running led pada shield
seperti tutorial led sebelum nya, namun kali ini kecepatan berlari nya led akan dipengaruhi oleh
putaran potensio. Mari kita bahas sketch nya.
---------------------------------------------------------------------------------------------------------------------------------------------
/*
TUTORIAL LED BERKEDIP BERGANTIAN PADA ARDUINO
GABUNG DENGAN POTENSIO
D4 -> Led Merah
D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
Potensio :
kaki kiri -> VCC
kaki tengah -> A0
kaki kanan -> GND
*/
#define merah 4
#define hijau 5
#define biru 6
#define kuning 7
int jeda; //variabel untuk menyimpan waktu jeda delay nyala led
void setup()
{
pinMode(A0, INPUT); //set A0 menjadi input
pinMode(kuning, OUTPUT);//set menjadi output
}
void loop()
{
jeda = analogRead(A0); //baca nilai A0 dan simpan ke variabel jeda
nyalaKuning();
nyalaBiru();
nyalaHijau();
nyalaMerah();
}
//membuat sub-sub program

void nyalaKuning()
{
delay(jeda);
}

Halaman :
Nama : 24-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
void nyalaBiru()
{
digitalWrite(kuning, LOW);//mematikan led kuning (memberi tegangan 0V)
delay(jeda);
}
void nyalaHijau()
{
delay(jeda);
}
void nyalaMerah()
{
delay(jeda);
}
---------------------------------------------------------------------------------------------------------------------------------------------
Jika anda perhatikan sketch tersebut, baris-per baris nya tidak jauh berbeda dengan contoh pada
tutorial-tutorial sebelum nya. Sketch tersebut adalah gabungan sketch running led pada
TUTORIAL LED 3 dengan TUTORIAL POTENSIOMETER 1, dimana nilai dari A0 yang
ditangkap oleh analogRead(A0) dijadikan sebagai nilai ke variabel “jeda” yang merupakan
nilai delay().
void loop()
{
jeda = analogRead(A0); //baca nilai A0 dan simpan ke variabel jeda
nyalaKuning();
nyalaBiru();
nyalaHijau();
nyalaMerah();
}
Variabel jeda menyimpan nilai yang diperoleh dari pembacaan analog pada pin A0, dimana pada
shield pin A0 terhubung ke kaki B dari potensiometer. Nilai Jeda tersebut digunakan sebagai nilai
delay() pada masing-masing sub program yang menyalakan LED.
void nyalaBiru()
{
digitalWrite(kuning, LOW);//mematikan led kuning (memberi tegangan 0V)
delay(jeda);
}

Halaman :
Nama : 25-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Dengan demikian akan tampak efek bahwa kecepatan running led akan dipengaruhi oleh posisi
lengan potensiometer. Kecepatan running led akan melambat atau semakin cepat tergantung arah
putaran anda pada lengan potensiometer.

Halaman :
Nama : 26-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 06 - Pengenalan Pulse Width Modulation (PWM)
Pada tutorial-tutorial sebelum nya kita belajar memberikan perintah untuk mengeluarkan 5V atau
0V kepada pin digital dengan menggunakan digitalWrite(). Kita juga telah mempelajari
membaca nilai dari pin analog dengan menggunakan perintah analogRead() dan menampilkan
nya pada serial monitor atau menggunakan nya untuk mengontrol sesuatu. Kali ini kita akan
belajar memberikan perintah kepada pin digital untuk mengeluarkan tegangan bukan hanya 0V
atau 5V, tapi bisa diantara 0 sampai 5V.
Teknik yang digunakan adalah PWM atau Pulse Width Modulation. Anda bisa googling untuk
mendapatkan definisi teknis mengenai PWM, namun secara sederhana nya PWM dapat di
analogikan sebagai berikut :
Bayangkan anda memegang sebuah switch yang terhubung dengan sebuah led dan sumber
tegangan 5V. Jika tombol switch itu ditekan, led akan menyala karena arus 5V mengalir ke led.
Ketika tombol tidak ditekan, led tidak akan menyala karena airan arus ke led terputus. Ketika
anda menekan switch tadi, itu sama dengan digitalWrite(pin, HIGH), memberikan 5V ke
pin I/O. Ketika anda tidak menekan itu sama dengan digitalWrite(pin, LOW). Lalu
bagaimana jika anda bisa menekan dan melepaskan dengan kecepatan sangat tinggi? Asumsikan
anda dapat melakukan nya, apa yang terjadi dengan nyala led? Led akan menyala paling terang
ketika kecepatan on/off anda sangat tinggi, karena akan menyerupai dengan ditekan terus
menerus, dan akan menyala redup ketika kecepatan anda melakukan on/off melambat, karena
seakan akan ada off diantara on.
Mikrokontroller seperti yang terdapat pada board Arduino bisa melakukan proses on/off tersebut
berulang kali dengan kecepatan tinggi. Pada kecepatan paling tinggi nya, nilai tegangan yang
keluar pada sebuah pin akan sangat mendekati 5V. Dan pada kecepatan terendah nya, akan
mendekati 0V. Hanya saja tidak semua pin I/O yang bisa melakukan hal tersebut. Hanya pin yang
memiliki kemampuan PWM yang bisa melakukan nya.
Pada board UNO, terdapat beberapa pin yang merupakan pin PWM, yaitu pin 3, 5, 6, 9, 10 dan
11, yang ditandai dengan tanda ~ pada keterangan nomer pin di PCB board Uno.
Untuk memberikan tegangan antara 0V sampai 5V pada pin PWM, perintah yang digunakan
adalah

Halaman :
Nama : 27-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
analogWrite(pin, nilai);
dimana pin adalah nomer pin PWM yang akan digunakan, dan nilai adalah antara 0 sampai 255. 0
adalah nilai terendah yang akan memberikan 0V pada pin PWM dan 255 adalah nilai tertinggi
yang akan memberikan 5V pada pin PWM.
Pada shield yang kita gunakan, led hijau dan led biru yang terhubung ke pin PWM (pin 5 dan 6).
Untuk mencoba nya, buatlah program (sketch) sederhana melalui EDITOR pada software
“Arduino IDE” dan beri nama dengan TUTORIAL_LED_5.ino dan upload ke board Uno. Akan
tampak led biru menyala seakan akan berdenyut, dari redup perlahan menuju terang dan perlahan
menuju redup kembali. Mari kita bahas sketch nya.
/*
TUTORIAL LED PWM PADA ARDUINO
LED MENYALA BERDENYUT
D4 -> Led Merah
D5 -> Led Hijau (pin PWM)
D6 -> Led Biru (pin PWM)
D7 -> Led Kuning
*/
#define pinLed 6 //led biru pada D6 yang merupakan pin PWM
int intensitas = 0;
int jumlahStep = 1;
void setup()
{
}

Halaman :
Nama : 28-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
void loop()
{
analogWrite(pinLed, intensitas);
intensitas = intensitas + jumlahStep;
if (intensitas <= 0 || intensitas >= 255)
{
jumlahStep = -jumlahStep;
}
delay(5);
}
Sebagian besar perintah pada sketch tersebut tentunya sudah anda pahami, hanya beberapa
perintah saja yang merupakan perintah yang baru.
int intensitas = 0;
int jumlahStep = 1;
Variabel integer intensitas diberi nilai 0 saat awal. Variabel ini untuk menampung nilai PWM dari
0 sampai 255 yang akan diterapkan pada pin 6 yang diberi nama pinLed. Variabel jumlahStep
yang diberi nilai 1 akan digunakan sebagai nilai langkah atau selisih penambahan/pengurangan
dalam perhitungan.
Konsep nya adalah memberikan nilai 0 ke pin 6, lalu sejalan bertambahnya waktu, nilai tersebut
akan bertambah (sejumlah nilai variabel jumlahStep) hingga akhirnya mencapai nilai maksimum
255. Setelah memncapai nilai maksimum, perhitungan dibalik menjadi pengurangan dari 255
menuju 0. Demikian seterus-nya. Sehingga tegangan yang diterima led biru akan mulai dari 0V
menuju 5V secara bertahap, lalu setelah mencapai 5V akan menurun ke 0V lagi secara bertahap,
lalu kembali lagi menuju 5V secara bertahap, dan begitu seterus nya.
Mari kita perhatikan baris-baris perintah di bagian loop() satu persatu.
analogWrite(pinLed, intensitas);
pada perintah tersebut, ketika awal loop() akan memerintahkan analogWrite() ke pin 6
dengan nilai 0, karena nilai awal variabel intenstitas adalah 0 (ditentukan sebelum bagian
setup()). Dengan demikian pada titik ini led tidak akan menyala.
Setelah baris tersebut, perintah selanjutnya adalah menambah nilai intensitas dengan nilai
jumlahStep yang dalam hal ini adalah 1. Dengan demikian, pada baris ini nilai pwm bertambah
1 menjadi 2, dan seiring berlalu nya pengulangan loop(), nilai ini akan terus bertambah sehingga
led akan mulai menyala terang dan semakin terang.
intensitas = intensitas + jumlahStep;
Jika ini tidak dibatasi, maka pada suatu titik, nilai intensitas akan melebihi 255, sementara

Halaman :
Nama : 29-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
sebagaimana yang kita ketahui sebelum nya, nilai untuk pin PWM adalah antara 0 sampai 255.
Untuk mencegah hal tersebut digunakan baris perintah selanjutnya :
if (intensitas <= 0 || intensitas >= 255)

{
}
Perintah tersebut menggunakan perintah IF, yang kita gunakan untuk melaksanakan perintah
bersyarat. Perintah didalam perintah IF hanya akan dilaksanakan kalau kondisi IF nya terpenuhi.
Syntax dari perintah IF adalah
IF (kondisi syarat)
{
É. Perintah yang dijalankan jika syarat terpenuhi É.
}
Pada perintah IF kita tadi, syarat yang harus dipenuhi adalah jika intensitas lebih kecil dari 0
intensitas <= 0
atau jika intensitas lebih besar atau sama dengan 255
intensitas >= 255
Operator logika ATAU menggunakan lambang || dan operator logika DAN menggunakan
lambang &&. Pada sketch ini kita menggunakan operator logika ATAU.
Perintah yang dijalankan JIKA kondisi tersebut terpenuhi adalah
jadi ketika nilai intensitas mencapai maksimum 255, atau mencapai nilai minimum 0, nilai
jumlah step akan dibalik, yang awal nya +1 menjadi -1, atau sebalik nya. Sehingga pada awal nya
terjadi penambahan, ketika mencapai 255 akan terjadi pengurangan terhadap nilai variabel
intensitas. Ketika pengurangan mencapai nilai 0, terjadi pembalikan lagi menjadi penambahan.
Demikian seterusnya sehingga menampilkan efek led menyala berdenyut.

Halaman :
Nama : 30-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 07 - Nyala Redup Terang LED menggunakan PWM dengan input data dari
Potensiometer
Pada tutorial sebelum nya yaitu TUTORIAL LED 5 kita telah belajar mengenai PWM untuk
mengatur tingkat terang nya led biru, yang diatur secara program dengan penambahan dan
pengurangan secara otomatis sehingga menimbulkan efek led menyala berdenyut. Pada tutorial
kali ini kita akan menyoba mengatur tingkat kecerahan berdasarkan putaran manual pada lengan
potensiometer, sebagai input manual yang mempengaruhi pwm.
nama dengan TUTORIAL_Led_6.ino dan upload ke board Uno. Akan tampak led biru yang
menyala dengan tingkat kecerahan yang sesuai dengan putaran potensiometer. Mari kita bahas
sketch nya.
/*
TUTORIAL LED PWM PADA ARDUINO
PENGATURAN VIA
D4 -> Led Merah

D7 -> Led Kuning
*/
#define pinLed 6 //led biru pada D6 yang merupakan pin PWM
#define pinPot A0
void setup()
{
pinMode(pinPot, INPUT); //set sebagai input
}
void loop()
{
int a = analogRead(pinPot);
int b = map(a,0,1023,0,255); //mapping nilai analog potensio ke nilai
//analog pwm
analogWrite(pinLed, b);
delay(5);
}
Konsep sketch tersebut adalah memberikan nilai PWM ke pin 6 dengan nilai yang diperoleh dari
nilai Potensiometer (pin A0). Pengambilan nilai potensiometer telah dipelajari pada tutorial
sebelumnya menggunakan perintah analogRead(), dan perintah untuk memberikan nilai PWM
ke pin PWM adalah dengan perintah analogWrite(). Namun sekarang terdapat sedikit
masalah, nilai dari analogRead() adalah antara 0 hingga 1023, sementara nilai dari
analogWrite() hanyalah 0 hingga 255. Bagaimana cara kita menselaraskan antara 0-1023 dan
0-255 sehingga menjadi linier? Disinilah gunanya perintah map.

Halaman :
Nama : 31-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Syntax dari perintah map adalah
map(variabel yang akan di-peta kan, nilai min rentang A, nilai max
rentang A, nilai min rentang B, nilai max rentang B)
Pada sketch diatas, hasil mapping/pemetaan variabel disimpan di variabel b, yang kemudian
digunakan sebagai nilai dalam analogWrite()
int b = map(a,0,1023,0,255); //mapping nilai analog potensio ke nilai

//analog pwm
nilai dari potensio, dalam hal ini disimpan dalam variabel a, yang bernilai antara 0 sampai 1023,
akan di peta kan ke rentang 0 sampai 255 secara linier proporsional yang kemudian disimpan ke
variabel integer b. Karena nilai b digunakan kemudian sebagai nilai PWM pada
analogWrite(), maka kecerahan led akhirnya akan tergantung dari putaran potensio.
Sebagaimana dijelaskan sebelumnya, konsep potensiometer ini yang menjadi dasar dalam
penggunaan dan pembacaan data sensor. Dengan demikian, dengan konsep yang sama kita bisa
mengatur output PWM menggunakan sensor apapun nanti nya.

Halaman :
Nama : 32-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 08 - Pengenalan konsep millis(), Blink tanpa delay()
Pada tutorial kali ini kita akan belajar penggunaan perintah millis(). Untuk apakah millis()
digunakan? Untuk memahami millis, buatlah program (sketch) sederhana melalui EDITOR pada
software “Arduino IDE” dan beri nama dengan TUTORIAL_Serial_monitor_3.ino dan upload ke
board Arduino.
/*
TUTORIAL SERIAL MONITOR ARDUINO
MENAMPILKAN NILAI MILLIS
*/
void setup()
{
Serial.begin(115200); //memulai inisiasi komunikasi serial dengan baud
//rate 115200 bps
}
void loop()
{
Serial.print("Nilai dari millis saat ini :");
Serial.println(millis());
delay(1000);
}
Selanjutnya buka jendela serial monitor, dan akan tampak nilai seperti berikut :

Halaman :
Nama : 33-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Sketch tersebut menampilkan nilai dari perintah millis() setiap 1 detik yang ditunda oleh
perintah delay(1000). Terlihat pada gambar diatas, nilai millis bertambah sekitar 1000 setiap
detik nya.
Jadi apakah millis() itu? Perintah millis() akan memberika nilai jumlah miliseconds atau
milidetik yang telah berselang sejak board arduino dinyalakan atau reset. Nilai nya akan selalu
bertambah. Ketika kita memberikan perintah millis() kita akan diberi nilai millis saat itu.
Beberapa detik atau bahkan beberapa milidetik kemudian ketika kita meminta nilai millis lagi,
nilai nya akan berbeda lagi.
Millis kita gunakan sebagai pengatur waktu terjadi nya sesuatu perintah. Lalu apa bedanya
dengan delay()?
Pada perintah delay(), ketika microcontroller menemukan baris delay(), misal

delay(1000); maka microcontroller akan ‘sibuk’ menunggu selama 1000 miliseconds dan tidak
mau mengerjakan hal lain selain menunggu 1000 miliseconds berlalu. Hal ini tentu bukan masalah
untuk beberapa program sederhana, namun ketika program semakin kompleks dan menuntut
beberapa hal bisa dilakukan bersamaan, penggunaan delay() akan sangat mengganggu karena
microcontroller tidak bisa diperintah hal lain ketika menemukan perintah delay().
Bagaimana cara penggunaan millis sebagai ‘pengganti’ delay()? Mari kita buat program
(sketch) sederhana melalui EDITOR pada software “Arduino IDE” dan beri nama dengan
TUTORIAL_Led_7.ino dan upload ke board Uno.
Setelah di upload, yang akan tampak adalah led merah berkedip nyala dan mati setiap 1 detik,
serupa dengan tutorial awal. Lalu apa beda nya, mari kita lihat sketch nya.
/*
TUTORIAL LED PADA ARDUINO
BLINK (LED BERKEDIP) TANPA PENGGUNAAN DELAY
D4 -> Led Merah
D7 -> Led Kuning
*/
#define pinLed 4
int statusLed = LOW;

unsigned long millisSebelumnya = 0;
const long interval = 1000;
void setup()
{

Halaman :
Nama : 34-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
}
void loop()
{
unsigned long millisSekarang = millis();
if(millisSekarang - millisSebelumnya >= interval)
{
millisSebelumnya = millisSekarang;
statusLed=!statusLed;
}
digitalWrite(pinLed, statusLed);
}
Pada baris awal sebelum bagian setup() kita deklarasikan variabel millisSebelumnya
dengan tipe data unsigned long dan nilai awal 0. Baris berikutnya adalah deklarasi variabel
interval berjenis const long dengan nilai 1000. Ini akan digunakan sebagai interval waktu antar
event.
unsigned long millisSebelumnya = 0;

const long interval = 1000;
Variabel integer statusLed yang diberi nilai awal LOW digunakan sebagai variabel untuk
menyimpan kondisi HIGH atau LOW led nanti nya.
Pada bagian awal loop(), terdapat perintah yang merekam angka millis saat itu ke variabel
millisSekarang
unsigned long millisSekarang = millis();
Jadi pada saat itu, nilai waktu millis() di simpan ke variabel millisSekarang. Sebagaimana
dijelaskan sebelumnya, nilai millis akan selalu bertambah, setiap milliseconds, dan satu
milliseconds berlalu dengan sangat cepat.
Perintah selanjut nya, adalah perintah kondisi IF yang akan membandingkan millis saat kondisi
if diuji dengan millis yang sebelumnya direkam di variabel millisSekarang dengan variabel
millisSebelumnya (yang dideklarasikan sebagai 0 di awal sebelum bagian setup)
if(millisSekarang - millisSebelumnya >= interval)

{
}
Jika nilai selisih antara millisSekarang dengan millisSebelumnya lebih besar atau sama
dengan interval, yang dalam hal ini adalah 1000 atau telah berselang 1000 milliseconds dari sejak
merekam millisSebelumnya, maka kondisi IF menjadi true sehingga perintah dalam if akan
dijalan kan, yaitu merubah nilai millisSebelumnya menjadi nilai millisSekarang.

Halaman :
Nama : 35-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
dan juga melaksanakan perintah untuk membalik kan statusLed yang awal nya LOW menjadi
HIGH, atau jika awal nya HIGH menjadi LOW dengan perintah.
Dengan demikian, baris selanjutnya yaitu
digitalWrite(pinLed, statusLed);
akan dijalankan dengan isi statusLed yang berganti-ganti antara HIGH dan LOW setiap 1000
milliseconds. Efek yang tampak led merah akan berkedip setiap 1 detik, persis seperti Tutorial
Led 1, namun kali ini kita tidak menggunakan delay().
Kegunaan dari penggunaan millis() dan menghindari delay() akan kita rasakan dalam
tutorial yang menyatukan beberapa fungsi dan tugas sekaligus yang akan kita bahas nanti.

Halaman :
Nama : 36-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 09 - Mapping Nilai
Tutorial potensiometer kali ini merupakan gabungan antara pembacaan nilai potensio di Tutorial
Potensiometer 1 dengan pelajaran mapping nilai sebelum nya. Buatlah program (sketch)
sederhana melalui EDITOR pada software “Arduino IDE” dan beri nama dengan
TUTORIAL_Potensio_2.ino dan upload ke board Uno.
/*
TUTORIAL POTENSIOMETER PADA ARDUINO DENGAN MAPPING NILAI
Pinout (dari kiri ke kanan potensiometer) :

GND,A0,VCC
Untuk membaca nilai dari pin analog (nilai 0 - 1023)

dan mapping ke nilai tertentu
*/
void setup()
{
Serial.println("Mencoba mapping nilai potensiometer pada Arduino");
}
void loop()
{
//hasil
int hasilMap = map(hasil,0,1023,1,4); //mapping nilai 0 s/d 1023 ke 1 s/d
//4
Serial.println("Nilai dari potensio : " + String(hasil)); //tampilkan
Serial.println("Nilai hasil mapping : " + String(hasilMap)); //tampilkan
delay(500); //jeda waktu 500 uS
}
Selanjutnya jalankan Serial Monitor dan akan tampak data seperti gambar berikut :

Halaman :
Nama : 37-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Pada sketch di atas, nilai dari analogRead() dari potensio yang memiliki rentang antara 0
hingga 1023 di peta kan ke rentang kecil, 1 sampai 4.
Perintah-perintah pada sketch tersebut sebagian besar telah anda pahami dari tutorial-tutorial
sebelumnya. Sesuatu yang baru pada sketch ini adalah penggunaan perintah map untuk dua
rentang nilai yang berbeda cukup jauh, dan penulisan gabungan dua tipe data yang berbeda pada
Serial.println()
Serial.println("Nilai dari potensio : " + String(hasil));
Pada perintah diatas, penggabungan dua nilai menggunakan operator +.
Fungsi String() digunakan untuk mengubah tipe data variabel “hasil” yang asalnya adalah
integer menjadi String sehingga bisa ditampilkan dalam satu baris di perintah
Serial.println()

Halaman :
Nama : 38-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 10 - Penggunaan Mapping dan Led Serta Kondisi IF
Tutorial kali ini adalah gabungan tutorial sebelumnya dengan tutorial led, dimana kali ini kita akan
belajar memetakan nilai analog yang diperoleh dari putaran potensio di A0 untuk mengatur nyala
led.
nama dengan TUTORIAL_Potensio_3.ino dan upload ke board Uno. Akan tampak satu led
menyala tergantung posisi lengan potensio. Putaran potensiometer akan memperngaruhi led mana
yang menyala. Mari kita lihat sketch nya
/*
TUTORIAL POTENSIOMETER PADA ARDUINO DENGAN MAPPING NILAI DAN LED
Pinout (dari kiri ke kanan potensiometer) :

GND,A0,VCC

dan mapping ke nilai tertentu
cerminkan ke nyala led
A0 -> kaki tengah potensio

D4 -> Led Merah
D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/
#define merah 4
#define hijau 5
#define biru 6
#define kuning 7
#define pinPotensio A0
void setup()
{
pinMode(pinPotensio, INPUT); //set menjadi input
Serial.println("Mencoba mapping nilai potensiometer pada Arduino dan led
indikator");
}
void loop()
{
int hasil = analogRead(pinPotensio); //ambil data nilai A0 dan simpan ke
//variabel hasil
int hasilMap = map(hasil, 0, 1023, 0, 4); //mapping nilai 0 s/d 1023 ke 0
//s/d 4
Serial.println("Nilai dari potensio : " + String(hasil)); //tampilkan pada
//serial monitor
Serial.println("Nilai hasil mapping : " + String(hasilMap)); //tampilkan
if (hasilMap == 0)
{

Halaman :
Nama : 39-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
digitalWrite(kuning, LOW);
digitalWrite(biru, LOW);
digitalWrite(hijau, LOW);
digitalWrite(merah, LOW);
}
if (hasilMap == 1)
{
digitalWrite(kuning, HIGH);
}
if (hasilMap == 2)
{
digitalWrite(biru, HIGH);
}
if (hasilMap == 3)
{
digitalWrite(hijau, HIGH);
}
if (hasilMap == 4)
{
digitalWrite(merah, HIGH);
}
delay(100); //jeda waktu

}
Nilai yang diperoleh dari potensiometer di pin A0 di petakan ke 4 nilai yang akan kita gunakan
dalam struktur IF untuk menyalakan led yang dikehendaki
int hasil = analogRead(pinPotensio); //ambil data nilai A0 dan simpan ke

//variabel hasil
int hasilMap = map(hasil, 0, 1023, 0, 4); //mapping nilai 0 s/d 1023 ke 0
//s/d 4
dengan perintah map, nilai hasilMap akan berisi integer 0 sampai 4, dan hasil tersebut
digunakan untuk menyalakan led sesuai nilai yang keluar dari putaran potensiometer.

Halaman :
Nama : 40-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN XX -

Halaman :
Nama : 41-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 11 - Pengenalan Penggunaan Input Push Button
Jika pada tutorial-tutorial sebelum nya kita telah mempelajari penggunaan pin I/O sebagai output
untuk menyalakan led, dan sebagai input untuk menangkap nilai perubahan tegangan dari pin I/O,
pada tutorial kali ini kita akan belajar penggunaan pin I/O sebagai input yang akan kita gunakan
dalam tombol push button.
Tombol push button sering digunakan sebagai input dalam peralatan yang menggunakan
mikrokontroller. Salah satu contoh penggunaan nya seperti pada jam digital, dimana kita harus
menekan tombol-tombol untuk menyesuaikan jam, menit dan alarm. Konsep penggunaan tombol
tersebut adalah menangkap nilai digital dari pin yang digunakan (yang biasanya hanya HIGH atau
LOW), dimana nilai tersebut nantinya akan digunakan untuk kepentingan selanjutnya.
nama dengan file TUTORIAL_BUTTON_1.ino dan upload lah ke board Uno. Setelah selesai
upload, buka jendela Serial Monitor, dan cobalah menekan tombol A dan tombol B yang ada pada
shield. Setiap penekanan tombol akan terbaca oleh mikrokontroller dan informasi aktifitas tersebut
ditampilkan di Serial Monitor.
/*
TUTORIAL PUSH BUTTON PADA ARDUINO
TAMPILKAN STATUS BUTTON PADA SERIAL MONITOR
Pinout :
Tombol 1 -> D9
Tombol 2 -> D8
*/
#define TOMBOL1 9
#define TOMBOL2 8

Halaman :
Nama : 42-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
void setup()
{
Serial.begin(115200); // memulai komunikasi serial
Serial.println("Mencoba Push Button");
pinMode(TOMBOL1, INPUT); //set menjadi input
digitalWrite(TOMBOL1, HIGH); //pull high sebagai default awal
}
void loop()
{
int a = digitalRead(TOMBOL1); //ditekan nilai menjadi 0 (LOW)
int b = digitalRead(TOMBOL2); //ditekan nilai menjadi 0 (LOW)
Serial.print("Status tombol A adalah : ");
Serial.println(a);
Serial.print("Status tombol B adalah : ");
Serial.println(b);
delay(100);
}
Konsep dari sketch tersebut adalah menangkap nilai digitalRead() dari pin 8 dan pin 9 yang
kemudian ditampilkan ke Serial monitor dengan Serial.print() dan Serial.println().
Dengan demikian ketika tombol tidak ditekan, tegangan 5V akan mengalir ke pin 8 dan 9 yang
akan menghasilkan nilain digitalRead() HIGH (atau 1). Nilai tersebut akan berubah menjadi
LOW (atau 0) ketika tombol ditekan karena pin yang bersangkutan akan terhubung ke GND.

Halaman :
Nama : 43-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 12 - Push Button dan Led
Tutorial ini melanjutkan tutorial push button sebelumnya, dimana jika sebelumnya nilai yang
tertangkap oleh pin yang terhubung ke push button hanya kita tampilkan ke Serial Monitor, kali
ini kita gunakan untuk menyalakan led.
nama dengan file TUTORIAL_BUTTON_2.ino dan upload ke board Uno. Sekarang jika anda
menekan tombol A maka ada satu led yang menyala dan begitu juga dengan tombol B.
Mari kita lihat sketch nya
/*
PUSH BUTTON DAN LED
Pinout :
Tombol 1 -> D9
Tombol 2 -> D8
D4 -> Led Merah

D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/
#define TOMBOL1 9
#define TOMBOL2 8
#define merah 4
#define hijau 5
#define biru 6
#define kuning 7
void setup()
{
pinMode(kuning, OUTPUT);
pinMode(biru, OUTPUT);
}
void loop()
{
int a = digitalRead(TOMBOL1); //ditekan nilai menjadi 0 (LOW)
int b = digitalRead(TOMBOL2); //ditekan nilai menjadi 0 (LOW)
if (a == 0)
{
} else
{
}
if (b == 0)
{

Halaman :
Nama : 44-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
} else
{
}
delay(100);
}
Konsep dari sketch tersebut adalah menangkap nilai dari pin 8 dan 9 yang terhubung ke push
button A dan B. Pada kondisi awal, pin 8 dan 9 akan bernilai HIGH karena terhubung ke VCC.
Namun ketika tombol di tekan, pin yang bersangkutan akan menjadi LOW.
Kondisi tersebut dimanfaatkan melalui struktur IF, dimana jika tombol A ditekan maka led kuning
menyala, tombol B ditekan maka led biru menyala. Ketika kedua tombol ditekan maka led kuning
dan biru akan menyala.
if (a == 0)
{
} else
{
}
Jika nilai a adalah 0 atau LOW, dimana nilai a diperoleh dari digitalRead() pin 9, maka led
kuning akan nyala. Kondisi kebalikan nya di muat dalam bagian else
Pada sketch ini led hanya akan menyala selama tombol di tekan, karena hanya selama di tekan lah
pin I/O terhubung ke GND.

Halaman :
Nama : 45-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 13 - Pengenalan Konsep Debounce
Pada tutorial sebelum nya kita telah mempelajari bagaimana caranya menangkap nilai pada pin
yang terhubung dengan push button untuk digunakan menyalakan led. Pada sketch sebelum nya,
selama tombol ditekan, maka selama itu pula led akan menyala. Bagaimana jika kita ingin led
menyala dengan menekan tombol sekali, dan mati ketika kita menekan tombol sekali lagi?
Tutorial kali ini akan membahas hal tersebut.
Konsep sketch nya adalah menangkap nilai dari pin push button, dan menyimpan nya ke sebuah
variabel. Jika tombol di tekan, variabel akan berubah, misal variabel awal bernilai 0, dan ketika
ditekan variabel tersebut berubah menjadi 1. Ketika tombol ditekan lagi, variabel berubah lagi
menjadi 0. Demikian seterusnya, bolak balik antara 0 dan 1 setiap penekanan tombol.
Namun kemudian akan timbul masalah baru jika kita hanya menggunakan cara digitalRead()
biasa. Microcontroller akan menangkap perubahan tersebut dengan sangat sensitif, nilai LOW
akan ditangkap LOW dengan cepat walau pin hanya terhubung sangat sebentar (hitungan milli
detik). Cara kerja push button adalah menempelkan dua lempeng logam dengan cara ditekan, yang
sebelum nya ditahan oleh sebuah pegas. Masalah akan timbul karena jika diperhatikan secara
mikroskopik, disaat kedua lempeng logam tersebut bersatu karena tombol kita tekan, di area
lempengan logam tersebut telah terjadi hubungan sambung putus beberapa kali dalam hitungan
microseconds.

Halaman :
Nama : 46-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Jadi jika kita hanya menggunakan digitalRead() biasa, sebenarnya dalam sekali penekanan
tombol bisa tertangkap beberapa kali on off, terutama ketika kedua lempengan logam tadi di
posisi akan menuju bersatu. Ketika telah bersatu sempurna tentunya nilai nya sudah pasti, yang
menjadi masalah adalah disaat momen lempengan tersebut akan bersatu, terjadi resonansi antara
high dan low. Hal ini akan menyulitkan ketika kita menginginkan sebuah perintah akan dijalankan
ketika terdapat 1 buah LOW, dan menjalankan perintah lain nya ketika terdapat LOW berikutnya.
Misal LOW pertama adalah untuk menyalakan led, dan LOW kedua untuk mematikan nya,
dengan adanya resonansi antara HIGH dan LOW tersebut maka sketch akan berjalan tidak sesuai
rencana.
Seperti tampak pada grafik oscilloscope diatas, posisi awal nya adalah LOW (garis di bawah).
Ketika ditekan, terjadi loncatan ke HIGH dan LOW bolak balik beberapa kali sebelum pada akhir
nya stabil di HIGH (garis di atas).
Bagaimana cara mengatasi masalah ini? Disinilah konsep Debounce diperkenalkan. Debounce
berarti anti loncatan, kita harus membuat algoritma program yang membuat microcontroller
‘menanti’ dulu nilai stabil dari penekanan tombol, dan mengabaikan loncatan-loncatan yang
terjadi sebelum nya.
Untuk melihat konsep debounce diterapkan, buatlah program (sketch) sederhana melalui EDITOR
pada software “Arduino IDE” dan beri nama dengan file TUTORIAL_BUTTON_3.ino dan
upload ke board Uno. Ketika dijalankan, tombol akan mematikan dan menyalakan led biru pada
setiap aksi menekan tombol. Sekali tekan menyalakan, tekan kembali mematikan. Mari kita lihat
sketch nya.
/*
PUSH BUTTON DAN LED PENGGUNAAN DEBOUNCE
Pinout :
Tombol 1 -> D9
Tombol 2 -> D8
D4 -> Led Merah

D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/
#define TOMBOL1 9
#define TOMBOL2 8
#define merah 4
#define hijau 5
#define biru 6

Halaman :
Nama : 47-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
#define kuning 7

int statusTombolTerakhir = HIGH;
int statusTombol;
unsigned long lastDebounceTime = 0;

unsigned long debounceDelay = 50;
void setup()
{
digitalWrite(biru, statusLed);
}
void loop()
{
int a = digitalRead(TOMBOL1);
if (a != statusTombolTerakhir) // reset debouncing timer

{
lastDebounceTime = millis();
}
if ((millis() - lastDebounceTime) > debounceDelay)

{
if (a != statusTombol)
{
statusTombol = a;
if (statusTombol == LOW)
{
statusLed = !statusLed;
}
}
}
statusTombolTerakhir = a;
}
Pada bagian sebelum setup(), beberapa variabel ditentukan terlebih dahulu untuk penerapan
algoritma debounce pada push button :
Perintah tersebut untuk menyimpan variabel statusLed dengan nilai awal LOW atau 0. Variabel
ini nantinya akan kita gunakan untuk menyalakan atau mematikan led dengan perintah
digitalWrite().
Variabel statusTombolTerakhir dengan nilai awal HIGH digunakan sebagai pembanding

terhadap perubahan nilai pin tombol. Nilai awal diberi HIGH karena tombol kita menggunakan
Pull Up dimana pin terhubung ke 5V saat default.
int statusTombol;
Varibel statusTombol dideklarasikan dalam tipe integers untuk menampung nilai pin saat
Halaman :
Nama : 48-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
periode resonansi atau periode tidak stabil dimana nilai berubah ubah antara LOW dan HIGH
dengan sangat cepat.
Variabel lastDebounceTime dengan nilai awal 0 akan digunakan untuk merekam titik waktu
dimana periode resonansi terakhir terjadi
Variabel debounceDelay digunakan untuk menyimpan nilai waktu menanti dalam milliseconds
dimana kita bisa yakin bahwa sebuah nilai sudah stabil. Disini kita menggunakan 50 milliseconds,
berati ketika nilai pin tombol sudah tidak loncat-loncat lagi, tunggu dulu selama 50 miiliseconds
dan analisa apakah sudah stabil, jika tetap tidak berubah nilainya berarti sudah stabil dan nilai
akhir bisa dianggap nilai yang benar.
Sekarang mari kita telaah bagian loop()
nilai dari pin tombol ditangkap dengan digitalRead() dan disimpan ke variabel a
if (a != statusTombolTerakhir) // reset debouncing timer

{
lastDebounceTime = millis();
}
Pada kondisi if diatas, jika nilai a yang hasil kita tangkap dari pin pada baris sebelumnya, tidak
sama dengan nilai statusTombolTerakhir (yang untuk awal telah kita isi dengan nilai awal
HIGH), maka variabel lastDebounceTime akan diisi dengan angka millis() saat itu.
Dititik ini, jika tombol ditekan saat baris tersebut di eksekusi, maka nilai a akan LOW (karena
tombol ditekan menghubungkan pin ke GND) sehingga menjadi tidak sama dengan
statusTombolTerakhir yang memiliki nilai awal HIGH, sehingga kondisi IF menjadi
terpenuhi, nilai lastDebounceTime akan berisi nilai millis() saat itu.

{
{
statusTombol = a;
{
}
}
}

Halaman :
Nama : 49-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Pada perintah if bertingkat diatas, dianalisa apakah terjadi loncatan perubahan low high low high
dengan membandingkan nilai selisih antara millis() saat baris tersebut dieksekusi dengan nilai
lastDebounceTime. Jika selisihnya melebihi debounceDelay yang dalam hal ini adalah 50
milliseconds, kondisi if terpenuhi dan akan melaksanakan kondisi if dibawah nya. Hal ini
berarti sudah tidak ada lagi resonansi nilai
Kondisi if dibawah nya adalah menguji apakah nilai a tidak sama dengan nilai statusTombol.
Ingat bahwa if bagian ini hanya dilaksanakan setelah dianggap nilai telah stabil, sehingga
statusTombol adalah nilai a yang dianggap stabil.
{
}
Karena nilai statusTombol adalah nilai yang sudah dianggap stabil dan sah untuk digunakan,
nilai ini bisa digunakan untuk aktifasi led. Pada sirkuit pull up, tombol disebut aktif akan
mengeluarkan nilai LOW. Di perintah diatas, ketika LOW terjadi, nilai statusLed akan diubah
menjadi kebalikan nya dengan perintah statusLed = !statusLed. Jadi misal yang asalnya
statusLed adalah LOW akan menjadi HIGH dan demikian pun sebaliknya.
Di perintah itu akan dinyalakan atau dimatikan led sesuai nilai statusLed dengan perintah
digitalWrite(). Dibawah nya adalah perintah mengisi nilai statusTombolTerakhir
dengan nilai a yang ada, sebagai nilai untuk dibandingkan ke atas loop lagi.
Konsep debounce ini memang agak sulit dipahami pada awal nya. Namun dengan latihan dan
sering menggunakan nya anda akan dapat mengerti pada akhirnya. Intinya adalah mengeliminasi
periode resonansi, dan hanya mengambil nilai yang sudah tidak berubah-ubah lagi sebagai nilai
sah yang akan digunakan, dengan penggunaan perintah millis() sebagai penanda waktu nya.
Konsep perintah millis() pada tutorial sebelum nya akan membantu anda memahami konsep
debounce ini

Halaman :
Nama : 50-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 14 - Pengenalan Penggunaan Sensor Dan Library
Setelah mempelajari konsep dasar output dan input pada tutorial-tutorial sebelumnya, pada tutorial
kali ini kita akan mulai menggunakan sensor, yang dalam hal ini kita akan mencoba memperoleh
data dari sensor suhu dan kelembaban udara DHT11.
Sensor DHT11 memiliki kemampuan untuk memberi kita data suhu udara dan kelembaban udara,
berdasarkan karakteristik nya yang didesain sedemikian rupa sehingga perubahan suhu dan
kelembaban udara akan menghasilkan perubahan hambatan pada kaki signal nya. Hal ini mirip
dengan konsep potensiometer yang pernah dipelajari sebelumnya, dimana kita akan mengambil
nilai perubahan tersebut.
Sedikit berbeda dengan tutorial potensio sebelum nya, pada pengambilan data spesifik dari sensor,
kita memerlukan perhitungan lebih lanjut untuk menterjemahkan perubahan tegangan yang khas
dari masing-masing sensor menjadi nilai yang diinginkan. Misal dalam sensor DHT11 ini data
yang kita harapkan adalah data suhu dalam celcius dan data kelembaban udara dalam persentase
jumlah air di udara.

Halaman :
Nama : 51-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Proses algoritma menterjemahkan data-data tegangan dan hambatan tersebut cukup rumit untuk
dilakukan. Untungnya dalam platform Arduino, terdapat fasilitas yang sangat memudahkan untuk
pemula, yaitu fasilitas Library. Sudah ada orang lain yang melakukan perhitungan dan
pemrograman rumit tersebut dalam bentuk file-file program khusus yang di platform Arduino kita
sebut file library, sehingga kita tinggal menggunakan nya. Setiap sensor biasanya akan memiliki
library tersendiri. Dan karena Arduino adalah open source, maka bisa jadi untuk sebuah sensor
akan terdapat beberapa library yang bisa kita pilih untuk digunakan salah satu.
Darimana kita memperoleh Library? Untuk beberapa sensor atau alat yang lazim digunakan,
biasanya sudah built in di program Arduino IDE. Untuk beberapa sensor lain nya, seperti sensor
DHT yang akan kita gunakan ini, kita tinggal mencari nya di internet dengan mudah dan download
dengan gratis (biasanya dalam bentuk zip file)
Library DHT11 yang kita gunakan dalam tutorial ini bisa di download di
http://ecadio.com/arduino-library/dht11/DHTLib.zip
Jika pertama kali anda menggunakan sebuah library, maka library tersebut harus diinstall ke
program Arduino IDE anda. Ada beberapa cara melakukan nya. Cara pertama yang paling mudah
adalah menggunakan menu Sketch – Include Library – Add .Zip Library di Arduino IDE, lalu pilih
zip file yang telah anda download sebelum nya.
Cara kedua adalah extract file zip tersebut, dan copy kan ke folder My Documents, Arduino,
Library
Pastikan anda telah menginstall library untuk DHT11 sebelum mencoba sketch pada tutorial ini.
nama dengan file TUTORIAL_DHT_1.ino dan upload ke board Uno. Buka jendela Serial
Monitor dan akan tampak nilai suhu udara dan kelembaban udara di tempat anda saat ini.
/*
TUTORIAL SENSOR SUHU DAN KELEMBABAN PADA ARDUINO
Pinout :
DHT signal -> D12
Untuk membaca nilai dari pin signal DHT11 dan dijadikan tampilan suhu
dan kelembaban
*/
// include library yang dibutuhkan

// library bisa di download di http://ecadio.com/arduino-

Halaman :
Nama : 52-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
library/dht11/DHTLib.zip
#include <dht.h>
dht SENSOR_DHT; //inisiasi dht
#define DHT_PIN 12 //definisikan DHT_PIN untuk pin 12
void setup()
{
Serial.println("Mencoba Sensor Suhu dan Kelembaban Udara DHT11 pada
Arduino");
}
void loop()
{
int cek = SENSOR_DHT.read11(DHT_PIN);
Serial.print("Temperatur = ");
Serial.print(SENSOR_DHT.temperature,0); //data suhu udara
Serial.write(0xC2); //simbol derajat
Serial.write(0xB0); //simbol derajat
Serial.println("C");
Serial.print("Kelembaban = ");
Serial.print(SENSOR_DHT.humidity,0); //data kelembaban udara
Serial.println(" %");
delay(2000); //delay minimum DHT11
}
Data ditampilkan setiap 2 detik. Untuk sensor DHT11, sensor tersebut memerlukan waktu
‘refresh’ minimal 2 detik sebelum bisa memberikan data lagi.
Mari kita bahas sketch nya
Untuk menggunakan library DHT11 yang telah didownload dan diinstall sebelum nya, kita
gunakan perintah #include

Halaman :
Nama : 53-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
#include <dht.h>
Library dht.h yang kita gunakan meminta untuk kita melakukan inisiasi. Pada sketch ini kita
inisiasi objek dengan nama SENSOR_DHT
dht SENSOR_DHT;
Pada shield yang kita gunakan, sensor DHT11 terhubung ke pin 12
Perintah diatas adalah menyimpan nilai bacaan dari sensor ke variabel integers cek. Library DHT
yang kita gunakan memiliki syntax
Nama_sensor.read11(pin_dht);
Dimana kita telah melakukan inisiasi sebelumnya dengan nama SENSOR_DHT dan pin 12 dengan
nama DHT_PIN
Nilai suhu udara bisa diambil dengan syntax nama_sensor.temperature sehingga bisa kita
tampilkan ke Serial Monitor dengan perintah :
Serial.print(SENSOR_DHT.temperature,0); //data suhu udara
Sedangkan nilai kelembaban udara bisa diambil dengan syntax nama_sensor.humidity
Serial.print(SENSOR_DHT.humidity,0); //data kelembaban udara
Dua perintah berikut adalah untuk menampilkan simbol derajat di Serial Monitor:
Serial.write(0xC2); //simbol derajat

Serial.write(0xB0); //simbol derajat
Penggunaan library memang sangat memudahkan kita yang sedang mempelajari pemrograman
Arduino tingkat pemula, sehingga kita bisa menampilkan data seperti suhu dan kelembaban udara
menggunakan sketch yang cukup ringkas seperti contoh diatas. Yang perlu diingat adalah, setiap
sensor akan memiliki library masing-masing, dan setiap library memiliki aturan dan syntax
masing-masing. Demikian pula untuk sebuah sensor yang sama, misal DHT11 ini, bisa terdapat
banyak pilihan library yang tersedia di internet, jadi bisa jadi anda sama-sama sedang melakukan
pemrograman mengenai DHT11 bersama teman anda, dan hasil nya sama, namun menggunakan
library yang berbeda. Jika kondisi demikian, sketch anda tidak bisa digunakan di komputer teman
anda tersebut dan begitupun sebalik nya, karena pada komputer masing-masing terinstall library
DHT11 yang berbeda pada software Arduino IDE nya.

Halaman :
Nama : 54-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Beberapa tutorial kedepan akan mulai menggunakan beberapa library sesuai dengan sensor atau
alat yang akan digunakan.

Halaman :
Nama : 55-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 15 - Pengenalan menggunakan LCD 1602 dengan modul I2C
Jika sebelumnya kita hanya menampilkan data di Serial Monitor, kini saat nya kita mulai
menggunakan layar LCD untuk menampilkan data.
Layar LCD yang kita gunakan adalah LCD dengan 2 baris dan 16 karakter per baris nya. LCD
jenis ini memiliki backlight yang dapat di kontrol nyala matinya dan dapat diatur juga tingkat
kontras karakter nya.
Sejati nya, untuk mengontrol LCD jenis ini kita harus menggunakan banyak pin I/O dan banyak
kabel. Namun pada kit Compact ini, dengan menggunakan modul I2C yang telah tersolder ke
LCD 1602 kita dapat mempelajari cara mengendalikan LCD ini dengan sangat mudah, hanya
menggunakan 2 kabel saja untuk komunikasi menggunakan I2C yaitu SDA dan SCL (4 kabel jika
dengan VCC dan GND).

Halaman :
Nama : 56-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Apakah I2C itu? I2C (Inter Integrated Circuit) adalah salah satu protokol komunikasi antar alat
atau integrated circuit. Sederhananya, dalam tutorial ini kita menggunakan protokol komunikasi
I2C untuk proses komunikasi data antara microcontroller Arduino dengan board controller LCD
yang akan kita gunakan. Mengapa menggunakan I2C? Karena memudahkan dalam perakitan yang
hanya membutuhkan sedikit kabel untuk komunikasi antar alat nya.
Pada board Arduino UNO, pin untuk komunikasi I2C terletak pada pin A4 (SDA) dan A5 (SCL).
Dua pin tersebut bisa kita gunakan untuk banyak alat yang mendukung komunikasi I2C, seperti
layaknya kita melakukan pararel pada lampu. Lalu bagaimana cara microcontroller mengetahui
alat mana yang akan dihubungi nya dalam komunikasi? Itulah guna nya I2C address. Masing-
masing alat akan memiliki address yang unik untuk membedakan nya.

Halaman :
Nama : 57-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Mari kita hubungkan terlebih dahulu LCD yang telah tersolder modul I2C ke board shield.
Gunakan kabel female-female yang ada dalam kit, cukup 4 lembar untuk menghubungkan VCC di
LCD ke VCC shield, GND ke GND, SDA ke SDA, dan SCL ke SCL. Periksa kembali apakah
kabel telah terpasang dengan benar dan di posisi yang benar sebelum melanjutkan ke langkah
selanjutnya.
nama dengan file TUTORIAL_LCD_1.ino. Sketch tersebut menggunakan library
Newliquidcrystal yang bisa didownload di http://ecadio.com/arduino-library/Newliquidcrystal.zip.
Download dan install library tersebut, dan upload sketch ke board Uno. Buka juga jendela Serial
Monitor.
Halaman :
Nama : 58-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Pada saat pertama kali dinyalakan, layar LCD akan berkedip beberapa kali, dan kemudian muncul
tulisan “Hello Word”
Setelah itu muncul tulisan “Use serial mon” dan “Type to display”. Pada posisi ini, apapun yang
anda ketik di layar Serial Monitor akan ditampilkan di layar LCD. Jangan dilupakan batasan
karakter LCD ini adalah 16 karakter per baris nya.
Sekarang mari kita bahas sketch nya :
/*
TUTORIAL LCD 1602 PADA ARDUINO
MENGGUNAKAN I2C
---TEST FILE---
Pinout LCD :
SDA -> SDA
SCL -> SCL
VCC -> VCC
GND -> GND
*/
#include <Wire.h>
library/lcd/Newliquidcrystal.zip
#include <LiquidCrystal_I2C.h>
//set I2C address untuk Modul I2C LCD, beberapa modul menggunakan 0x3F
atau 0x27
// addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
void setup()
{

Halaman :
Nama : 59-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Serial.begin(115200); // untuk penggunaan input serial monitor
lcd.begin(16, 2); // inisiasi lcd
// ------- blink backlight 3x -------------

for (int i = 0; i < 3; i++)
{
lcd.backlight();
delay(250);
lcd.noBacklight();
delay(250);
}
lcd.backlight(); // nyalakan backlight
//-------- Menulis karakter pada display LCD ------------------

// NOTE: Posisi cursor : (KOLOM, BARIS) mulai dari 0
lcd.setCursor(0, 0); //set cursor untuk mulai pada kolom 0 di baris 0
lcd.print("Hello, world!");
delay(1000);
lcd.setCursor(0, 1); //set kolom 0 baris 1
lcd.print("OTOTRONIK ");
delay(8000);
lcd.clear(); //membersihkan layar
lcd.setCursor(0, 0);
lcd.print("Use Serial Mon");
lcd.print("Type to display");
}
//pada bagian loop, menangkap apa yang ditulis di seial monitor dan
tampilkan ke lcd
void loop()
{
if (Serial.available())
{
delay(100); //tunggu data dari input serial
lcd.clear();
while (Serial.available() > 0)
{
lcd.write(Serial.read()); //tulis ke lcd
}
}
}
Library New Liquid Crystal menggunakan protocol I2C untuk komunikasi dengan board Uno,
oleh karena itu library Wire.h juga dibutuhkan
#include <Wire.h>
Baris selanjutnya dibagian sebeum setup() adalah inisiasi objek yang kita namakan lcd.
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
Pada baris perintah diatas, kita menggunakan address I2C di 0x3F. Beberapa modul ada juga yang
menggunakan address 0x27. Ubahlah address jika tidak muncul karakter di lcd.
Pada bagian setup(), karena kita akan menggunakan Serial Monitor maka harus ada perintah
Serial.begin(115200);

Halaman :
Nama : 60-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Setelah itu, untuk library lcd ini kita harus memberikan perintah berikut di bagian setup()
lcd.begin(16, 2);
dimana angka 16 menunjukkan jumlah karakter dan angka 2 menunjukkan jumlah baris dari jenis
LCD yang akan kita gunakan.
Pada perintah selanjutnya kita akan menampilkan tulisan Hello Word pada baris pertama, dengan
menggunakan perintah :

lcd.print("Hello, world!");
perintah lcd.setCursor(0,0) memerintahkan posisi kursor ke posisi baris 0 dan kolom 0,

atau baris pertama kolom pertama, sebelum mulai menulis karakter.
Perintah lcd.print(“Hello, world!”); adalah merintah untuk menulis karakter Hello

world seperti yang muncul di layar lcd
Untuk menulis di baris kedua, dan di posisi kolom ke 1, pindahkan kursor dengan perintah :
lcd.setCursor(0, 1); //set kolom 0 baris 1
Tulisan berikutnya yang diperintahkan dengan perintah lcd.print() akan muncul di baris
kedua kolom pertama.
Jadi untuk menulis karakter di layar lcd ini, pertama kali yang harus ditentukan adalah di posisi
kursor manakah tulisan akan mulai ditampilkan. Syntax untuk memindahkan kursor adalah
lcd.setCursor(kolom,baris); //set kolom dan baris
dimana kolom dan baris dimulai dari angka 0. Maksimum nilai baris adalah 1 dan maksimum nilai
kolom adalah 15, sehingga total karakter per baris nya adalah 16 karakter dan total baris adalah 2.
Bagian setup selanjutnya adalah perintah yang membuat layar lcd berkedip. Pada baris perintah ini
dibuat pengulangan menghidupkan dan mematikan backlight dari lcd.
for (int i = 0; i < 3; i++)

{
lcd.backlight();
delay(250);
lcd.noBacklight();
delay(250);
}
Perintah lcd.backlight(); akan menyalakan lampu backlight, dan perintah lcd.noBacklight() akan

Halaman :
Nama : 61-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
mematikan nya.
Pengulangan dilakukan dengan struktur perintah for. Pada struktur for diatas, for (int i =
0; i<3 ; i++) berarti pengulangan dari i=0 hingga i<3 dimana i bertambah 1 setiap siklus
for, yang ditulis dengan notasi i++. Perintah yang berada di dalam struktur for tersebut (yang
diawali dan diakhiri kurung kurawal) akan diulang-ulang seperti loop, hingga nilai i tercapai.
Ketika nilai i tercapai, baru perintah selanjutnya setelah loop for tersebut akan mulai di eksekusi.
Pada bagian loop() hanya berisi perintah yang menunggu data dari serial (data yang kita ketik di
Serial Monitor) untuk kemudian di tampilkan di layar lcd.
if (Serial.available())
perintah If tersebut akan di eksekusi hanya jika terdapat data di saluran komunikasi serial.
while (Serial.available() > 0)

{
lcd.write(Serial.read()); //tulis ke lcd
}
Dan di perintah diatas, setiap kali ada data di saluran serial (Serial.available() > 0)
maka tulislah data tersebut ke lcd dengan perintah lcd.write(). Kita gunakan lcd.write()
disini bukan lcd.print() seperti sebelum nya karena data yang masuk di kanal serial dalam
bentuk byte, dan untuk menulis byte menggunakan lcd.write(). Perintah Serial.read()
adalah perintah untuk membaca data dari serial (yang pada contoh kali ini memperoleh input dari
jendela Serial Monitor)
Dengan komunikasi serial seperti itu maka apapun yang anda tulis di jendela Serial Monitor akan
muncul di layar lcd.

Halaman :
Nama : 62-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 16 - LCD dan Nilai Analog dari Potensiometer
Setelah anda bisa menampilkan karakter pada layar LCD 1602 seperti dijelaskan pada tutorial
sebelumnya, maka pada tutorial kali ini kita akan menggabungkan tutorial potensiometer yang
pernah dipelajari untuk ditampilkan ke lcd. Koneksi wiring sama seperti sebelumnya, diperlukan 4
kabel female/female untuk menghubungkan pin I2C pada lcd ke pin header I2C di shield. VCC ke
VCC, GND ke GND, SDA ke SDA dan SCL ke SCL.
nama dengan file TUTORIAL_LCD_2.ino dan upload ke board Uno. Coba lah untuk memutar
lengan potensiometer yang ada pada shield dan perhatikan nilai yang tampil pada layar lcd.
Sketch dari tutorial ini adalah sebagai berikut:
/*
MENGGUNAKAN I2C
MENAMPILKAN NILAI ANALOG DARI POTENSIO
Pinout LCD :
SDA -> SDA
SCL -> SCL
VCC -> VCC
GND -> GND
Potensio center pin -> A0

*/
#include <Wire.h>
//set I2C address untuk Modul I2C LCD, beberapa modul menggunakan 0x3F atau
0x27
void setup()
{
Serial.begin(115200); // memulai komunikasi serial untuk debug
Serial.println("Mencoba potensiometer pada Arduino");

lcd.print("Nilai Potensio");
}
void loop()
{

Halaman :
Nama : 63-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
hasil
lcd.print(hasil);
delay(500);
}
Sekarang anda sudah bisa melihat sketch dan mengerti bagaimana perintah tersebut dilaksanakan.
Pada sketch tersebut nilai analogRead() dari pin potensio pada A0 akan ditampilkan langsung di
layar pada baris 1 kolom 1.

Halaman :
Nama : 64-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 17 - LCD dan Sensor Cahaya LDR
Jika sebelumnya kita menampilkan data dari hasil pembacaan pin A0 ang terhubung ke
potensiometer, kali ini kita akan menampilkan data hasil pembacaan dari LDR yang terdapat pada
shield.
LDR adalah singkatan dari Light Dependent Resistor, yang pada dasarnya adalah sebuah resistor
atau hambatan, hanya saja nilai hambatan nya akan berubah sejalan dengan jumlah intensitas
cahaya yang diterima nya.
Cara kerjanya mirip dengan potensio, akan terjadi terjadi perubahan hambatan tergantung kondisi.
Jika pada potensiometer perubahan terjadi akibat putaran yang kita lakukan terhadap lengan
potensio, pada LDR perubahan terjadi akibat perubahan intensitas cahaya. Seperti halnya pada
tutorial potensiometer, pada LDR pun yang kita manfaatkan adalah perubahan tegangan yang
terjadi akibat perubahan hambatan, yang akan kita tangkap nilai nya dengan perintah
analogRead();

Halaman :
Nama : 65-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Pada modul shield yang kita gunakan, LDR terhubung ke pin A2.
nama dengan file TUTORIAL_LCD_3.ino dan upload ke board Uno. Hasilnya akan ditampilkan
nilai analog dari A2, dan untuk mencoba mengubah nya anda coba halangi LDR tersebut dari
cahaya. Perubahan intensitas cahaya yang diterima oleh LDR akan mengubah nilai yang di
tampilkan.
Sketch dari tutorial LDR ini adalah sebagai berikut :
/*
MENGGUNAKAN I2C
MENAMPILKAN NILAI ANALOG DARI LDR
Pinout LCD :
SDA -> SDA
SCL -> SCL
VCC -> VCC
GND -> GND
LDR -> A2
*/
#include <Wire.h>
0x27
void setup()
{
Serial.println("Mencoba LDR pada Arduino");

lcd.print("Nilai LDR");
void loop()
{
hasil
lcd.print(hasil);
delay(500);
}

Halaman :
Nama : 66-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Jika anda perhatikan, sketch tersebut mirip dengan sketch yang menampilkan nilai potensiometer.
Hal ini sesuai seperti yang dijelaskan pada tutorial potensiometer awal, dimana konsep potensio
itu memang untuk memudahkan kita memahami cara kerja sensor

Halaman :
Nama : 67-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 18 - Menampilkan data Suhu dan Kelembaban Udara di LCD
Sekarang anda sudah bisa menampilkan data dari sensor apapun di layar LCD. Pada tutorial kali
ini kit akan mencoba menampilkan data suhu dan kelembaban udara di layar LCD 1602.
nama dengan file TUTORIAL_LCD_4.ino dan upload ke board Uno. Pada layar LCD akan
ditampilkan suhu ruangan anda saat itu beserta tingkat kelembaban udara nya.
Mari kita buka sketch nya :
/*
MENGGUNAKAN I2C
MENAMPILKAN SUHU DAN KELEMBABAN UDARA
Pinout LCD :
SDA -> SDA
SCL -> SCL
VCC -> VCC
GND -> GND
DHT signal -> D12

*/
#include <Wire.h>
#include <dht.h>
// library dht11 bisa di download di http://ecadio.com/arduino-
// library lcd bisa di download di http://ecadio.com/arduino-

Halaman :
Nama : 68-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
0x27
//inisiasi dht
dht SENSOR_DHT;
//definisikan DHT_PIN untuk pin 12

#define DHT_PIN 12
void setup()
{
Serial.println("Mencoba Sensor Suhu dan Kelembaban Udara DHT11 pada
Arduino");

}
void loop()
{
lcd.print("Temp. : ");
lcd.print(SENSOR_DHT.temperature, 0); //data suhu udara
lcd.print(char(223));//simbol derajat
lcd.print("C");//simbol C
lcd.print("Humid. : ");
lcd.print(SENSOR_DHT.humidity, 0); //data kelembaban udara
lcd.print("%");//simbol C
delay(2000);
}
Sketch tersebut merupakan gabungan dari sketch tutorial DHT11 yang telah anda pelajari sebelum
nya dengan sketch menampilkan data di LCD.
lcd.print(char(223));//simbol derajat
Perintah diatas adalah perintah untuk menuliskan simbol derajat di layar LCD

Halaman :
Nama : 69-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 19 - Pengenalan Seven Segment
Seven segment adalah salah satu jenis display yang sudah cukup lama digunakan. Pada dasar nya
seven segment merupakan rangkaian led yang terdiri dari 7 buah led yang dirangkai sedemikian
rupa sehingga akan menampilkan efek digit sebuah angka yang disusun dalam segment-segment
yang membentuk seperti angka 8. Rangkaian terdiri dari 7 buah segment led inilah yang akhirnya
disebut seven segment
Penamaan segment secara standar terlihat pada gambar diatas. Segment dinamai dari mulai A
hingga G. Sejati nya terdapat 8 led pada seven segment modern, penambahan 1 buah led untuk
titik yang dinamai DP (Dot Point)
Rangkaian seven segment modern terdiri dari rangkaian 8 led yang disusun sedemikian rupa
sehingga memiliki 1 kaki yang dipakai bersama (common) dan 8 kaki yang terpisah. Seperti yang
telah anda pelajari pada tutorial led sebelumnya, dimana kita menggunakan 4 buah led, pada 4
buah led tersebut kaki negatif led semua terhubung ke GND, dan 4 kaki positif led terhubung ke 4
pin I/O. Led akan menyala jika diberi HIGH. Karena kaki negatif led (katode) yang disatukan,

Halaman :
Nama : 70-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
maka disebut rangkaian Common Katode.
Kita bisa juga membuat rangkaian sebalik nya. 4 buah led namun kali ini kaki poisif led (anode)
yang disatukan, dan 4 kaki negatif yang tersisa masing-masing dihubungkan ke pin I/O.
Rangkaian led ini disebut rangkaian Common Anode, dan untuk menyalakan led dengan memberi
nilai LOW
Begitupun dengan rangkaian Seven Segment, terdapat 2 jenis, Common Anode dan Common
Catode. Gambar berikut adalah skematik dari seven segment kedua jenis tersebut
Sekarang bagaimana caranya menyalakan seven segment? Karena seven segment adalah
rangkaian led, maka anda bisa memperlakukan nya seperti led biasa.
Misal anda menggunakan seven segment jenis common cathode, maka seluruh kutub negatif led

Halaman :
Nama : 71-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
telah terhubung ke kaki GND pada seven segment, sehingga anda tinggal menghubungkan GND
ke GND pada board Uno. Untuk masing-masing segment, anda bisa mengubungkan ke masing-
masing pin I/O, misal segment a ke pin 2, segment b ke pin 3, segment c ke pin 4 dan seterus nya.
Untuk menyalakan/mematikan nya tentu tinggal menggunakan perintah digitalWrite() seperti
biasa.
Bagaimana cara menampilkan angka? Efek angka terjadi karena kita menyalakan led yang sesuai.
Misal untuk angka 1 anda menyalakan segmen b dan c. Angka 2 adalah menyalakan segmen a, b,
d, e dan g. Angka 8 adalah semua segment menyala dari a hingga g. Demikian seterus nya.
Dengan demikian anda bisa meilihat sekarang, untuk menyalakan 1 digit seven segment dengan
cara standar, anda memerlukan 7 buah pin I/O di board Uno. Dan untuk menyalakan 4 buah seven
segment seperti pada rangkaian jam digital, anda akan memerlukan 28 pin I/O, sementara pada
board Uno kita hanya memiliki 18 buah pin yang bisa digunakan. Itupun jika anda tidak
menggunakan pin untuk sensor yang akan anda coba tampilkan di seven segment. Kita kehabisan
pin I/O, belum lagi jumlah kabel yang cukup banyak dan merepotkan dalam merangkai nya.
Bagaimana cara mengatasi masalah tersebut? Banyak solusi yang bisa kita ambil.
Penggunaan bantuan chip salah satu nya, dimana pada akhirnya penggunaan jumlah pin I/O dari
micro controller bisa di minimisasi, walaupun kita mengendalikan banyak digit seven segment.
Pada modul shield yang kita gunakan, seven segment yang terpasang adalah seven segment 4
digit, dan telah dirangkai serta menggunakan chip tambahan sehingga anda tidak direpotkan
dengan proses wiring bisa lebih ber konsentrasi dalam coding dan berkreatifitas

Halaman :
Nama : 72-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Mari kita mulai mencoba mengontrol seven segment. Buatlah program (sketch) sederhana melalui
EDITOR pada software “Arduino IDE” dan beri nama dengan file
TUTORIAL_7SEGMENT_1.ino. Sketch ini menggunakan library yang mengontrol chip yang
digunakan. Download library yang dibutuhkan dan install library tersebut. Library bisa di
download di http://ecadio.com/arduino-library/seven-segment/TM1637.zip
Setelah selesai install library, upload sketch ke board Uno. Sketch tersebut adalah sketch Test File
untuk library chip TM1637. Ketika dijalankan, akan tampil beberapa efek di seven segment. Mari
kita kupas sketch Test File tersebut.
/*
TUTORIAL SEVEN SEGMENT PADA ARDUINO
MENGGUNAKAN CHIP TM1637
---TEST FILE---
Pinout :
CLK -> D10
DIO -> D11
*/

// library bisa di download di http://ecadio.com/arduino-library/seven-
segment/TM1637.zip
#include <Arduino.h>
#include <TM1637Display.h>
// Module connection pins (Digital Pins)

#define CLK 10

Halaman :
Nama : 73-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
#define DIO 11
// The amount of time (in milliseconds) between tests

#define TEST_DELAY 2000
const uint8_t SEG_DONE[] =

{
SEG_B | SEG_C | SEG_D | SEG_E | SEG_G, // d
SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F, // O
SEG_C | SEG_E | SEG_G, // n
SEG_A | SEG_D | SEG_E | SEG_F | SEG_G // E
};
TM1637Display display(CLK, DIO);
void setup()
{
}
void loop()
{
int k;
uint8_t data[] = { 0xff, 0xff, 0xff, 0xff };
uint8_t blank[] = { 0x00, 0x00, 0x00, 0x00 };
display.setBrightness(0x0f);
// All segments on
display.setSegments(data);
delay(TEST_DELAY);
// Selectively set different digits

data[0] = display.encodeDigit(0);
delay(TEST_DELAY);
display.clear();
display.setSegments(data+2, 2, 2);
delay(TEST_DELAY);
display.clear();
delay(TEST_DELAY);

Halaman :
Nama : 74-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
display.clear();
delay(TEST_DELAY);
// Show decimal numbers with/without leading zeros

display.showNumberDec(0, false); // Expect: ___0
delay(TEST_DELAY);
display.showNumberDec(0, true); // Expect: 0000
delay(TEST_DELAY);
delay(TEST_DELAY);
delay(TEST_DELAY);
display.showNumberDec(301, false); // Expect: _301
delay(TEST_DELAY);
delay(TEST_DELAY);
display.clear();
display.showNumberDec(14, false, 2, 1); // Expect: _14_
delay(TEST_DELAY);
display.clear();
display.showNumberDec(4, true, 2, 2); // Expect: 04__
delay(TEST_DELAY);
display.showNumberDec(-1, false); // Expect: __-1
delay(TEST_DELAY);
display.showNumberDec(-12); // Expect: _-12
delay(TEST_DELAY);
display.showNumberDec(-999); // Expect: -999
delay(TEST_DELAY);
display.clear();
display.showNumberDec(-5, false, 3, 0); // Expect: _-5_
delay(TEST_DELAY);
display.showNumberHexEx(0xf1af); // Expect: f1Af
delay(TEST_DELAY);
display.showNumberHexEx(0x2c); // Expect: __2C
delay(TEST_DELAY);
display.showNumberHexEx(0xd1, 0, true); // Expect: 00d1
delay(TEST_DELAY);
display.clear();
display.showNumberHexEx(0xd1, 0, true, 2); // Expect: d1__
delay(TEST_DELAY);
// Run through all the dots

for(k=0; k <= 4; k++)
{
display.showNumberDecEx(0, (0x80 >> k), true);

Halaman :
Nama : 75-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
delay(TEST_DELAY);
}
// Brightness Test
for(k = 0; k < 4; k++)
data[k] = 0xff;
for(k = 0; k < 7; k++)
{
display.setBrightness(k);
delay(TEST_DELAY);
}
// On/Off test
for(k = 0; k < 4; k++)
{
display.setBrightness(7, false); // Turn off
delay(TEST_DELAY);
display.setBrightness(7, true); // Turn on
delay(TEST_DELAY);
}
// Done!
display.setSegments(SEG_DONE);
while(1);
}
Chip TM1637 hanya menggunakan 2 pin I/O yang pada modul shield menggunakan pin 11 untuk
DIO (Data In Out) dan pin 10 untuk CLK (Clock). Penggunaan pin tersebut kita definisikan untuk
mempermudah pemrograman dan debug
#define CLK 10
#define DIO 11
Sketch ini menggunakan library, sehingga harus ada baris yang memasukkan file library ke sketch
ini.
Library Arduino.h diperlukan juga agar library TM6127Display.h bisa bekerja dengan sempurna.

Halaman :
Nama : 76-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
const uint8_t SEG_DONE[] =
{
SEG_B | SEG_C | SEG_D | SEG_E | SEG_G, // d
SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F, // O
SEG_C | SEG_E | SEG_G, // n
SEG_A | SEG_D | SEG_E | SEG_F | SEG_G // E
};
Perintah diatas adalah membuat sebuah array bernama SEG_DONE[] dimana didalam nya berisi
segmen-segmen mana yang akan dinyalakan per digit nya. Hasil dari array ini nanti adalah
ditampilkan nya tulisan “d0nE” pada seven segment.

Perintah tersebut adalah membuat array dengan nama data[] yang berisi nilai hex 0xff untuk
masing-masing digit. Ingat kita memiliki 4 digit. Efek yang timbul nanti dari array ini adalah
semua segment akan dinyalakan, termasuk titik.
uint8_t blank[] = { 0x00, 0x00, 0x00, 0x00 };
Serupa dengan perintah sebelumnya, perintah diatas membuat lagi sebuah array dengan nama
blank[] yang berisi nilai hex 0x00 pada setiap digit nya. Efek yang akan timbul dari array ini
adalah semua segment akan padam.
Perintah diatas adalah untuk men set timngkat kecerahan dari led seven segment. Nilai nya adalah
dari 0 hingga 15, dan di contoh diatas diisi 0x0f dalam hex atau 15 dalam decimal.
Perintah display.setSegments() diatas me load array data[] yang telah kita buat sebelum
nya. Array data[] menyalakan semua segment termasuk titik
Pada perintah tersebut masing-masing slot array diisi dengan nilai. Untuk digit pertama diisi
dengan 0 melalui perintah data[0] = display.encodeDigit(0); sehingga pada digit

Halaman :
Nama : 77-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
pertama akan ditampilkan angka 0. Hasil dari deretan perintah tersebut adalah ditampilkan 0123
display.clear();
Perintah display.clear() digunakan untuk membersihkan seluruh layar, sehingga tidak ada
sisa segment yang menyala yang bisa menggangg tampilan perintah selanjutnya
Hasil dari perintah setSegments diatas adalah dimunculkan angka 23 yang mulai tampil di digit
ke 3, jadi angka 2 di digit 3 dan angka 3 di digit 4. Dari mana angka 2 dan 3 berasal? Dari array
data[] yang di buat pada perintah baris sebelumnya yaitu
Mengapa bukan dari data[0] yang berisi angka 0? Karena ada nilai data+2 di perintah
setSegments nya, yang berarti ambil lah data mulai dari data ke 0+2 atau sama dengan 2. Nilai 2
ditengan berarti ambillah 2 buah data, berarti terambil angka 2 dan angka 3. Nilai 2 terakhir pada
perintah display.setSegments(data+2, 2, 2); adalah menentukan posisi digit dimana
akan ditampilkan, yaitu digit ke 3, karena hitungan nya adalah 0,1,2,3.
Lebih jelasnya perhatikan perintah berikut nya
Perintah diatas memunculkan angka 23 yang disimpan ditengah, atau dimulai dari digit ke 2.
Perhatikan angka posisi pada perintah tersebut adalah 1, berarti mulai di digit ke 2
Perintah tersebut memunculkan angka 123 yang dimulai dari digit ke 2, atau tampak tulisan 123
rata kanan pada display seven segment 4 digit yang kita gunakan.
Perintah tersebut akan memunculkan angka 0 yang disimpan rata kanan. Nilai false disini
memerintahkan untuk tidak menggunakan leading zero atau angka 0 lain nya didepan nilai yang
akan ditampilkan.

Halaman :
Nama : 78-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Ini adalah contoh ketika akan menampilkan angka 0, tapi dengan leading zero, nilai true disana
yang membedakan dengan baris sebelumnya, sehingga akan tampil 0000 di seven segment
Perintah showNumberDec akan menampilkan angka dengan rata kanan. True untuk
menambahkan 0 didepan nilai, false untuk tidak menambahkan 0. Variasi dari contoh serupa
adalah perintah-perintah setelah nya :

display.showNumberDec(301, false); // Expect: _301
Variasi lain dari perintah showNumberDec() adalah seperti perintah selanjutnya
display.showNumberDec(14, false, 2, 1); // Expect: _14_
Pada perintah tersebut, nilai 2 adalah menunjukkan 2 karakter yang diambil, nilai 1 menunjukkan
posisi digit. Nilai posisi disitu adalah 1 yang berarti akan ditampilkan mulai dari digit ke 2. Hasil
dari perintah tersebut adalah ditampilkan angka 14 di tengah tengah seven segment 4 digit
Perintah-perintah selanjutnya adalah variasi dari showNumberDec() yang akan dengan mudah
anda pahami setelah memahami penjelasan diatas. Perintah yang akan berbeda adalah
display.showNumberHexEx(0xf1af); // Expect: f1Af
Disitu kita memunculkan bukan nilai desimal, tapi nilai hex dengan perintah
showNumberHexEx(). Pada perintah diatas, akan ditampilkan f1Af pada seven segment. Nilai
hex yang bisa kita gunakan adalah 0 sampai 9, dan a sampai f. Nilai akan ditampilkan rata kanan,
dan berlaku juga syntax seperti sebelumnya dimana penggunaan true dan false untuk leading zero,
serta posisi dimulai nya karakter ditampilkan, seperti perintah berikut :
display.showNumberHexEx(0x2c); // Expect: __2C

display.showNumberHexEx(0xd1, 0, true); // Expect: 00d1
display.showNumberHexEx(0xd1, 0, true, 2); // Expect: d1__
Perintah selanjutnya adalah memunculkan angka 0000 pada display, dengan titik yang menyala
dari kiri ke kanan bergantian, atau dari titik posisi 1 ke titik posisi 2 demikian hingga 4 (ada 4 titik
pada seven segment yang kita pergunakan)

Halaman :
Nama : 79-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
for(k=0; k <= 4; k++)
{
display.showNumberDecEx(0, (0x80 >> k), true);
delay(TEST_DELAY);
}
Perintah selanjutnya adalah struktur loop menggunakan for untuk mengubah nilai brightness atau
tingkat kecerahan led dari redup ke terang
for(k = 0; k < 4; k++)

data[k] = 0xff;
for(k = 0; k < 7; k++)
{ display.setBrightness(k);
delay(TEST_DELAY);
}
Untuk mengubah nilai brightness, gunakan perintah display.setBrightness() yang diisi

nilai parameter 0 hingga 15
Penggunaan parameter false pada perintah setBrightness() akan memadamkan led, dan
parameter true akan menyalakan nya kembali, seperti pada perintah berikut nya
display.setBrightness(7, false); // Turn off

display.setBrightness(7, true); // Turn on
Sketch ini tidak menggunakan bagian loop(), perintah-perintah tersebut diatas disimpan di
bagian setup() sehingga hanya sekali saja di laksanakan. Jika anda ingin mengulangi melihat
efek-efek yang ditampilkan, anda harus me reset board Uno atau mencabut kabel usb/sumber
tegangan untuk memulai kembali perintah dalam bagian setup().
Silahkan ber eksperimen dengan test file dari library seven segment ini. Metode-metode ini akan
kita gunakan dalam tutorial-tutorial selanjutnya untuk menampilkan data-data nilai bacaan pin atau
sensor ke seven segment.

Halaman :
Nama : 80-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 20 - Penggunaan TM1637 pada Seven Segment
Tutorial kali ini adalah versi singkat nya dari tutorial seven segment sebelumnya. Pada sketch
yang akan kita coba kali ini, anda bisa melihat secara lebih sederhana dan efektif penggunaan
library TM1637 untuk menampilkan data pada seven segment.
nama dengan file TUTORIAL_7SEGMENT_2.ino dan upload ke board Uno. Akan tampil
beberapa angka dan tulisan. Berikut adalah sketch nya :
/*
MENULIS DIGIT
Pinout :
CLK -> D10
DIO -> D11
*/

segment/TM1637.zip

#define CLK 10
#define DIO 11
//custom karakter
const uint8_t SEG_HORE[] =
{
SEG_C | SEG_E | SEG_F | SEG_G, // h
SEG_C | SEG_D | SEG_E | SEG_G, // o
SEG_E | SEG_G, // r
SEG_A | SEG_B | SEG_D | SEG_E | SEG_F | SEG_G // e
};
void setup()
{
}
void loop()
{
// menampilkan digit manual per digit

data[0] = display.encodeDigit(6); //menampilkan angka 6 di digit ke 1
delay(TEST_DELAY);

Halaman :
Nama : 81-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
// Menampilkan angka 81 rata kanan
display.showNumberDec(81, false);
delay(TEST_DELAY);
// Menampilkan angka 76 rata kanan didahului angka 0

display.showNumberDec(76, true);
delay(TEST_DELAY);
//menampilkan huruf hex ECA

display.showNumberHexEx(0xeca);
delay(TEST_DELAY);
//menampilkan huruf hex DIO

display.showNumberHexEx(0xd10);
delay(TEST_DELAY);
display.setSegments(SEG_HORE);
delay(TEST_DELAY);
}
Bisa anda lihat sketch tersebut lebih sederhana dan lebih mudah dipahami dari pada sketch test
file sebelum nya. Jadikan sketch ini sebagai pegangan dan acuan untuk tutorial seven segment
selanjutnya.

Halaman :
Nama : 82-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 21 - Menampilkan Nilai Analog Potensiometer Ke Seven Segment
Seperti tutorial-tutorial sebelumnya, pada display seven segment ini pun kita akan belajar
menampilkan nilai yang paling sederhana dulu yaitu nilai yang diperoleh dari potensio di pin I/O.
nama dengan file TUTORIAL_7SEGMENT_3.ino dan upload ke board Uno. Ketika dijalankan,
akan tampil nilai dari analogRead() pin yang terhubung ke potensio pada display seven
segment. Nilai akan berubah-ubah sejalan dengan putaran lengan potensio.
Berikut adalah sketch nya :
/*
MENAMPILKAN NILAI ANALOG POTENSIO
Pinout :
CLK -> D10
DIO -> D11
POTENSIO -> A0
*/

segment/TM1637.zip

#define CLK 10
#define DIO 11
#define pinPotensio A0
void setup()
{
pinMode(pinPotensio, INPUT);
}
void loop()
{
int nilaiPot = analogRead(pinPotensio);
// Menampilkan angka potensio rata kanan

display.showNumberDec(nilaiPot, false);
delay(TEST_DELAY);
}
Terlihat cukup singkat dan sederhana sketch tersebut. Anda pun sekarang sudah bisa mulai cepat
membaca sketch dan alur konsep program, hasil dari kerja keras anda mempelajari tutorial-tutorial

Halaman :
Nama : 83-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
sebelum nya.
Pada sketch tersebut, nilai yang diperoleh dari analogRead() di pin A0 yang terhubung ke
potensio langsung ditampilkan ke seven segment menggunakan perintah showNumberDec(),
sehingga setiap putaran pada lengan potensio akan merubah nilai yang tampil pada seven segment.

Halaman :
Nama : 84-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 22 - Menampilkan Counter
Pada tutorial kali ini kita akan membuat sebuah counter per detik yang ditampilkan pada layar
display seven segment. Buatlah program (sketch) sederhana melalui EDITOR pada software
“Arduino IDE” dan beri nama dengan file TUTORIAL_7SEGMENT_4.ino dan upload ke board
Uno. Ketika dijalankan, akan tampil counter yang akan bertambah setiap detik.
Berikut adalah sektch nya :
/*
MENAMPILKAN COUNTER PER DETIK
Pinout :
CLK -> D10
DIO -> D11
*/

segment/TM1637.zip

#define CLK 10
#define DIO 11
#define TEST_DELAY 1000 //1 detik
int angka = 0; //variabel counter awal
void setup()
{
}
void loop()
{
// Menampilkan angka counter rata kanan didahului angka nol
display.showNumberDec(angka, true);
delay(TEST_DELAY);
angka++ ; //tambah 1
if (angka == 9999) //kalau mencapai 9999 balikkan ke 0

{
angka = 0;
}
}
Konsep dari sketch ini cukup sederhana. Nilai dari variabel integer “angka” yang pada awal diberi
nilai 0 akan selalu di tambah 1 dengan delay 1 detik pada setiap loop. Dengan demikian akan
ditampilkan efek counter yang akan selalu bertambah setiap detik pada seven segment.

Halaman :
Nama : 85-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
display.showNumberDec(angka,true);
delay(TEST_DELAY);
angka++ ; //tambah 1
Pada baris perintah tersebut, perintah display.showNumberDec(angka,true); akan

menampilkan nilai dari variabel angka saat itu dengan leading zero atau diawali dengan beberapa
angka nol.
Perintah angka++ adalah sama dengan perintah angka = angka +1; yang berarti selalu
menambahkan nilai dari variabel angka dengan 1.

{
angka = 0;
}
Perintah diatas me reset nilai dari variabel angka ke 0, jika nilai variabel angka telah mencapai
9999, karena kita menggunakan seven segment 4 digit yang secara matematis hanya bisa
menampilkan digit 9999 sebagai nilai tertinggi.

Halaman :
Nama : 86-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 23 - Menampilkan Countdown
Tutorial kali ini adalah kebalikan dari tutorial counter sebelum nya. Buatlah program (sketch)
sederhana melalui EDITOR pada software “Arduino IDE” dan beri nama dengan file
TUTORIAL_7SEGMENT_5.ino dan upload ke board Uno. Akan tampil counter 1 menit dari
detik ke 60 ke detik 0 dengan interval 1 detik.
Sketch nya adalah sebagai berikut :
/*
MENAMPILKAN COUNTER COUNTDOWN PER DETIK
Pinout :
CLK -> D10
DIO -> D11
*/

segment/TM1637.zip

#define CLK 10
#define DIO 11
#define TEST_DELAY 1000 //1 detik
int angka = 60; //variabel counter awal
void setup()
{
}
void loop()
{
// Menampilkan angka counter rata kanan tanpa didahului angka nol
display.showNumberDec(angka, false);
delay(TEST_DELAY);
angka-- ; //kurang 1

{
angka = 60;
}
}
Sketch tersebut mirip dengan sketch counter. Bedanya pada sketch counter dilakukan
penambahan dengan perintah angka++, disini menggunakan perintah pengurangan dengan
angka--;.

Halaman :
Nama : 87-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 24 - Menampilkan Nilai Analog LDR Pada Seven Segment
Di tutorial ini kita akan menggabungkan tutorial LDR sebelum nya dengan tutorial seven segment,
dimana nilai analog yang diperoleh dari LDR akan ditampilkan pada seven segment.
nama dengan file TUTORIAL_7SEGMENT_6.ino dan upload ke board Uno. Akan tampil nilai
analog dari LDR yang akan berubah-ubah tergantung intensitas cahaya yang diterima oleh LDR.
/*
MENAMPILKAN NILAI ANALOG LDR
Pinout :
CLK -> D10
DIO -> D11
LDR -> A2
*/

segment/TM1637.zip

#define CLK 10
#define DIO 11
#define pinLdr A2
void setup()
{
pinMode(pinLdr, INPUT);
}
void loop()
{
int nilaiLdr = analogRead(pinLdr);
// Menampilkan angka potensio rata kanan

display.showNumberDec(nilaiLdr, false);
delay(TEST_DELAY);
}
Konsep dari sektch ini adalah mengambil nilai analog dari pin A2 dimana pada modul shield yang
kita gunakan pin tersebut terhubung dengan LDR. Nilai yang terbaca oleh perintah
analogRead() kemudian ditampilkan ke seven segment dengan perintah showNumberDec().

Halaman :
Nama : 88-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Nilai false yang digunakan dalam perintah berarti nilai ditampilkan pada seven segment tanpa
leading zero, tanpa diawali angka 0.

Halaman :
Nama : 89-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 25 - Menampilkan Suhu dan Kelembaban Udara pada Seven Segment
Tutorial ini menggabungkan tutorial seven segment dengan tutorial DHT11 sehingga kita bisa
menampilkan nilai yang terbaca oleh sensor suhu dan kelembaban udara DHT11 ke seven
segment.
nama dengan file TUTORIAL_7SEGMENT_7.ino dan upload ke board Uno. Akan ditampilkan
suhu dan kelembaban udara saat itu secara bergantian pada seven segment.
/*
MENAMPILKAN SUHU DAN KELEMBABAN UDARA DHT11
Pinout :
CLK -> D10
DIO -> D11
DHT signal -> D12

*/

segment/TM1637.zip
#include <dht.h>

#define CLK 10
#define DIO 11
#define DHT_PIN 12
//inisiasi TM1637
//inisiasi dht
dht SENSOR_DHT;
void setup()
{
}
void loop()
{
// Menampilkan angka suhu rata kanan

display.showNumberDec(SENSOR_DHT.temperature, false,2,0);
delay(TEST_DELAY);
display.clear();
display.showNumberDec(SENSOR_DHT.humidity, false,2,2);

Halaman :
Nama : 90-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
delay(TEST_DELAY);
display.clear();
}
Jika anda telah memahami tutorial DHT11 dan tutorial awal seven segment tentunya anda tidak
akan kesulitan membaca dan memahami sketch diatas.

Halaman :
Nama : 91-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 26 - Membuat Jam Digital
Seven segment seringkali kita jumpai digunakan pada jam digital. Oleh karena itu pada tutorial
kali ini kita akan membuat jam digital menggunakan Arduino dan seven segment.
Ada beberapa tutorial yang harus sudah anda pahami sebelum membuat jam digital pada tutorial
ini. Disini akan digabungkan beberapa tutorial yang telah dijelaskan sebelum nya yaitu tutorial
Led, Push Button, Counter, dan tentunya Seven Segment.
nama dengan file TUTORIAL_7SEGMENT_8.ino dan upload ke board Uno. Akan tampil waktu
dalam format 4 digit, 2 digit untuk jam dan 2 digit untuk menit. Empat buah led yang biasa kita
gunakan sebelum nya pun akan berfungsi sebagai penunjuk detik.
Mari kita bahas sketch nya :

/*
MEMBUAT JAM DIGITAL
Pinout :
CLK -> D10
DIO -> D11
Tombol 1 -> D9
Tombol 2 -> D8
D4 -> Led Merah

D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/

segment/TM1637.zip

#define CLK 10
#define DIO 11
#define merah 4
#define hijau 5
#define biru 6
#define kuning 7
#define TOMBOL1 9
#define TOMBOL2 8
//inisiasi TM1637
int jam = 10;

int menit = 30;
int detik = 0;
int waktu;

Halaman :
Nama : 92-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
void setup()
{
pinMode(hijau, OUTPUT);
pinMode(merah, OUTPUT);
pinMode(TOMBOL1, INPUT);
}
void loop()
{
detik++;
if (detik == 60)
{
detik = 0;
menit++;
}
if (menit == 60)
{
menit = 0;
jam++;
}
if (jam == 24)
{
jam = 0;
}
waktu = (jam * 100) + menit;

cekLed();
display.showNumberDecEx(waktu, (0x80 >> 1), true);

delay(500);
display.showNumberDec(waktu, true);
delay(500);
if (digitalRead(TOMBOL1) == LOW)
{
jam++;
detik = 0;
}
{
menit++;
detik = 0;
}
}
void cekLed()
{
if(detik>=0 && detik<15)
{
digitalWrite(kuning,HIGH);
digitalWrite(biru,LOW);
digitalWrite(hijau,LOW);
digitalWrite(merah,LOW);
}
{
digitalWrite(biru,HIGH);
}

Halaman :
Nama : 93-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
{
digitalWrite(hijau,HIGH);
}
{
digitalWrite(merah,HIGH);
}
}
Konsep dari sketch ini adalah, menampilkan jam dan menit pada seven segment, serta detik
berlalu pada 4 led.
Pada bagian sebelum setup(), beberapa variabel di tentukan dimuka.
int jam = 10;

int menit = 30;
int detik = 0;
int waktu;
Variabel jam diberi nilai awal 10, menit diberi 30, dan variabel detik diberi 0. Variabel integer
waktu akan digunakan sebagai variabel untuk menyimpan nilai yang akan ditampilkan sebagai
waktu pada seven segment
Untuk menghitung waktu, loop dibuat dengan delay 1 detik. Diawal loop(), diberi perintah
untuk penambahan variabel detik, sehingga nilai variabel detik akan selalu bertambah setiap loop,
yang dalam hal ini setiap loop menggunakan total delay 1 detik sehingga akan bertambah setiap
detik.
detik++;
Perintah selanjutnya adalah penggunaan struktur IF untuk mengolah data menit dan jam. Dalam
menghitung waktu sebagai jam digital, jumlah detik maksimal adalah 60, dan pada detik ke 60
maka jumlah menit akan bertambah. Begitupun dengan jumlah jam. Jumlah jam akan bertambah
ketika jumlah menit mencapai mencapai nilai maximal 60.
if (detik == 60)
{
detik = 0;
menit++;
}
if (menit == 60)
{
menit = 0;
jam++;
}
if (jam == 24)

Halaman :
Nama : 94-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
{
jam = 0;
}
Variabel detik juga harus kembali menjadi 0 ketika sudah mencapai 60. Begitupun dengan
variabel menit. Variabel jam harus kembali ke 0 setelah mencapai 24. Pada sketch jam digital kali
ini kita akan menampilkan jam dalam format 24h.
Perintah selanjutnya adalah memanipulasi nilai jam dan menit yang diperoleh sebelum nya
menjadi sebuah nilai integer 4 digit yang disimpan ke variabel integer bernama waktu. Jadi misal
diperoleh nilai jam 10 dan nilai menit 30 maka nilai variabel waktu harus 1030 agar bisa
ditampilkan di seven segment dengan perintah showNumberDec(). Cara sederhana nya adalah
dengan mengalikan nilai jam dengan 100 dan menambahkan dengan nilai menit.
Perintah selanjutnya adalah untuk melakukan pemeriksaan telah sampai detik keberapa kah saat
itu dan tampilkan dengan 4 led. Perintah yang digunakan adalah memanggil sub program
cekLed(), dimana didalamcub program cekLed() berisi struktur IF yang akan menyalakan
jumlah led sesuai dengan jumlah detik.
void cekLed()
{
{
}
{
}
{
}
{
}
Semakin mendekati detik ke 60 maka jumlah led yang menyala akan semakin banyak, dengan

Halaman :
Nama : 95-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
total jumlah led yang akan menyala adalah 4 buah.
Perintah selanjutnya adalah untuk menampilkan nilai waktu pada seven segment, namun tidak
hanya menampilkan waktu tapi juga menampilkan efek detik berdetak pada satu titik led di tengah
seven segment sebagai penanda detik yang berdetak seperti layaknya jam digital. Trik yang
digunakan adalah menampilkan data waktu beserta titik di tengah selama 1/2 detik untuk
kemudian menampilkan data waktu tanpa titik selama 1/2 detik. Dengan demikian akan diperoleh
efek berdetak seperti yang diinginkan. Perintah yang digunakan adalah

delay(500);
delay(500);
Total delay menjadi 1 detik seperti yang direncanakan sebelum nya.
Perintah selanjunya adalah menangkap nilai dari push button A dan push button B. Kedua tombol
tersebut kita manfaat kan sebagai tombol untuk men set jam dan menit. Konsep nya seperti
konsep push button yang telah dijelaskan pada tutorial Push Button, namun disini setiap
penekanan tombol maka akan terjadi penambahan nilai variabel. Pada tombol A akan menambah
nilai variabel jam, pada tombol B akan menambah nilai variabel menit.
{
jam++;
detik = 0;
}
{
menit++;
detik = 0;
}
Selamat, anda telah berhasil membuat jam digital sendiri. Untuk menyesuaikan waktu anda tinggal
menekan tombol A dan tombol B sehingga jam menampilkan waktu yang tepat. Gunakan baterai
9V dan kancing baterai yang disediakan sehingga board Uno dan shield anda bisa anda pajang di
meja.
Jam digital ini akan menghitung waktu terus menerus selama arduino tetap nyala. Ketika arduino
di reset atau kehilangan sumber tegangan, maka nilai waktu akan kembali ke nilai awal yang di set
di bagian sebelum setup().

Halaman :
Nama : 96-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 27 - Jam Digital Tanpa Delay() dan Menggunakan Debounce
Tutorial ini adalah pengembangan dari tutorial membuat jam digital sebelum nya. Pada tutorial ini,
penggunaan perintah delay() dihilangkan dan diganti dengan penggunaan perintah millis(). Input
tombol juga di tambahkan algoritma debouce untuk data input yang lebih valid. Oleh karena itu
anda harus sudah memahami tutorial penggunaan millis() dan penggunaan debounce seperti yang
telah dijelaskan sebelum nya untuk bisa memahami sketch pada tutorial ini.
nama dengan file TUTORIAL_7SEGMENT_9.ino dan upload ke board Uno. Jika dijalankan,
hasilnya akan sama dengan jam digital sebelumnya, namun pada sketch nya tidak terdapat
perintah delay(). Yang akan lebih terasa adalah penambahan algoritma debounce pada tombol,
sehingga penekanan tombol A dan B untuk set jam dan menit akan terasa lebih natural.
/*
MEMBUAT JAM - TANPA MENGGUNAKAN DELAY()
GABUNG PENGGUNAAN DEBOUNCE PADA TOMBOL
Pinout :
CLK -> D10
DIO -> D11
Tombol 1 -> D9
Tombol 2 -> D8
D4 -> Led Merah

D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/

segment/TM1637.zip

#define CLK 10
#define DIO 11
#define merah 4
#define hijau 5
#define biru 6
#define kuning 7
#define TOMBOL1 9
#define TOMBOL2 8
TM1637Display display(CLK, DIO); //inisiasi TM1637
int jam = 10;

int menit = 30;

Halaman :
Nama : 97-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
int detik = 0;
int waktu;
int statusTitik = 0;
unsigned long millisSebelumnya1 = 0;

unsigned long millisSebelumnya2 = 0;
unsigned long waktuDebounceTerakhir1 = 0;

unsigned long waktuDebounceTerakhir2 = 0;
unsigned long delayDebounce = 50;
int statusTombol1;
int statusTombol2;
int statusTerakhirTombol1 = HIGH;
int statusTerakhirTombol2 = HIGH;
void setup()
{
pinMode(hijau, OUTPUT);
}
void loop()
{
unsigned long millisSekarang1 = millis();
if (millisSekarang1 - millisSebelumnya1 >= 1000)
{
millisSebelumnya1 = millisSekarang1;
detik++;
}
if (detik == 60)
{
detik = 0;
menit++;
}
if (menit == 60)
{
menit = 0;
jam++;
}
if (jam == 24)
{
jam = 0;
}
cekLed();

{
statusTitik = !statusTitik;
}
if (statusTitik == 0)
{
} else
{
display.showNumberDec(waktu, true);
}

Halaman :
Nama : 98-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
if (a != statusTerakhirTombol1)
{
waktuDebounceTerakhir1 = millis();
}
if ((millis() - waktuDebounceTerakhir1) > delayDebounce)
{
if (a != statusTombol1)
{
statusTombol1 = a;
if (statusTombol1 == LOW)
{
jam++;
detik = 0;
}
}
}
statusTerakhirTombol1 = a;
int b = digitalRead(TOMBOL2);
if (b != statusTerakhirTombol2)
{
waktuDebounceTerakhir2 = millis();
}
if ((millis() - waktuDebounceTerakhir2) > delayDebounce)
{
if (b != statusTombol2)
{
statusTombol2 = b;
if (statusTombol2 == LOW)
{
menit++;
detik = 0;
}
}
}
statusTerakhirTombol2 = b;
}
void cekLed()
{
if (detik >= 0 && detik < 15)
{
}
{
}
{
}
{

Halaman :
Nama : 99-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
}
}
Pada sketch tersebut, penggunaan perintah millis() cukup intensif. Delay 1 detik pada sketch
sebelum nya diganti dengan perintah

{
detik++;
}
Sedangkan untuk millis() pada baris-baris perintah selanjutnya digunakan untuk algoritma
debounce pada tombol-tombol.

Halaman :
Nama : 100-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 28 - Pengenalan Sensor Suhu Thermistor NTC
Pada modul Shield yang kita gunakan, terdapat sensor suhu lain selain sensor suhu dan
kelembaban udara DHT11, yaitu sensor suhu Thermistor atau NTC. NTC adalah singkatan dari
Negative Temperature Coefficient. Thermistor pada dasarnya adalah resistor atau hambatan yang
nilai nya akan berubah-ubah tergantung suhu yang diterima nya. Karena bersiftat seperti resistor
yang dapat berubah, berarti bersifat seperti potensiometer, sehingga bisa kita gunakan sketch yang
mirip dengan tutorial Potensiometer sebelum nya untuk menangkap nilai analog dari sensor
Thermistor ini.
nama dengan file TUTORIAL_NTC_1.ino dan upload ke board Uno. Buka juga jendela Serial
Monitor. Akan tampak nilai analog dari pin A1 yang pada Shield terhubung ke Thermistor.
Mari kita lihat sketch nya
/*
TUTORIAL NTC PADA ARDUINO
MEMBACA NILAI ANALOG DARI NTC
Pinout :
NTC -> A1
*/
void setup()
{
delay(100);

Halaman :
Nama : 101-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Serial.println("Mencoba baca nilai Analog NTC pada Arduino");
}
void loop()
{
hasil
Serial.println("Nilai analog dari NTC : " + String(hasil)); //tampilkan pada
serial monitor
}
Anda bisa perhatikan sketch tersebut mirip dengan tutorial Potensiometer sebelumnya, dimana
kita mengambil data yang dibaca oleh perintah analogRead() di pin A1 dan menampilkan nya
di Serial Monitor. Nilai tersebut berubah-ubah tergantung suhu di dekat sensor Thermister NTC

Halaman :
Nama : 102-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 29 - Sensor Suhu Thermister NTC dan Seven Segment
Tutorial kali ini adalah lanjutan tutorial NTC sebelumnya. Jika pada tutorial sebelum nya kita
hanya mengambil dan menampilkan nilai analog dari pin yang terhubung ke NTC, pada tutorial
sekarang kita akan menampilkan dalam satuan derajat celcius.
Proses konversi dari nilai analog ke nilai dalam satuan derajat celcius yang sesuai dengan standar
memerlukan perhitungan yang cukup rumit. Untunglah sudah ada yang membuat algoritma
tersebut dalam bentuk file library, sehingga kita tinggal menggunakan library tersebut.
Sketch pada tutorial ini menggunakan library yang bisa didownload di http://ecadio.com/arduino-
library/NTC/EcadioNTC.zip. Download dan install library tersebut ke Arduino IDE.
nama dengan file TUTORIAL_NTC_2.ino dan upload ke board Uno. Hasilnya adalah akan
ditampilkan suhu pada NTC di seven segment saat itu, dalam satuan derajat celcius. Cobalah
untuk menyentuh NTC dengan tangan anda, maka suhu NTC akan berubah karena terkena panas
tubuh.
Mari kita lihat sketch nya :
/*
TUTORIAL NTC PADA ARDUINO
MEMBACA NILAI ANALOG DARI NTC
Pinout :
NTC -> A1
CLK -> D10
DIO -> D11
*/
#include "EcadioNTC.h"
//download library di http://ecadio.com/arduino-library/NTC/EcadioNTC.zip

#define NTC_PIN A1
#define CLK 10
#define DIO 11
TM1637Display display(CLK, DIO); //inisiasi

NTC temper(NTC_PIN);
void setup()
{
delay(100);
Serial.println("Baca suhu NTC pada Arduino");
}

Halaman :
Nama : 103-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
void loop()
{
float suhu;
suhu = temper.getTemperature();
Serial.print("Temperature pada board : ");
Serial.print(suhu);
Serial.write(0xC2);//simbol derajat
Serial.write(0xB0);//simbol derajat
Serial.println("C");
display.showNumberDec(suhu, false);
delay(1000);
}
Pada sketch tersebut kita menggunakan library EcadioNTC selain library Seven Segment sehingga
kita harus memiliki baris perintah berikut sebelum setup()
Pada modul shield, sensor Thermister NTC terhubung ke pin A1
Dan inisiasi library NTC dilakukan dengan perintah :
NTC temper(NTC_PIN);
Nilai suhu dalam celcius diperoleh dengan perintah temper.getTemperature(); yang

disimpan di variabel bernama suhu. Untuk menampilkan di seven segment dengan perintah
display.showNumberDec(suhu, false);
perintah display.showNumberDec() adalah perintah library seven segment yang telah

dipelajari pada tutorial sebelum nya

Halaman :
Nama : 104-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 30 - Pengenalan Buzzer
Pada tutorial kali ini adalah saat nya kita membuat Arduino mulai bersuara. Output dalam bentuk
suara sering digunakan pada microcontroller sebagai output tambahan selain visual, misal untuk
peringatan atau notifikasi.
Komponen yang kita gunakan pada tutorial ini adalah Buzzer yang berjenis passive buzzer, yang
sifatnya mirip dengan speaker, akan menghasilkan getaran suara tergantung dari tegangan yang
diberikan. Dengan demikian prinsip yang akan diterapkan adalah metode output, dimana kita akan
memberikan tegangan ke sebuah pin yang diatur sedemikian rupa sehingga menghasilkan getaran
suara pada buzzer.
nama dengan file TUTORIAL_Buzzer_1.ino dan upload ke board Uno. Ketika sketch berjalan,
akan terdengar nada dari C dan C’ pada buzzer. Mari kita lihat sketch nya
/*
TUTORIAL PASSIVE BUZZER PADA ARDUINO
D3 -> Passive Buzzer +
*/
#define pinBuzzer 3 //buzzer pada pin D3
void setup()
{
pinMode(pinBuzzer, OUTPUT); //set menjadi output
}
void loop()

Halaman :
Nama : 105-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
{
for (int i = 0; i < 2; i++)
{
playTone(261.63, 350);
delay(1000);
}
for (int j = 0; j < 2; j++)
{
playTone(523.25, 350);
delay(1000);
}
}
void playTone(long note, long millisecond)

{
long frequency = note;
long length = millisecond;
if (frequency > 0)
{
long delayValue = 1000000 / frequency / 2;
/* calculate the delay value between transitions 1 second's worth
of microseconds, divided by the frequency, then split in half
since there are two phases to each cycle */
long numCycles = frequency * length / 1000;
/* calculate the number of cycles for proper timing multiply
frequency, which is really cycles per second, by the number of
seconds to get the total number of cycles to produce */
for (long i = 0; i < numCycles; i++) // for the calculated length of
time...
{
digitalWrite(pinBuzzer, HIGH); // write the buzzer pin high to push out
the diaphram
delayMicroseconds(delayValue); // wait for the calculated delay value
digitalWrite(pinBuzzer, LOW); // write the buzzer pin low to pull back
the diaphram
delayMicroseconds(delayValue); // wait again or the calculated delay
value
}
}
else delay(millisecond);
}
Pada sketch ini kita membuat sebuah fungsi atau sub program yang diberi nama playTone()
yang memiliki 2 parameter yang diberi nama tone dan milliseconds. Fungsi ini bertujuan untuk
memberi perintah digitalWrite() ke pin I/O dimana buzzer terhubung (pin 3) diatur
sedemikian rupa untuk nyala dan mati pada interval delay tertentu sehingga membentuk sebuah
getaran frekuensi suara. Getaran suara dengan nada terdengar sebagai nada C memiliki frekuensi
261.63 Hz atau bergetar sebanyak 261.63 getaran per detik. Nada C’ atau satu oftav diatas nya
memiliki frekuensi 523.25 Hz. Masing-masing nada pada tangga nada memiliki frekuensi yang
unik. Untuk mencoba fungsi ini anda bisa memasukkan sembarang frekuensi, tidak harus
frekuensi yang sama dengan nada musik, kecuali anda akan membuat bunyi yang memainkan
sebuah lagu.
Mari kita telaah dulu fungsi tersebut

Halaman :
Nama : 106-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Perintah tersebut mengambil nilai dari parameter pertama (note) ke variabel yang diberi nama
frequency, dan dari parameter kedua (milliseconds) ke variabel length. Jadi misal jika pada baris
perintah yang menjalankan fungsi tersebut adalah playTone(100,300); berarti nilai frequency
akan menjadi 100 dan nilai length menjadi 300. Variabel frequency akan dipakai untuk
menyimpan jumlah getaran per detik, variabel length akan dipakai untuk menyimpan nilai lama
nya frekuensi tersebut berlangsung dalam milliseconds.
Perintah selanjutnya berada dalam struktur if(frequency>0) yang berarti hanya dieksekusi
jika nilai frequency lebih besar dari nol. Didalam struktur if tersebut berisi perintah yang mengatur
seberapa banyak pin 3 akan on/off dalam 1 detik dan berapa interval antar siklus on/off nya.
Proses on off menggunakan perintah digitalWrite() seperti biasa.
Variabel baru yang diberi nama delayValue ini digunakan untuk menyimpan waktu lamanya
interval antara on/off, yang direncanakan dalam satuan microseconds. Jika misal frekuensi 10
getaran per detik (atau 10Hz), berarti harus on dan off sebanyak 10 kali dalam 1 detik. Karena
ada dua proses yang memerlukan delay yaitu proses on dan proses off dalam 1 detik, maka nilai
1000000 microseconds (atau sama dengan 1 detik) dibagi 2, sehinga nilai delayValue adalah
1000000 dibagi frekuensi dibagi 2.
Pada perintah sebelumnya, nilai variabel length adalah untuk menyimpan seberapa lama frekuensi
tersebut berjalan, yang kalau nanti nya akan menjadi seberapa panjang bunyi dihasilkan. Karena
kita membuat sebuah bunyi dari rangkaian beberapa on dan off dengan delay waktu senilai
delayValue, berarti seberapa panjang bunyi akan dihasilkan adalah jumlah berapa banyak siklus
on/off tersebut dalam 1 detik. Jumlah silkus tersebut disimpan ke variabel numCycles yang
dihitung dari nilai variabel frequency dikali nilai length dibagi 1000. Dibagi 1000 karena nilai
length dalam milliseconds, agar menjadi detik.
Baris perintah selanjutnya adalah perintah pengulangan loop dengan perintah for
for (long i = 0; i < numCycles; i++)
Dengan perintah tersebut, akan di ulang-ulang baris-baris perintah di dalam loop for sebanyak

Halaman :
Nama : 107-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
nilai numCycles. Perintah yang diulang-ulang adalah
digitalWrite(pinBuzzer, HIGH);
delayMicroseconds(delayValue);
digitalWrite(pinBuzzer, LOW);
dimana perintah tersebut adalah on/off dengan jeda selama nilai delayValue dalam satuan
microseconds. Dengan demikian fungsi playTone() akan menghasil kan bunyi dengan frekuensi
dan lama yang bisa kita tentukan. Mari kita lihat bagian loop() dari sketch :
for (int i = 0; i < 2; i++)

{
playTone(261.63, 350);
}
for (int j = 0; j < 2; j++)
{
playTone(523.25, 350);
}
Terlihat pada bagian loop() diatas, terdapat 2 perintah pengulangan loop, dimana
masing¬masing berisi perintah playTone() yang berbeda frekuensi. Sehingga jika sketch di
jalankan akan terdengar 2x nada C dan 2x nada C’ dengan jeda 1 detik dan panjang bunyi
masing¬masing nada selama 350 milliseconds.

Halaman :
Nama : 108-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 31 - Menggunakan Buzzer Untuk Memainkan Tangga Nada
Di tutoria sebelumnya telah dijelaskan bagaimana cara menghasilkan bunyi dengan frekuensi
tertentu menggunakan buzzer. Tutorial ini menggunakan metode yang sama untuk menghasilkan
tangga nada.
nama dengan file TUTORIAL_Buzzer_2.ino dan upload ke board Uno. Akan terdengar tangga
nada dari C ke C’. Berikut adalah sketch nya :
/*
*/
int jeda=200;
void setup()
{
}
void loop()
{
playTone(261.63, 300); //nada C
delay(jeda);
playTone(293.66, 300); //nada D
delay(jeda);
playTone(329.63, 300); //nada E
delay(jeda);
playTone(349.23, 300); //nada F
delay(jeda);
playTone(392, 300); //nada G
delay(jeda);
playTone(440, 300); //nada A
delay(jeda);
playTone(493.88, 300); //nada B
delay(jeda);
playTone(523.25, 300); //nada C'
delay(jeda);
}

{
if (frequency > 0)
{
{
}
}

Halaman :
Nama : 109-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
}
Terlihat bahwa isi dari loop() adalah menggunakan fungsi playTone() untuk membuat bunyi
dengan frekuensi tertentu beberapa kali sehingga membuat tangga nada. Nilai frekuensi dari
masing-masing tangga nada adalah standar, anda dapat mencari nya di internet untuk tangga nada
hingga beberapa oktav.

Halaman :
Nama : 110-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 32 - Pengaturan Bunyi Menggunakan Potensiometer
Di tutorial ini kita akan menggabungkan buzzer dengan potensiometer dan seven segment. Pada
setiap perubahan pada putaran lengan potensio akan merubah frekuensi bunyi yang dihasilkan
oleh buzzer, dan juga menampilkan frekuensi yang sedang terdengar di layar seven segment.
nama dengan file TUTORIAL_Buzzer_3.ino dan upload ke board Uno. Terdengar bunyi yang
sesuai dengan frekuensi yang ditampilkan di seven segment. Putaran pada lengan potensio akan
merubah frekuensi yang ditampilkan dan bunyi yang dihasilkan. Mari kita lhat sketch nya :
/*
GABUNG POTENSIO DAN SEVEN SEGMENT
Potensio -> A0
CLK -> D10
DIO -> D11
*/

#define PIN_POTENSIO A0
#define CLK 10
#define DIO 11
int jeda = 200;
void setup()
{
pinMode(PIN_POTENSIO, INPUT); //set A0 menjadi input (potensio)
}
void loop()
{
int nilaiPotensio = analogRead(PIN_POTENSIO);
int frek = map(nilaiPotensio, 0, 1023, 251, 1046); //memetakan nilai
analog potensio 0-1023 ke nilai rentang frekwensi
playTone(frek, 300); //nada C
display.showNumberDec(frek, false);
delay(jeda); //jeda waktu 1 detik, akan tetap menyala selama 1 detik
}

{
if (frequency > 0)
{
{

Halaman :
Nama : 111-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
}
}
}
Sketch tersebut menggunakan fungsi playTone() yang dipergunakan pada tutorial-tutorial

sebelum nya. Nilai analog yang ditangkap oleh perintah analogRead() dari potensio di peta kan
dengan perintah map ke rentang frekuensi yang akan digunakan, sehingga dapat ditampilkan di
seven segment dan digunakan oleh fungsi playTone() untuk menghasil kan bunyi yang sesuai.

Halaman :
Nama : 112-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 33 - Memainkan Musik Menggunakan Buzzer
Jika sebelumnya kit membuat sebuah fungsi untuk menggerakkan diagfragma buzzer dengan
frekuensi tertentu sehingga membentuk nada, pada tutorial kali ini kita akan membuat musik
dengan menggunakan fungsi tone() yang built in di Arduino IDE.
nama dengan file TUTORIAL_Buzzer_4.ino dan upload ke board Uno. Kali ini ada yang berbeda
pada sketch anda, terdapat tambahan file (nada.h). Pada file baru tersebut (nada.h) berisi nilai
#define dari frekuensi tiap nada yang akan kita gunakan.
/*
ecadio.com
*/
#include "nada.h"
#define PIN_BUZZER 3
// notes in the melody:

int melody[] =
{
NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4, 0,
NOTE_C5, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_G4, 0, NOTE_B4, NOTE_C5
};
// note durations: 4 = quarter note, 8 = eighth note, etc.:

int noteDurations[] =
{
4, 8, 8, 4, 4, 4, 4, 4, 4,
4, 8, 8, 4, 4, 4, 4, 4
};
void setup()
{
}
void loop()
{
mainkanMusik();
delay(3000);
}
void mainkanMusik()
{
for (int thisNote = 0; thisNote < 17; thisNote++)
{

Halaman :
Nama : 113-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
/* to calculate the note duration, take one second
divided by the note type.
e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc. */
int noteDuration = 1000 / noteDurations[thisNote];
tone(PIN_BUZZER, melody[thisNote], noteDuration);
/* to distinguish the notes, set a minimum time between them.

the note's duration + 30% seems to work well: */
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
noTone(PIN_BUZZER); // stop the tone playing:

}
}
Pada sketch tersebut kita menyimpan urutan nada yang akan dimainkan di sebuah array yang
diberi nama melody[]
int melody[] = {
NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4, 0,
NOTE_C5, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_G4, 0, NOTE_B4, NOTE_C5 };
Nilai dari frekuensi masing-masing anggota array tersebut telah didefinisikan di nada.h. Nilai 0
berarti berhenti berbunyi.
Panjang nada disimpan di array noteDuration[], sesuai dengan jumlah nada yang akan
dimainkan pada array melody[].
int noteDurations[] = {
4, 8, 8, 4, 4, 4, 4, 4, 4,
4, 8, 8, 4, 4, 4, 4, 4 };
Bagian setup() dibiarkan kosong, dan pada bagian loop() diisi perintah fungsi
mainkanMusic() yang akan diulang dalam loop dengan interval delay 3 detik.
Fungsi atau sub program mainkanMusik() berisi struktur pengulangan FOR yang akan
memainkan setiap nada pada array melody[] dengan panjang nada yang ada di array
noteDuration[].
for (int thisNote = 0; thisNote < 17; thisNote++)
Perintah tersebut adalah struktur pengulangan FOR, yang akan diulang sebanyak 17 kali, atau
sejumlah nada yang akan dimainkan (jumlah anggota array melody[])
int noteDuration = 1000 / noteDurations[thisNote];
Pada perintah diatas, variabel noteDuration adalah 1000 dibagi nilai dari anggota array
noteDurations pada posisi langkah loop FOR. Misal pada langkah FOR ke 2, maka
noteDurations[2] adalah 8 sehingga nilai noteDuration adalah 1000/8=125. Nada yang

Halaman :
Nama : 114-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
akan dimainkan adalah array melody[2] yaitu NOTE_G3. Pada langkah FOR ke 3,
noteDurations[3] adalah 4 sehingga nilai noteDuration adalah 1000/4=250. Nada yang
akan dimainkan adalah NOTE_A3
Untuk menyalakan buzzer, di contoh ini kita mempergunakan perintah tone() yang memiliki
syntax:
tone(pin, frekuensi, durasi)
sehingga di sketch ini buzzer dinyalakan dengan perintah
tone(PIN_BUZZER, melody[thisNote], noteDuration);
Agar nada dapat dimainkan dan menjadi musik yang wajar didengar tempo nya, dibutuhkan waktu
jeda antar nada :
int pauseBetweenNotes = noteDuration * 1.30; delay(pauseBetweenNotes);

noTone(PIN_BUZZER);
dimana perintah noTone() digunakan untuk mematikan buzzer.
Jika sketch tersebut dijalankan, anda akan mendengar sebuah lagu yang sudah anda kenal.
Silahkan bereksperimen membuat lagu lain nya.

Halaman :
Nama : 115-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 34 - Pengenalan Remote Infra Merah (IR)
Pada tutorial ini kita akan mempelajari konsep input yang juga sudah cukup lama dipergunakan
dalam microcontroller, yaitu input kontrol melalui remote infra merah. Konsep yang sama
dipergunakan pada peralatan yang biasa anda gunakan, seperti TV, AC, Radio/MP3 dan banyak
peralatan lain yang menggunakan remote IR. Dengan demikian andapun bisa menggunakan
remote TV/AC/Radio tersebut untuk eksperimen ini, selain menggunakan remote IR yang tersedia
pada kit.
nama dengan file TUTORIAL_IR_1.uno dan upload pada board Uno. Buka juga Serial Monitor.
Sketch ini menggunakan library, silahkan download dan install terlebih dahulu. Library IR dapat
didownload dari
http://ecadio.com/arduino-library/IR/EcadioIRremote.zip
Pada board multi I/O yang kita gunakan terdapat sensor penerima IR yang akan membaca nilai
dari tombo remote yang kita tekan. Nilai dari kode tombol yang kita tekan akan ditampilkan pada
serial monitor dan pada seven segment.
Mari kita lihat sketch nya :
/*
TUTORIAL IR REMOTE RECEIVER PADA ARDUINO
TAMPILKAN KODE IR PADA SEVEN SEGMENT

Halaman :
Nama : 116-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
D4 -> Led Merah
D2 -> IR
*/
#include <Wire.h>
#include "EcadioIRremote.h"
//library IR : http://ecadio.com/arduino-library/IR/EcadioIRremote.zip
#define RECV_PIN 2//the SIG pin of Infrared Receiver is connected with D2

of OPEN-SMART UNO R3
#define CLK 10
#define DIO 11
#define merah 4
IRrecv IR(RECV_PIN);
void setup()
{
IR.enableIRIn(); // memulai receiver
}
void loop()
{
if (IR.decode()) //kalau ada kode yang valid
{
if (IR.isReleased())
{
Serial.print("key code is ");
Serial.println(IR.keycode, DEC);
display.showNumberDec(IR.keycode);
Serial.println("*************");
}
IR.resume(); //lanjutkan menerima sinyal IR lagi
}
}
Seperti biasa library kita masukkan kedalam sketch dengan perintah #include
Pada board multi I/O shield yang kita gunakan, sensor IR terhubung ke pin 2
#define RECV_PIN 2
dan inisiasi library ini menggunakan perintah
Pada bagian setup, masukkan perintah
Untuk memulai menerima sinyal IR

Halaman :
Nama : 117-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
DI bagian loop, terdapat struktur IF bertingkat. IF yang pertama adalah menyaring sinyal IR,
sehingga hanya IR yang dianggap valid saja yang akan diproses
if (IR.decode()) {//kalau ada kode yang valid
Pada IF kedua, adalah struktur if yang akan dijalankan jika sinyal IR telah lengkap dipancarkan
Sinyal kode dari tombol yang kita tekan terekam dalam IR.keycode, sehingga bisa di tampilkan
di layar Serial Monitor dan di seven segment

Penggunaan led merah pada sketch ini adalah sebagai indikator penerimaan sinyal IR.
Dengan sketch ini, anda bisa mengetahui nilai kode keycode dari masing-masing tombol remote
yang anda gunakan. Nilai keycode tersebut lah yang akan bisa anda gunakan dalam struktur IF
untuk mengaktifkan sesuatu, yang akan kita pelajari di tutorial selanjutnya.

Halaman :
Nama : 118-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 35 - Menyalakan Led menggunakan Remote Infra Merah
Pada tutorial sebelum nya kita telah mempelajari bagaimana caranya menangkap kode yang
dipancarkan oleh remote infra merah, dan menampilkan nya di Serial Monitor dan Seven
Segment. Pada tutorial kali ini kita akan menggunakan kode IR yang terpancar oleh
masing¬masing tombol remote untuk melakukan tugas tertentu, yang dalam hal ini di
sederhanakan dengan beberapa buah led.
nama dengan file TUTORIAL_IR_2.ino dan upload ke board Uno. Cobalah tekan tombol 1
sampai dengan 6 pada remote IR dan perhatikan apa yang terjadi pada led. Led akan nyala dan
mati tergantung tombol yang ditekan. Misal tombol 1 untuk menyalakan led dan tombol 3 untuk
mematikan nya. Mari kita lihat sketch nya.
/*
TAMPILKAN KODE IR PADA SEVEN SEGMENT
DAN ON OFF LED
D4 -> Led Merah

D2 -> IR
D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/
#include <Wire.h>

Halaman :
Nama : 119-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
#define CLK 10
#define DIO 11
#define merah 4
#define hijau 5
#define biru 6
#define kuning 7
void setup()
{
pinMode(kuning,OUTPUT);
pinMode(hijau,OUTPUT);
pinMode(biru,OUTPUT);
}
void loop()
{
{
{
}
if(IR.keycode==69)
{
}
if(IR.keycode==68)
{
digitalWrite(kuning,LOW);
}
if(IR.keycode==70)
{
}
if(IR.keycode==64)
{
}
if(IR.keycode==71)
{
}
if(IR.keycode==67)
{
}
}
}
Pada sketch tersebut, nilai tombol 1 hingga tombol 6 telah di catat sebelumnya menggunakan
sketch pada tutorial sebelum nya. Tombol 1 memancarkan kode 69, tombol 2 adalah 70, tombol 3
adalah 71 dan seterusnya. Nilai-nilai tersebut kemudian digunakan dalam struktur IF untuk kondisi
Halaman :
Nama : 120-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
menyalakan atau mematikan led tertentu.
Konsep yang sama seperti itulah yang bisa anda gunakan untuk mengontrol sesuatu menggunakan
remote IR.
Untuk menyalakan dan mematikan (on/off) menggunakan satu tombol, dimana satu kali tekan
menyalakan lalu tekan kembali tombol yang sama akan kebalikan nya, silahkan membuat program
(sketch) sederhana melalui EDITOR pada software “Arduino IDE” dan beri nama dengan file
TUTORIAL_IR_3.ino yang isi nya adalah sebagai berikut :
/*
DAN ON OFF LED DENGAN 1 TOMBOL
D4 -> Led Merah

D6 -> Led Biru
*/

#define biru 6
#define merah 4
void setup()
{
}
void loop()
{
{
{
}
if(IR.keycode==28)
{
statusLed = !statusLed; //kebalikan nya
}
digitalWrite(biru,statusLed);
}
}

Halaman :
Nama : 121-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 36 - Pengenalan Pin I/O Sebagai Sensor Tegangan
Pada tutorial-tutorial sebelum nya kita telah mencoba berbagai percobaan input, baik itu
menggunakan potensio, tombol, maupun sensor. Semua nya memiliki persamaan pada satu hal,
mendeteksi perubahan tegangan yang dihitung sehingga menampilkan data yang diinginkan.
Pada tutorial kali ini kita akan langsung mendeteksi tegangan yang terhubung ke pin I/O, dan
menghitungnya untuk ditampilkan sebagai nilai tegangan dalam Volt.
Pin I/O yang akan kita gunakan adalah pin A3, yang pada board Shield Multi Sensor yang kita
gunakan pin tersebut telah dihubungkan dengan terminal baut yang bisa anda pasangkan kabel ke
sumber tegangan DC, misal ke baterai 9V
nama dengan file TUTORIAL_VOLTAGE_1.ino dan upload ke board Uno. Buka lah Serial
Monitor. Akan ditampilkan tegangan yang terhubung ke terminal baut. Jika belum ada yang
terhubunh, akan terbaca 0 volt. Cobalah hubungkan terminal baut bagian + ke kutub positif baterai
9V, dan bagian – ke kutub negatif dari baterai dan lihatlah nilai voltage yang ditampilkan.
Mari kita perhatikan sketch nya :
/*
TUTORIAL SENSOR TEGANGAN PADA ARDUINO
MEMBACA NILAI TEGANGAN DARI I/)
Pinout :
Tegangan + -> A3

Halaman :
Nama : 122-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
* Untuk membaca nilai tegangan masuk di pin analog A3
*/
#define pinVoltage A3
#define GAIN 0.11 //Vread = VIN * GAIN angka untuk kalibrasi
#define ADC_REF 5 //referensi voltage ADC adalah 5V
int samples = 10; //jumlah sampling

int nilaiSensor;
void setup()
{
pinMode(pinVoltage,INPUT); //set A3 menjadi input
delay(100);
Serial.println("Mencoba baca nilai Voltage pada Arduino");
}
void loop()
{
long jumlah = 0;
for(int i = 0;i<samples;i++)
{
nilaiSensor=analogRead(pinVoltage);
jumlah +=nilaiSensor;
delay(2);
}
nilaiSensor = jumlah / samples; //rata2 nya
float voltage = nilaiSensor*ADC_REF/1024/GAIN;
Serial.println("Voltage terbaca : " + String(voltage)); //tampilkan pada
serial monitor
}
Terlihat pada sketch tersebut menggunakan pembacaan pada pin A3 menggunakan analogRead()
yang sudah anda kenal. Perbedaan pada tutorial kali ini adalah metode pengambilan datanya,
dimana kali ini kita mengambil rata-rata dari beberapa kali sampel.
long jumlah = 0;
{
delay(2);
}
Nilai rata-rata dari nilai analogRead() diperoleh dari penjumlahan beberapa kali
analogRead() da dibagi dengan jumlah pengambilan data. Pada sketch tersebut, nilai akumulasi
disimpan ke variabel yang diberi nama “ jumlah” dan nilai jumlah sample ke variabel
“samples”, sehingga nilai rata-ratanya, yang disimpan ke variabel nilaiSensor adalah jumlah
dibagi samples.
Sebelumnya telah kita pelajari bahwa nilai dari analogRead() pada pin analog akan memiliki
nilai 0-1023, atau sebanyak 1024 nilai. Untuk memperoleh nilai tegangan dalam satuan voltage,
nilai rata-rata tersebut dibagi 1024, dan dikali 5, karena pada board Uno, rentang voltage yang
Halaman :
Nama : 123-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
digunakan adalah 5V, sehingga akan ditemukan nilai tegangan dalam satuan voltage (ADC_REF
adalah 5 pada sketch diatas).
Nilai hasil tersebut dibagi lagi dengan variabel GAIN hanyalah untuk kalibrasi atau penyesuaian
sehingga kita bisa memperoleh hasil yang akurat.
Silahkan coba hubungkan terminal baut pada shield ke baterai AA, baterai AAA. Perhatikan kutub
+ dan – jangan sampai terbalik.
Untuk menampilkan nilai tegangan tersebut pada seven segment, buatlah program (sketch)
sederhana melalui EDITOR pada software “Arduino IDE” dan beri nama dengan file
TUTORIAL_VOLTAGE_2.ino yang isi nya dalah sebagai berikut :
/*
TUTORIAL SENSOR TEGANGAN PADA ARDUINO
MEMBACA NILAI TEGANGAN DARI I/O DAN TAMPILKAN PADA SEVEN SEGMENT
Pinout :
Tegangan + -> A3
Untuk membaca nilai tegangan masuk di pin analog A3

*/
#define CLK 10
#define DIO 11
#define pinVoltage A3
#define GAIN 0.11 //Vread = VIN * GAIN angka untuk kalibrasi
#define ADC_REF 5 //referensi voltage ADC adalah 5V
int samples = 10; //jumlah sampling

int nilaiSensor;
void setup()
{
pinMode(pinVoltage,INPUT); //set A3 menjadi input
delay(100);
Serial.println("Mencoba baca nilai Voltage pada Arduino");
}
void loop()
{
long jumlah = 0;
{
delay(2);
}
nilaiSensor = jumlah / samples; //rata2 nya

Halaman :
Nama : 124-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Serial.println("Voltage terbaca : " + String(voltage)); //tampilkan pada
serial monitor
display.showNumberDec(voltage);
}

Halaman :
Nama : 125-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 37 - Pengenalan Sensor Jarak Ultrasonic
Di tutorial ini kita akan mencoba salah satu sensor lain yang terdapat dalam kit yaitu sensor
Ultrasonic yang bisa kita gunakan untuk menghitung jarak. Sensor ultrasonic menggunakan suara
ultrasonic sebagai media nya. Metode yang digunakan adalah dengan memancarkan suara
ultrasonic dan kemudian menghitung waktu yang dibutuhkan pantulan suara untuk kembali ke
sensor. Dari nilai tersebut, karena kecepatan suara sudah kita ketahui, maka akan dapat diperoleh
nilai jarak dalam satuan cm.
Hubungkan sensor Ultrasonic menggunakan kabel female/female yang ada dalam kit ke board
Shield Multi Sensor dengan aturan berikut
SENSOR ULTRASONIC BOARD SHIELD MULTI

VCC -> VCC
GND -> GND
TRIG -> SDA
ECHO -> SCL
Periksa lagi hubungan kabel tersebut sebelum melanjutkan ke tahap selanjutnya.

Halaman :
Nama : 126-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
nama dengan file TUTORIAL_Ultrasonic_1.ino dan upload ke board Uno. Buka juga jendela
Serial Monitor. Pada jendela Serial Monitor akan ditampilkan nilai jarak dalam cm. Nilai jarak
yang di tampilkan adalah jarak sensor terhadap benda yang berada di depan nya, karena sensor
ultrasonic bekerja menggunakan prinsip pantulan suara. Cobalah untuk menghalangi sensor dan
ubah jarak nya.
Mari kita perhatikan sketch nya :

/*
TUTORIAL SENSOR JARAK ULTRASONIC PADA ARDUINO
Pinout
VCC Ultrasoonic -> VCC
GND Ultrasonic -> GND
Trig Ultrasonic -> SDA (A4)
Echo ultrasonic -> SCL (A5)
*/
#define TRIGGER A4
#define ECHO A5
long durasi, cm;
void setup()
{
pinMode(TRIGGER,OUTPUT); //set menjadi OUTPUT
pinMode(ECHO,INPUT); //set menjadi INPUT
Serial.println("Mencoba Sensor Jarak Ultrasonic pada Arduino");
}
void loop()
{
//kirim ping
digitalWrite(TRIGGER, LOW);
delayMicroseconds(5);
digitalWrite(TRIGGER, HIGH);
//baca echo pantulan

durasi = pulseIn(ECHO,HIGH);
//konversi waktu durasi ke jarak

cm = (durasi/2) /29.1;
Serial.println("Jarak : " + String(cm)+" cm"); //tampilkan pada serial

monitor
delay(250); //jeda waktu 250 mS
}
Pin A4 (yang diberi label SDA pada board shield) telah anda hubungkan ke kaki TRIG pada
sensor. DI sketch diatas, pin A4 di definisikan sebagai TRIGGER.
Kaki TRIG pada sensor adalah kaki yang terhubung ke bagian sensor yang memancarkan suara
ultrasonic, yang akan menyala kalau diberi HIGH menggunakan perintal digitalWrite().
Pada bagian loop bisa kita lihat terdapat baris-baris perintah yang menyalakan kaki tersebut
Halaman :
Nama : 127-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
selama 10 microseconds
Untuk menangkap pantulan, kaki ECHO pada sensor telah anda hubungkan ke pin A5 (diberi label
SCL pada shield). Pada pin A5 tersebut akan kita tangkap nilai nya menggunakan perintah
pulseIn().
Waktu yang diperlukan untuk gelombang suara terkena objek didepan nya dan memantul kembali
disimpan ke variabel yang diberi nama durasi, yang berasal dari perintah pulseIn() di pin ECHO
atau pin A4, dan menghitung waktu antara sinyal HIGH.
durasi = pulseIn(ECHO,HIGH);
Perintah pulseIn() diatas, berarti akan menghitung waktu jeda pin A4 dimulai dari sejak
perubahan dari LOW ke HIGH, hingga menerima LOW lagi. Kaki ECHO pada sensor ultrasonic akan
bernilai HIGH jika menerima suara ultrasonic.
Dengan demikian kita bisa menghitung jarak dalam centimeter dengan perintah
cm = (durasi/2) /29.1;
Variabel durasi kita bagi dua karena durasi yang terjadi adalah waktu pulang dan pergi nya suara,
dan kita hanya perlu watu setengah nya. Nilai cm diperoleh dengan membagi waktu tempuh
dengan 29.1

Halaman :
Nama : 128-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 38 - Sensor Utrasonic dan Led
Jika pada tutorial sebelumnya anda telah bisa menampilkan nilai jarak menggunakan sensor jarak
ultrasonic, pada tutorial kali ini kita akan menggunakan nilai yang diperoleh tersebut untuk
mengontrol led.
nama dengan file TUTORIAL_Ultrasonic_2.ino dan upload ke board Uno. Akan tampak
perubahan nyala led tergantung jarak objek yang berada di hadapan sensor ultrasonic.
Sketch nya adalah sebagai berikut :

/*
TUTORIAL SENSOR JARAK ULTRASONIC PADA ARDUINO
GABUNG DENGAN LED
Pinout
VCC Ultrasoonic -> VCC
GND Ultrasonic -> GND
Trig Ultrasonic -> SDA (A4)
Echo ultrasonic -> SCL (A5)
D4 -> Led Merah

D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/
#define TRIGGER A4
#define ECHO A5
#define merah 4
#define hijau 5
#define biru 6
#define kuning 7
long durasi, cm;
void setup()
{

Halaman :
Nama : 129-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
pinMode(TRIGGER, OUTPUT); //set menjadi OUTPUT
pinMode(ECHO, INPUT); //set menjadi INPUT
pinMode(merah, OUTPUT); //set menjadi OUTPUT
pinMode(kuning, OUTPUT); //set menjadi OUTPUT
pinMode(hijau, OUTPUT); //set menjadi OUTPUT
pinMode(biru, OUTPUT); //set menjadi OUTPUT
Serial.println("Mencoba Sensor Jarak Ultrasonic pada Arduino");
}
void loop()
{
//kirim ping
durasi = pulseIn(ECHO, HIGH); //baca echo pantulan
cm = (durasi / 2) / 29.1; //konversi waktu durasi ke jarak
Serial.println("Jarak : " + String(cm) + " cm"); //tampilkan pada serial
monitor
nyalakanLed(cm);
}
void nyalakanLed(int nilaiJarak)

{
if(nilaiJarak<10){
digitalWrite(kuning,LOW);
}
if(nilaiJarak>10 && nilaiJarak<=20){
}
}
}
if(nilaiJarak>40 ){
}
}
Terlihat pada sketch tersebut, nilai jarak yang diperoleh dari sensor jarak ultrasonic dipergunakan
untuk mengatur nyala led menggunakan struktur IF

Halaman :
Nama : 130-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 39 - Pengenalan Kontrol Servo
Pada banyak tutorial sebelum nya anda telah belajar cukup banyak sehingga sudah bisa
mengontrol I/O dengan bantuan led, sudah bisa mengambil nilai input baik melalui potensio,
tombol, maupun sensor, dan sudah bisa menampilkan data baik pada serial monitor, pada LCD
dan pada seven segment, bahkan membuat Arduino anda menghasilkan musik. Pada tutorial kali
ini anda akan belajar untuk mulai menggerak kan sesuatu secara mekanik, jadi tidak hanya
menyala, tampil atau berbunyi, tapi juga bisa bergerak.
Salah satu alat yang bisa mengubah sinyal elektronik seperti yang dihasilkan oleh arduino menjadi
gerakan adalah Servo. Motor Servo menerima sinyal logic HIGH dan LOW yang dikirim dari pin
I/O dan menterjemahkan menjadi gerakan putaran.
Servo yang akan kita pergunakan adalah micro servo, yang memiliki lengan yang dapat berputar
dari 0 hingga 180 derajat. Kita dapat memerintahkan lengan servo untuk menuju ke posisi derajat
tertentu, dan juga dengan kecepatan gerakan tertentu.
Pada servo yang akan kita pergunakan pada tutorial ini, seperti pada kebanyakan servo lain nya,
memiliki 3 buah kabel yaitu VCC, GND, dan Signal. Kabel berwarna coklat adalah GND, kabel
merah adalah VCC, dan kabel oranye adalah Signal.
Kita akan menggunakan pin A4 di tutorial ini sebagai signal, yang pada board Shield Multi Sensor
diberi label SDA. Hubungkan kabel ke board dengan aturan berikut :

Halaman :
Nama : 131-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
SERVO BOARD SHIELD MULTI
GND (Coklat) -> GND
VCC (Merah) -> VCC
SIG (Oranye) -> SDA
Pasanglah salah satu lengan servo pada as servo, dan periksa kembali apakh hubungan sudah
benar sebelum melanjutkan ke langkah berikutnya.
nama dengan file TUTORIAL_SERVO_1.ino dan upload ke board Uno. Servo akan mulai
bergerak ke arah yang diperintahkan pada sketch dengan interval tertentu. Mari kita lihat sketch
nya :
/*
TUTORIAL SERVO PADA ARDUINO
MENGGERAKKAN SERVO
Pinout :
Kabel coklat servo -> GND
Kabel coklat merah -> VCC
Kabel coklat kuning -> SDA (atau A4)
*/
#include <Servo.h>
int servoPin = A4;
Servo servo;
int servoAngle = 0;
void setup()
{
servo.attach(servoPin);
}

Halaman :
Nama : 132-144
Tutorial Starter Kit BelajarArduino Compact – ecadio.com 6 5 1 5 1 0 1 0 130
_ P r
P e n g e n a l
void loop()
{
servo.write(45); // Turn SG90 servo Left to 45 degrees
delay(1000); // Wait 1 second
servo.write(90); // Turn SG90 servo back to 90 degrees (center
position)
servo.write(135); // Turn SG90 servo Right to 135 degrees
servo.write(90); // Turn SG90 servo back to 90 degrees (center
position)
delay(1000);
}
Untuk menggerakkan servo, pada sketch ini kita menggunakan library Servo.h yang sudah built
in di Arduino IDE
#include <Servo.h>
Definisi pin A4 sebagai servoPin dan inisiasi objek servo bernama “servo”
int servoPin = A4;

Servo servo;
Pada bagian setup, mulai mengaktifkan servo dengan perintah servo.Attach()
Perintah untuk menggerakkan servo ke posisi derajat tertentu menggunakan perintah

servo.Write(nilai_derajat);
servo.write(45);
Perintah diatas memerintahkan lengan servo untuk bergerak ke posisi 45 derajat. Untuk
menggerakkan lengan servo ke arah 90 derajat, perintah nya adalah
servo.write(90);
Batas maksimal adalah 180 derajat. Pada sketch tersebut servo bergerak dengan kecepatan
maksimum nya. Trik untuk mengubah kecepatan adalah dengan menggerakkan servo per derajat
tertentu dengan jeda delay() tertentu dalam sebuah struktur loop FOR. Semakin besar nilai delay
maka akan semakin lambat gerakan lengan servo.

Halaman :
Nama : 133-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
nama dengan file TUTORIAL_SERVO_2.ino adalah contoh menggerakkan servo dengan
menerapkan kecepatan yang lebih lambat. Mari kita lihat sketch nya
/*
MENGGERAKKAN SERVO DENGAN KECEPATAN
Pinout :
*/
#include <Servo.h>
int servoPin = A4;
int angle = 10;
Servo servo;
int servoAngle = 0;
void setup()
{
servo.write(angle);
}
void loop()
{
for(angle = 10; angle < 180; angle++) // scan from 0 to 180 degrees
{
servo.write(angle);
delay(15);
}
for(angle = 180; angle > 10; angle--) // now scan back from 180 to 0
degrees
{
servo.write(angle);
delay(15);
}
}
Pada sketch tersebut kecepatan lengan servo bergerak diatur dengan menggerakkan lengan servo
Halaman :
Nama : 134-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
setiap 1 derajat dengan waktu jeda menggunakan delay() antar setiap pergerakannya,
menggunakan struktur loop FOR
for(angle = 10; angle < 180; angle++)

{
servo.write(angle);
delay(15);
}
Dengan perintah tersebut maka lengan servo akan bergerak lebih lambat karena adanya delay().
Aplikasi servo banyak diterapkan pada robotika seperti pada lengan-lengan robot maupun robot-
robot humanoid, karena kita bisa mengatur gerakan lengan-lengan servo untuk bergerak ke posisi
tertentu pada waktu tertentu.

Halaman :
Nama : 135-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 40 - Servo dan Potensiometer
Tutorial ini menggabungkan tutorial tentang potensiometer sebelumnya dengan tutorial servo,
dimana nilai yang diperoleh dari potensio akan di peta kan ke gerakan lengan servo sehingga
putaran lengan potensio akan selaras dengan putaran lengan servo
nama dengan file TUTORIAL_SERVO_3.ino dan upload ke board Uno. Putarlah lengan
potensiometer, dan lengan servo akan berputar selaras dengan putaran potensiometer.

/*
MENGGERAKKAN SERVO SESUAI POTENSIO
Pinout :
Potensio pada A0
*/
#include <Servo.h>
#define PIN_POTENSIO A0
int servoPin = A4;

int derajat;
Servo servo;
void setup()
{
delay(100);
Serial.println("Menggerakkan servo pada Arduino");
pinMode(PIN_POTENSIO, INPUT); //set A0 menjadi input (potensio)
}
void loop()
{
derajat = map(nilaiPotensio, 0, 1023, 0, 180);//memetakan nilai potensio
yang memiliki range 0-1023 ke nilai derajat servo 0-180 derajat
servo.write(derajat);
Serial.println(derajat);
delay(1);
}
Nilai analog dari potensio diperoleh dari perintah analogRead(). Nilai tersebut di petakan
dengan perintah map, dimana nilai potensio memiliki rentang antara 0 sampai 1023 dan rentang
derajat putaran servo antara 0 sampai 180 derajat
derajat = map(nilaiPotensio, 0, 1023, 0, 180);
// memetakan nilai potensio yang memiliki range 0-1023 ke nilai derajat
servo 0-180 derajat servo.write(derajat);

Halaman :
Nama : 136-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 41 - Pengenalan Penggunaan Relay
Pada tutorial-tutorial sebelum nya anda telah mempelajari beebagai metode pengendalian led.
Mengapa dalam banyak tutorial Arduino selalu menggunakan led? Karena led dapat memberi
indikator posisi I/O pin saat itu, apakah HiGH atau LOW, apakah mengeluarkan 5V atau 0V.
Ketika sebuah pin mengeluarkan tegangan 5V (atau 0V), arus yang mengalir tersebut cukup untuk
menyalakan sebuah led, namun tidak cukup untuk menyalakan alat lain, walaupun alat tersebut
memiliki tegangan kerja 5V, karena arus yang dialirkan melalui pin I/O sangat terbatas, hanya
40mA maksimum. Diatas itu akan merusak chip ATMega328 yang digunakan. Oleh karena itu pin
I/O hanya disebut mengeluarkan sinyal logic, sinyal kecil yang bisa digunakan untuk
mengaktifkan modul/alat lain nya, yang pada tutorial kali ini kita akan mengendalikan rmodul
relay untuk menyalakan alat yang membutuhkan tegangan dan arus yang jauh lebih besar.
Apakah relay itu? Pada dasarnya relay adalah sebuah switch, yang bekerja dengan prinsip
elektromagnetic. Pada relay terdapat dua bagian utama, bagian tegangan input untuk menyalakan
kumparan yang akan menjadi magnet ketika ada arus yang mengalir, dan bagian switch yang akan
terhubung ketika lengan switch tertarik oleh medan magnet.
Bagian kumparan dan bagian switch tidak saling terhubung secara fisik, dengan demikian kita
dapat menggunakan relay sebagai switch untuk menyalakan/mematikan alat yang menggunakan
tegangan/arus yang lebih besar dengan aman, misal motor DC 12V, atau bahkan lampu 220V
dengan menggunakan sinyal 5V yang dikeluarkan dari Arduino.

Halaman :
Nama : 137-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Switch pada relay memiliki 2 posisi, yaitu Normally Open (NO) dan Normally Closed (NC). Kaki
switch NC tidak akan terhubung dengan kaki Common ketika dalam kondisi tidak ada arus pada
kumparan relay, dan kaki Common akan terhubung dengan kaki NC pada saat itu. Sebalik nya,
ketika kumparan relay dialiri listrik, kaki NO akan terhubung dengan kaki Common, dan kaki NC
akan terangkat sehingga tidak terhubung dengan kaki Common.
Pada tutorial kali ini kita akan menggunakan Modul Relay 1 channel, yang pada modul tersebut
telah dilengkapi dengan rangkaian yang dibutuhkan sehingga kita tinggal menghubungkan pin I/O
ke modul relay untuk mengendalikan nya.
Hubungkan modul relay ke modul shield multi sensor menggunakan kabel female/female yang
terdapat dalam kit dengan aturan sebagai berikut :
RELAY BOARD SHIELD MULTI

GND -> GND
VCC -> VCC
IN -> SDA
Periksa kembali hubungan kabel tersebut sebelum melanjutkan ke langkah selanjutnya.

Halaman :
Nama : 138-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
nama dengan file TUTORIAL_RELAY_1.ino dan upload ke board Uno. Sketch tersebut mirip
dengan sketch led berkedip yang pernah dipelajari sebelumnya, hanya saja kali ini kita
menyalakan relay bukan led. Akan terdengar bunyi relay aktif dan non aktif selang 3 detik.
/*
TUTORIAL RELAY 1 PADA ARDUINO
D4 -> Led Merah
VCC relay -> VCC
GND relay -> GND
IN RELAY -> SDA (atau sama dengan A4)
*/
#define pinLed 4 //led merah pada D4

#define pinRelay A4
void setup()
{
pinMode(pinRelay, OUTPUT); //set menjadi output
}
void loop()
{
digitalWrite(pinRelay, LOW); //menyalakan relay (memberi tegangan 0V,
karena modul relay berjenis Active Low, sehingga aktif saat diberi LOW)
delay(3000); //jeda waktu 3 detik
digitalWrite(pinRelay, HIGH); //mematikan relay (memberi tegangan 5V,
karena modul relay berjenis Active Low, sehingga mati saat diberi HIGH)
delay(3000); //jeda waktu 3 detik
}
Terlihat pada sketch diatas, untuk menyalakan atau mematikan relay menggunakan perintah
digitalRead() seperti yang digunakan dalam tutorial led.
Modul relay yang kita gunakan berjenis Active Low, yang berarti relay akan aktif jika pada kaki

Halaman :
Nama : 139-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
IN modul relay diberi sinyal LOW, dan akan tidak aktif jika diberi sinyal HIGH
Gambar di bawah ini adalah skema dari penggunaan relay untuk menyalakan lampu bertegangan
AC 220V, dimana modul relay berfungsi sebagai switch. Harap berhati-hati saat anda merangkai
nya, karena tegangan AC PLN 220V sangat berbahaya. Periksa kembali setiap hubungan kabel,
dan pastikan anda mencabut steker yang terhubung ke PLN ketika anda akan merubah-ubah
kabel.
Terlihat pada gambar tersebut, kabel hubungan lampu listrik AC 220V melalui kaki NO
(Normally Open) dan kaki Common dari modul relay, sehingga ketika relay tidak aktif, lampu
mati. Ketika relay aktif, maka listrik 220V akan mengalir ke lampu sehingga lampu akan menyala.

Halaman :
Nama : 140-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 42 - Mengendalikan Relay dengan Tombol
Pada tutorial sebelumnya anda telah mulai mengenal untuk mengendalikan relay, dimana pada
dasarnya bisa anda anggap sebagai led dalam pemrograman nya. Pada tutorial kali ini adalah
mengendalikan relay menggunakan input dari tombol, yang tentunya mirip dengan pengendalian
led menggunakan tombol. Beda nya, dengan relay kita tidak hanya menyalakan led, tapi dapat
menyalakan peralatan yang lebih besar.
nama dengan file TUTORIAL_RELAY_2.ino dan upload ke board Uno. Anda dapat
menyalakan/mematikan relay dengan menekan tombol
/*
TUTORIAL RELAY PADA ARDUINO
PUSH BUTTON DAN RELAY
DENGAN PENGGUNAAN DEBOUNCE
Pinout :
Tombol 1 -> D9
D4 -> Led Merah
VCC relay -> VCC
GND relay -> GND
*/
#define TOMBOL1 9
#define merah 4
#define pinRelay A4

int statusRelay = HIGH;
int statusTombol;

void setup()
{

Halaman :
Nama : 141-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
pinMode(pinRelay, OUTPUT); //set menjadi output
digitalWrite(merah, statusLed);
digitalWrite(pinRelay, statusRelay);
}
void loop()
{
if (a != statusTombolTerakhir)
{
lastDebounceTime = millis(); // reset debouncing timer
}

{
{
statusTombol = a;
{
statusRelay = !statusRelay; //kebalikan nya
}
}
}
digitalWrite(merah, statusLed);
}
Sketch diatas telah menggunakan algoritma debounce dari tombol untuk memperoleh input tombol
yang lebih akurat dan natural

Halaman :
Nama : 142-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
PERCOBAAN 43 - Mengendalikan Relay dengan Remote IR
Jika anda telah bisa mengendalikan led dengan remote infra merah, anda pun bisa mengendalikan
modul relay dengan remote IR.
nama dengan file TUTORIAL_RELAY_3.ino dan upload ke board Uno. Tekan tombol OK pada
remote infra merah untuk menyalakan/mematikan relay.
/*
TUTORIAL RELAY 3
ON/OFFRELAY DENGAN IR REMOTE RECEIVER PADA ARDUINO
D4 -> Led Merah
D6 -> Led Biru
VCC relay -> VCC
GND relay -> GND
*/

#define biru 6
#define merah 4
#define pinRelay A4
int statusRelay = HIGH;
void setup()
{
pinMode(pinRelay, OUTPUT);
digitalWrite(pinRelay,HIGH);//mematikan relay saat awal, relay Active LOW
dimatikan dengan HIGH
}
void loop()
{
{
{
}
if (IR.keycode == 28)
{
statusRelay = !statusRelay;
}

Halaman :
Nama : 143-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
}
}
Dengan sketch tersebut sekarang anda bisa menyalakan dan mematikan peralatan listrik yang
lebih besar seperti lampu AC 220V atau peralatan lain menggunakan remote IR.
DAFTAR PUSTAKA
1. Ecadio.com, “Belajar Arduino dengan Gampang” Tutorial Starter Kit Belajar Arduino
Compact – ecadio.com.

Halaman :
Nama : 144-144
6 5 1 5 1 0 1 0
_ P r
P e n g e n a l
Halaman:
145

09 - 65151010 - PR Pengenalan Mikrokontroler - Arduino

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

09 - 65151010 - PR Pengenalan Mikrokontroler - Arduino

Diunggah oleh

Hak Cipta:

Format Tersedia

VEHICLE CONTROL SYSTEM

DASAR SISTEM KONTROL OTOMOTIF

Pengenalan Mikrokontroler (Prakterk)

ALAT BAHAN WAKTU

PERCOBAAN 01 - Menyiapkan kit yang diperlukan untuk memasukkan program ke chip

A. Instal software Arduino IDE.

Program Studi : Dikeluarkan oleh : Tanggal :

Program Studi : Dikeluarkan oleh : Tanggal :

5. Penjelasan ringkas mengenai fungsi-fungsi pada software Arduino IDE

 Tombol “New” untuk membuat file baru.

Program Studi : Dikeluarkan oleh : Tanggal :

Program Studi : Dikeluarkan oleh : Tanggal :

Contoh program/sketch TUTORIAL_led_1.ino:

#define pinLed 4 //definisikan pinLed adalah 4, led merah ada pada D4

Program Studi : Dikeluarkan oleh : Tanggal :

pinMode(pinLed, OUTPUT); //set menjadi output

Program Studi : Dikeluarkan oleh : Tanggal :

Baris pertama dalam bagian loop adalah

digitalWrite(pinLed, HIGH); //menyalakan led (memberi tegangan 5V)

Baris tersebut berisi perintah digitalWrite(), yang syntax nya adalah :

Perintah digitalWrite(pinLed, HIGH); berarti memerintahkan untuk mengalirkan 5V

Baris berikutnya adalah delay(1000);.

delay(1000); //jeda waktu 1 detik, akan tetap menyala selama 1 detik

digitalWrite(pinLed, LOW); //mematikan led (memberi tegangan 0V)

Program Studi : Dikeluarkan oleh : Tanggal :

Perintah selanjutnya yang akan di jalankan adalah

delay(1000); //jeda waktu 1 detik, akan tetap mati selama 1 detik

maka kedua kutub led

Program Studi : Dikeluarkan oleh : Tanggal :

PERCOBAAN 02 - Contoh Program Aplikasi pada Led

A. Blink Multiple Led

Mari kita perhatikan isi program/sketch nya :

Program Studi : Dikeluarkan oleh : Tanggal :

digitalWrite(kuning, LOW); //mematikan led kuning (memberi tegangan 0V)

digitalWrite(kuning, LOW); //mematikan led kuning (memberi tegangan 0V)

digitalWrite(kuning, LOW); //mematikan led kuning (memberi tegangan 0V)

Program Studi : Dikeluarkan oleh : Tanggal :

Program Studi : Dikeluarkan oleh : Tanggal :

Program Studi : Dikeluarkan oleh : Tanggal :

//membuat sub-sub program

Program Studi : Dikeluarkan oleh : Tanggal :

Program Studi : Dikeluarkan oleh : Tanggal :

Program Studi : Dikeluarkan oleh : Tanggal :

Program Studi : Dikeluarkan oleh : Tanggal :

Perintah selanjutnya adalah Serial.println(). Serial.println() kita gunakan untuk

Serial.println("Mencoba Serial Monitor 2");

pinMode(A5,INPUT); //set pin Analog 5 atau A5 menjadi input

Program Studi : Dikeluarkan oleh : Tanggal :

Baris perintah berikutnya adalah di bagian loop().

int nilai = analogRead(A5);

Serial.print("Nilai dari A5 :");

Apa perbedaan Serial.print() dengan Serial.println()? Perbedaan nya adalah setelah

Program Studi : Dikeluarkan oleh : Tanggal :

Program Studi : Dikeluarkan oleh : Tanggal :

Program / sketch nya dalah sebagai berikut :

Program Studi : Dikeluarkan oleh : Tanggal :

Program Studi : Dikeluarkan oleh : Tanggal :

Program Studi : Dikeluarkan oleh : Tanggal :

//membuat sub-sub program

Program Studi : Dikeluarkan oleh : Tanggal :

Program Studi : Dikeluarkan oleh : Tanggal :

Program Studi : Dikeluarkan oleh : Tanggal :

Program Studi : Dikeluarkan oleh : Tanggal :