Tutorial Belajar Arduino Kit Essentials

Dengan Starter Kit Belajar Arduino – Essentials
TUTORIAL UNTUK STARTER KIT ESSENTIALS BELAJAR ARDUINO

ECADIO.COM
DAFTAR ISI
DAFTAR ISI ............................................................................................................. i

PRAKATA ............................................................................................................. iii
Mengenal board UNO R3 ...................................................................................... 1
Upload program ke board UNO ............................................................................. 1
Mempersiapkan File dan Library yang dibutuhkan................................................. 9
Pengenalan Breadboard (papan prototype project) ............................................... 1
BLINK – Memahami konsep dasar I/O Arduino ...................................................... 1
BLINK Multiple Led ............................................................................................... 9
BLINK Multiple Led dan Konsep Sub Program ...................................................... 13
Pengenalan Serial Monitor dan Input I/O ............................................................ 16
Pengenalan Potensiometer Sebagai Simulasi Sensor ........................................... 22
Potensio dan Led ................................................................................................ 27
Pengenalan Pulse Width Modulation (PWM) ....................................................... 31
Led menggunakan PWM dengan input data dari Potensiometer .......................... 36
Pengenalan konsep millis(), Blink tanpa delay() ................................................... 38
Mapping Nilai ..................................................................................................... 41
Penggunaan Mapping dan Led Serta Kondisi IF .................................................... 44
Pengenalan Penggunaan IC Shift Register ............................................................ 48
Shift Register, Led, dan Potensio ......................................................................... 55
Pengenalan Penggunaan Led RGB ....................................................................... 57
Pengenalan Penggunaan Input Push Button ........................................................ 62
Push Button dan Led ........................................................................................... 69
Pengenalan Konsep Debounce ............................................................................ 72
Pengenalan Penggunaan Sensor Dan Library ....................................................... 77
Pengenalan menggunakan LCD 1602 dengan modul I2C ...................................... 83
LCD dan Nilai Analog dari Potensiometer ............................................................ 91
LCD dan Sensor Cahaya LDR ................................................................................ 94
Menampilkan data Suhu dan Kelembaban Udara di LCD ...................................... 97
Jam Digital Tanpa Delay() dan Menggunakan Debounce .....................................101
Pengenalan Penggunaan KEYPAD 4x4.................................................................109
i
Tutorial Starter Kit Belajar Arduino Essentials – ecadio.com
Password dengan KEYPAD 4x4 dan LCD ..............................................................115
Pengenalan Seven Segment ...............................................................................118
Seven Segment dengan IC Shift Register .............................................................124
Seven Segment dan Potensiometer ....................................................................129
Pengenalan Buzzer .............................................................................................133
Menggunakan Buzzer Untuk Memainkan Tangga Nada ......................................137
Pengaturan Bunyi Menggunakan Potensiometer ................................................139
Memainkan Musik Menggunakan Buzzer ...........................................................142
Pengenalan Remote Infra Merah (IR) .................................................................146
Menyalakan Led menggunakan Remote Infra Merah ..........................................152
Pengenalan Sensor Jarak Ultrasonic ...................................................................157
Sensor Utrasonic dan Led ...................................................................................161
Sensor Utrasonic dan LCD ..................................................................................164
Pengenalan Kontrol Servo ..................................................................................167
Servo dan Potensiometer ...................................................................................172
Pengenalan Penggunaan Relay ...........................................................................175
Mengendalikan Relay dengan Tombol ................................................................180
Mengendalikan Relay dengan Remote IR ...........................................................183
PENUTUP ...........................................................................................................185
ii
PRAKATA
Terima kasih telah memilih Ecadio Arduino Starter Kit Essentials version sebagai
penunjang anda dalam mempelajari Arduino.
Starter Kit Essentials ini kami desain khusus sedemikian rupa berdasarkan
pengalaman pribadi saat pertama mempelajari Arduino, dimana terdapat
kebingungan akan komponen dan modul apa saja yang diperlukan saat awal agar
dapat mempelajari konsep-konsep Arduino tanpa bolak balik membeli komponen
yang kurang, karena jika hanya board Arduino Uno saja, sangat terbatas yang bisa
dilakukan. Untuk itu telah kami pilihkan modul dan komponen yang essentials dalam
kit ini agar anda bisa mempelajari micro controller konsep Arduino dengan lancar
Tutorial ini pun kami desain agar anda bisa mempelajari platform Arduino dengan
mudah, walaupun anda sama sekali belum mengenal Arduino. Materi disusun
secara bertahap, agar anda bisa memahami konsep-konsep yang akan sering
digunakan dalam platform Arduino. Anda akan mempelajari banyak hal, hingga
pada akhirnya anda bisa membuat banyak rangkaian percobaan, dan akan bisa
dengan mudah membuat dan mengikuti tutorial apapun yang banyak terdapat di
internet.
Silahkan dipelajari secara berurutan agar anda bisa menguasai Arduino dengan
cepat dan mudah. Contoh program/sketch atau library yang dibutuhkan juga telah
kami sediakan dalam CD atau bisa di download pada link yang disediakan. Selamat
belajar dan semoga sukses
iii
PENGENALAN DEVELOPMENT BOARD UNO R3
Mengenal board UNO R3
Tak kenal maka tak sayang. Oleh karena itu, sebelum kita memulai melakukan beberapa
eksperimen dalam mempelajari Arduino, ada baiknya kita mengenal terlebih dahulu MCU
(Micro Controller Unit) yang akan kita gunakan, yaitu Board Uno R3.
Board UNO R3 adalah sebuah development board untuk chip ATMega328. Anda bisa lihat
chip tersebut pada gambar diatas adalah chip yang berbentuk seperti IC dengan 32 kaki
bertuliskan ATMEL ATMEGA328. Development board berarti board ini didesain sedemikian
rupa agar memudahkan kita dalam prototyping rangkaian yang menggunakan chip
ATMega328 tersebut.
Misal anda akan membuat sebuah jam digital menggunakan chip ATMega328 yang
menampilkan jam pada seven segment, memiliki feature alarm dan sensor suhu. Anda bisa
saja langsung merangkai komponen-komponen tersebut pada PCB buatan anda sendiri, atau
pada PCB lubang, dan menyolder kaki-kaki dari chip ATMega328 ke seven segment, sensor
suhu, buzzer alarm, dan tombol-tombol. Namun jika langsung dirangkai dalam PCB sebelum
melalui proses purwa rupa atau prototyping, kemungkinan besar rangkaian tersebut akan
mengalami banyak kegagalan, atau memerlukan penyempurnaan tambahan. Dan jika sudah
disolder, memperbaiki kegagalan tersebut akan lebih sulit dan lebih memakan waktu.
1
Untuk alasan itulah development board diciptakan. Pada development board seperti board
UNO R3 ini, chip ATMega328 telah dirangkai sedemikian rupa, sehingga anda bisa
menghubungkan pin-pin I/O dengan mudah melalui lubang-lubang header yang disediakan.
Teknik prototyping dilakukan dengan bantuan Breadboard atau papan projek dan kabel-
kabel jumper. Komponen-komponen atau modul dan sensor yang diperlukan dihubungkan
ke breadboard, dan dari breadboard ke development board dengan kabel-kabel jumper.
Karena pemasangan dan pelepasan kabel pada breadboard sangat mudah serta tidak
memerlukan penyolderan, maka proses prototyping dan trial and error menjadi mudah
sehingga bisa tercapai rangkaian yang sempurna dengan lebih cepat. Pemrograman chip bisa
dilakukan tanpa repot, dan jika setelah rangkaian dan pemrogaman selesai, skema dan
program yang sama bisa diterapkan pada PCB akhir yang menggunakan chip yang sama.
2
Pin Input Output (I/O) pada board UNO R3 berjumlah 18 buah, 14 buah pin digital, dan 6
buah pin Analog. Jumlah pin I/O tersebut sama dengan pin yang dimiliki oleh chip
ATMega328 karena pada dasarnya development board UNO R3 hanyalah sebuah board yang
memperpanjang kaki chip ke lubang-lubang header agar mudah ditancap kan kabel jumper,
ditambah beberapa aksesoris seperti beberapa led, colokan jack daya dan USB.
3
Sekarang mari kita lihat letak pin digital dan pin analog tersebut pada board UNO.
Pin digital tersebut diletakkan bertetangga dari mulai pin D0 hingga pin D13, yang ditandai
dengan angka 0 hingga 13. Jika anda perhatikan, pada beberapa pin yaitu pin 3, 5, 6, 9, 10,
dan 11 memiliki tanda khusus yaitu tanda ~ yang disitu berarti pin tersebut memiliki
4
kemampuan PWM (Pulse Width Modulation). Apa itu PWM akan dijelaskan pada tutorial
selanjutnya.
Pada pin 0 dan 1 pun memiliki tanda khusus. Pin 0 memiliki tanda RX dan pin 1 memiliki
tanda TX. Kedua pin ini adalah pin komunikasi serial (Hardware UART) yang digunakan untuk
komunikasi dengan alat lain, dimana RX adalah pin yang menerima data (Receive) dan TX
adalah untuk mengirim data (Transmit). Karena kedua pin ini adalah pin komunikasi data
serial, maka kedua pin ini jarang kita pergunakan, karena akan bentrok dengan komunikasi
data USB (ketika kita mengupload program/sketch, atau ketika kita membuka jendela Serial
Monitor). Saat kita menggunakan USB, pin 0 dan 1 akan otomatis terpakai.
Pin analog terletak pada sisi yang berseberangan dengan pin digital.
Terdapat 6 buah pin analog yang dapat anda pergunakan, A0 hingga A5.
Pin lain yang ada pada board adalah pin-pin kelompok Power, atau pin-pin yang berkaitan
dengan sumber daya. Sebelum melanjutkan pembahasan mengenai pin power pada board
UNO ini, mari kita ketahui terlebih dahulu, bagaimana cara memberi sumber daya ke board
UNO.
Chip micro controller ATMega328 memiliki tegangan kerja 5V, sehingga tegangan yang
dibutuhkan oleh chip adalah 5V. Karena board UNO adalah develompent board dari chip
Atmega328, maka board UNO memerlukan tegangan 5V untuk bisa bekerja.
Sumber tegangan untuk board UNO bisa diperolleh dari beberapa cara. Cara pertama yang
paling mudah adalah melalui kabel USB ke port USB yang ada pada board.
5
Ketika anda menghubungkan board ke port USB laptop atau komputer anda, maka board
UNO akan memperoleh tegangan 5V yang mengalir di setiap port USB. Demikian juga
dengan power bank. Jika anda menghubungkan kabel USB dari power bank ke board UNO,
maka board akan menyala.
Cara kedua untuk memberi tegangan ke board UNO adalah menggunakan adaptor DC
melalui jack DC yang ada pada board UNO. Adaptor yang bisa digunakan adalah adaptor
bertegangan 7V hingga 12V, dan disarankan di 9V. Pada board UNO sudah ada chip regulator
yang akan menurunkan tegangan 7-12V tadi menjadi 5V yang sama dengan tegangan kerja
chip ATMega328.
6
Cara ketiga adalah dengan memberikan tegangan 5V langsung ke pin yang bertuliskan 5V
pada board Uno. Dengan memberikan 5V langsung ke pin itu, maka akan mengalir 5V ke
semua jalur VCC pada board sehingga board UNO akan menyala.
Mari kita perhatikan pin-pin power yang ada pada board UNO. Pin yang bertuliskan GND
adalah Ground atau yang biasa ditafsirkan sebagai kutub negatif dari sumber tegangan. Ada
3 buah pin GND, dan semua nya saling terhubung, anda bebas menggunakan yang manapun.
7
Pin 5V terhubung dengan seluruh jalur 5V pada board, sehingga jika kita memberi tegangan
5V ke pin tersebut maka board akan menyala. Begitupun jika kita memberi tegangan ke
board via USB atau jack DC, akan ada tegangan 5V dari pin tersebut.
Pin bertuliskan 3.3V akan mengeluarkan tegangan 3.3V jika board sedang menyala.
Tegangan 3.3V ini diperoleh dari tegangan 5V yang diturunkan menjadi 3.3V oleh chip
regulator yang terdapat pada board Uno.
Pin Vin bersifat mirip dengan jack DC. Pin tersebut bisa menerima 7V hingga 12V untuk
memberi tenaga ke board Uno. Arus yang masuk via pin Vin akan diturunkan ke 5V oleh chip
voltage regulator yang built in pada board.
Pin Res adalah pin yang terhubung dengan kaki RESET dari chip ATMega328. Reset
digunakan dalam proses upload sketch, atau digunakan untuk me restart arduino. Untuk me
restart arduino, pin reset dihubungkan ke GND, atau bisa juga dengan menekan tombol
reset yang ada di pojok board.
8
Pin AREF adalah pin referensi tegangan untuk Analog to Digital Converter (ADC). Misal jika
kita akan menggunakan ADC untuk memonitor sebuah sinyal yang memiliki rentang antara
0 sampai 1.5V, maka kita bisa memperoleh skala penuh dari ADC dengan menghubungkan
pin AREF ke sinyal 1.5V. Pin ini hanya bisa menerima antara 0 sampai 5V.
Pin AREF agak jarang digunakan pada percobaan untuk pemula. Pin ini akan mulai digunakan
pada tutorial tingkat lanjut dimana tingkat ketelitian pembacaan tegangan dibutuhkan
dengan presisi lebih tinggi.
Pin SDA dan SCL terhubung ke pin A4 dan A5, arti nya menggunakan pin SDA dan SCL akan
sama dengan menggunakan pin A4 dan A5. Pin SDA dan SCL adalah pin yang digunakan
dalam komunikasi data menggunakan I2C
9
Mari kita lihat ada apa lagi di board UNO yang harus kita ketahui.
Pada board UNO, terdapat beberapa led yang terpasang. 1 buah led yang bertuliskan ON
adalah led power, yang akan menyala ketika board menerima tegangan 5V.
Led bertuliskan TX dan RX adalah led untuk indikator komunikasi UART. Led tersebut akan
menyala ketika ada aktifitas Transmit dan Receive pada saluran komunikasi serial (UART),
baik itu melalui port USB atau langsung melalui pin 0 dan 1.
Led terakhir yang di beri label L, ini adalah led yang secara built in terhubung ke pin digital
13. Jadi anda bisa menggunakan led built in ini untuk mencoba sketch-sketch yang
menggunakan led, tanpa harus memasang led tambahan
Sekarang anda sudah mengetahui pin-pin yang terdapat pada board UNO. Anda pun sudah
mengetahui fungsi dari 4 led yang ada. Akan muncul pertanyaan lagi, untuk apa header 3x2
pin yang ada pada board Uno?
10
Header male tersebut adalah header ICSP (In Circuit Serial Programming). Port ICSP bisa kita
gunakan untuk memprogram chip ATMega328 secara langsung ke chip, tanpa melalui USB
atau UART. Melalui ICSP ini juga kita bisa mengisi bootloader Arduino ke chip ATMega328.
Bootloader bisa dianggap sebagai OS (Operating System) dasar untuk chip microcontroller,
sehingga chip bisa berkomunikasi dengan program Arduino IDE. Pada setiap board Uno R3
yang ada dalam kit, sudah terisi bootloader pada chip ATMega328 nya, sehingga anda bisa
langsung menggunakan nya dengan program Arduino IDE.
Upload program atau sketch melalui ICSP dapat dilakukan dengan bantuan modul-modul
programmer seperti Modul USBASP Programmer. Tinggal hubungkan modul USBASP ke
header ICSP tersebut, hubungkan USBASB ke port USB komputer, dan upload sketch dengan
menu Upload Using Programmer pada program Arduino IDE. Namun untuk hal ini tidak
diperlukan untuk belajar tahap awal. Upload sketch bisa dilakukan dengan mudah hanya
dengan menggunakan kabel USB pada port USB yang ada
11
Lubang-lubang header juga banyak terdapat pada boar Uno ini. Pada setiap sisi pin I/O,
terdapat lubang header yang bisa dipasagkan header male jika dibutuhkan. Lubang-lubang
itu berhubungan dengan pin I/O yang bersebelahan dengan nya, misal lubang di sisi A5
adalah sama dengan A5, lubang disisi A4 adalah sama dengan pin A4, demikian dengan
lubang-lubang disisi pin lain nya.
Pada bagian dekat pin-pin analog terdapat lubang-lubang yang bisa dipasang header male
tambahan. Pada dasarnya lubang-lubang tersebut hanya pararel dengan pin-pin yang sudah
ada sebelum nya. RX dan TX, sama dengan pin 0 dan 1, SDA dan SCL sama dengan pin
SDA/SCL yang telah dijelaskan sebelum nya. GND, 5V, dan 3.3V juga sama dengan pin-pin
power yang telah ada
12
SOFTWARE ARDUINO IDE
Upload program ke board UNO
Anda telah mengenal development board UNO secara fisik, mana chip utama, mana pin-pin
digital, pin analog, pin power, led-led built in, dan header ICSP, serta bagaimana menyalakan
board UNO. Namun tanpa program yang kita simpan pada chip maka board Uno tidak
memiliki fungsi apapun jika diberi tegangan.
Bagaimana cara memasukkan program ke chip ATMega328 yang ada pada board UNO?
Disinilah guna nya software Arduino IDE.
Arduino IDE adalah software untuk anda mengetikkan kode-kode program (atau yang biasa
disebut Sketch pada platform Arduino), dan melakukan Upload (mengirim kode program
tersebut ke chip). Software Arduino IDE ada di CD yang ada pada kit ini, dan bisa juga anda
download gratis dari website resmi Arduino di https://www.arduino.cc/en/Main/Software
atau download dari Microsoft Store jika anda menggunakan Windows 10 keatas
Software Arduino IDE tersedia untuk berbagai platform, bisa Windows, Mac, Linux, bahkan
Arm. Silahkan install ke komputer anda sesuai platform yang anda gunakan. Jika
menggunakan selain Windows 10, install lah driver untuk chip USB nya terlebih dahulu. Chip
USB yang digunakan adalah chip CH340G. Driver bisa diperoleh pada CD yang ada dalam kit
atau download di internet. Jika telah terinstall, maka akan tampak sebuah COM port baru
pada jendela Device Manager saat board Uno dihubungkan ke komputer.
1
Buka lah software Arduino IDE dan hubungkan board Uno ke komputer menggunakan kabel
USB yang disediakan
2
Pada jendela itulah anda bisa mengetikkan perintah-perintah yang akan anda upload ke
board Uno. Beberapa hal yang harus diperhatikan sebelum memulai adalah pemilihan board
yang akan digunakan pada software Arduino IDE dan pada port berapa board tersebut
terhubung. Pilihlah board Arduino/Genuino Uno pada menu Tools - Board
Setelah itu mari kita tentukan port yang akan digunakan untuk komunikasi komputer dengan
board Uno. Pilihlah port dimana board Uno anda terhubung dengan komputer anda, dengan
menu Tools – Port. Port mana yang dipilih adalah port yang muncul pada jendela Device
Manager pada Windows sebelum nya.
3
Pemilihan board dan port hanya cukup sekali saja dilakukan, kecuali anda mengganti board
atau mengganti port usb. Software Arduino IDE ini bisa digunakan untuk semua board
berbasis Arduino seperti board Uno, Mega2560, Nano, Pro Mini, Pro Micro, Lilypad, dan
bahkan board-board lain yang support platform Arduino
Sebelum melanjutkan lebih jauh, mari kita setting dulu bagian Preferences agar lebih sesuai
dan mudah dalam mengikuti tutorial ini. Pada menu software Arduino IDE, buka lah menu
File - Preferences
4
Kita sesuaikan beberapa setting Preferences agar lebih mudah di proses selanjutnya
Pastikan bagian Show verbose output during, di checklist compilation dan upload sudah di
centang. Ini dimaksudkan agar anda bisa melihat proses yang sedang berjalan saat compile
dan upload pada jendela verbose (bagian berwarna hitam di jendela Arduino IDE), sehingga
akan memudahkan proses debugging ketika ada masalah.
Juga pada bagian centang Display line numbers, agar terlihat nomer baris pada setiap
program yang kita buat nanti.
Pada bagian pojok kiri atas ada beberapa shortcut yang akan sering anda gunakan
5
Tombol New untuk membuat file baru. Tombol Open untuk membuka file yang telah dibuat
dan disimpan sebelum nya. Tombol Save untuk menyimpan.
Tombol Compile untuk melakukan proses compile. Proses compile ini akan menterjemahkan
perintah-perintah yang kita tulis pada jendela sketch menjadi bahasa yang dimengerti mesin.
Pada proses compile, akan dilakukan pemeriksaan terhadap perintah yang kita buat. Jika
terdapat kesalahan, proses compile akan dihentikan dan kesalahan akan di tampilkan.
Tombol Upload adalah untuk melakukan proses upload ke board Uno, dimana kode-kode
perintah yang kita tulis akan di compile dan dituliskan ke chip ATMega328 yang ada pada
board Uno. Setiap kita klik tombol upload, dengan otomatis akan melakukan proses compile
terlebih dahulu. Proses yang sedang berlangsung dapat anda lihat di jendela verbose di
bagian bawah Arduino IDE
Setelah upoad berhasil, maka pada chip ATMega328 yang ada pada board UNO telah
dituliskan perintah yang kita buat. Chip akan terus melaksanakan perintah tersebut, sampai
apabila hubungan arus ke board di putuskan. Dalam hal ini, selama masih terhubung dengan
USB komputer, dimana terdapat 5V pada USB tersebut, perintah pada chip akan tetap
berjalan. Jika hubungan dengan komputer di cabut, board akan kehilangan daya dan
berhenti bekerja. Namun jika diberi sumber tegangan lain selain komputer, misal nya dari
powerbank, chip akan kembali melaksanakan perintah yang telah tersimpan dalam chip,
walaupun sudah tidak terhubung dengan komputer yang memprogram nya sebelumnya.
Program pada chip akan selalu ada pada chip tersebut dan akan selalu di eksekusi. Program
akan tergantikan (Replace) jika anda meng upload sketch lain.
Sekarang, mari kita mencoba upload sketch pertama kali. Untuk percobaan pertama ini, kita
ambil saja file contoh yang sudah ada di Arduino IDE. Untuk contoh ini, kita ambil file sketch
Blink dengan menu File – Examples – 01.Basics - Blink
6
Isi file program tersebut adalah sebuah program dasar yang biasa digunakan dalam belajar
micro controller, dimana kita akan menyalakan dan mematikan led secara berulang sehingga
menimbulkan efek berkedip atau blinking. Oleh karena itu file nya dinamai Blink
Klik tombol shortcut Upload yang ada di area pojok kiri atas. Sketch akan di compile dan
selanjutnya diupload menuju chip. Proses yang sedang berlangsung akan di tampilkan di
jendela verbose (karena kita telah setting sebelum nya di bagian Preferences). Jika semua
berjalan lancar, pada Arduino IDE akan tampil tulisan Upload Done dan pada board Uno
anda dapat melihat led yang ber label L akan berkedip kedip. Selamat, anda telah berhasil
melakukan upload sketch yang pertama kali
7
Proses yang sama dilakukan untuk setiap sketch yang akan anda upload ke board Uno. Jika
ada masalah, akan muncul pesan error nya di bagian verbose. Kesalahan bisa di deteksi dari
pesan error yang di tampilkan. Misal jika pesan nya adalah Unable to compile, berarti
masalah di program/sketch yang dibuat, masih ada perintah yang salah yang harus dikoreksi.
Atau misal pesan error nya adalah unable to upload, berarti secara compile sudah selesai
(berarti sketch sudah benar), namun tidak bisa di upload ke board. Seringkali masalah nya
adalah human error sederhana, dimana kita begitu semangat melakukan klik upload, namun
lupa menghubungkan terlebih dahulu kabel USB ke board Uno sehingga menimbulkan pesan
error tersebut.
Tutorial selanjutnya, kita akan mulai merangkai rangkaian dan menulis program. Namun
sebelumnya, mari kita persiapkan semua file dan library yang akan dibutuhkan pada tutorial
kit Essentials agar lebih mudah dan terorganisir dengan rapih.
8
FILE SKETCH DAN LIBRARY
Mempersiapkan File dan Library yang dibutuhkan

Pada kit Essentials telah kami persiapkan banyak file program atau sketch dan beberapa
library yang akan digunakan pada tutorial-tutorial di buku ini. Silahkan anda lihat pada CD
yang disertakan.
File-file sketch secara default akan disimpan di folder Documents – Arduino pada Windows.
Copy lah file-file yang ada pada CD ke folder tersebut sehingga tampak seperti berikut
Pada folder Documents – Arduino tersebut juga secara default ada folder bernama libraries.
Folder libraries tersebut adalah folder yang digunakan oleh program Arduino IDE untuk
menyimpan library-library yang di butuhkan.
Pada tutorial kit Essentials ini, kita pun akan menggunakan beberapa library, yang dalam CD
masih berbentuk file ZIP, yaitu EcadioIRremote.zip, DHTLib.zip, Keypad.zip, dan
Newliquidcrystal.zip. Untuk menambahkan library-library tersebut, gunakan cara berikut
untuk masing-masing library :
Buka program Arduino IDE, dan klik menu Sketch – Include Library – Add .ZIP Library
9
Lalu pilih ZIP library yang akan di tambahkan. Lakukan hal tersebut untuk ke 4 library yang
dibutuhkan (add satu per satu)
Jika telah selesai melakukan add library satu-persatu, maka pada folder Documents –
Arduino – libraries akan terdapat beberapa folder seperti berikut
Dengan demikian anda telah mempersiapkan file-file sketch dan library yang akan
dibutuhkan dalam tutorial-tutorial selanjutnya dimana membuka file akan lebih mudah dan
terorganisir.
Sebagai contoh, untuk membuka file ESSENTIALS_LCD_4.ino, anda cukup klik menu File –
Sketchbook – ESSENTIALS_LCD_4 dan file yang dimaksud akan segera dibuka. Cobalah
compile file tersebut. Jika anda telah benar melakukan copy file dan library, file tersebut
akan berhasil di compile tanpa kendala
10
11
BREADBOARD
Pengenalan Breadboard (papan prototype project)

Board UNO didesain sedemikian rupa agar kita bisa mempelajari Arduino dengan mudah,
bahkan untuk pemula sekalipun. Layout dari pin-pin header yang tersedia, juga di desain
untuk memudahkan kita menghubungkan kabel-kabel ke sumber tegangan atau modul-
modul sensor dalam proses prototyping.
Seperti yang telah dijelaskan sebelumnya, proses prototyping biasanya melibatkan project
board atau breadboard serta kabel-kabel jumper untuk proses wiring sebuah rangkaian.
Breadboard membantu untuk menjembatani kabel-kabel jumper, sehingga kita tidak perlu
repot-repot menyambungkan kabel-kabel secara manual. Cukup menusukkan kabel-kabel
jumper pada breadboard (breadboard dan kabel jumper sudah terdapat pada kit)
Agar lebih memahami bagaimana breadboard melakukan jembatan-jembatan kabel, mari

kita mengenali dulu anatomi dari sebuah breadboard.
Pada sebuah breadboard, terdapat dua bagian utama, bagian titik-titik koneksi kabel dan
bagian titik-titik koneksi power (power rail). Titik-titk di kolom a, b, c, d, e, f, g, h, I, j adalah
1
titik-titik koneksi kabel yang bisa digunakan untuk menyimpan komponen. Titik-titik pada
bagian sisi kanan dan kiri adalah power rail, yang biasa digunakan untuk menghubungkan
tegangan. Warna merah digunakan untuk tegangan positif (yang bertuliskan +) dan warna
biru digunakan untuk tegangan negatif atau gnd (yang bertuliskan -)
Power rail terhubung secara vertikal. Titik-titik sepanjang garis merah saling terhubung, titik-
titik sepanjang garis biru saling terhubung. Namun titik-titik garis merah tidak terhubung
dengan titik-titik garis biru.
Power rail bagian sisi kiri tidak terhubung dengan bagian sisi kanan. Artinya, titik-titik
sepanjang garis merah (+) bagian kiri tidak berhubungan dengan titik-titik sepanjang garis
merah di sisi bagian kanan. Begitu pun dengan garis biru (-)
Titik-titik koneksi kabel terhubung secara horisontal. Misal titik-titik di baris 30, kolom a, b, c,
d, e saling terhubung. Namun tidak terhubung dengan sesama baris 30 di kolom f, g, h, i, j.
Titik-titik di baris 30 pada kolom f, g, h, i, j saling terhubung, namun tidak terhubung dengan
kolom f, g, h, i, j yang ada di baris 29
Lebih mudah nya bisa diamati gambar berikut ini
2
Semua titik pada garis merah bagian kiri saling terhubung. Semua titik pada garis biru saling
terhubung. Garis merah bagian kiri tidak terhubung dengan garis merah bagian kanan.
Demikian juga dengan garis biru bagian kiri tidak terhubung dengan garis biru bagian kanan.
Titik-titik koneksi kabel area tengah diilustrasikan dengan garis-garis warna hijau. Terlihat
bagaimana sifat koneksi masing-masing garis hijau
Dengan menggunakan peta garis-garis koneksi pada breadboard tersebut kita bisa
menggunakan breadboard sebagai jembatan koneksi beberapa kabel. Dalam satu jalur yang
sama kita bisa menusukkan beberapa kabel jumper atau beberapa kaki komponen. Mari kita
praktekkan dalam tutorial selanjutnya.
3
TUTORIAL LED 1
BLINK – Memahami konsep dasar I/O Arduino
Setelah mengenal board Uno, mengetahui cara mengupload sketch ke board, dan mengenal
anatomi breadboard, marilah kita mulai belajar konsep-konsep dasar Arduino melalui
eksperimen langsung. Pada tutorial pertama ini kita akan belajar mengenai konsep I/O atau
Input Output pada micro controller, yang pada kali ini kita akan menggunakan mikro
kontroller berbasis Arduino yaitu board UNO
Komponen yang akan kita gunakan dalam tutorial kali ini adalah breaboard, beberapa kabel
jumper, 1 buah led, 1 buah resistor 220 ohm, dan tentunya board Uno. Semua komponen
ada di kit Essentials.
Pasanglah led, dan resistor serta kabel-kabel jumper seperti pada gambar diatas. Dari pin 5V
arduino ke power rail warna merah di breadboard. Pin GND ke power rail warna biru. Bagian
1
kutub led negatif (yang berkaki lebih pendek) dihubungkan ke power rail warna biru dengan
kabel jumper. Bagian kutub positif led (yang berkaki lebih panjang) dihubungkan ke resistor
via breadboard. Ujung resistor lain dihubungkan ke pin 13 dari board Uno.
Komponen led adalah komponen yang akan cukup sering anda gunakan dalam percobaan-
percobaan dan latihan Arduino karena sifat nya yang sederhana. Jika kaki anoda (positif led)
dari led dihubungkan ke kutub positif sumber tegangan, dan kaki katoda (negatif led)
dihubungkan ke kutub negatif sumber tegangan, maka led akan menyala seperti lampu pada
umum nya.
Berapa tegangan yang bisa di terima sebuah led? Led ukuran 5mm seperti yang ada pada kit
akan menyala jika dialiri tegangan antara 3V hingga 5V. Tegangan 5V pada board Arduino
akan bisa menyalakan led (anda bisa mencobanya dengan langsung menghubungkan kaki
panjang led ke pin 5V dan kaki pendek nya ke pin GND), namun agar arus yang mengalir ke
led tidak sampai merusak led, maka kita akan menggunakan resistor 220 ohm untuk
membatasi nya.
Jadi, jika kita mengaliri kaki positif led dengan tegangan, dan kaki negatif terhubung ke GND,
led akan menyala. Sifat led ini yang akan sering kita gunakan untuk memeriksa apakah pada
sebuah pin I/O terdapat tegangan (posisi HIGH) atau sedang terhubung ke GND (posisi LOW)
Kembali ke diagram rangkaian diatas, jika anda memperhatikan peta anatomi breadboard
sebelum nya, rangkaian ini sebenarnya sederhana, dimana kaki + led dihubungkan ke pin 13
melalui sebuah resistor, dan kaki – led dihubungkan ke GND. Resistor 220 ohm digunakan
disini hanya untuk melindungi agar led tidak kelebihan arus. Pin 5V sebenarnya tidak
terpakai pada rangkaian breadboard ini, namun hal ini dilakukan agar anda memiliki
kebiasaan yang baik, dimana selalu akan menghubungkan 5V dan GND ke breadboard, dan
nanti akan mengambil 5V atau GND dari breadboard
2
Dengan demikian, jika terdapat tegangan pada pin 13 (posisi HIGH), led akan menyala. Jika
pin 13 tidak memiliki tegangan (posisi LOW), maka led akan mati, karena tidak ada arus yang
mengalir.
Mari kita coba program nya. Bukalah file tutorial ESSENTIALS_led_1.ino yang ada pada CD,
dan upload sketch tersebut ke board UNO. Anda akan melihat bahwa led merah akan
berkedip, nyala dan mati dengan selang waktu 1 detik.
Mari kita perhatikan isi sketch nya :
/*
TUTORIAL LED BERKEDIP 1 PADA ARDUINO
ecadio.com
D13 -> Led Merah
*/
#define pinLed 13 //led merah pada D13
void setup() {
pinMode(pinLed, OUTPUT); //set menjadi output
}
3
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
}
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 catatan untuk program tersebut
/*
TUTORIAL LED BERKEDIP 1 PADA ARDUINO
ecadio.com
D13 -> Led Merah
*/
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
kita mendefinisikan kata pinLed adalah 13, sehingga setiap kata pinLed yang ada dalam
program akan diartikan sebagai 13. 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. Bagian loop() adalah bagian yang akan selalu 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 13 (dimana kutub positif led merah terhubung ke pin digital 13 via resistor dan kutub
negatif ke ground) menjadi output, karena kita akan memberikan tegangan ke pin tersebut,
bukan menangkap nilai tegangan, sehingga perintah nya adalah pinMode(13, OUTPUT);
Syntax perintah pinMode adalah :
pinMode(pin,value)
4
dimana pin adalah nomer pin yang akan digunakan, nilai adalah INPUT atau OUTPUT
Karena kita telah mendefinisikan kata pinLed adalah 13, 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 13, 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
saja yaitu #define pinLed 7 daripada mengganti baris berisi angka 13 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 13 dalam hal ini (karena pinLed adalah sama dengan 13 yang kita definisikan
sebelumnya). Karena pin 13 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 13 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.
5
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
terhubung ke GND. Seperti yang telah disebutkan sebelum nya, kutub positif led merah
terhubung ke pin 13 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
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 13 (tentunya dengan menyesuaikan rangkaian pada breadboard)
Rangkaian led tersebut adalah rangkaian Active High, dimana led akan menyala ketika diberi
nilai HIGH pada pin yang berkaitan (pin 13 pada contoh diatas). Alternatif lain adalah
rangkaian Active Low, dimana led akan menyala ketika diberi nilai LOW pada pin yang
bersangkutan.
Untuk mencoba rangkaian led Active Low, rangkaian nya mirip dengan rangkaian sebelum
nya, namun kali ini kaki negatif led yang dihubungkan ke pin 13, sedangkan kaki positif
terhubung ke 5V melalui resistor 220 ohm
Dengan demikian, ketika terdapat nilai LOW pada pin 13, led akan menyala karena kaki
negatif led yang terhubung ke pin 13 sedangkan kaki positif telah terhubung ke 5V melalui
resistor.
Diagram rangkaian untuk led aktive low bisa diikuti seperti gambar berikut :
6
Untuk sketch nya, silahkan upload ESSENTIALS_Led_1a.ino
/*
TUTORIAL LED BERKEDIP PADA ARDUINO
Active Low Circuit
ecadio.com
D13 -> Led Merah
*/
void setup() {
}
void loop() {
digitalWrite(pinLed, HIGH); //mematikan led
digitalWrite(pinLed, LOW); //menyalakan led (konek ke gnd)
delay(100); //jeda waktu 100 mili detik, akan tetap menyala selama 100
mili detik
7
}
Hasilnya, led akan menyala berkedip seperti percobaan sebelum nya. Pada sketch ini, led di
program untuk menyala lebih sebentar dari mati nya, menyala hanya 100 mili detik dan mati
selama 1 detik, yang menampilkan efek kedipan cepat
Perhatikan pada led standar yang menempel pada board arduino Uno, led tersebut juga ikut
berkedip karena secara internal, led tersebut terhubung ke pin 13, namun led pada board
berkedip kebalikan dari kedipan led pada breadboard karena perbedaan rangkaian.
Rangkaian pada breadboard menggunakan active low, sedangkan pada led built ini
menggunakan active high.
8
TUTORIAL LED 2
BLINK Multiple Led
Tutorial ini adalah mengembangan dari Tutorial Led 1 dimana kali ini kita akan mencoba
sketch led berkedip namun untuk beberapa led yang menghasilkan efek cahaya tertentu.
Kali ini kita akan menggunakan 4 buah led, 4 buah resistor 220 ohm dan pasang rangkaian
seperti gambar berikut :
Warna led tidak terlalu berpengaruh pada program ini, anda bebas memilih warna. Hanya
dalam penamaan di sketch yang kita bedakan antara led 1, 2, 3, dan 4 dengan nama merah,
kuning, biru, dan hijau. Masing-masing kaki led positif terhubung ke pin 4, 5, 6, dan 7 pada
board Uno via resistor. Kaki negatif masing-masing led terhubung ke GND
9
Bukalah file tutorial ESSENTIALS_led_2.ino, dan upload 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 sketch nya :
/*
TUTORIAL LED BERKEDIP BERGANTIAN PADA ARDUINO
ecadio.com
D4 -> Led Merah
D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/
#define merah 4
#define hijau 5
#define biru 6
#define kuning 7
void setup() {
pinMode(merah, OUTPUT); //set menjadi output
pinMode(hijau, OUTPUT); //set menjadi output
10
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 menyala dan sisanya

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

digitalWrite(merah, HIGH); //menyalakan led merah(memberi tegangan 5V)
}
Pada sketch 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 breadboard, 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
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.
11
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 menyala dan sisanya
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 :

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

dan terakhir giliran led merah menyala dan led lainnya mati :

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
12
TUTORIAL LED 3
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.
Bukalah file tutorial ESSENTIALS_led_3.ino, dan upload sketch tersebut ke board UNO. Anda
akan melihat bahwa led akan menyala dan mati secara bergantian sehingga memberikan
efek led nyala berjalan (running led) seperti tutorial sebelumnya, namun kali ini kita
mencoba menulis program dengan cara lain
Wiring rangkaian masih sama dengan yang sebelum nya
Mari kita bedah sketch nya
13
/*
PENGENALAN SUB PROGRAM
ecadio.com
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(){
delay(jeda);
}
void nyalaBiru(){
delay(jeda);
}
void nyalaHijau(){
delay(jeda);
}
void nyalaMerah(){
14
delay(jeda);
}
Perhatikan pada sketch tersebut, perbedaan dengan sketch ESSENTIALS_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 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.
15
TUTORIAL SERIAL MONITOR 1
Pengenalan Serial Monitor dan Input I/O
Pada tutorial kali ini kita akan berkenalan dengan feature Serial Monitor, yang akan cukup
sering digunakan nanti, terutama untuk debugging. 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 kali ini, wiring rangkaian yang digunakan hanya board Uno
yang terkoneksi ke komputer via USB, tanpa komponen atau modul apapun.
Bukalah file ESSENTIALS_Serial_Monitor_1.ino dan upload ke board Uno. Setelah di upload,

tidak akan tampak apa-apa pada board 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.
16
Pada jendela Serial Monitor, akan tampak data seperti gambar di bawah ini
Pastikan sudah menggunakan baud rate 115200 di bagian pojok kanan bawah jendela serial
monitor agar sama dengan kecepatan baud rate yang kita tentukan dalam sketch
Mari kita bahas sketch ESSENTIALS_Serial_Monitor_1
/*
ecadio.com
*/
int x = 1;
void setup() {
Serial.begin(115200);//memulai inisiasi komunikasi serial dengan baud
rate 115200 bps
Serial.println("Mencoba Serial Monitor");
}
void loop() {
Serial.print("Ini loop ke : ");
Serial.println(x);
x++;
delay(2000);
}
Pada bagian sebelum setup(), ada baris perintah yang menyimpan variabel memori x dengan
nilai 1. Variabel ini akan kita gunakan dalam perintah dalam loop nanti
int x = 1;
Pada pemrograman Arduino, kita tidak bisa menyimpan data variabel tanpa
mendeklarasikan jenis tipe data variabel tersebut. Oleh karena itu kita menulis int di depan
variabel x untuk mendeklarasikan bahwa variabel x berjenis integer
17
Pada bagian setup(), untuk bisa menggunakan komunikasi serial seperti menampilkan data
pada serial Monitor, gunakan perintah Serial.begin(115200); untuk memerintahkan untuk
memulai komunikasi serial dengan baudrate 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.
Serial.println("Mencoba Serial Monitor");
Pada baris perintah diatas, kita akan memunculkan tulisan “Mencoba Serial Monitor” pada
jendela Serial Monitor. Tulisan tersebut hanya akan muncul sekali saat board dinyalakan,
karena perintah ditulis di bagian setup().
Baris perintah berikutnya adalah di bagian loop().
Serial.print("Ini loop ke : ");

Serial.println(x);
Baris perintah tersebut menulis tulisan “Ini loop ke : “ yang dilanjutkan dengan menulis nilai
variabel x. Saat awal di eksekusi, nilai x adalah 1, karena kita telah menyimpan integer 1
sebelum nya.
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.
x++;
Bari perintah tersebut menambahkan nilai x dengan 1, sehingga nilai x akan menjadi 2. Nilai
2 ini akan ditampilkan pada loop berikutnya, yang kemudian akan ketemu baris x++ lagi,
yang akan ditambahkan 1 lagi, demikian seterus nya
delay(2000);
Perintah delay 2 detik tersebut dimaksudkan agar data yang tampil di Serial Monitor tidak
tampil terlalu cepat, tapi ada jeda setiap 2 detik
18
Sama seperti tutorial sebelum nya, untuk mencoba Serial Monitor kali ini, wiring rangkaian
yang digunakan hanya board Uno yang terkoneksi ke komputer via USB, tanpa komponen
atau modul apapun. Pada kesempatan kali kini kita akan mencoba menggunakan Serial
Monitor untuk menampilkan nilai yang diperoleh pada pin I/O.
Bukalah file ESSENTIALS_Serial_Monitor_2.ino dan upload ke board Uno. Setelah di upload,

tidak akan tampak apa-apa pada board secara hardware karena pada saat ini kita tidak
menambahkan hardware apapun.
Untuk memunculkan jendela Serial Monitor, kembali klik icon yang berada di pojok kanan
atas jendela Arduino IDE. Pastikan juga board Arduino sudah terkoneksi ke komputer melalui
kabel USB.
Pada jendela Serial Monitor, akan tampak data seperti gambar di bawah ini
19
Pastikan sudah menggunakan baud rate 115200 di bagian pojok kanan bawah jendela serial
monitor agar sama dengan kecepatan baud rate yang kita tentukan dalam sketch
Mari kita bahas sketch ESSENTIALS_Serial_Monitor_2
/*
TUTORIAL SERIAL MONITOR ARDUINO
MENAMPILKAN NILAI DARI SEBUAH PIN
ecadio.com
*/
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.
20
Perintah selanjutnya adalah Serial.println(). Serial.println() kita gunakan untuk menuliskan
data yang akan muncul di jendela Serial Monitor.
Serial.println("Mencoba Serial Monitor 2");
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
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 atau menangkap 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. Sedangkan pada 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.
21
TUTORIAL POTENSIOMETER 1
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 titik 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.
22
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 5V
Sekarang mari kita coba menggunakan potensiometer di arduino. Komponen yang

digunakan adalah 1 buah potensiometer, breadboard, dan beberapa kabel jumper.
Rangkailah seperti pada skema berikut :
23
Pada skema itu pada dasarnya menghubungkan 3 kaki potensiometer. 2 kaki ujung ke VCC
dan GND, 1 kaki tengah ke pin A0
Bukalah file ESSENTIALS_Potensio_1.ino dan upload ke board UNO.
Sketch nya dalah sebagai berikut :
/*
* TUTORIAL POTENSIOMETER PADA ARDUINO
* ecadio.com
*
* Pinout (dari kiri ke kanan potensiometer) :
* GND,A0,VCC
*
* 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");
24
}
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 anaog diperoleh dari
nilai yang tergantung pada putaran lengan potensio.
Setelah upload sketch tersebut, bukalah jendela Serial Monitor dan perhatikan nilai yang
tampil, sambil mencoba memutar lengan potensiometer. Nilai tersebut akan berubah-ubah
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.
25
Konsep ini lah yang digunakan untuk mengambil nilai dari sensor, konsep perubahan
tegangan 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.
26
TUTORIAL LED 4
Potensio dan Led
Di tutorial ini kita akan belajar menggabungkan konsep potensiometer sebelum nya dengan
beberapa led yang telah dipelajari pada Tutorial Led 3. Buka file ESSENTIALS_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.
27
Mari kita bahas sketch nya.
/*
GABUNG DENGAN POTENSIO
ecadio.com
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
28
void setup() {
pinMode(A0, INPUT); //set A0 menjadi input

}
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);
}
void nyalaBiru(){
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() {
29
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(){
delay(jeda);
}
Dengan demikian akan tampak efek bahwa kecepatan running led akan dipengaruhi oleh
posisi lengan potensio meter. Kecepatan running led akan melambat atau semakin cepat
tergantung arah putaran anda pada lengan potensiometer.
30
TUTORIAL LED 5
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
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.
31
Wiring diagram untuk mencoba PWM kali ini, kita akan menggunakan 1 buah led, 1 buah
resistor 220 ohm, breadboard dan beberapa kabel jumper. Kaki + led ke pin D6 melalui
resistor 220 ohm, kaki – led ke GND
32
Untuk mencoba nya, buka file ESSENTIALS_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
ecadio.com
D6 -> Led Merah (pin PWM)
*/
#define pinLed 6 //led merah pada D6 yang merupakan pin PWM

int intensitas = 0;
int jumlahStep = 1;
void setup() {
}
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.
33
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
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
34
variabel intensitas. Ketika pengurangan mencapai nilai 0, terjadi pembalikan lagi menjadi
penambahan. Demikian seterusnya sehingga menampilkan efek led menyala berdenyut.
35
TUTORIAL LED 6
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, 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.
Wiring rangkaian mirip dengan sebelum nya, di tambah dengan rangkaian potensiometer.
Bukalah file ESSENTIALS_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.
36
/*
TUTORIAL LED PWM PADA ARDUINO
PENGATURAN VIA POTENSIO
ecadio.com
D6 -> Led Biru (pin PWM)

*/
#define pinLed 6 //led merah pada D6 yang merupakan pin PWM

#define pinPot A0 //kaki tengah potensiometer ke pin 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
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.
37
TUTORIAL LED 7
Pengenalan konsep millis(), Blink tanpa delay()
Pada tutorial kali ini kita akan belajar penggunaan perintah millis(). Untuk apakah millis()
digunakan? Untuk memahami millis, buka file ESSENTIALS_Serial_monitor_3.ino dan upload
ke board Arduino. Buka jendela serial monitor, dan akan tampak nilai seperti berikut :
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
38
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 buka file
ESSENTIALS_Led_7.ino dan upload ke board Uno. Untuk wiring, kita tidak menggunakan
rangkaian tambahan, cukup menggunakan board Uno saja, memanfaatkan led built in yang
ada pada board, yang secara internal terhubung dengan pin 13
Setelah di upload, yang akan tampak adalah led merah berkedip nyala dan mati setiap 1
detik, serupa dengan tutorial blink yang pertama kali. Lalu apa beda nya, mari kita lihat
sketch nya.
/*
TUTORIAL LED PADA ARDUINO
BLINK (LED BERKEDIP) TANPA PENGGUNAAN DELAY
ecadio.com
D13 -> Led Merah
*/
#define pinLed 13
int statusLed = LOW;

unsigned long millisSebelumnya = 0;
const long interval = 1000;
void setup() {
}
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
39
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.
dan juga melaksanakan perintah untuk membalik kan statuLed 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.
40
Mapping Nilai
Tutorial potensiometer kali ini merupakan gabungan antara pembacaan nilai potensio di
Tutorial Potensiometer 1 dengan pelajaran mapping nilai sebelum nya. Wiring rangkaian
adalah seperti diagram berikut :
Buka file ESSENTIALS_Potensio_2.ino dan upload ke board Uno. Jalankan Serial Monitor dan
akan tampak data seperti gambar berikut :
41
Pada sketch ini, nilai dari analogRead() dari potensio yang memiliki rentang antara 0 hingga
1023 di peta kan ke rentang kecil, 1 sampai 4. Mari kita lihat sketch nya
/*
* TUTORIAL POTENSIOMETER PADA ARDUINO DENGAN MAPPING NILAI
* ecadio.com
*
* 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,0,100); //mapping nilai 0 s/d 1023 ke 0
s/d 100
pada serial monitor
Serial.print("Putaran potensio : " + String(hasilMap)); //tampilkan pada
serial monitor
Serial.println("%"); //tampilkan pada serial monitor
delay(500); //jeda waktu 500 uS
}
42
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()
43
Penggunaan Mapping dan Led Serta Kondisi IF

Tutorial kali ini adalah gabungan tutorial potensio sebelumnya dengan tutorial 4 led, dimana
kali ini kita akan belajar memetakan nilai analog yang diperoleh dari putaran potensio di A0
untuk mengatur posisi nyala led
Diagram wiring nya adalah sebagai berikut :
Buka ESSENTIALS_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
ecadio.com
Pinout (dari kiri ke kanan potensiometer) :

GND,A0,VCC
44
Untuk membaca nilai dari pin analog (nilai 0 - 1023)
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
pada serial monitor
Serial.println("Nilai hasil mapping : " + String(hasilMap)); //tampilkan
pada serial monitor
if (hasilMap == 0) {
digitalWrite(kuning, LOW);
digitalWrite(biru, LOW);
digitalWrite(hijau, LOW);
digitalWrite(merah, LOW);
}
digitalWrite(kuning, HIGH);
}
digitalWrite(biru, HIGH);
}
45
digitalWrite(hijau, HIGH);
}
digitalWrite(merah, HIGH);
}
delay(100); //jeda waktu

}
Nilai yang diperoleh dari potensiometer di pin A0 yang disimpan dalam variabel memori
bernama “hasil”
int hasil = analogRead(pinPotensio); //ambil data nilai A0 dan simpan ke

variabel hasil
Variabel hasil tadi di petakan menjadi 4 nilai yang akan kita gunakan dalam struktur IF untuk
menyalakan led yang dikehendaki, disimpan dalam variable hasilMap
s/d 4
dengan perintah map, variabel hasilMap akan berisi integer 0 sampai 4, dan hasil tersebut
digunakan untuk menyalakan led sesuai nilai yang keluar dari putaran potensiometer
dengan menggunakan perintah IF.
Syntax perintah IF pada pemrograman Arduino adalah :
IF (kondisi yang disyaratkan) {

… Perintah yang akan dijalankan jiga syarat dipenuhi …
… Perintah yang akan dijalankan jiga syarat dipenuhi …
}
Nilai hasilMap akan salah satu dari 0, 1, 2, 3, atau 4. Makan akan ada 5 IF untuk mengcover
kemungkinan yang terjadi
}
Perintah IF diatas adalah jika nilai hasilMap adalah 0, maka bisa dilihat, semua led
diperintahkan untuk tidak menyala karena diberi LOW
46
}
Pada perintah IF bagian kedua, yaitu jika nilai hasilMap adalah 1, led pertama yang akan
menyala (diberi HIGH) sedangkan led lain tidak menyala (diberi LOW)
}
Pada perintah IF bagian ke tiga, led pertama dan kedua yang diberi HIGH sehingga akan ada
2 led menyala dan 2 led mati
}
Pada bagian IF diatas, sekarang ada 3 led yang menyala (diberi HIGH) dan hanya 1 led yang
mati (diberi LOW)
}
Bagian IF terakhir, semua led akan menyala, karena semua diberi nilai HIGH
Pada sketch ini kita mengaktifkan juga serial monitor, sehingga nilai-nilai yang ada bisa kita
lihat juga pada jendela Serial Monitor. Silahkan klik icon Serial Monitor untuk melihatnya

pada serial monitor
Serial.println("Nilai hasil mapping : " + String(hasilMap)); //tampilkan
pada serial monitor
47
TUTORIAL SHIFT REGISTER
Pengenalan Penggunaan IC Shift Register
Pada tutorial bagian awal, kita telah belajar bagaimana menyalakan led dengan
menggunakan perintah digitalWrite(). Ketika anda mengirimkan nilai HIGH dengan perintah
digitalWrite() tersebut, maka akan mengalir tegangan logic 5V pada pin yang bersangkutan,
sehingga jika pin tersebut tersambung dengan led, led akan menyala. Ketika mengirim nilai
LOW, secara tegangan logic akan dikirim 0V atau terhubung dengan GND, dan led yang
terhubung akan mati.
Untuk menyalakan atau mematikan 1 led, anda menggunakan 1 buah pin I/O, misal
menggunakan pin digital 13 pada contoh Blink sebelum nya. Ketika anda mencoba
mengontrol 4 buah led, anda akan menggunakan 4 buah pin I/O, seperti misal pin 2, 3, 4,
dan 5. Lalu bagaimana caranya jika kita akan mengontrol lebih banyak led? Misal 16 led,
atau 64 buah led, sedangkan board Arduino Uno hanya memiliki 14 pin digital dan 6 pin
analog (total 20 pin)?
Adakalanya kita harus mengontrol banyak led, misal pada kasus penggunaan seven segment
display, dimana pada 1 segment nya terdapat 8 buah led, sehingga jika menggunakan 4 buah
segment (misal pada rangkaian jam menggunakan seven segment) akan ada total 64 buah
led yang harus di kontrol, ditambah input-input lain seperti untuk menyalakan buzzer alarm,
tombol-tombol pengatur jam, dan lain-lain. Tentunya total jumlah pin I/O yang dimiliki
Arduino Uno tidak akan mencukupi
Salah satu metode untuk mengatasi masalah tersebut adalah penggunaan chip atau IC
tambahan, yang bisa membantu kita mengontrol lebih banyak logic I/O tapi menggunakan
hanya sedikit pin I/O dari Arduino Uno.
Pada tutorial kali ini kita akan menggunakan IC Shift Register 74HC595. Dengan 1 buah IC
kita dapat mengontrol 8 led, namun hanya mengkonsumsi 3 pin I/O pada Arduino
48
Penomoran kaki IC dimulai dari sisi IC yang bertanda coak dan ada tanda titik di pojok nya. IC
74HC595 terdiri dari 16 kaki, yang pinout (pementaan pin nya) adalah seperti pada gambar
diatas.
QA hingga QH dihubungkan ke output. SLCLR dan VCC ke 5V. OE dan GND ke GND. SER, RCLK
dan SRCLK ke pin I/O Arduino.
Silahkan rangkai IC Shift Register 74HC595 sesuai skema berikut ini
Buka file ESSENTIALS_Shift_Register_1.ino dan upload ke board Uno. Akan tampak led yang
menyala bergantian. Pada rangkaian ini kita menggunakan 8 buah led (dengan 8 resistor 220
ohm) namun hanya mengkonsumsi 3 buah pin I/O dari Arduino.
Mari kita lihat sketch nya
/*
TUTORIAL PENGGUNAAN IC SHIFT REGISTER 74HC595 PADA ARDUINO
49
ecadio.com
Pinout :
Led 8 buah di kaki nomer 1, 2, 3, 4, 5, 6, 7, dan 15 pada IC 74HC595
Kaki IC nomer 8 ke GND
Kaki IC nomer 10 ke 5V
Kaki IC nomer 12 (RCLK / LATCH) ke D5
Kaki IC nomer 11 (SRCLK) ke D6
Kaki IC nomer 14 (SER) ke D4
*/
int latchPin = 5; // Pin Latch/RCLK 74HC595 ke D5

int clockPin = 6; // Pin Clock/SRCLK 74HC595 ke D6
int dataPin = 4; // Pin Data/SER 74HC595 ke D4
void setup()
{
// Set pins 74HC595 sebagai OUTPUT
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
}
void loop()
{
digitalWrite(latchPin, LOW); //pin Latch di set LOW agar dapat menerima
data
shiftOut(dataPin, clockPin, LSBFIRST, B11110000); //mengirim 8 bit data
digitalWrite(latchPin, HIGH); //pin Latch di set HIGH untuk menandakan
penerimaan data selesai
delay(1000);
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, LSBFIRST, B00001111);
digitalWrite(latchPin, HIGH);
delay(1000);
}
Bagian awal dari sketch di isi dengan penamaan pin I/O yang akan digunakan menggunakan
variabel memori latchPin untuk pin 5, clockPin untuk pin 6, dan dataPin untuk pin 4.

Untuk mengendalikan IC ini, pada bagian setup, pin-pin yang digunakan untuk komunikasi
dengan IC 74HC595 harus di buat sebagai output
50
Pada bagian loop, di tutorial kali ini kita membuat 2 pola led yang akan bergantian di
jalankan. Pola pertama dijalankan pada perintah berikut :

data
shiftOut(dataPin, clockPin, LSBFIRST, B11110000); //mengirim 8 bit data
Pengiriman data biner dilakukan dengan perintah shiftOut(). Agar IC bisa menerima data, pin
Latch/RCLK harus dalam kondisi LOW terlebih dahulu, oleh karena nya di beri perintah
digitalWrite(latchPin, LOW) sebelum perintah shiftOut(). Setelah data dikirim, kembali di
buat HIGH
Perhatikan data yang di kirim dengan perintah shiftOut diatas. Data yang dikirim dalam
bentuk biner, sehingga di awali dengan huruf B (pada baris diatas adalah B11110000). Biner
B11110000 berarti 4 led pertama bernilai 1 (atau HIGH) dan 4 led sisanya bernilai 0 (atau
LOW). Dengan demikian, akan tampak 4 led pertama menyala dan 4 led sisa nya mati
51
Pola kedua menggunakan biner B00001111, sehingga 4 led pertama mati, 4 led sisanya
menyala. Contoh lain pola biner bisa diperhatikan gambar di bawah ini.
Terlihat, led akan menyala di setiap ada angka 1 di posisi led yang bersangkutan. Biner
B00000000 berarti tidak ada led yang menyala. Biner 10000000 berarti hanya led paling kiri
yang menyala. B00000001 berarti hanya led paling kanan yang menyala
Untuk mencoba konsep tersebut lebih lanjut, silahkan buka file

ESSENTIALS_Shift_Register_2.ino dan upload ke board Uno. Skema rangkaian breadboard
masih sama
/*
TUTORIAL PENGGUNAAN IC SHIFT REGISTER 74HC595 PADA ARDUINO
ecadio.com
Pinout :
52
*/

byte posisiLed[10] = {B00000000, B10000000, B01000000, B00100000,

B00010000, B00001000, B00000100, B00000010, B00000001 };
void setup()
{
}
void loop()
{
for (int i = 1; i < 9; i++) {

data
shiftOut(dataPin, clockPin, LSBFIRST, posisiLed[i]); //mengirim 8 bit
delay(200);
}
for (int x = 7; x > 1; x--) {

shiftOut(dataPin, clockPin, LSBFIRST, posisiLed[x]);
delay(200);
}
Pada sketch tersebut, mirip dengan sketch sebelum nya, namun sekarang kita menggunakan
metode yang sedikit berbeda dalam menyimpan bilangan biner nya. 8 buah pola biner di
simpan dalam sebuah array yang diberi nama posisiLed[]

B00010000, B00001000, B00000100, B00000010, B00000001};
Dalam sebuah array, untuk memanggil anggta array tersebut, cukup dipanggil nama array
nya dengan posisi anggota array yang di panggil. Sebagai contoh, posisiLed[0] akan
menghasilkan nilai B00000000. PosisiLed[1] akan menghasilkan B10000000. PosisiLed[8]
akan menghasilkan B000000001.
53
Pada bagian loop, ada 2 buah bagian loop FOR. Bagian pengulangan FOR pertama,
memanggil posisiLed[1] hingga posisiLed[8] sehingga led akan menyala bergantian dari led
pertama hingga led ke 8 dengan jeda 200 millisecond
for (int i = 1; i < 9; i++) {

data
delay(200);
}
Dan pada bagian pengulangan FOR yang kedua, memanggil posisiLed mundur dari
posisiLed[7] ke posisiLed[2]
for (int x = 7; x > 1; x--) {

shiftOut(dataPin, clockPin, LSBFIRST, posisiLed[x]);
delay(200);
}
Perintah dalam loop tersebut akan menampilkan ilusi sebuah led yang menyala berlari ke
kanan dan ke kiri.
54
TUTORIAL SHIFT REGISTER 2
Shift Register, Led, dan Potensio

Tutorial ini adalah pengembangan dari tutorial sebelum nya dimana rangkaian nya mirip
hanya di tambahkan sebuah potensiometer seperti tampak pada skema berikut
Buka file ESSENTIALS_Shift_Register_3.ino dan upload ke board Uno. Coba lah memutar
lengan potensiometer dan lihat efek nya pada led yang menyala
/*
55
TUTORIAL PENGGUNAAN IC SHIFT REGISTER 74HC595 DAN POTENSIO PADA ARDUINO
ecadio.com
Pinout :
Kaki tengah potensio ke A0, kaki sisi ke 5V dan GND
*/


B00010000, B00001000, B00000100, B00000010, B00000001 };
void setup()
{
pinMode(A0, INPUT);
}
void loop()
{
int hasilPotensio = analogRead(A0);
int hasilMap = map(hasilPotensio, 0, 1023, 1, 8);
data
shiftOut(dataPin, clockPin, LSBFIRST, posisiLed[hasilMap]); //mengirim 8
bit
delay(200);
}
Konsep sketch ini adalah menggabungkan sketch pengenalan shift register dengan sketch
pottensiometer, dimana nilai analog yang di baca dari potensiometer digunakan untuk
mengendalikan pemanggilan anggota array posisiLed[]
56
TUTORIAL LED RGB
Pengenalan Penggunaan Led RGB
Led RGB memiliki karakteristik yang unik, dimana dalam sebuah komponen yang bentuk nya
menyerupai sebuah led 5mm tapi bisa mengeluarkan banyak pilihan warna. Jumlah warna
yang bisa di tampilkan sangat banyak karena menggunakan kombinasi campuran 3 warna
yaitu merah (Red), hijau (Green) dan biru (Blue). Oleh karena itu jenis led seperti ini di sebut
dengan led RGB.
Led RGB 5mm pada umum nya terdiri dari 2 jenis, Common Cathode dan Common Anode.
Pada common cathode, terdapat satu kaki negatif dan 3 kaki positif untuk warna R (red), G
(green), dan B (blue). Kebalikan nya, pada jenis led RGB common anode, terdapat satu kaki
positif dan 3 kaki negatif. Pada tutorial kali ini kita akan menggunakan led RGB yang berjenis
Common Anode
Untuk mengatur warna yang akan ditampilkan pada led RGB adalah dengan memberikan
nilai yang berbeda pada setiap channel warna nya. Artinya, warna yang akan di tampilkan
adalah percampuran antara 3 warna merah (R), hijau (G), dan biru (B). Nilai masing-masing
channel adalah antara 0 hingga 255. Jadi misal untuk warna merah, adalah 100% Red, 0%
Green, dan 0% Blue. Atau nilai 255 untuk merah, 0 untuk hijau, dan 0 untuk biru.
Dengan demikian, untuk menampilkan warna hijau berarti menggunakan 0% merah, 100%
hijau, dan 0% biru (atau 0 Red, 255 Green, dan 0 Blue). Begitupun untuk menampilkan warna
biru, dimana nilai Blue 255 dan sisa nya 0
Apa yang terjadi jika R, G, dan B bernilai maksimum 255? Sama seperti mencampur merah,
hijau, dan biru dengan porsi yang sama, akan keluar warna putih.
Bagaimana jika mencampur warna merah dan hijau? (red 255, green 255, dan blue 0), maka
akan keluar warna putih
57
Berarti akan sangat banyak yang bisa anda tampilkan pada led RGB, karena untuk masing-
masing channel warna anda memiliki nilai 0 hingga 255, ada 256 nilai yang bisa di pilih per
channel warna, dan bisa berbeda nilai tiap channel nya.
Untuk mencoba tutorial led RGB ini, rangkailah led RGB seperti pada skema berikut
Kaki paling panjang dihubungkan ke 5V. Kaki masing-masing channel warna ke pin 11, 10,
dan 9 melalui resistor 220 ohm
/*
TUTORIAL PENGGUNAAN LED RGB PADA ARDUINO
ecadio.com
Pinout :
kaki paling panjang ke 5V
kaki R yang paling kiri ke pin 11 arduino
kaki G ke pin 10
kaki B ke pin 9
*/
58
int red_light_pin= 11;
int green_light_pin = 10;
int blue_light_pin = 9;
void setup() {
pinMode(red_light_pin, OUTPUT);
pinMode(green_light_pin, OUTPUT);
pinMode(blue_light_pin, OUTPUT);
}
void loop() {
RGB_color(255, 0, 0); // Red
delay(1000);
RGB_color(0, 255, 0); // Green
delay(1000);
RGB_color(0, 0, 255); // Blue
delay(1000);
RGB_color(255, 255, 125); // Raspberry
delay(1000);
RGB_color(0, 255, 255); // Cyan
delay(1000);
RGB_color(255, 0, 255); // Magenta
delay(1000);
RGB_color(255, 255, 0); // Yellow
delay(1000);
RGB_color(255, 255, 255); // White
delay(1000);
}
void RGB_color(int red_light_value, int green_light_value, int

blue_light_value)
{
analogWrite(red_light_pin, red_light_value);
analogWrite(green_light_pin, green_light_value);
analogWrite(blue_light_pin, blue_light_value);
}
Pada bagian awal, penomoran masing-masing pin I/O disimpan dalam variabel-variabel
memori dengan jenis data integer
int red_light_pin= 11;

int green_light_pin = 10;
int blue_light_pin = 9;
Pada bagian setup(), berisi perintah untuk menetapkan pin-pin tersebut sebagai output
dengan perintah pinMode()
pinMode(red_light_pin, OUTPUT);
pinMode(green_light_pin, OUTPUT);
pinMode(blue_light_pin, OUTPUT);
Untuk memudahkan menampilkan sebuah warna pada led menggunakan 3 channel warna
RGB, pada sketch ini kita membuat sebuah fungsi atau sub program di bagian bawah, yang
dinamai RGB_color()
59
void RGB_color(int red_light_value, int green_light_value, int
blue_light_value)
{
analogWrite(red_light_pin, red_light_value);
analogWrite(green_light_pin, green_light_value);
analogWrite(blue_light_pin, blue_light_value);
}
Fungsi RGB_color memiliki 3 parameter, yaitu red_light_value, green_light_value, dan

blue_light_value. Pada penggunaan nya nanti, parameter-parameter tersebut diisi dengan
nilai 0-255 tergantung warna yang kita inginkan
Bagian badan fungsi RGB_color() berisi 3 baris perintah, yang masing-masing menulis
analogWrite() untuk setiap channel warna dengan nilai yang sesuai parameter fungsi
Di bagian loop, berisi perintah menyalakan led dalam beberapa warna secara bergantian
dengan jeda waktu delay 1 detik
RGB_color(255, 0, 0); // Red
60
Perintah tersebut memanggil fungsi RGB_color dengan parameter 255 untuk red, dan 0
untuk green dan blue. Hasil nya led akan menyala warna merah
RGB_color(0, 255, 0); // Green
Perintah tersebut memanggil fungsi RGB_color dengan parameter 255 untuk green, dan 0
untuk red dan blue. Hasil nya led akan menyala warna hijau
RGB_color(255, 255, 0); // Yellow
Perintah diatas memanggil fungsi RGB_color dengan parameter 255 untuk red dan green
dengan 0 untuk blue. Dengan demikian sama dengan mencampur warna merah dan hijau,
yang akan menghasilkan led menyala warna kuning
Silahkan bereksperimen dengan sketch tersebut untuk mencoba nilai-nilai lain per channel
warna dan lihatlah warna apa yang akan di tampilkan oleh led RGB
61
TUTORIAL PUSH BUTTON 1
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.
Komponen yang akan kita butuhkan pada tutorial kali ini adalah 2 buah push button (yang
kecil), 2 buah resistor 10k ohm untuk rangkaian pull up, breadboard dan beberapa kabel
jumper. Rangkailah seperti skema wiring berikut :
62
Buka file ESSENTIALS_BUTTON_1.ino dan upload lah ke board Uno. Setelah selesai upload,
buka jendela Serial Monitor, dan cobalah menekan pertama dan tombol kedua yang telah
anda pasang pada breadboard tadi. Setiap penekanan tombol akan terbaca oleh
mikrokontroller dan informasi aktifitas tersebut ditampilkan di Serial Monitor.
63
Terlihat nilai kedua tombol adalah 1 ketika tidak di tekan, dan menjadi 0 jika ditekan. Hal ini
terjadi karena pin I/O yang terhubung dengan push button dihubungkan ke 5V via resistor
10k. Kaki push button satu lagi dihubungkan ke GND, sehingga ketika di tekan pin I/O akan
menerima GND sehingga status nya menjadi 0 atau LOW.
Untuk lebih memahami bagaimana hal tersebut terjadi, mari kita pahami terlebih dahulu
cara kerja push button.
Push button yang digunakan pada kit adalah push button 4 kaki, namun pada dasarnya
adalah sama, yaitu sebagai switch yang hanya 2 kaki, yang menyambungkan atau memutus
sebuah rangkaian.
64
Terlihat pada gambar diatas, kaki 1 dan 2 selalu terhubung, kaki 3 dan 4 selalu terhubung,
sehingga penggunaan kaki sebagai switch adalah kaki 1 dan 3 atau kaki 2 dan 4 (salah satu
saja). Pada tombol push button yang kecil pun berlaku prinsip yang sama
Pada rangkaian wiring tadi, kaki 1 dihubungkan ke VCC 5V melalui resistor 10K dan juga
dihubungkan ke pin I/O (pin 9 untuk tombol A). Dengan demikian ketika pertama kali
dinyalakan, pin 9 akan menerima 5V sehingga berada dalam kondisi HIGH.
Kaki 3 dihubungkan ke GND. Sehingga ketika tombol ditekan, pin 9 akan terhubung ke GND
yang mengakibatkan niai LOW akan tertangkap oleh pin 9. Demikian juga dengan tombol
kedua, menggunakan konsep yang sama namun menggunakan pin 8.
Mengapa harus menggunakan resistor 10K? Karena jika tidak menggunakan resistor dan kaki
1 dihubungkan langsung ke VCC, saat pertama kali dinyalakan dan tombol tidak ditekan
maka tidak akan ada masalah apa-apa, dan nilai tertangkap di pin akan HIGH karena
terhubung ke VCC. Namun ketika ditekan, maka akan terjadi short circuit atau korslet karena
VCC akan terhubung langsung ke GND oleh penekanan tombol.
Oleh karena itulah diberi resistor 10K antara kaki 1 dengan VCC. Dengan ada nya resistor 10K
maka nilai yang tertangkap ke pin memang tidak mencapai 5V, tapi cukup untuk
memberikan tegangan yang sudah dianggap sebagai HIGH oleh board Uno (diatas 3V), dan
tetap aman ketika jalur pin I/O di hubungkan ke GND dengan penekanan tombol
65
Rangkaian penggunaan resistor seperti itu lazim disebut rangkaian Pull Up Resistor. Pada
rangkaian pull up, pin I/O diberi nilai awal HIGH untuk bersiap-siap menerima nilai LOW
ketika tombol ditekan (pin I/O jadi terhubung ke GND)
Rangkaian lainnya yang lazim digunakan pada rangkaian push button adalah Pull Down.
Kebalikan dari Pull Up, pada rangkaian Pull Down, pin I/O dihubungkan ke GND melalui
resistor 10K, sehingga nilai awal akan LOW, dan ketika tombol ditekan akan menjadi HIGH.
Pada tutorial kali ini kita menggunakan pull up resistor sehingga nilai awal adalah HIGH, dan
ketika tombol ditekan akan menjadi LOW. Mari kita lihat sketch nya
66
/*
TUTORIAL PUSH BUTTON PADA ARDUINO
TAMPILKAN STATUS BUTTON PADA SERIAL MONITOR
ecadio.com
Pinout :
Tombol 1 -> D9
Tombol 2 -> D8
*/
#define TOMBOL1 9
#define TOMBOL2 8
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);
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 ke
variabel a dan b, 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.
Pada bagian awal sebelum setup(), kita definisikan pin-pin I/O yang akan digunakan agar
lebih mudah memanggil nya dalam perintah-perintah berikut nya
#define TOMBOL1 9
#define TOMBOL2 8
Pada bagian setup(), kita isi dengan perintah untuk mangaktifkan serial monitor di baudrate
115200 bps, memerintahkan pin 8 dan 9 menjadi output, dan memberi nilai awal high pada
pin-pin tersebut
Serial.begin(115200); // memulai komunikasi serial
67
Serial.println("Mencoba Push Button");
Di bagian loop, nilai yang ada pada pin 8 dan 9 di tangkap dengan perintah analogRead() dan
disimpan ke variabel memori a dan b untuk kemudian ditampilkan di jendela serial monitor
Serial.print("Status tombol A adalah : ");
Serial.println(a);
Serial.print("Status tombol B adalah : ");
Serial.println(b);
68
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.
Buka file ESSENTIALS_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.
/*
PUSH BUTTON DAN LED
ecadio.com
Pinout :
Tombol 1 -> D9
Tombol 2 -> D8
69
D4 -> Led Merah
D5 -> Led Hijau
*/
#define TOMBOL1 9
#define TOMBOL2 8
#define merah 4
#define hijau 5
void setup()
{
pinMode(merah, OUTPUT);
pinMode(hijau, OUTPUT);
}
void loop()
{
if (a == 0) {
} else {
}
if (b == 0) {
} 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
merah menyala, tombol B ditekan maka led hijau menyala. Ketika kedua tombol ditekan
maka kedua led 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
70
if (b == 0) {
} else {
}
Jika nilai b adalah 0 atau LOW, dimana nilai b diperoleh dari digitalRead() pin 8, 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
71
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
Jadi jika kita hanya menggunakan digitalRead() biasa, sebenarnya dalam sekali penekanan
tombol bisa tertangkap beberapa kali on off, terutama ketika kedua lempengan logam tadi
72
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, buka file ESSENTIALS_BUTTON_3.ino dan

upload ke board Uno. Ketika dijalankan, tombol akan mematikan dan menyalakan led biru
73
pada setiap aksi menekan tombol. Sekali tekan menyalakan, tekan kembali mematikan. Mari
kita lihat sketch nya
/*
PUSH BUTTON DAN LED
PENGGUNAAN DEBOUNCE
ecadio.com
Pinout :
Tombol -> D8
D5 -> Led hijau
*/
#define TOMBOL1 8
#define hijau 5

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

unsigned long debounceDelay = 50;
void setup()
{
digitalWrite(hijau, statusLed);
}
void loop()
{
if (a != statusTombolTerakhir) {
// reset debouncing timer
lastDebounceTime = millis();
}
if ((millis() - lastDebounceTime) > debounceDelay) {

if (a != statusTombol) {
statusTombol = a;
if (statusTombol == LOW) {
statusLed = !statusLed;
}
}
}
statusTombolTerakhir = a;
}
74
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
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
}
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.
75
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;
}
}
}
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.
76
TUTORIAL SENSOR SUHU DAN KELEMBABAN 1
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.
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)
77
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. (Jika anda telah melakukan copy file-file sketch dan add library pada tahap awal buku ini,
maka hal ini tidak perlu dilakukan lagi)
78
Buka file ESSENTIALS_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.
79
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
/*
* TUTORIAL SENSOR SUHU DAN KELEMBABAN PADA ARDUINO
* ecadio.com
*
* 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-
library/dht11/DHTLib.zip
#include <dht.h>
//inisiasi dht
dht SENSOR_DHT;
//definisikan DHT_PIN untuk pin 12

#define DHT_PIN 12
void setup() {
80
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
}
Untuk menggunakan library DHT11 yang telah didownload dan diinstall sebelum nya, kita
gunakan perintah #include
#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
dht SENSOR_DHT;
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
81
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.
Beberapa tutorial kedepan akan mulai menggunakan beberapa library sesuai dengan sensor
atau alat yang akan digunakan
82
TUTORIAL LCD 1
Pengenalan menggunakan LCD 1602 dengan modul I2C
Jika sebelumnya kita hanya menampilkan data di Serial Monitor, kini saat nya kita mulai
menggunakan modul display external untuk menampilkan data. Pada tutorial kita kali ini,
kita akan menggunakan modul display LCD 1602 yang telah dilengkapi dengan modul
backpack I2C
Layar LCD yang kita gunakan adalah LCD dengan 2 baris dan 16 karakter per baris nya, oleh
karena itu biasa disebut LCD 1602. 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 seperti pada rangkaian diatas. Mengkonsumsi 6 pin I/O untuk mengontrol LCD
jika menggunakan cara langsung koneksi ke modul LCD1602. Namun pada kit Essentials 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) seperti
pada skema dibawah ini.
83
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.
84
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 micro controller
mengetahui alat mana yang akan dihubungi nya dalam jalur komunikasi I2C? Itulah guna nya
I2C address. Masing-masing alat akan memiliki address yang unik untuk membedakan nya.
Seperti alamat nomer rumah, walau ada beberapa rumah dalam satu jalan, kita bisa
menemukan rumah yang tepat jika ada alamat lengkap nya.
Mari kita hubungkan terlebih dahulu LCD yang telah tersolder modul I2C sesuai dengan
skema diatas. Periksa kembali apakah kabel telah terpasang dengan benar dan di posisi yang
benar sebelum melanjutkan ke langkah selanjutnya.
Buka file ESSENTIALS_LCD_1.ino. Sketch tersebut menggunakan library Newliquidcrystal

yang terdapat di CD atau bisa juga 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
Jika tidak muncul apa-apa pada layar LCD, ada 2 kemungkinan yang terjadi. Pertama address
yang belum sesuai. Beberapa modul I2C ada yang menggunakan address 0x27 dan beberapa
menggunakan address 0x3F. Silahkan di coba salah Satu
85
Kemungkinan kedua adalah, kontras pada lcd terlalu kecil. Silahkan atur kontras layar
dengan memutar potensio pada belakang layar lcd di bagian board I2C menggunakan obeng
kecil hingga tampak kontras yang sesuai keinginan anda
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. Silahkan coba menulis
di field isian Serial Monitor tersebut, dan klik tombol Send. Jangan dilupakan batasan
karakter LCD ini adalah 16 karakter per baris nya.
86
Apapun yang anda tulis di layar serial monitor tersebut, akan di tampilkan ke layar LCD
Sekarang mari kita bahas sketch nya :
/*
TUTORIAL LCD 1602 PADA ARDUINO
MENGGUNAKAN I2C
---TEST FILE---
ecadio.com
Pinout LCD :
SDA -> A4
SCL -> A5
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 address
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()
{
Serial.begin(115200); // untuk penggunaan input serial monitor
87
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("ecadio.com");
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()) {//tunggu data dari input serial
delay(100);
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
88
Serial.begin(115200); // untuk penggunaan input serial monitor
Setelah itu, untuk library lcd ini kita harus memberikan perintah berikut di bagian setup()
dimana 16 adalah 16 karakter dan 2 adalah 2 baris, 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 :
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);
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 mematikan nya.
89
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()) {//tunggu data dari input serial
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.
90
TUTORIAL LCD 2
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. Rangkailah seperti diagram
berikut ini
Buka file ESSENTIALS_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
ecadio.com
Pinout LCD :
SDA -> SDA
SCL -> SCL
VCC -> 5v
91
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

lcd.print("Nilai Potensio");
void loop()
{
hasil
lcd.print(hasil);
delay(500);
}
Bagian awal sketch adalah dimana kita melakukan include library yang dibutuhkan
#include <Wire.h>
0x27
Dilanjutkan dengan inisiasi LCD berdasarkan perintah yang ditentukan oleh library yang
bersangkutan
92
Pada bagian setup(), dimana telah anda ketahui bahwa bagian setup hanya dilaksanakan
satu kali saja saat pertama kali Arduino dijalakan, kita perintah kan untuk menentukan pin
mode dari pin-pin I/O yang akan digunakan (A0 sebagai input di sketch ini), inisiasi lcd, dan
menulis karakter-karakter awal pada lcd
void setup()
{

lcd.print("Nilai Potensio");
Selanjutnya di bagian loop, kita perintahkan untuk mengambil data analog dari pin A0 yang
disimpan dalam variabel memori ‘hasil’ untuk kemudian di tampilkan pada baris ke 2 kolom
pertama lcd
void loop()
{
hasil
lcd.print(hasil);
delay(500);
}
93
TUTORIAL LCD 3
LCD dan Sensor Cahaya LDR

Jika sebelumnya kita menampilkan data dari hasil pembacaan pin A0 ang terhubung ke
potensiometer, dimana nilai nya akan berubah-ubah sesuai putaran lengan potensio, kali ini
kita akan mulai mencoba untuk menampilkan data hasil pembacaan sensor. Sensor pertama
yang akan kita gunakan adalah sensor cahaya LDR yang terdapat pada kit.
LDR adalah singkatan dari Light Dependent Resistor, yang pada dasarnya adalah sebuah
komponen unik yang bersifat seperti 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 (nilai resistor
nya) 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();
Silahkan rangkai terlebih dahulu seperti skema diagram dibawah ini. Pin SDA dan SCL lcd
dihubungkan ke A4 dan A5, VCC dan GND lcd ke 5V dan GND. Salah satu kaki LDR
dihubungkan ke 5V. Kaki lain nya terhubung ke pin A2 dan ke GND via resistor 10k ohm.
Rangkaian resistor ini adalah rangkaian pull down, resistor di hubungkan ke GND
94
Buka file ESSENTIALS_LCD_3.ino dan upload ke board Uno. Hasilnya akan ditampilkan nilai
analog dari A2, yang nilai nya akan berubah-ubah tergantung banyak nya cahaya yang di
terima LDR. Cobalah 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
ecadio.com
Pinout LCD :
SDA -> SDA
SCL -> SCL
VCC -> VCC
GND -> GND
LDR -> A2
*/
#include <Wire.h>
0x27
95
void setup()
{
Serial.println("Mencoba LDR pada Arduino");

lcd.print("Nilai LDR");
void loop()
{
hasil
lcd.print(hasil);
delay(500);
}
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
96
TUTORIAL LCD 4
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
menggunakan sensor DHT11 yang merupakan sensor yang sensitif terhada perubahan suhu
dan kelembaban udara
Silahkan rangkai rangkaian dibawah ini pada breadboard. Rangkaian tersebut mirip dengan
rangkaian LCD sebelum nya, hanya saja penggunaan sensor kali ini menggunakan sensor
DHT11. Resistor yang digunakan adalah resistor 10k ohm, yang digunakan sebagai rangkaian
resistor pull up pada sensor DHT11 (resistor dihubungkan ke pin signal dan 5V)
Buka file ESSENTIALS_LCD_4.ino. Untuk mengendalikan sensor DHT11 ini kita memerlukan
library khusus juga, sebagaimana kita memerlukan library untuk mengendalikan LCD.
Silahkan tambahkan terlebih dahulu library DHTLib.zip tersebut. Library ada di CD dalam kit
atau bisa juga di download di https://ecadio.com/arduino-library/dht11/DHTLib.zip
Pada layar LCD akan ditampilkan suhu ruangan anda saat itu beserta tingkat kelembaban
udara nya.
97
Mari kita buka sketch nya :
/*
MENGGUNAKAN I2C
MENAMPILKAN SUHU DAN KELEMBABAN UDARA
ecadio.com
Pinout LCD :
SDA -> A4
SCL -> A5
VCC -> 5V
GND -> GND
DHT signal -> D12

*/
#include <Wire.h>
#include <dht.h>
// library dht11 bisa di download di https://ecadio.com/arduino-
// library lcd bisa di download di https://ecadio.com/arduino-
0x27
98
//inisiasi dht
dht SENSOR_DHT;

#define DHT_PIN 12
void setup()
{
}
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);
}
Pada bagian awal sketch, karena kita akan menggunakan dua buah library (untuk lcd dan
sensor DHT11) maka harus menulis perintah untuk include library-library tersebut
#include <Wire.h>
#include <dht.h>
// library dht11 bisa di download di https://ecadio.com/arduino-
// library lcd bisa di download di https://ecadio.com/arduino-
0x27
Selanjutnya adalah perintah untuk inisiasi sensor DHT11 dimana syntax nya tergantuk dari
penyedia library. Dalam sketch ini digunakan perintah berikut
//inisiasi dht
dht SENSOR_DHT;
Dimana kita menamai sensor yang akan kita gunakan dengan nama SENSOR_DHT, yang akan
kita alokasi kan di pin 12 pada arduino. Pin 12 kita definisikan sebagai DHT_PIN dengan
perintah

#define DHT_PIN 12
Pada bagian setup(), hanya berisi 1 perintah yang merupakan perintah untuk inisiasi lcd 16
kolom 2 karakter (LCD 1602)
99
void setup()
{
}
Pada bagian loop, pertama kali yang dilakukan adalah membuat variabel memori ‘cek’
berjenis integer yang akan berisi nilai bacaan sensor dht11 di pin 12
Nilai dari variabel cek tersebut kemudian akan di tampilkan pada layar lcd dengan beberapa
perintah

lcd.print("Temp. : ");
lcd.print(SENSOR_DHT.temperature, 0); //data suhu udara
lcd.print("C");//simbol C
lcd.print("Humid. : ");
lcd.print(SENSOR_DHT.humidity, 0); //data kelembaban udara
lcd.print("%");//simbol C
Penggunaan char(223) adalah perintah untuk menuliskan simbol derajat di layar LCD,
dimana simbol tersebut memiliki nomer kode 223 di tabel ANSI
100
TUTORIAL LCD 5
Jam Digital Tanpa Delay() dan Menggunakan Debounce
Pada tutorial ini kita akan menggabungkan penggunaan LCD dan input push button atau
tombol. LCD akan menampilkan jam digital, dan tombol-tombol digunakan untuk
menyesuaikan jam dan menit. Algoritma dounce juga di terapkan pada sketch tombol agar
penekanan tombol lebih natural dan akurat. Perhitungan waktu akan menggunakan millis()
Silahkan rangkai terlebih dahulu rangkaian dibawah ini pada breadboard. Resistor yang
digunakan adalah resistor 10k ohm yang digunakan sebagai resistor pull up pada tombol-
tombol. Koneksi LCD seperti biasa menggunakan I2C yaitu di A4 dan A5 (SDA dan SCL)
Buka file ESSENTIALS_LCD_5.ino dan upload ke board Uno. Akan tampak jam yang mulai
berjalan. Sesuaikan jam dengan menekan tombol penyesuai jam dan menit.
Berikut adalah sketch nya :
/*
TUTORIAL JAM DIGITAL PADA LCD
MEMBUAT JAM - TANPA MENGGUNAKAN DELAY()
GABUNG PENGGUNAAN DEBOUNCE PADA TOMBOL
ecadio.com
Pinout LCD :
SDA -> A4
SCL -> A5
VCC -> 5V
101
GND -> GND
Pinout :
Tombol 1 -> D9
Tombol 2 -> D8
*/

0x3F atau 0x27
// Module connection pins (Digital Pins)
#define TOMBOL1 9
#define TOMBOL2 8
int jam = 0;
int menit = 0;
int detik = 0;
String sJam, sMenit, sDetik;
int statusDetik = 0;
unsigned long millisSebelumnya1 = 0;

unsigned long waktuDebounceTerakhir1 = 0;

unsigned long delayDebounce = 50;
int statusTombol1;
int statusTombol2;
int statusTerakhirTombol1 = HIGH;
void setup()
{
pinMode(TOMBOL1, INPUT);
pinMode(13, OUTPUT);

lcd.backlight();
lcd.print("Jam Digital");
delay(2000);
102
lcd.print("Waktu saat ini");
}
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;
}
if (jam < 10) {

sJam = '0' + String(jam);
} else {
sJam = String(jam);
}
if (menit < 10) {

sMenit = '0' + String(menit);
} else {
sMenit = String(menit);
}
if (detik < 10) {

sDetik = '0' + String(detik);
} else {
sDetik = String(detik);
}
lcd.print(sJam + ':' + sMenit + ':' + sDetik);

statusDetik = !statusDetik;
}
digitalWrite(13, statusDetik);
if (a != statusTerakhirTombol1) {
waktuDebounceTerakhir1 = millis();
}
if ((millis() - waktuDebounceTerakhir1) > delayDebounce) {
103
if (a != statusTombol1) {
statusTombol1 = a;
if (statusTombol1 == LOW) {
jam++;
detik = 0;
}
}
}
statusTerakhirTombol1 = a;
if (b != statusTerakhirTombol2) {
}
if (b != statusTombol2) {
statusTombol2 = b;
menit++;
detik = 0;
}
}
}
statusTerakhirTombol2 = b;
}
Pada bagian awal sketch, seperti biasa kita akan membuat definisi-definisi untuk
memudahkan penulisan pin dan include library yang dibutuhkan. Karena kita akan
menggunakan LCD dengan I2C, maka kita menggunakan library LCD seperti yang digunakan
pada tutorial LCD sebelum nya
0x3F atau 0x27
#define TOMBOL1 9
#define TOMBOL2 8
Bagian selanjutnya, masih di bagian awal sebelum bagian setup(), adalah deklarasi beberapa
variabel memori yang akan digunakan pada sketch
int jam = 0;
int menit = 0;
int detik = 0;
Variabel memori jam, menit, dan detik berjenis integer dan bernilai awal 0 yang akan
digunakan dalam menghitung waktu. Konsep dalam sketch ini adalah, menghitung waktu
berjalan menggunakan millis(), dan hasil perhitungan akumulasi waktu berjalan akan di
akumulasi ke detik. Penambahan detik di akumulasi ke menit, dan penambahan menit akan
di akumulasi ke jam
String sJam, sMenit, sDetik;
104
Variabel sJam, sMenit, dan sDetik berjenis data String. Kita deklarasikan disini karena nanti
akan menggunakan jenis data string agar bisa di tampilkan di LCD. Data integer jam akan di
konversi menjadi sJam, menit ke sMenit dan detik ke sDetik
int statusDetik = 0;
Variabel memori statusDetik yang bernilai awal 0 atau LOW ini akan digunakan untuk
membuat led berkedip setiap detik
Perintah-perintah berikut nya adalah untuk kepentingan debounce


unsigned long delayDebounce = 50;
int statusTombol1;
int statusTombol2;
Anda bisa membaca kembali pada tutorial debounce agar lebih memahami nya. Tujuan nya
agar penekanan dua tombol lebih akurat dan natural
Sekarang pada bagian setup(). Di bagian awal setup adalah menentukan pin mode dari
masing-masing pin yang akan digunakan
pinMode(13, OUTPUT);
Selanjutnya adalah inisiasi LCD dan menulis beberapa karakter awal

lcd.backlight();
lcd.print("Jam Digital");
delay(2000);

lcd.print("Waktu saat ini");
Di bagian loop, kita akan mulai menghitung waktu dan menampilkan setiap detik nya pada
lcd dan melakukan kedipan pada led
105
Pada sketch tersebut, penggunaan perintah millis() cukup intensif. Delay 1 detik dengan
menggunakan millis adalah seperti ini

detik++;
}
Sedangkan untuk millis() pada baris-baris perintah selanjutnya digunakan untuk algoritma
debounce pada tombol-tombol.
Tampak pada baris diatas, nilai detik akan selalu di tambahkan pada setiap loop dengan
perintah
detik++;
Perintah tersebut sama juga dengan detik = detik + 1; sehingga nilai detik akan selalu
ditambah 1 setiap pengulangan loop terjadi
Perintah selanjtnya adalah mengakumulasi nilai detik ke menit dan jam. Jika nilai detik telah
mencapai 60 maka nilai menit akan bertambah dan nilai detik di reset menjadi 0. Begitupun
dengan nilai menit, jika telah mencapai 60, maka nilai jam akan bertambah dan nilai menit
akan di reset menjadi 0 kembali. Nilai jam akan di reset menjadi 0 jika telah mencapai 24
(sketch ini menggunakan format jam 24h agar mudah dipahami)
if (detik == 60) {
detik = 0;
menit++;
}
if (menit == 60) {
menit = 0;
jam++;
}
if (jam == 24) {
jam = 0;
}
Baris-baris perintah selanjutnya digunakan untuk memanipulasi string pada data jam, menit
dan detik, serta menyimpan nya ke variabel berjenis string yang telah kita persiapkan
sebelum nya yaitu sDetik, sMenit, dan sJam
if (jam < 10) {

sJam = '0' + String(jam);
} else {
sJam = String(jam);
}
if (menit < 10) {

sMenit = '0' + String(menit);
} else {
106
sMenit = String(menit);
}
if (detik < 10) {

sDetik = '0' + String(detik);
} else {
sDetik = String(detik);
}
Manipulasi string yang dilakukan adalah penambahan angka 0 di depan data, jika data
kurang dari 10, sehingga jam 1 akan tampil 01, menit 7 akan tampil 07 atau detik 9 akan
tampil 09, sebagaimana layaknya jam digital pada umum nya
Setelah data hasil konversi diatas telah siap, baru kita bisa menampilkan ke LCD dengan
perintah
lcd.print(sJam + ':' + sMenit + ':' + sDetik);
Perintah berikut nya adalah untuk membuat led berkedip seiring penambahan detik

statusDetik = !statusDetik;
}
digitalWrite(13, statusDetik);
Dan perintah bagian akhir adalah untuk mengontrol input tombol menggunakan metode
debounce. Tombol pertama untuk menambah data jam, tombol kedua untuk menambah
data menit. Dengan demikian kedua tombol tersebut bisa digunakan untuk menyesuaikan
jam saat ini
if (a != statusTerakhirTombol1) {
}
if (a != statusTombol1) {
statusTombol1 = a;
jam++;
detik = 0;
}
}
}
statusTerakhirTombol1 = a;
if (b != statusTerakhirTombol2) {
}
if (b != statusTombol2) {
statusTombol2 = b;
107
menit++;
detik = 0;
}
}
}
statusTerakhirTombol2 = b;
108
TUTORIAL KEYPAD
Pengenalan Penggunaan KEYPAD 4x4
Pada tutorial push button sebelum nya anda telah memahami rangkaian push button,
dimana 1 buah tombol push button mengkonsumsi 1 buah pin I/O pada arduino. Untuk 3
buah push button, tentunya akan menggunakan 3 buah pin Arduino. Lalu bagaimana jika
akan menggunakan 16 push button seperti input keypad yang biasa digunakan pada
peralatan-peralatan elektronika (pada pesawat telepon misalnya), apakah harus
menghabiskan 16 pin I/O pada micro controller? Tentunya akan sangat boros penggunaan
pin, belum lagi alokasi pin I/O untuk komponen lain nya, seperti sensor-sensor atau layar
display, tidak akan cukup pin I/O yang dimiliki untuk mewujudkan nya
Untuk mensiasati hal tersebut, dibuatlah tombol-tombol yang di atur sedemikian rupa agar
bisa memperoleh input yang banyak namun menggunakan pin I/O yang minimal. Salah satu
nya adalah modul Keypad 4x4, yang terdiri dari 4 baris dan 4 kolom matriks tombol.
109
Pada tutorial kali ini kita akan belajar penggunaan Keypad 4x4, yang pada dasarnya adalah
16 buah tombol atau push button yang diatur dengan layout khusus sedemikian rupa
sehingga dapat kita kontrol menggunakan Arduino.
Terlihat dalam gambar diatas, bagaimana ke 16 buah tombol diatur dalam sebuah matriks
4x4. Gambar tersebut adalah tampak bawah dari keypad 4x4 ketika bagian bawah di kelupas
agar terlihat jalur koneksi nya.
110
Pada skema diatas bisa terlihat lebih jelas bagaimana jalur koneksi sebuah keypad 4x4.
Tombol-tombol diatur dalam 4 baris, R1, R2, R3, dan R4 serta dalam 4 kolom, C1, C2, C3, dan
C4. Dengan demikian, walaupun terdapat 16 buah tombol input namun kita hanya akan
memakai total 8 buah pin Arduino.
R1, R2, R3, dan R4 dihubungkan ke pin-pin Arduino sebagai input. Demikian juga C1, C2, C3,
dan C4. Total ada 8 pin, 4 pin untuk baris (row R1-R4) dan 4 pin untuk kolom (column, C1-C4)
Bagaimana kita bisa mendeteksi tombol mana yang di tekan? Teknik yang digunakan adalah
dengan proses Scanning. Proses nya dimulai beberapa tahap
Pertama, semua kolom diberi nilai awal HIGH. Berarti C1, C2, C3, dan C4 diberi nilai awal 1.
Semua baris juga diberi nilai awal HIGH. R1, R2, R3, dan R4 memiliki nilai awal 1.
Kedua, dilakukan pemeriksaan bertahap, menggunakan loop, dimulai dari baris pertama, lalu
kedua, ketiga hingga baris ke empat secara bergiliran. Ketika pada giliran memeriksa baris
pertama atau R1 dalam loop, pin R1 di beri nilai LOW atau 0, sementara R2, R3, dan R4 tetap
pada nilai awal nya yaitu 1. Pada tahap ini, jika ada tombol yang di tekan pada baris pertama,
maka kita bisa akan mengetahui tombol mana yang di tekan, apakah tombol 1, 2, 3, atau A,
dari nilai yang dimiliki di pin C1, C2, C3, dan C4. Misal jika pada tahap ini ada nilai LOW atau
0 di C2, berarti tombol 2 yang di tekan. Jika ada nilai 0 di C3, berarti tombol 3 ditekan
Pemeriksaan giliran berikut nya adalah baris kedua (R2). Di tahap ini, R1 kembali diberi 1, R2
yang diberi 0, dan R3 serta R4 tetap 1. Saat ini, kita akan tahu tombol mana di baris kedua
yang ditekan, dengan mendeteksi nilai pada C1, C2, C3, dan C4. Jika ada nilai 0 di C1, berarti
tombol 4 yang di tekan. Jika ada nilai 0 di C4, berarti tombol B yang di tekan
111
Proses tahapan giiliran memeriksa setiap baris tersebut dilanjutkan ke baris ke 3 (R3) dan
baris ke 4 (R4). Semua proses dilakukan dalam sebuah loop dan dilakukan dengan sangat
cepat dan terus menerus, sehingga kita dapat mengetahui tombol mana yang di tekan.
Proses diatas memang tampak rumit untuk dipahami dan dilakukan. Untunglah sudah ada
library yang akan memudahkan kita dalam menulis sketch mengontrol input Keypad 4x4.
Kita akan menggunakan library tersebut agar lebih sederhana dalam penulisan program nya.
Silahkan rangkai keypad dan hubungkan ke board Arduino Uno seperti pada gambar diatas.
112
Untuk sketch nya, buka file ESSENTIALS_Keypad_1.ino
Library Keypad yang dibutuhkan bisa di download di :

https://ecadio.com/arduino-library/keypad/Keypad.zip
Add library tersebut dengan menu Sketch – Include Library – Add .zip library dan pilihlah
Keypad.zip yang telah di download tadi
Upload sketch ESSENTIALS_Keypad_1.ino dan buka juga serial monitor. Akan tampil tombol
yang anda tekan pada keypad di layar serial monitor
/*
TUTORIAL INPUT KEYPAD 4x4 PADA ARDUINO
ecadio.com
Pinout : Pin keypad ke pin 2, 3, 4, 5, 6, 7, 8, 9
*/
#include <Keypad.h>
const byte ROWS = 4;

const byte COLS = 4;
char hexaKeys[ROWS][COLS] = {
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
113
};
byte rowPins[ROWS] = {9, 8, 7, 6};

byte colPins[COLS] = {5, 4, 3, 2};
Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS,

COLS);
void setup(){
Serial.begin(115200);
}
void loop(){
char customKey = customKeypad.getKey();
if (customKey){
Serial.println(customKey);
}
}
114
TUTORIAL KEYPAD 2
Password dengan KEYPAD 4x4 dan LCD
Pada tutorial kali ini kita akan memanfaatkan input kepad sebagai input password untuk
menyalakan led. Jika password benar, led akan menyala beberapa detik. Pada aplikasi nyata,
metode ini sering digunakan pada security door yang penggunakan keypad untuk membuka
pintu nya
Rangkaian sama dengan rangkaian keypad sebelum nya, dimana pin-pin keypad
dihubungkan ke pin 2, 3, 4, 5, 6, 7, 8, 9 pada Arduino Uno. Di rangkaian ini hanya
ditambahkan koneksi ke LCD menggunakan I2C (ke pin SDA dan SDL atau A4 dan A5) serta
sebuah led yang terhubung ke pin 12 via resistor 220 ohm)
Buka file ESSENTIALS_Keypad_2.ino dan upload ke board Arduino Uno. Pada layar LCD akan
tampak Enter Password. Silahkan anda coba ketik password nya menggunakan keypad 4X4.
Jika password benar, led akan menyala beberapa detik (Password benar di set di 123A456)
115
/*
TUTORIAL KEYPAD DAN LCD 1602 PADA ARDUINO
---TEST FILE---
ecadio.com
Pinout LCD :
SDA -> A4
SCL -> A5
VCC -> VCC
GND -> GND
Led pada pin 12

Pin keypad ke pin 2, 3, 4, 5, 6, 7, 8, 9
*/
#include <Wire.h>
#include <Keypad.h>
#define Password_Length 8
int ledPin = 12;
char Data[Password_Length];
char Master[Password_Length] = "123A456";
byte data_count = 0, master_count = 0;
bool Pass_is_good;
char customKey;
const byte ROWS = 4;

const byte COLS = 4;
char hexaKeys[ROWS][COLS] = {
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {9, 8, 7, 6};

byte colPins[COLS] = {5, 4, 3, 2};
Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS,

COLS);
void setup(){
lcd.backlight();
pinMode(ledPin, OUTPUT);
}
void loop(){
lcd.setCursor(0,0);
lcd.print("Enter Password:");
116
customKey = customKeypad.getKey();
if (customKey){
Data[data_count] = customKey;
lcd.setCursor(data_count,1);
lcd.print(Data[data_count]);
data_count++;
}
if(data_count == Password_Length-1){
lcd.clear();
if(!strcmp(Data, Master)){
lcd.print("Correct");
digitalWrite(ledPin, HIGH);
delay(5000);
digitalWrite(ledPin, LOW);
}
else{
lcd.print("Incorrect");
delay(1000);
}
lcd.clear();
clearData();
}
}
void clearData(){
while(data_count !=0){
Data[data_count--] = 0;
}
return;
}
117
TUTORIAL SEVEN SEGMENT 1
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
118
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, 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
119
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 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.
120
Buka lah file sketch ESSENTIALS_Seven_segment_1.ino dan upload ke board Arduino Uno.
Akan tampak seven segment menampilkan angka 1 hingga 3 dan kembali ke 1 lagi dengan
jeda masing-masing 1 detik.
/*
TUTORIAL PENGGUNAAN SEVEN SEGMENT SEDERHANA PADA ARDUINO
ecadio.com
Pinout :
kaki tengah seven segment common anoda ke 5v
kaki a hingga h sesuai pinout ke pin digital 2 hingga 7
*/
#define a 2
#define b 3
#define c 4
#define d 5
#define e 6
#define f 7
#define g 8
void setup()
{
// Set pins 2 hingga 8 sebagai OUTPUT
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);
}
void loop()
{
//menampilkan angka 1
digitalWrite(a, 0); //segment a LOW
digitalWrite(b, 1); //segment b HIGH
digitalWrite(c, 1); //segment c HIGH
digitalWrite(d, 0); //segment a LOW
digitalWrite(e, 0); //segment a LOW
digitalWrite(f, 0); //segment a LOW
digitalWrite(g, 0); //segment a LOW
delay(1000); //jeda waktu 1 detik
digitalWrite(a, 1);
digitalWrite(b, 1);
digitalWrite(c, 0);
digitalWrite(d, 1);
digitalWrite(e, 1);
digitalWrite(f, 0);
121
digitalWrite(g, 1);
digitalWrite(a, 1);
digitalWrite(b, 1);
digitalWrite(c, 1);
digitalWrite(d, 1);
digitalWrite(e, 0);
digitalWrite(f, 0);
digitalWrite(g, 1);
Pertama, kita buat sederhana penamaan pin yang akan kita gunakan pada sketch dengan
menbuat beberapa baris #define supaya lebih mudah dalam wiring urutan segmen dari a
hingga segmen g. Segmen h tidak kita pakai saat ini, karena segmen h adalah led titik atau
DP (Dot Point) yang tidak kita gunakan pada keperlun sekarang
#define a 2
#define b 3
#define c 4
#define d 5
#define e 6
#define f 7
#define g 8
Pada bagian setup awal, seperti biasa kita set pin mode yang akan kita pakai menyalakan led
sebagai output
// Set pins 2 hingga 8 sebagai OUTPUT

pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);
Bagian loop, kita menyalakan segmen-segmen sedemikian rupa agar membentuk angka.
Angka 1 diperoleh dengan menyalakan segmen b dan c saja sehingga led pada seven segmen
menyala membentuk angka 1
digitalWrite(a, 0); //segment a LOW
digitalWrite(b, 1); //segment b HIGH
digitalWrite(c, 1); //segment c HIGH
digitalWrite(d, 0); //segment a LOW
digitalWrite(e, 0); //segment a LOW
digitalWrite(f, 0); //segment a LOW
digitalWrite(g, 0); //segment a LOW
Angka 2 akan ditampilka dengan menyalakan segmen a, b, d, dan e
122
digitalWrite(a, 1);
digitalWrite(b, 1);
digitalWrite(c, 0);
digitalWrite(d, 1);
digitalWrite(e, 1);
digitalWrite(f, 0);
Dengan cara yang sama, angka 3 di tampilkan dengan menyalakan segmen a, b, c, d, dan g
digitalWrite(a, 1);
digitalWrite(b, 1);
digitalWrite(c, 1);
digitalWrite(d, 1);
digitalWrite(e, 0);
digitalWrite(f, 0);
digitalWrite(g, 1);
Selain angka, cara yang sama juga bisa untuk menampilkan beberapa huruf, seperti A, a, B,
b, C, c, d, E, e, F, G, H, h, I, J, L, O, o, P, S, U, u. Silahkan bereksperimen untuk menampilkan
angka atau huruf sesuai keinginan anda
123
Seven Segment dengan IC Shift Register

Pada tutorial pengenalan seven segment sebelum nya anda telah belajar cara menampilkan
angka atau huruf pada seven segment dengan cara yang sederhana seperti menyalakan
beberapa led. Pada tutorial led sebelum nya pun anda telah belajar menggunakan IC shift
register untuk mengendalikan banyak led namun dengan menggunakan hanya sedikit pin
I/O. Konsep tersebut akan kita terapkan pada tutorial kali ini untuk mengendalikan seven
segment namun menggunakan sedikit pin I/O, karena pada dasarnya seven segment adalah
7 led yang dirangkai sedemikian rupa sehingga ketika menyala akan menampilkan ilusi
sebuah angka atau huruf
124
Rangkailah pada breadboard sehingga menjadi seperti skema diatas. Pada tutorial kali ini
kita menggunakan seven segment yang berjenis common cathode, sehingga kaki common
(yang berada di tengah seven segment bagian atas atau bawah) dihubungkan ke GND
melalui sebuah resistor 220 ohm
Kaki-kaki IC dipasang sesuai ketentuan pinout IC 74HC595. Hubungan ke seven segment juga
sesuai aturan pinout nya, QA ke segmen a, QB ke segmen b, hingga QH ke segmen h pada
seven segment
Buka file ESSENTIALS_Seven_Segment_2.ino dan upload ke board Arduino Uno. Akan

tampak seven segment menampilkan angka 1, 2, 3, 4, 5, 6, 7, 8, 9, dan 0 secara bergantian.
Mari kita lihat sketch nya.
/*
TUTORIAL PENGGUNAAN SEVEN SEGMENT DENGAN IC SHIFT REGISTER 74HC595
ecadio.com
Pinout :
*/

byte posisiLed[10] = {
B11111100, //angka 0
125
B01100000, //angka 1
B11011010, //angka 2
B11110010, //angka 3
B01100110, //angka 4
B10110110, //angka 5
B10111110, //angka 6
B11100000, //angka 7
B11111110, //angka 8
B11110110 //angka 9
};
void setup()
{
}
void loop()
{
for (int i = 0; i <= 9; i++) {

data
delay(500);
}
}
Konsep sketch tersebut sama dengan tutorial pengendalian led menggunakan IC Shift
register. Array posisiLed berisi 10 anggota, yang masing-masing berisi 8 bit yang kita siapkan
untuk mengontrol 8 led (7 segmen led ditambah 1 dot point)
Misal untuk menampilkan angka 1 maka data nya adalah B01100000, dimana hanya led
segmen b dan c yang menyala, karena hanya b dan c yang bernilai 1 atau HIGH, sisa nya 0
atau LOW
SEGMEN a b c d e f g h
B 0 1 1 0 0 0 0 0
Untuk menampilkan angka 2, data nya adalah B11011010
SEGMEN a b c d e f g h
B 1 1 0 1 1 0 1 0
Pada bagian setup, kita harus menset pin-pin IO yang digunakan untuk komunikasi ke IC
sebagai output

126
Pada bagian loop, terdapat loop FOR untuk membuat pengulangan dari 0 hingga 9, yang isi
dari loop FOR tersebut adalah menampilkan data 8 bit secara bergantian dari data yang
menampilkan angka 0 hingga data yang menampilkan angka 9
for (int i = 0; i <= 9; i++) {

data
delay(500);
}
Terlihat pada loop FOR tersebut, nilai i akan digantikan dengan angka 0 hingga 9 secara
bergantian. Memanggil array dengan perintah posisiLed[0] akan mengeluarkan anggota
array pertama yaitu B11111100, yang akan menampilkan angka 0 pada seven segment.
127
Perintah memanggil array posisiLed[1] akan mengeluarkan anggota array ke 2 yaitu
B01100000 yang akan menampilkan angka 1 pada seven segment. Demikian seterus nya.
128
Seven Segment dan Potensiometer
Setelah anda memahami mengendalikan seven segment menggunakan IC Shift Register pada
tutorial sebelum nya, pada kesempatan tutorial kali ini kita akan mencoba menambahkan
input berupa potensiometer, dimana action pada lengan potensio akan di tampilkan pada
seven segment. Silahkan rakit skema breadboard berikut pada breadboard. Resistor yang
digunakan masih sama seperti sebelum nya yaitu 220 ohm
129
Buka file ESSENTIALS_Seven_Segment_3.ino dan upload ke board Uno. Angka yang di
tampilkan pada seven segment antara 0 hingga 9 tergantung dari putaran lengan
potensiometer. Mari kita lihat sketch nya
/*
TUTORIAL PENGGUNAAN SEVEN SEGMENT DENGAN IC SHIFT REGISTER 74HC595
Menampilkan data potensio
ecadio.com
Pinout :
Kaki tengah potensio ke A0, kaki kana kiri ke 5V dan GND
*/

byte posisiLed[10] = {
B11111100, //angka 0
B01100000, //angka 1
B11011010, //angka 2
B11110010, //angka 3
B01100110, //angka 4
B10110110, //angka 5
B10111110, //angka 6
B11100000, //angka 7
B11111110, //angka 8
B11110110 //angka 9
};
void setup()
{
pinMode(A0, INPUT); //set A0 menjadi input
void loop()
{
hasil
s/d 9
130
data
bit
delay(1);
}
Sketch tersebut mirip dengan sketch pada tutorial sebelum nya. Perbedaan disini adalah
pada data apa yang di tampilkan di seven segment. Data yang di tampilkan disini adalah
angka dari 0 hingga 9 yang tergantung dari posisi lengan potensio
Dalam loop, pertama kali kita mabil nilai analog potensio yang terhubung ke pin A0 ke
variabel memori “hasil” dengan perintah

hasil
Nilai variabel “hasil” akan berkisar antara 0 hingga 1023 (nilai yang mungkin keluar dari
sebuah pin analog), sementara seven segment kita hanya bisa menampilkan 0 hingga 9
(karena 1 digit), oleh karena itu perlu di peta kan skala yang berbeda tersebut dengan
perintah Map

s/d 9
Perintah tersebut di atas memetakan (map) nilai 0-1023 ke 0-9 dan disimpan ke variabel
memori hasilMap. Nilai variabel memori hasilMap tersebut yang akhirnya di tampilkan pada
seven segment dengan perintah

data
bit
131
132
TUTORIAL BUZZER 1
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.
Harap diperhatikan, buzzer memiliki polaritas, jadi tidak bisa terbalik antara + dan – nya.
Pada badan buzzer terdapat tanda +, bagian itu untuk dikoneksikan ke pin I/O. Kaki lain nya
ke GND
133
Buka file ESSENTIALS_Buzzer_1.ino dan upload ke board Uno. Ketika sketch berjalan, akan
terdengar nada dari C dan C’ (satu oktav lebih tinggi) pada buzzer. Mari kita lihat sketch nya
/*
TUTORIAL PASSIVE BUZZER PADA ARDUINO
ecadio.com
D3 -> Passive Buzzer +
*/
#define pinBuzzer 3 //buzzer pada pin D3
void setup() {
pinMode(pinBuzzer, OUTPUT); //set menjadi output
}
void loop() {
//memainkan nada rendah 2x
for (int i = 0; i < 2; i++) {
playTone(261.63, 350);
delay(1000);
}
//memainkan nada lebih tinggi 2x
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
134
//// 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

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.
long delayValue = 1000000 / frequency / 2;
135
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.
long numCycles = frequency * length / 1000;
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 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.
136
TUTORIAL BUZZER 2
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.
Buka file ESSENTIALS_Buzzer_2.ino dan upload ke board Uno. Akan terdengar tangga nada
dari C ke C’. Berikut adalah sketch nya :
/*
ecadio.com
*/
137
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);

for (long i = 0; i < numCycles; i++) {
}
}
}
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.
138
TUTORIAL BUZZER 3
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.
Buka file ESSENTIALS_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
ecadio.com
139
Potensio -> A0
CLK -> D10
DIO -> D11
*/
#include <Arduino.h>

#define PIN_POTENSIO A0
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
delay(jeda); //jeda waktu 1 detik, akan tetap menyala selama 1 detik
}

for (long i = 0; i < numCycles; i++) {
}
}
}
140
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 digunakan
oleh fungsi playTone() untuk menghasil kan bunyi yang sesuai.
141
TUTORIAL BUZZER 4
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.
Buka file ESSENTIALS_Buzzer_4.ino dan upload ke board Uno. Kali ini ada yang berbeda pada
jendela sketch anda, terdapat tab kedua (nada.h). Pada tab baru tersebut berisi nilai #define
dari frekuensi tiap nada yang akan kita gunakan.
142
Kita dapat membuat file .h yang berisi kumpulan #define dan memasukkan nya kedalam
sketch dengan perintah #include seperti pada contoh sketch ini
/*
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
143
};
// 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++) {
// 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);
// stop the tone playing:
noTone(PIN_BUZZER);
}
}
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.
144
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 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.
145
TUTORIAL REMOTE IR 1
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 elektronika yang sudah 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.
Remote Infra Merah terdiri dari dua bagian utama. Bagian remote, yang seperti remote IR
pada umum nya terdiri dari beberapa tombol yang ketika tombol tersebut ditekan akan
memancarkan sinar infra merah. Remote untuk tutorial ini telah disediakan dalam kit,
namun anda bisa menggunakan remote TV atau AC atau remote IR apapun yang sudah ada
di rumah. Untuk remote dalam kit, jangan lupa untuk memasang baterai nya terlebih
dahulu. Baterai telah tersedia dalam kit
Bagian kedua adalah komponen receiver atau penerima sinyal yang dikirimkan oleh remote.
Receiver ini yang akan dihubungkan ke pin I/O arduino, dimana kemudian sinyal akan di
proses oleh sketch yang kita buat
Silahkan rangkai rangkaian berikut pada breadboard. Dalam rangkaian kali ini, kita
menggunakan 1 buah sensor IR receiver VS1838, 1 buah led, dan 1 buah resistor 220 ohm
untuk pelindung led
146
147
Buka file ESSENTIALS_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
Nilai dari kode tombol yang kita tekan akan ditampilkan pada serial monitor dan pada seven
segment.
Pada contoh data yang tampil pada serial monitor diatas, tombol 1 ditekan menampilkan
code 69. Ketika tombol 2 pada remote di tekan, code 70 yang di tampilkan. Tombol 3 pada
remote memunculkan code 71. Code yang muncul tersebut berasosiasi dengan tombol
remote yang ditekan. Code tersebut yang kita catat dan akan digunakan dalam sketch pada
tutorial penggunaan remote IR selanjutnya.
Mari kita lihat sketch nya :
/*
TUTORIAL IR REMOTE RECEIVER PADA ARDUINO
TAMPILKAN KODE IR PADA SEVEN SEGMENT
ecadio.com
D4 -> Led Merah

D2 -> IR
*/
148
#include <Wire.h>
#include "EcadioIRremote.h"
//library IR : http://ecadio.com/arduino-library/IR/EcadioIRremote.zip
#define RECV_PIN 2//definisikan RECV_PIN sebagai 2 untuk koneksi ke pin 2

arduino
#define merah 4
IRrecv IR(RECV_PIN); // deklarasi library IRrecb
void setup()
{
IR.enableIRIn(); // memulai receiver
}
void loop()
{
if (IR.decode()) {//kalau ada kode yang valid
if (IR.isReleased())
{
digitalWrite(merah, HIGH); //menyalakan led ketika menerima sinyal IR
Serial.print("key code is ");
Serial.println(IR.keycode, DEC); //menulis code dalam bilangan
desimal
Serial.println("*************");
}
IR.resume(); //lanjutkan menerima sinyal IR lagi

}
}
Sketch ini menggunakan library untuk mengontrol receiver IR. Seperti biasa library kita
masukkan kedalam sketch dengan perintah #include
Pin Signal sensor IR akan dihubungkan ke pin 2, untuk memudahkan coding kita definisikan
pin 2 sebagai RECV_PIN
#define RECV_PIN 2
dan inisiasi library untuk mengontrol sensor IR receiver ini menggunakan perintah
IRrecv IR(RECV_PIN);
Pada bagian setup, masukkan perintah
149
Untuk memulai menerima sinyal IR, di bagian loop, kita gunakan struktur IF bertingkat. IF
yang pertama adalah menyaring sinyal IR, sehingga hanya IR yang dianggap valid saja yang
akan diproses
Pada IF kedua, adalah struktur if yang akan dijalankan jika sinyal IR valid 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

Serial.println(IR.keycode, DEC);
display.showNumberDec(IR.keycode);
Penggunaan led merah pada sketch ini adalah sebagai indikator penerimaan sinyal IR. Led
akan menyala ketika sensor infra merah menerima sinar IR yang dipancarkan remote saat
menerima sinyal
150
Jika anda menerima sensor IR receiver dalam bentuk modul di kit, bukan dalam bentuk
komponen, rangkaian nya adalah seperti berikut
Hubungkan kaki Signal ke pin D2, VCC ke 5V dan GND ke GND
151
TUTORIAL IR 2
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. Pada tutorial kali ini
kita akan menggunakan kode IR yang terpancar oleh masing-masing tombol remote dan
telah kita catat sebelumnya untuk melakukan tugas tertentu, yang dalam hal ini di
sederhanakan dengan beberapa buah led.
Rangkaian kali ini menggunakan 4 buah led, 4 buah resistor 220 ohm, dan sensor IR receiver
Buka file ESSENTIALS_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. Code masing-masing tombol juga ditampilkan pada jendela Serial Monitor.
Mari kita lihat sketch nya.
152
/*
TAMPILKAN KODE IR PADA SEVEN SEGMENT
DAN ON OFF LED
ecadio.com
D4 -> Led Merah

D2 -> pin signal IR receiver
D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/
#include <Wire.h>
#define RECV_PIN 2 //definisikan RECV_PIN sebagai 2 untuk koneksi ke pin 2

arduino
#define merah 4
#define hijau 5
#define biru 6
#define kuning 7
void setup()
{
pinMode(kuning, OUTPUT);
pinMode(biru, OUTPUT);
}
void loop()
{
{
}
if (IR.keycode == 69) { //code tombol 1
}
}
}
153
}
}
}
}
}

}
delay(1);
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
154
adalah 70, tombol 3 adalah 71 dan seterusnya. Nilai-nilai tersebut kemudian digunakan
dalam struktur IF untuk kondisi 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 lihat
pada sketch ESSENTIALS_IR_3.ino yang isi nya adalah sebagai berikut :
/*
DAN ON OFF LED DENGAN 1 TOMBOL
ecadio.com
D4 -> Led Merah

D6 -> Led Biru
*/
#define RECV_PIN 2
#define biru 6
#define merah 4
void setup()
{
void loop()
{
{
}
if(IR.keycode==28){
statusLed = !statusLed; //kebalikan nya
}
digitalWrite(biru,statusLed);
155
}
}
Pada sketch tersebut, code nomer 28 adalah code IR untuk tombol OK. Dengan menekan
tombol OK pada remote, led akan menyala. Menekan sekali lagi, led akan mati.
if(IR.keycode==28){
}
Teknik on-off yang digunakan disini menggunakan variabel memori yang kita namai
statusLed. Variabel statusLed saat diawal sketch telah diisi dengan 0 (LOW)
Pada perintah diatas, jika keycode adalah 28 maka variabel memori statusLed akan di buah
menjadi kebalikan nya. Misal nilai nya adalah 0, akan menjadi 1. Jika nilai nya 1, akan
menjadi 0. Dengan demikian, perintah digitalWrite() berikutnya akan mengikuti nilai
statusLed, akan HIGH jika nilai statusLed adalah 1, dan LOW jika nilai statusLed adalah 0
digitalWrite(biru,statusLed);
156
TUTORIAL SENSOR JARAK ULTRASONIC 1
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 mengukur jarak sebuah objek dari depan sensor.
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 dengan pinout sebagai berikut
SENSOR ULTRASONIC ARDUINO

VCC -> 5V
GND -> GND
TRIG -> A0
ECHO -> A1
Periksa lagi hubungan kabel tersebut sebelum melanjutkan ke tahap selanjutnya.
157
Bukalah file ESSENTIALS_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.
158
Mari kita perhatikan sketch nya :
/*
* TUTORIAL SENSOR JARAK ULTRASONIC PADA ARDUINO
* ecadio.com
*
* Pinout
* VCC Ultrasoonic -> VCC
* GND Ultrasonic -> GND
* Trig Ultrasonic -> A0
* Echo ultrasonic -> A1
*
*/
#define TRIGGER A0
#define ECHO A1
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
}
Pin A0 telah anda hubungkan ke kaki TRIG pada sensor. DI sketch diatas, pin A0 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
selama 10 microseconds
159
Untuk menangkap pantulan, kaki ECHO pada sensor telah anda hubungkan ke pin A1. Pada
pin A1 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 A0, dan menghitung waktu antara sinyal HIGH.
durasi = pulseIn(ECHO,HIGH);
Perintah pulseIn() diatas, berarti akan menghitung waktu jeda pin A0 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
160
TUTORIAL SENSOR ULTRASONIC 2
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.
Buka file ESSENTIALS_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
ecadio.com
161
Pinout
VCC Ultrasoonic -> VCC
GND Ultrasonic -> GND
Trig Ultrasonic -> A0
Echo ultrasonic -> A1
D4 -> Led Merah

D5 -> Led Hijau
D6 -> Led Biru
D7 -> Led Kuning
*/
#define TRIGGER A0
#define ECHO A1
#define merah 4
#define hijau 5
#define biru 6
#define kuning 7
long durasi, cm;
void setup() {
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
}
void loop() {
//kirim ping

durasi = pulseIn(ECHO, HIGH);

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

monitor
nyalakanLed(cm);
delay(250); //jeda waktu 250 uS
}
void nyalakanLed(int nilaiJarak){

if(nilaiJarak<=5){
digitalWrite(kuning,LOW);
digitalWrite(biru,LOW);
digitalWrite(hijau,LOW);
digitalWrite(merah,LOW);
}
if(nilaiJarak>5 && nilaiJarak<=10){
digitalWrite(kuning,HIGH);
digitalWrite(biru,LOW);
162
}
digitalWrite(biru,HIGH);
}
digitalWrite(hijau,HIGH);
}
if(nilaiJarak>20 ){
digitalWrite(hijau,HIGH);
digitalWrite(merah,HIGH);
}
Terlihat pada sketch tersebut, nilai jarak yang diperoleh dari sensor jarak ultrasonic
dipergunakan untuk mengatur nyala led menggunakan struktur IF
163
TUTORIAL SENSOR ULTRASONIC 3
Sensor Utrasonic dan LCD
Jika pada tutorial sebelumnya anda telah bisa menampilkan nilai jarak menggunakan sensor
jarak ultrasonic, menampilkan pada indikator led, maka pada tutorial kali ini kita akan
menggunakan nilai yang diperoleh tersebut untuk ditampilkan dalam LCD
Buka file ESSENTIALS_Ultrasonic_3.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
ecadio.com
Pinout
VCC Ultrasoonic -> VCC
GND Ultrasonic -> GND
Trig Ultrasonic -> A0
Echo ultrasonic -> A1
164
pin SDA LCD -> A4 (SDA)
pin SCL LCD -> A5 (SCL)
pin VCC LCD -> 5V
pin GND LCD -> GND
*/
#define TRIGGER A0
#define ECHO A1
long durasi, cm;
void setup() {
pinMode(TRIGGER, OUTPUT); //set menjadi OUTPUT
pinMode(ECHO, INPUT); //set menjadi INPUT

}
void loop() {
//kirim ping

durasi = pulseIn(ECHO, HIGH);

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

monitor
lcd.setCursor(0, 0); //set cursor untuk mulai pada kolom 0 di baris
pertama
lcd.print("Ultrasonic");
lcd.setCursor(0, 1); //set cursor untuk mulai pada kolom 0 di baris kedua
lcd.print("Distance : ");
lcd.print(String(cm)); //data jarak
lcd.print(" cm ");
165
166
TUTORIAL SERVO 1 dan 2
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 3 di tutorial ini sebagai signal, yang pada board Shield Multi
Sensor diberi label SDA. Hubungkan kabel ke board dengan aturan berikut :
167
SERVO ARDUINO
GND (Coklat) -> GND
VCC (Merah) -> VCC
SIG (Oranye) -> D3
Pasanglah salah satu lengan servo pada as servo, dan periksa kembali apakh hubungan
sudah benar sebelum melanjutkan ke langkah berikutnya.
Buka file ESSENTIALS_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
* ecadio.com
*
* Pinout :
* Kabel coklat servo -> GND
* Kabel merah servo -> VCC
* Kabel kuning servo -> D3
*
*
*/
168
#include <Servo.h>
int servoPin = 3;
Servo myservo;
void setup() {
myservo.attach(servoPin);
void loop() {
myservo.write(45); // Turn SG90 servo Left to 45 degrees
delay(1000); // Wait 1 second
myservo.write(90); // Turn SG90 servo back to 90 degrees (center
position)
myservo.write(135); // Turn SG90 servo Right to 135 degrees
myservo.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 3 sebagai servoPin dan inisiasi objek servo bernama “servo”
int servoPin = 3;
Servo servo;
Pada bagian setup, mulai mengaktifkan servo dengan perintah servo.Attach()
servo.attach(servoPin);
Perintah untuk menggerakkan servo ke posisi derajat tertentu menggunakan perintah

servo.Write(nilai_derajat);
myservo.write(45);
Perintah diatas memerintahkan lengan servo untuk bergerak ke posisi 45 derajat. Untuk
menggerakkan lengan servo ke arah 90 derajat, perintah nya adalah
myservo.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.
169
File TUTORIAL_SERVO_2.ino adalah contoh menggerakkan servo dengan menerapkan
kecepatan yang lebih lambat. Mari kita lihat sketch nya
/*
TUTORIAL SERVO PADA ARDUINO
MENGGERAKKAN SERVO DENGAN KECEPATAN
ecadio.com
Pinout :
Kabel coklat servo -> GND
Kabel merah servo -> VCC
Kabel kuning servo -> D3
*/
#include <Servo.h>
int servoPin = 3;
Servo myservo;
int pos = 0;
void setup() {
delay(100);
void loop() {
for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180
degrees
// in steps of 1 degree
170
myservo.write(pos); // tell servo to go to position in
variable 'pos'
delay(10); // waits 15ms for the servo to reach
the position
}
for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0
degrees
myservo.write(pos); // tell servo to go to position in
variable 'pos'
delay(10); // waits 15ms for the servo to reach
the position
}
}
Pada sketch tersebut kecepatan lengan servo bergerak diatur dengan menggerakkan lengan
servo 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.
171
TUTORIAL SERVO 3
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
Buka file ESSENTIALS_SERVO_3.ino dan upload ke board Uno. Putarlah lengan

potensiometer, dan lengan servo akan berputar selaras dengan putaran potensiometer.
/*
TUTORIAL SERVO PADA ARDUINO
MENGGERAKKAN SERVO SESUAI POTENSIO
172
ecadio.com
Pinout :
Kabel coklat servo -> GND
Kabel coklat merah -> VCC
Kabel coklat kuning -> D3
Potensio pada A0
*/
#include <Servo.h>
#define PIN_POTENSIO A0
int servoPin = 3;
int derajat;
Servo myservo;
void setup() {
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
myservo.write(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);
173
174
TUTORIAL RELAY 1
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
175
menggunakan tegangan/arus yang lebih besar dengan aman, misal motor DC 12V, atau
bahkan lampu 220V dengan menggunakan sinyal 5V yang dikeluarkan dari Arduino.
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 :
176
RELAY ARDUINO
GND -> GND
VCC -> VCC
IN -> A4
Periksa kembali hubungan kabel tersebut sebelum melanjutkan ke langkah selanjutnya.
Buka file ESSENTIALS_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
ecadio.com
D4 -> Led Merah
VCC relay -> VCC
GND relay -> GND
IN RELAY -> A4
*/
177
#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)
digitalWrite(pinRelay, HIGH); //mematikan relay (memberi tegangan 5V,
karena modul relay berjenis Active Low, sehingga mati saat diberi HIGH)
}
Terlihat pada sketch diatas, untuk menyalakan atau mematikan relay menggunakan perintah
digitalRead() seperti yang pernah kita gunakan dalam tutorial led.
Modul relay yang kita gunakan berjenis Active Low, yang berarti relay akan aktif jika pada
kaki 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.
178
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.
179
TUTORIAL RELAY 2
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
Buka file ESSENTIALS_RELAY_2.ino dan upload ke board Uno. Anda dapat

menyalakan/mematikan relay dengan menekan tombol
/*
TUTORIAL RELAY PADA ARDUINO
180
PUSH BUTTON DAN RELAY
DENGAN PENGGUNAAN DEBOUNCE
ecadio.com
Pinout :
Tombol 1 -> D9
D4 -> Led Merah
VCC relay -> VCC

GND relay -> GND
IN RELAY -> A4
*/
#define TOMBOL1 9
#define merah 4
#define pinRelay A4

int statusRelay = HIGH;
int statusTombol;

void setup()
{
pinMode(pinRelay, OUTPUT); //set menjadi output
digitalWrite(merah, statusLed);
digitalWrite(pinRelay, statusRelay);
void loop()
{
}

statusTombol = a;
statusRelay = !statusRelay; //kebalikan nya
}
}
}
181
digitalWrite(merah, statusLed);
}
Sketch diatas telah menggunakan algoritma debounce dari tombol untuk memperoleh input
tombol yang lebih akurat dan natural
Ketika tombol ditekan sekali, relay akan aktif. Ketika tombol di tekan lagi, relay akan non
aktif.
182
TUTORIAL RELAY 3
Mengendalikan Relay dengan Remote IR

Jika anda telah bisa mengendalikan led dengan remote infra merah, anda pun bisa
mengendalikan modul relay dengan remote IR.
Buka file ESSENTIALS_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
ecadio.com
183
D4 -> Led Merah
D6 -> Led Biru
VCC relay -> VCC

GND relay -> GND
IN RELAY -> A4
*/
#define RECV_PIN 2
#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;
}
digitalWrite(biru, statusLed);

}
}
Dengan sketch tersebut sekarang anda bisa menyalakan dan mematikan peralatan listrik
yang lebih besar seperti lampu AC 220V atau peralatan lain menggunakan remote IR.
184
PENUTUP
Selamat, anda telah mempelajari banyak hal mengenai dasar-dasar konsep Arduino. Saat ini
anda sudah bisa membuat sendiri banyak kombinasi eksperimen dari berbagai sensor yang
terdapat pada Kit Essentials sesuai kreasi anda. Anda pun sekarang tidak akan bingung lagi
ketika akan mengikuti tutorial-tutorial yang menarik yang banyak terdapat di internet.
Lalu apa lagi yang bisa dilakukan dengan menggunakan board Uno ini?
Sangat banyak hal. Dengan dasar pengetahuan yang telah anda miliki sekarang, masih
banyak yang bisa anda lakukan dengan board Arduino yang anda miliki, dan anda bisa bebas
berkreasi sesuai kreativitas anda yang tidak terbatas. Untuk setiap kreasi yang ingin anda
ciptakan, ada modul atau sensor yang sesuai untuk itu.
Sebagai contoh nya, anda ingin memperdalam tentang tampilan led, anda bisa membuat led
cube, yang terdiri dari banyak puluhan hingga ratusan led yang membentuk cahaya yang
indah. Atau ingin mencoba membuat seperti running text, ada Modul Led Matrix, yang bisa
anda pakai beberapa modul sekaligus sehingga membentuk seperti running text.
Modul Led Dot Matrix 8x8

Modul Dot Matrix 4 in 1
Untuk menampilkan data, masih banyak pilihan lain selain LCD 1602 dan Seven Segment
seperti yang telah anda pelajari. Ada LCD Nokia, LCD 2004, LCD Touch Screen, LCD TFT
warna, LCD OLED, LCD Gafik, dan masih banyak pilihan lain nya, bahkan sampai mencetak
pada printer.
185
Anda juga sudah bisa untuk memulai belajar Communication pada Arduino, bagaimana
board Arduino bisa berkomunikasi dengan board Arduino lain nya, atau dengan alat lain
seperti handphone Android dan membuat applikasi Android sendiri. Anda bisa
menggunakan Modul Bluetooth untuk komunikasi dengan Android. Atau ingin mulai
menerapkan penggunaan WiFi dan internet ke Arduino, bisa menggunakan Modul Wifi
ESP8266, NodeMCU, ESP32, Ethernet LAN Shield
Komunikasi dengan MCU lain bisa menggunakan kabel dengan I2C, RS232, atau RS485, dan
bisa juga secara wireless menggunakan gelombang radio, yang bahkan bisa hingga puluhan
kilometer. Anda bisa menggunakan Modul RF, NRF24L01, LoRa
Untuk input, selain tombol push button anda bisa menggunakan Keypad 4x4, Modul Touch
Pad, bahkan penggunaan RFID card dan tag, Sensor Sidik Jari, Voice Command, hingga
penggunaan kamera
186
Jika anda tertarik dengan robotika, anda sudah bisa mulai belajar menggerakkan motor-
motor DC sehingga membentuk Smart Robot Car, membuat lengan robot (Robot Arm)
menggunakan servo yang telah anda kenal, atau sampai membuat Printer 3D sendiri.
Untuk sensor, disinilah yang paling banyak varian nya. Platform Arduino menyediakan sangat
banyak pilihan sensor sesuai kebutuhan anda. Untuk sensor jarak saja, ada Sensor Jarak
Laser, Sensor Jarak IR, dan lain lain. Ada berbagai sensor lain seperti sensor debu, sensor
kelembaban tanah, sensor hujan, sensor ketinggian air, sensor arus air, sensor intensitas
cahaya, sensor suara, sensor gerak, sensor gas, dan masih banyak lagi sensor. Intinya,
silahkan anda berkreasi sesuai kreativitas anda, tidak usah khawatir, akan ada sensor atau
modul untuk mendukung kreasi anda itu.
187
Yang penting anda telah menguasai dasar-dasar menuju penggunaan modul dan sensor yang
tersedia banyak itu, yang mana inilah tujuan dari Starter Kit, sebagai starter awal untuk
selanjutnya anda bisa melaju dengan kencang. Untuk ide-ide awal anda bisa search di
internet untuk project-project yang menurut anda menarik untuk dikerjakan.
Selamat berkreasi
188

Tutorial Belajar Arduino Kit Essentials

Diunggah oleh

Informasi Dokumen

Deskripsi 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

Tutorial Belajar Arduino Kit Essentials

Diunggah oleh

Hak Cipta:

Format Tersedia

Dengan Starter Kit Belajar Arduino – Essentials

TUTORIAL UNTUK STARTER KIT ESSENTIALS BELAJAR ARDUINO

DAFTAR ISI ............................................................................................................. i

Mengenal board UNO R3

Upload program ke board UNO

Mempersiapkan File dan Library yang dibutuhkan

Pengenalan Breadboard (papan prototype project)

Agar lebih memahami bagaimana breadboard melakukan jembatan-jembatan kabel, mari

Lebih mudah nya bisa diamati gambar berikut ini

BLINK – Memahami konsep dasar I/O Arduino

Mari kita perhatikan isi sketch nya :

#define pinLed 13 //led merah pada D13

#define pinLed 13 //led merah pada D13

Syntax perintah pinMode adalah :

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

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 ke pinLed

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)

Perintah selanjutnya yang akan di jalankan adalah

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

#define pinLed 13 //led merah pada D13

BLINK Multiple Led

Mari kita perhatikan isi sketch nya :

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)

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

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)

BLINK Multiple Led dan Konsep Sub Program

Wiring rangkaian masih sama dengan yang sebelum nya

Mari kita bedah sketch nya

D4 -> Led Merah

//membuat sub-sub program

Perhatikan pada sketch tersebut, perbedaan dengan sketch ESSENTIALS_led_2.ino adalah

Pengenalan Serial Monitor dan Input I/O

Bukalah file ESSENTIALS_Serial_Monitor_1.ino dan upload ke board Uno. Setelah di upload,

Mari kita bahas sketch ESSENTIALS_Serial_Monitor_1

Syntax dari Serial.begin() adalah

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

Serial.println("Mencoba Serial Monitor");

Baris perintah berikutnya adalah di bagian loop().

Serial.print("Ini loop ke : ");

Bukalah file ESSENTIALS_Serial_Monitor_2.ino dan upload ke board Uno. Setelah di upload,

Mari kita bahas sketch ESSENTIALS_Serial_Monitor_2

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

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

Baris perintah berikutnya adalah di bagian loop().

int nilai = analogRead(A5);

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

Pengenalan Potensiometer Sebagai Simulasi Sensor

Sekarang mari kita coba menggunakan potensiometer di arduino. Komponen yang

Bukalah file ESSENTIALS_Potensio_1.ino dan upload ke board UNO.

Sketch nya dalah sebagai berikut :

Potensio dan Led

D4 -> Led Merah

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

//membuat sub-sub program