Internal Pullup Resistor

Dengan adanya internal pullup resistor, kita tidak perlu lagi menambahkan resistor pada tombol sebagai
pullup. Cukup mengaktifkan internal pullup resistor dengan program.
Mungkin ada bertanya, buat apa sih pullup resistor?
Jika pin Arduino diset sebagai INPUT, maka logika yang terbaca oleh Arduino tergantung INPUT yang di-
berikan. Jika pin dihubungkan ke VCC, logika yang terbaca adalah HIGH. Jika pin dhibungkan ke GND, maka
logika yang terbaca adalah LOW. Lalu bagaimana jika pin tidak dihubungkan ke VCC atau GND?
Nah, kondisi seperti itu disebut floating. Logika pada pin bisa dibilang kacau, HIGH dan LOW bergantian.
Logika pada pin INPUT seakan digantung, nggak jelas. Sehingga kita butuh resistor untuk menentukan kondisi
defaultnya, apakah akan dibuat default HIGH atau default LOW.
Untuk mengaktifkan internal pullup resistor, pin Arduino tidak didefinisikan dengan INPUT lagi, tapi
INPUT_PULLUP. Langsung buat rangkaian seperti di bawah ini. Setelah itu, coba kedua program di bawah
untuk melihat perbedaan antara penggunaan INPUT dan INPUT_PULLUP.

Rangkaian Testing Pullup Resistor

Peralatan dan rangkaian yang perlu disiapkan adalah:

1. Arduino x 1
2. Push button x 1
3. Kabel jumper secukupnya
Program Tombol tanpan Pullup Resistor

1. /*
2. * INTERACTIVE ROBOTICS
3. * Program Tombol tanpa Pullup Resistor
4. */
5.
6. const byte PIN_TOMBOL = 2; // tombol pada pin 2
7.
8. boolean data = HIGH; // variabel penyimpan data dari tombol
9. boolean data_last = data; // dan data sebelumnya
10.
11. void setup() {
12. [Link](19200); // buka koneksi ke serial
13. while(!Serial);
14.
15. pinMode(PIN_TOMBOL,INPUT); // tombol sebagai input
16. }
17.
18. void loop() {
19. data = digitalRead(PIN_TOMBOL); // baca data tombol
20. if(data != data_last){ // jika data berbeda dari data sebelumnya
21. [Link]( data ); // cetak ke serial monitor
22.
23. data_last = data; // simpan data sebagai data sebelumnya
24.
25. }
26. }
27.

Setelah program diupload, Anda boleh cek di Serial Monitor dengan baud rate 19200. Nilai apa yang
keluar, 0 atau 1? Atau tampilannya kacau? Saya sengaja tidak menampilkan hasilnya di sini supaya Kalian
mencobanya sendiri. ^_^
 Ketika pin Arduino dalam kondisi floating (tidak jelas apakah defaultnya 0 atau 1), maka dia akan
kebingungan. Sehingga yang muncul di Serial Monitor adalah 0 dan1 bergantian, meski tombol tidak diapa-
apakan.
Selanjutnya edit baris 16 hingga menjadi program selanjutnya, dan bandingkan hasilnya.

1. /*
2. * INTERACTIVE ROBOTICS
3. * Program Tombol tanpa Pullup Resistor
4. */
5.
6. const byte PIN_TOMBOL = 2; // tombol pada pin 2
7.
8. boolean data = HIGH; // variabel penyimpan data dari tombol
9. boolean data_last = data; // dan data sebelumnya
10.
11. void setup() {
12. [Link](19200); // buka koneksi ke serial
13. while(!Serial);
14.
15. pinMode(PIN_TOMBOL,INPUT_PULLUP); // tombol sebagai input dengan
16. } // pullup resistor
17.
18. void loop() {
19. data = digitalRead(PIN_TOMBOL); // baca data tombol
20. if(data != data_last){ // jika data berbeda dari data sebelumnya
21. [Link]( data ); // cetak ke serial monitor
22.
23. data_last = data; // simpan data sebagai data sebelumnya
24.
25. }
26. }

Pada program yang kedua, data akan muncul jika tombol ditekan. Berdasarkan logika program, data di-
cetak ke serial monir apabila data berubah (logika yang diterima berbeda dengan logika sebelumnya), lihat
baris 20.

Dengan tambahan pengetahuan ini, Anda telah belajar bagaimana menangani input berupa tombol dan
mengerti tentang pullup resistor yang ada dalam internal Arduino.
Membuat Tombol Multikondisi
Apa maksud dari tombol multikondisi? Normalnya, tombol push button hanya punya dua logika, ON dan
OFF, namun kondisi ON tidak dapat terkunci. Jika kita menggukan switch ON/OFF seperi saklar, kondisi ON
akan terkunci dengan mudah karena proses pengunciannya secara fisik.

Jika kita pakai tombol push button, akan susah kalau kita ingin mengunci kondisi ON. Sebab logika tombol
akan langsung berubah menjadi OFF ketika tombol kita lepas.

Untuk mengawali belajar tentang tombol multikondisi, pertama kita akan membuat program yang lebih
manusiawi. Program yang lebih manusiawi maksudnya adalah informasi yang muncul di serial monitor bukan
angka 0 atau 1, tapi tulisan yang lebih bisa dipahami.

Program Tombol yang Manusiawi

Mungkin penamaannya aneh. Tapi nggak masalah, yang penting kita bisa membedakan berbagai program
dalam Modul ini berdasarkan nama programnya.
1. /*
2. * INTERACTIVE ROBOTICS
3. * Program Tombol Yang Manusiawi
4. */
5.
6. // kita set supaya tombol active low
7. #define ON LOW
8. #define OFF !ON
9.
10. const byte PIN_TOMBOL = 2; // tombol pada pin 2
11.
12. boolean data = OFF; // data awal ada OFF
13. boolean data_last = data; // dan data sebelumnya juga OFF
14.
15. void setup() {
16. // buka koneksi ke serial
17. [Link](19200);
18. while(!Serial);
19.
20. // tombol sebagai input dengan pullup resistor
21. pinMode(PIN_TOMBOL,INPUT_PULLUP);
22. }
23.
24. void loop() {
25. data = digitalRead(PIN_TOMBOL); // baca data tombol
26.
27. // jika data berbeda dari data sebelumnya
28. // cetak ke serial monitor
29. if(data != data_last){
30.
31. // jika ON, cetak ON
32. // jika OFF, cetak OFF
33. if(data == ON){
34. [Link](“ON”);
35. } else {
36. [Link](“OFF”);
37. }
38. // simpan data sebagai data sebelumnya
39. data_last = data;
40. }
41. }

Pada Serial Monitor dari output Program tersebut muncul tulisan ON ketika tombol ditekan. Lalu akan
muncul tulisan OFF ketika penekanan tombol dilepas. Mungkin sesekali akan muncul tulisan ON dan OFF
dua kali. Hal tersebut bisa menjadi masalah, sebab memang perubahaan data memang terjadi 2 kali yaitu
perubahan dari OFF ke ON ketika tombol mulai ditekan dan perubahan dari ON ke OFF saat tombol dilepas.
 Kita bisa memodifikasi karakteristik tombol di atas supaya mirip dengan switch ON/OFF. Jadi, ketika tom-
bol ditekan, maka kondisi akan ON. Jika tombol ditekan lagi, kondisi berubah menjadi OFF. Jika tombol dite-
kan lagi, kondisi menjadi ON lagi, dan seterusnya.
Jadi status ON dan OFF-nya seakan bisa dikunci seperti switch atau saklar. Silakan langsung coba program
selanjunya.

Program Tombol dengan Lock Status

1. /*
2. * INTERACTIVE ROBOTICS
3. * Program Tombol dengan Lock Status
4. */
5.
6. // kita set supaya tombol active low
7. #define ON LOW // active low
8. #define OFF !ON
9.
10. // tombol pada pin 2
11. const byte PIN_TOMBOL = 2;
12.
13. boolean data = OFF; // data awal ada OFF
14. boolean data_last = data; // dan data sebelumnya juga OFF
15.
16. boolean logika = data; // variabel untuk lock status
17.
18. // delay untuk penekanan tombol.
19. // setelah tombol ditekan, maka selama 150 ms
20. // tidak bisa ditekan.
21. // delay ini berguna untuk menghindari 2 kali eksekusi
22. unsigned long delay_press = 150; // dalam ms
23. unsigned long delay_press_last = 0;
24.
25. void setup() {
26. // buka koneksi ke serial
27. [Link](19200);
28. while(!Serial);
29.
30. pinMode(PIN_TOMBOL,INPUT_PULLUP); // tombol sebagai input dengan
31. } // pullup resistor
32.
33. void loop() {
34.
35. // jika selisih waktu penekanan tombol
36. // lebih besar dari waktu delay tombol
37. // baca tombol lagi, jika tidak tombol tdk dibaca
38. if( millis() - delay_press_last > delay_press ){
39.
40. data = digitalRead(PIN_TOMBOL); // baca data tombol
41.
42. // jika data berbeda dari data sebelumnya
43. // cetak ke serial monitor
44. if(data != data_last){
45.
46. if(data == ON){ // jika data = ON
47.
48. logika = !logika; // balik status logika tombol
49.
50. // jika ON, cetak ON
51. // jika OFF, cetak OFF
52. if( logika == ON ){
53. [Link](“ON”);
54.
55. } else {
56. [Link](“OFF”);
57. }
58. }
59.
60. // simpan data sebagai data sebelumnya
61. data_last = data;
62. // catat waktu penekanan tombol terakhir
63. delay_press_last = millis();
64. }
65. }
66. }
Pada Program Tombol dengan Lock Status, status ON atau OFF tombol tidak didasarkan pada data yang di-
baca oleh digitalRead(). Akan tetapi, status ON atau OFF ditentukan dengan variabel logika (lihat baris 16).
Cara kerjanya seperti ini :
1. Pertama kali, variabel logika berstatus OFF.
2. Jika tombol ditekan, data variabel logika dibalik menjadi OFF.
3. Jika tombol ditekan lagi, data variabel logika dibalik lagi menjadi ON. Begitu seterusnya.
4. Proses pembalikan logika dilakukan pada baris 48.
5. Untuk membalik logika, kita hanya butuh mendeteksi penekanan tombol, yaitu ketika kondisi tombol
= ON. Lihat baris46.

Program 9.4 sudah tidak lagi menampilkan dua kali eksekusi untuk sekali penekanan tombol. Pencegahan
dua kali eksekusi dilakukan dengan menambahkan pemeriksaan apakah logika tombol berubah atau tidak
(lihat baris 44). Terakhir kali menekan tombol dicatat pada baris 63.

Jadi, selama logika tombol tidak berubah, maka Arduino akan mengunci status dan tombol tidak akan
pernah terbaca berkali-kali. Kecuali tombol dilepas, baru status akan kembali berubah.

CHALANGE !
1. Tambahkan 1 buah LED, coba program-program yang sudah dibuat pada pertemuan ini dengan LED. Dan
amati cara kerja program-program tersebut. Catat apa yang kalian amati pada Handbook/catatan kalian.

SELAMAT MENCOBA ^_^

SEMANGAT!!!
Mengelola Banyak Tombol dengan Satu Pin

Syarat untuk mengelola tombol dengan sebuah pin Input adalah pin tersebut harus Analog. Di Arduino
Uno, kita bisa menggunakan pin A0 – A5. Kenapa harus analog? Sebab, kita akan mengimplementasikan
konsep pembagi tegangan dan data diterima dengan pin analog. Anda boleh memperhatikan gambar diatas,
sebab konsep yang akan kita pakai akan seperti gambar tersebut.

Jika semua resistor memiliki nilai resistansi yang sama, maka secara teori data output bisa dihitung seperti
Tabel di bawah ini. Berapapun nilai resistornya, yang penting nilainya seragam, maka hasilnya akan seperti
tabel ini.
 Berdasarkan tabel di atas, jika data dari analogRead() adalah sekitar 204, berarti tombol S1 ditekan. Jika
data dari analogRead() adalah sekitar 511, berarti tombol S4 ditekan. Saya sebut kira-kira karena bisa jadi
nilai resistansi resistor agak berbeda, jadi bisa kurang bisa lebih.
Untuk mengatasi kurang lebih nilai tersebut, kita bisa ambil nilai toleransi 10 – 20. Misal untuk tombol
S1, berarti nilai untuk mengidentifikasi tombolnya adalah antara 194 – 214. Selanjutnya, mari kita buktikan
dengan program.

Rangkaian Program untuk Membaca 5 Tombol

Peralatan dan rangkaian yang perlu disiapkan adalah:

1. Arduino x 1
2. Push button x 5
3. Resistor dengan nilai seragam x 5
4. Project board x 1
5. Kabel jumper secukupnya

Sambungan pin antara Arduino dan push button :

1. /*
2. * INTERACTIVE ROBOTICS
3. * Program Analisis Output Tombol
4. */
5.
6. // output tombol di pin A0
7. const byte PIN_TOMBOL = A0;
8.
9. // data saat ini dan data sebelumnya
10. int data = 0;
11. int data_last = 0;
12.
13. // delay untuk penekanan tombol.
14. // setelah tombol ditekan, maka selama 150 ms
15. // tidak bisa ditekan.
16. // delay ini berguna untuk menghindari 2 kali eksekusi
17. unsigned long delay_press = 150; // dalam ms
18. unsigned long delay_press_last = 0;
19.
20. void setup() {
21. // buka koneksi ke serial
22. [Link](19200);
23. while(!Serial);
24.
25. // tombol sebagai input
26. pinMode(PIN_TOMBOL,INPUT);
27. }
28.
29. void loop() {
30. // panggil fungsi utk membaca tombol
31. TombolListener();
32. }
33.
34. void TombolListener(){
35.
36. // jika selisih waktu penekanan tombol
37. // lebih besar dari waktu delay tombol
38. // baca tombol lagi, jika tidak tombol tdk dibaca
39. if( millis() - delay_press_last > delay_press ){
40.
41. data = analogRead(PIN_TOMBOL); // baca data tombol
42.
43. if( data < 10 ) return; // jika data lebih kecil dari 10 abaikan
44.
45. // jika data berbeda dari data sebelumnya
46. // cetak ke serial monitor
47. if(data != data_last){
48. [Link](data);
49. data_last = data;
50. delay_press_last = millis();
51. }
52. }
53. }
 Output pada serial monitor masing-masing muncul dua kali. Data pertama ketika ditekan, data kedua
muncul ketika dilepas. Berdasarkan data tersebut, kita bisa menggunakan toleransi 20. Sebab jika menggu-
nakan toleransi 10, nilai untuk SW2 mungkin tidak akan terdeteksi.
Berdasarkan perhitungan, nilai output untuk SW2 adalah 255, sementara yang muncul di serial monitor
adalah 246 atau 243. Jika menggunakan selisih 10, tentu angka 243 tidak terdeteksi sebagai SW2. Kurang
lebih seperti itu cara kerja dan perhitungannya. Selanjutnya, mari kita lanjut ke program untuk menampilkan
menu sesuai tombol yang ditekan.

Program Menu 5 Tombol

1 /*
2 * INTERACTIVE ROBOTICS
3 * Program Menu 5 Tombol
4 */
5
6 // definisikan 5 tombol
7 #define TOMBOL_NONE 0
8 #define TOMBOL1 1
9 #define TOMBOL2 2
10 #define TOMBOL3 3
11 #define TOMBOL4 4
12 #define TOMBOL5 5
13
14 // output tombol di pin A0
15 const byte PIN_TOMBOL = A0;
16
17 // nilai data tombol sesuai tabel
18 const int TOMBOL_VAL[] = {204,255,341,511,1023};
19
20 // nilai koreksi
21 const byte KOREKSI = 15;
22
24 // tombol dalam array
25 const byte TOMBOL[] = {
26 TOMBOL1, TOMBOL2, TOMBOL3,
27 TOMBOL4, TOMBOL5 };
28
29 // tombol saat ini dan tombol sebelumnya
30 byte tombol = 0;
31 byte tombol_last = 0;
32
33 // data saat ini dan data sebelumnya
34 int data = 0;
35 int data_last = 0;
36
37 // delay untuk penekanan tombol
38 unsigned long delay_press = 400; // dalam ms
39 unsigned long delay_press_last = 0;
40
41 void setup() {
42 // buka koneksi ke serial
43 [Link](19200);
44 while(!Serial);
45
46 // tombol sebagai input
47 pinMode(PIN_TOMBOL,INPUT);
48 }
49
50 void loop() {
51 // panggil fungsi utk membaca tombol
52 TombolListener();
53 }
54
55 void TombolListener(){
56 // jika selisih waktu penekanan tombol
57 // lebih besar dari waktu delay tombol
58 // baca tombol lagi, jika tidak tombol tdk dibaca
59 if( millis() - delay_press_last > delay_press ){
60 // baca data analog tombol
61 data = analogRead(PIN_TOMBOL);
62 // reset tombol sebelumnya
63 tombol = TOMBOL_NONE;
64 // cocokkan data dengan ke-5 data tombol
65 for(byte i=0; i<sizeof(TOMBOL); i++){
66 // hitung koreksi data tombol
67 // jika ada yang cocok,
68 // catat tombol yang sesuai, lalu
69 // hentikan looping.
70 if( abs(data - TOMBOL_VAL[i]) < KOREKSI ){
71 tombol = TOMBOL[i];
72 break;
73 }
74 }
75
76 // jika ada tombol yang cocok
77 // cetak tombol, panggil aksi tombol
78 // lalu catat waktu pembacaan tombol
79 if(tombol != TOMBOL_NONE){
80 [Link](tombol);
81
82 AksiTombol(tombol);
83
84 tombol_last = tombol;
85 delay_press_last = millis();
86 }
87 }
88 }
89
90 // fungsi AksiTombol
91 // INPUT : byte tombol
92 void AksiTombol(byte tombol){
93 switch(tombol){
94 case TOMBOL1:
95 // proses sesuatu
96 [Link](“Menu 1”);
97 break;
98 case TOMBOL2:
99 // proses sesuatu
100 [Link](“Menu 2”);
101 break;
102
103 case TOMBOL3:
104 // proses sesuatu
105 [Link](“Menu 3”);
106 break;
107
108 case TOMBOL4:
109 // proses sesuatu
110 [Link](“Menu 4”);
111 break;
112
113 case TOMBOL5:
114 // proses sesuatu
115 [Link](“Menu 5”);
116 break;
117 }
118 }

Cara kerja program tersebut yaitu:

1. Referensi data untuk 5 buah tombol ada di baris 18. Sedangkan nilai toleransi yang dipilih adalah angka
15 (lihat baris 21).
2. Ketika tombol ditekan, maka data dari tombol diterima dengan analogRead() pada baris 61.
3. Sebelum mendeteksi tombol, tombol direset untuk menghindari salah baca (lihat baris 63).
4. Berikutnya data yang terbaca akan dicocokkan dengan SEMUA referensi nilai tombol (lihat fungsi loop di
baris 65).
5. Data akan dicocokkan dengan setiap referensi data. Jika selisihnya lebih kecil dari nilai toleransi
(lihat baris 70), maka pilih tombol, lalu stop looping dengan perintah break pada baris 72.
6. Setelah tombol terpilih, pilih AksiTombol() yang sesuai denga tombol yang terpilih (lihat baris 82).
contoh tampilan output Menu 5 Tombol

Setelah program 5 tombol dengan satu pin ini bekerja dengan baik, mari kita lanjut dengan aksi untuk
menghidupkan led untuk setiap tombol. Program tombol dan LED ini adalah kombinasi dari program mem-
baca banyak tombol dan program tombol dengan lock status. Program tombol dan LED ini akan kita gunakan
sebagai dasar untuk mempelajari EEPROM pada bab berikutnya. Jadi, pastikan Anda mencoba program tera-
khir pada Bab ini.
Rangkain 5 Tombol 5 LED

Part yang harus disiapkan dan rangkaiannya adalah:

1. Arduino Uno x 1
2. Push button x 5
3. Resistor x 10 (bebas)
4. LED x 10
5. Project Board x 1
6. Jumper secukupnya

Skema Rangkaian
Program 5 Tombol 5 LED

1 /*
2 * INTERACTIVE ROBOTICS
3 * Program 5 Tombol 5 LED
4 */
5
6 // led setting active high
7 #define LED_ON HIGH
8 #define LED_OFF !LED_ON
9
10 // definisikan 5 tombol
11 #define TOMBOL_NONE 0
12 #define TOMBOL1 1
13 #define TOMBOL2 2
14 #define TOMBOL3 3
15 #define TOMBOL4 4
16 #define TOMBOL5 5
17
18 // output tombol di pin A0
19 // pin led di pin 2 - 6
20 const byte PIN_TOMBOL = A0;
21 const byte PIN_LED[] = {2,3,4,5,6};
22
23 // nilai data tombol sesuai tabel
24 // dan nilai toleransi 15
25 const int TOMBOL_VAL[] = {204,255,341,511,1023};
26 const byte TOLERANSI = 15;
27
28 // status led untuk lock status
29 byte STATUS_LED[] = {LED_OFF,LED_OFF,LED_OFF,LED_OFF,LED_OFF};
30
31 // tombol dalam array
32 const byte TOMBOL[] = {
33 TOMBOL1, TOMBOL2, TOMBOL3,
34 TOMBOL4, TOMBOL5 };
35
36 // tombol saat ini dan tombol sebelumnya
37 byte tombol = 0;
38 byte tombol_last = 0;
39
40 // data saat ini dan data sebelumnya
41 int data = 0;
42 int data_last = 0;
43
44 // delay untuk penekanan tombol
45 unsigned long delay_press = 400; // dalam ms
46 unsigned long delay_press_last = 0;
47
48 void setup() {
49 // buka koneksi ke serial
50 [Link](19200);
51 while(!Serial);
52
53 // tombol sebagai input
54 pinMode(PIN_TOMBOL,INPUT);
55
56 // pin sebagai output, defaultnya OFF
57 for(byte i=0; i<sizeof(PIN_LED); i++){
58 pinMode(PIN_LED[i],OUTPUT);
59 digitalWrite(PIN_LED[i],LED_OFF);
60 }
61 }
62
63 void loop() {
64
65 // panggil fungsi utk membaca tombol
66 TombolListener();
67 }
68
69 void TombolListener(){
70
71 // jika selisih waktu penekanan tombol
72 // lebih besar dari waktu delay tombol
73 // baca tombol lagi, jika tidak tombol tdk dibaca
74 if( millis() - delay_press_last > delay_press ){
75
76 // baca data analog tombol
77 data = analogRead(PIN_TOMBOL);
78 // reset tombol sebelumnya
79 tombol = TOMBOL_NONE;
80 // cocokkan data dengan ke-5 data tombol
81 for(byte i=0; i<sizeof(TOMBOL); i++){
82 // hitung koreksi data tombol
83 // jika ada yang cocok,
84 // catat tombol yang sesuai, lalu
85 // hentikan looping.
86 if( abs(data - TOMBOL_VAL[i]) < TOLERANSI ){
87 tombol = TOMBOL[i];
88 break;
89 }
90 }
91
92 // jika ada tombol yang cocok
93 // cetak tombol, panggil aksi tombol
94 // lalu catat waktu pembacaan tombol
95 if(tombol != TOMBOL_NONE){
96 [Link](tombol);
97
98 AksiTombol(tombol);
99
100 tombol_last = tombol;
101 delay_press_last = millis();
102 }
103 }
104 }
105 // fungsi AksiTombol
106 // INPUT : byte tombol
107 void AksiTombol(byte tombol){
108
109 // konversi dari nomer tombol menjadi index tombol
110 byte index_led = tombol-1;
111
112 // balik status LED sesuai index/led yang cocok
113 // jika HIGH, ubah jadi LOW, dan sebaliknya
114 STATUS_LED[index_led] = !STATUS_LED[index_led];
115
116 // cetak sesuai tombol yang terpilih
117 switch(tombol){
118 case TOMBOL1:
119 // proses sesuatu
120 if( STATUS_LED[index_led] == LED_ON ){
121 [Link](“Nyalakan LED 1”);
122 } else {
123 [Link](“Matikan LED 1”);
124 }
125 break;
126
127 case TOMBOL2:
128 // proses sesuatu
129 if( STATUS_LED[index_led] == LED_ON ){
130 [Link](“Nyalakan LED 2”);
131 } else {
132 [Link](“Matikan LED 2”);
133 }
134 break;
135
136 case TOMBOL3:
137 // proses sesuatu
138 if( STATUS_LED[index_led] == LED_ON ){
139 [Link](“Nyalakan LED 3”);
140 } else {
141 [Link](“Matikan LED 3”);
142 }
143 break;
144
145 case TOMBOL4:
146 // proses sesuatu
147 if( STATUS_LED[index_led] == LED_ON ){
148 [Link](“Nyalakan LED 4”);
149 } else {
150 [Link](“Matikan LED 4”);
151 }
152 break;
153
154 case TOMBOL5:
155 // proses sesuatu
156 if( STATUS_LED[index_led] == LED_ON ){
157 [Link](“Nyalakan LED 5”);
158 } else {
159 [Link](“Matikan LED 5”);
160 }
161 break;
162
163 }
164 // hidup matikan led, sesuai status led
165 digitalWrite(PIN_LED[index_led],STATUS_LED[index_led]);
166 }

Setelah Kalian mempelajari dan memahami cara kerja Program terakhir dari Bab ini, mari lanjut mem-
pelajari EEPROM. EEPROM bisa kita gunakan untuk menyimpan data-data aplikasi yang sifatnya tidak boleh
berubah ketika Arduino mati atau restart.
EEPROM SEBAGAI BLACKBOX

Secara singkat EEPROM bisa diibaratkan sebagai hardisk internal pada Arduino. Data yang disimpan dalam
EEPROM tidak akan hilang meski Arduino dimatikan. Mungkin Anda pernah menghadapi masalah tentang-
konfigurasi atau settingan Arduino yang hilang setelah Arduino restart atau mati. Kita ambil contoh Program
5 Tombol 5 Led pada bab sebelumnya.

Pada program 5 Tombol 5 Led, ketika beberapa LED kita hidupkan, lalu Arduino kita reset, maka led yang
tadinya hidup akan kembali ke kondisi awal, yaitu semua LED tidak menyala. Untuk menyimpan LED status
LED nyala atau tidak, kita bisa menyimpan informasi tersebut pada EEPROM. Apabila terjadi kegagalan sis-
tem, maka Arduino tidak akan kehilangan data meskipun Arduino restart berulang-ulang. Itulah kenapa judul
pada bab ini kita namakan BlackBox.

Beberapa hal yang harus dipahami tentang EEPROM:

1. Ketahui kapasitas EEPROM, beda Arduino bisa jadi beda kapasitasnya. Anda boleh cek di pengenalan
jenis-jenis Arduino.
2. Jika data pada alamat EEPROM belum pernah digunakan untuk menyimpan data, data defaultnya
adalah 255.
3. Setiap alamat EEPROM hanya bisa menyimpan tipe data byte, yaitu dari 0 – 255. Jika ingin menyimpan
data lebih dari 255, Anda harus memecahnya ke dalam beberapa alamat.
4. Library yang harus di-include adalah EEPROM.h yang sudah ada di Arduino IDE
5. Cara menyimpan ke EEPROM menggunakan perintah [Link](alamat,data);
6. Cata membaca data dari EEPROM menggunakan perintah [Link](alamat);

Mari kita membuat program counter sederhana. Jika arduino baru start atau restart, maka counter tidak
mengulang dari depan lagi, tapi melanjutkan counter sebelumnya. Membuat sistem yang seperti ini dapat
dilakukan dengan bantuan EEPROM. Mari kita praktek…

Program ini tidak membutuhkan rangkaian khusus karena kita hanya simulasi dengan counter dan EE-
PROM yang sudah ada di internal Arduino. Jika Anda baru saja mencoba rangkaian lain, biarkan saja rangka-
ian tersebut karena tidak akan mempengaruhi program.
Program Simulasi EEPROM

1 /*
2 * INTERACTIVE ROBOTICS
3 * Program Simulasi EEPROM
4 */
5
6 // import library EEPROM
7 #include <EEPROM.h>
8
9 // pilih adrress 0 untuk menyimpan data
10 const byte ADDR_COUNTER = 0;
11
12 // nilai maksimum counter
13 const byte counter_max = 100;
14
15 void setup() {
16 // buka koneksi ke serial
17 [Link](19200);
18 while(!Serial);
19
20 // print tulisan Starting saat mulai start
21 [Link](“Starting...”);
22 }
23
24 void loop() {
25 // gunakan nonblocking_delay
26 // untuk delay responsive
27 if ( nonblocking_delay(1000) ){
28
29 // eksekusi fungsi untuk membaca
30 // dan menyimpan data dalam EEPROM
31 byte data = ReadSaveCounter();
32
33 // cetak counter di serial monitor
34 [Link](“Counter : “);
35 [Link](data);
36 }
37
38 }
39
40 // fungsi untuk baca-tulis data ke EEPROM
41 // INPUT : -
42 // OUTPUT : byte data counter
43 byte ReadSaveCounter(){
44
45 // baca alamat 0 pada EEPROM
46 byte counter = [Link]( ADDR_COUNTER );
47 // data yang diperoleh dari EEPROM tambah 1
48 // jika hasil counter > nilai maksimum counter
49 // reset counter ke 0
50 counter++;
51 if (counter > counter_max) counter = 0;
52
53 // simpan lagi data yang telah dimodifikasi
54 [Link](ADDR_COUNTER, counter);
55
56 // return data
57 return counter;
58 }
59
60 // tambahan untuk membuat delay non blocking
61 unsigned long nonblocking_time = millis();
62 unsigned long nonblocking_last = millis();
63 boolean nonblocking_delay(long milidetik){
64 nonblocking_time = millis();
65 if(nonblocking_time - nonblocking_last >= milidetik){
66 nonblocking_last = nonblocking_time;
67 return true;
68 }
69 }
70 return false;
71 }
Output program simulasi EEPROM

Cara kerja program Simulasi EEPROM adalah:

1. Untuk menggunaan EEPROM, kita harus import library EEPROM.h pada baris 8.
2. Alamat EEPROM untuk menyimpan data counter adalah di alamat 0 (lihat baris 11).
3. Setiap arduino mulai start atau restart, kan muncul tulisan “Starting…” di serial monitor (lihat baris 21).
4. Proses baca tulis EEPROM dilakukan setiap 1 detik (1000 ms), nilai ini dimasukkan ke fungsi
nonblockin_delay() (lihat baris 29).
5. Setiap 1 detik, arduino akan menjalankan fungsi ReadSaveCounter() (lihat baris 31).
6. Arduino membaca data sebelumnya pada alamat 0 (lihat baris 48), apabila data nilainya lebih besar
dari nilai maksimum counter, reset counter menjadi 0. Jika tidak, data tersebut adalah data yang
terakhir disimpan.

Ouput program menunjukkan bahwa setiap program restart, data counter langsung dilanjut berdasarkan
data yang disimpan pada EEPROM. Selanjutnya mari kita membuat program 5 Tombol 5 LED dapat menyim-
pan status LED. Sehingga ketika Arduino aktif, status LED akan disesuaikan dengan kondisi status LED sebel-
umnya.
Program EEPROM 5 Tombol 5 LED

1 /*
2 * INTERACTIVE ROBOTICS
3 * Program Simulasi EEPROM
4 */
5
6 // import library EEPROM
7 # <EEPROM.h>
8
9 // led diset active high
10 #define LED_ON HIGH
11 #define LED_OFF !LED_ON
12
13 // definisikan 5 tombol
14 #define TOMBOL_NONE 0
15 #define TOMBOL1 1
16 #define TOMBOL2 2
17 #define TOMBOL3 3
18 #define TOMBOL4 4
19 #define TOMBOL5 5
20
21 // output tombol di pin A0
22 // pin led di pin 2 - 6
23 const byte PIN_TOMBOL = A0;
24 const byte PIN_LED[] = {2,3,4,5,6};
25
26 // alamat EEPROM untuk data LED
27 const byte ADDR_LED[] = {0,1,2,3,4};
28
29 // nilai data tombol sesuai tabel
30 // dan nilai toleransi 15
31 const int TOMBOL_VAL[] = {200,250,338,507,1014};
32 const byte TOLERANSI = 15;
33
34 // status led untuk lock status
35 byte STATUS_LED[] = {LED_OFF,LED_OFF,LED_OFF,LED_OFF,LED_OFF};
36
37 // tombol dalam array
38 const byte TOMBOL[] = {
39 TOMBOL1, TOMBOL2, TOMBOL3,
40 TOMBOL4, TOMBOL5 };
41
42 // tombol saat ini dan tombol sebelumnya
43 byte tombol = 0;
44 byte tombol_last = 0;
45
46 // data saat ini dan data sebelumnya
47 int data = 0;
48 int data_last = 0;
49
50 // delay untuk penekanan tombol
51 unsigned long delay_press = 400; // dalam ms
52 unsigned long delay_press_last = 0;
53
54 void setup() {
55 // buka koneksi ke serial
56 [Link](19200);
57 while(!Serial);
58
59 // tombol sebagai input
60 pinMode(PIN_TOMBOL,INPUT);
61
62 // pin sebagai output, defaultnya OFF
63 for(byte i=0; i<sizeof(PIN_LED); i++){
64 pinMode(PIN_LED[i],OUTPUT);
65 digitalWrite(PIN_LED[i],LED_OFF);
66 }
67
68 // panggil fungsi PrepareLED
69 // untuk mengetahui status led sebelumnya
70 PrepareLED();
71
72 }
73
74 void loop() {
75 // panggil fungsi utk membaca tombol
76 TombolListener();
77 }
78
79 void TombolListener(){
80
81 // jika selisih waktu penekanan tombol
82 // lebih besar dari waktu delay tombol
83 // baca tombol lagi, jika tidak tombol tdk dibaca
84 if( millis() - delay_press_last > delay_press ){
85
86 // baca data analog tombol
87 data = analogRead(PIN_TOMBOL);
88 // reset tombol sebelumnya
89 tombol = TOMBOL_NONE;
90 // cocokkan data dengan ke-5 data tombol
91 for(byte i=0; i<sizeof(TOMBOL); i++){
92 // hitung koreksi data tombol
93 // jika ada yang cocok,
94 // catat tombol yang sesuai, lalu
95 // hentikan looping.
96 if( abs(data - TOMBOL_VAL[i]) < TOLERANSI ){
97 tombol = TOMBOL[i];
98 break;
99 }
100 }
101
102 // jika ada tombol yang cocok
103 // cetak tombol, panggil aksi tombol
104 // lalu catat waktu pembacaan tombol
105 if(tombol != TOMBOL_NONE){
106 [Link](tombol);
107
108 AksiTombol(tombol);
109
110 tombol_last = tombol;
111 delay_press_last = millis();
112 }
113 }
114 }
115
116 // fungsi AksiTombol
117 // INPUT : byte tombol
118 void AksiTombol(byte tombol){
119
120 // konversi dari nomer tombol menjadi index tombol
121 byte index_led = tombol-1;
122
123 // balik status LED sesuai index/led yang cocok
124 // jika HIGH, ubah jadi LOW, dan sebaliknya
125 STATUS_LED[index_led] = !STATUS_LED[index_led];
126
127 // cetak sesuai tombol yang terpilih
128 switch(tombol){
129 case TOMBOL1:
130 // proses sesuatu
131 if( STATUS_LED[index_led] == LED_ON ){
132 [Link](“Nyalakan LED 1”);
133 } else {
134 [Link](“Matikan LED 1”);
135 }
136 break;
137
138 case TOMBOL2:
139 // proses sesuatu
140 if( STATUS_LED[index_led] == LED_ON ){
141 [Link](“Nyalakan LED 2”);
142 } else {
143 [Link](“Matikan LED 2”);
144 }
145 break;
146
147 case TOMBOL3:
148 // proses sesuatu
149 if( STATUS_LED[index_led] == LED_ON ){
150 [Link](“Nyalakan LED 3”);
151 } else {
152 [Link](“Matikan LED 3”);
153 }
154 break;
155
156 case TOMBOL4:
157 // proses sesuatu
158 if( STATUS_LED[index_led] == LED_ON ){
159 [Link](“Nyalakan LED 4”);
160 } else {
161 [Link](“Matikan LED 4”);
162 }
163 break;
164
165 case TOMBOL5:
166 // proses sesuatu
167 if( STATUS_LED[index_led] == LED_ON ){
168 [Link](“Nyalakan LED 5”);
169 } else {
170 [Link](“Matikan LED 5”);
171 }
172 break;
173 }
174
175 // hidup matikan led, sesuai status led
176 digitalWrite(PIN_LED[index_led],STATUS_LED[index_led]);
177 // simpan status led pada EEPROM sesuai alamat
178 [Link](ADDR_LED[index_led],STATUS_LED[index_led]);
179 }
180
181 // fungsi PrepareLED
182 // untuk membaca data EEPROM saat awal start
183 void PrepareLED(){
184 for(byte i=0; i<sizeof(ADDR_LED); i++){
185 // baca alamat EEPROM ke i
186 STATUS_LED[i] = [Link](ADDR_LED[i]);
187 // status led adalah boolean 0 atau 1
188 // jika data yg tersimpan > 1, reset ke 0
189 if(STATUS_LED[i] > 1) STATUS_LED[i] = 0;
190 // kondisikan LED sesuai data yg tersimpan
191 digitalWrite(PIN_LED[i],STATUS_LED[i]);
192 }
193 }

Cara kerja program ini seperti Program 5 Tombol 5 LED, yang membedakannya adalah proses penyim-
panan status LED di EEPROM (lihat baris 180). Selain itu, ketika program mulai start, maka program akan
membaca status LED sebelumnya di memori dengan fungsi PrepareLED (lihat baris 70). Fungsi PrepareLED()
ada di baris 183 – 193, sedangkan baris untuk membaca data di EEPROM ada di baris 186.

SELAMAT MENCOBA ^_^

SEMANGAT!!!

*Setelah materi ini dipelajari jangan lupa untuk terus di pelajari/diulang dirumah dengan alat asli/simulator.
karena sebelum kelas di mulai di pertemuan selanjutnya, akan ada rivew atau test singkat oleh Trainer...
HEHEHEHE.... Terus Semangat ‘-’)9
 Anda pasti pernah lihat display seven segment, entah di pom bensin, kalku-
lator generasi lama, atau perangkat elektronika yang menampilkan angka
dalam bentuk kotak. Display seven segment terdiri dari 7 buah lampu LED
yang bisa menampilkan angka, dan kadang ada tambahan 1 LED sebagai titik
di pojok bawah.

Sebelum kita lanjut membuat rangkaian dan program, ada baiknya kita pa-
hami dulu tentang tipe seven segmen yang biasa kita temui. Jangan sampai
salah pilih. Tipe seven segment yang penulis maksud adalah tipe Common
Cathode dan Common Anode. Cathode atau Katoda, adalah istilah lain dari
GND (ground).

Secara umum, LED pada seven segment diberi label A, B, C, D, E, F, G, dan DP. Semua segment LED te
hubung menjadi satu pada salah satu sisinya. Jika yang terhubung jadi satu adalah kaki positif, maka disebut
dengan Common Anode (CA). Jika yang terhubung jadi satu adalah kaki negatifnya, maka disebut dengan
Common Cathode (CC). Kalian boleh memperhatikan dengan seksama gabar di bawah ini.
Rangkaian Seven Segment 1 Digit

Peralatan dan rangkaian yang harus disiapkan adalah:

1. Arduino x 1
2. Display 7 Segment 1 Digit CC x 1
3. Resistor 1k x 1
4. Project Board x 1
5. Kabel jumper secukupnya

Sambungan pin Arduino dan display 7 segment yaitu :

 Rangkaian tersubut menunjukkan bahwa seven segment yang dipakai adalah Common Cathode (CC),
sebab kaki tengah dihubungkan ke GND. Pada rangkaian tersebut, kita mencoba menggunakan resistor di pin
common-nya. Sebenarnya penggunaan resistor yang seperti itu akan berpengaruh pada tingkat kecerahan
LED nya. Pengaruhnya adalah ketika menampilkan angka 1 akan lebih cerah daripada ketika menampilkan
angka 8. Kenapa? Sebab arus pada masing-masing LED dipakai bersama. Akan berbeda hasilnya apabila kita
menggunakan resistornya di masing-masing segment A, B, C, D, E, F, G, dan DP. Tetapi Untuk performa ter-
baik, gunakan resistor di masing-masing segment, ya.

Program Seven Segment 1 Digit

1 /*
2 * INTERACTIVE ROBOTICS
3 * Program Seven Segment 1 Digit
4 */
5
6 // definisikan CC, CA, ON, dan Brightness
7 #define COMMON_ANODE HIGH
8 #define COMMON_CATHODE LOW
9 #define ON HIGH
10 #define BRIGHTNESS 100
11
12 // konfigurasi seven segment CC
13 // CC : active low
14 boolean COMMON = COMMON_CATHODE;
15 boolean SEGMENT_ON = LOW;
16 boolean SEGMENT_OFF = !SEGMENT_ON;
17
18 // pin 2-9 untuk segmen A – DP
19 const byte SegA = 2; // A
20 const byte SegB = 3; // B
21 const byte SegC = 4; // C
22 const byte SegD = 5; // D
23 const byte SegE = 6; // E
24 const byte SegF = 7; // F
25 const byte SegG = 8; // G
26 const byte SegDp = 9; // DP
27 // jadikan array biar mudah
28 const byte SEGMENT[] = {SegA, SegB, SegC, SegD, SegE, SegF, SegG,
29 SegDp};
30
31 // pengaturan untuk brightness
32 unsigned long brightness_now = 0;
33 unsigned long brightness_last = 0;
34 unsigned long brightness_limit = 0;
35
36 // data counter untuk ditampilkan
37 byte counter = 0;
38
39 void setup() {
40 // sesuaikan active low/high
41 // dengan tipe Common Anode atau Common Cathode
42 if( COMMON == COMMON_ANODE ){
43 SEGMENT_ON = !ON;
44 } else {
45 SEGMENT_ON = ON;
46 }
47 SEGMENT_OFF = !SEGMENT_ON;
48
49 // set segment sebagai output
50 for(byte i=0; i<sizeof(SEGMENT); i++){
51 pinMode(SEGMENT[i],OUTPUT);
52 }
53 }
54
55 void loop() {
56 // counter data setiap 1 detik
57 // jika lebih besar dr 9, reset ke 0
58 if( nonblocking_delay(1000) ){
59 counter++;
60 if(counter > 9) counter = 0;
61 }
62
63 // tampilkan angka di seven segment
64 Digit(counter, SEGMENT_OFF, BRIGHTNESS);
65 }
66
67 // fungsi Digit
68 // untuk menampilkan angka pada seven segment
69 void Digit(byte data, boolean dp, int brightness){
70
71 // delay nyala segment, efeknya pada brigthness
72 brightness_limit = constrain(brightness,1,100);
73 brightness_limit = map(brightness_limit,1,100,1,5000);
74
75 brightness_now = micros();
76 if(brightness_now – brightness_last < brightness_limit){
77 // nyalakan 7 segmen sesuai angka
78 switch(data){
79 case 0:
80 digitalWrite(SegA, SEGMENT_ON);
81 digitalWrite(SegB, SEGMENT_ON);
82 digitalWrite(SegC, SEGMENT_ON);
83 digitalWrite(SegD, SEGMENT_ON);
84 digitalWrite(SegE, SEGMENT_ON);
85 digitalWrite(SegF, SEGMENT_ON);
86 digitalWrite(SegG, SEGMENT_OFF);
87 digitalWrite(SegDp, dp);
88 break;
89
90 case 1:
91 digitalWrite(SegA, SEGMENT_OFF);
92 digitalWrite(SegB, SEGMENT_ON);
93 digitalWrite(SegC, SEGMENT_ON);
94 digitalWrite(SegD, SEGMENT_OFF);
95 digitalWrite(SegE, SEGMENT_OFF);
96 digitalWrite(SegF, SEGMENT_OFF);
97 digitalWrite(SegG, SEGMENT_OFF);
98 digitalWrite(SegDp, dp);
99 break;
100
101 case 2:
102 digitalWrite(SegA, SEGMENT_ON);
103 digitalWrite(SegB, SEGMENT_ON);
104 digitalWrite(SegC, SEGMENT_OFF);
105 digitalWrite(SegD, SEGMENT_ON);
106 digitalWrite(SegE, SEGMENT_ON);
107 digitalWrite(SegF, SEGMENT_OFF);
108 digitalWrite(SegG, SEGMENT_ON);
109 digitalWrite(SegDp, dp);
110 break;
111
112 case 3:
113 digitalWrite(SegA, SEGMENT_ON);
114 digitalWrite(SegB, SEGMENT_ON);
115 digitalWrite(SegC, SEGMENT_ON);
116 digitalWrite(SegD, SEGMENT_ON);
117 digitalWrite(SegE, SEGMENT_OFF);
118 digitalWrite(SegF, SEGMENT_OFF);
119 digitalWrite(SegG, SEGMENT_ON);
120 digitalWrite(SegDp, dp);
121 break;
122
123 case 4:
124 digitalWrite(SegA, SEGMENT_OFF);
125 digitalWrite(SegB, SEGMENT_ON);
126 digitalWrite(SegC, SEGMENT_ON);
127 digitalWrite(SegD, SEGMENT_OFF);
128 digitalWrite(SegE, SEGMENT_OFF);
129 digitalWrite(SegF, SEGMENT_ON);
130 digitalWrite(SegG, SEGMENT_ON);
131 digitalWrite(SegDp, dp);
132 break;
133
134 case 5:
135 digitalWrite(SegA, SEGMENT_ON);
136 digitalWrite(SegB, SEGMENT_OFF);
137 digitalWrite(SegC, SEGMENT_ON);
138 digitalWrite(SegD, SEGMENT_ON);
139 digitalWrite(SegE, SEGMENT_OFF);
140 digitalWrite(SegF, SEGMENT_ON);
141 digitalWrite(SegG, SEGMENT_ON);
142 digitalWrite(SegDp, dp);
143 break;
144
145 case 6:
146 digitalWrite(SegA, SEGMENT_ON);
147 digitalWrite(SegB, SEGMENT_OFF);
148 digitalWrite(SegC, SEGMENT_ON);
149 digitalWrite(SegD, SEGMENT_ON);
150 digitalWrite(SegE, SEGMENT_ON);
151 digitalWrite(SegF, SEGMENT_ON);
152 digitalWrite(SegG, SEGMENT_ON);
153 digitalWrite(SegDp, dp);
154 break;
155
156 case 7:
157 digitalWrite(SegA, SEGMENT_ON);
158 digitalWrite(SegB, SEGMENT_ON);
159 digitalWrite(SegC, SEGMENT_ON);
160 digitalWrite(SegD, SEGMENT_OFF);
161 digitalWrite(SegE, SEGMENT_OFF);
162 digitalWrite(SegF, SEGMENT_OFF);
163 digitalWrite(SegG, SEGMENT_OFF);
164 digitalWrite(SegDp, dp);
165 break;
166
167 case 8:
168 digitalWrite(SegA, SEGMENT_ON);
169 digitalWrite(SegB, SEGMENT_ON);
170 digitalWrite(SegC, SEGMENT_ON);
171 digitalWrite(SegD, SEGMENT_ON);
172 digitalWrite(SegE, SEGMENT_ON);
173 digitalWrite(SegF, SEGMENT_ON);
174 digitalWrite(SegG, SEGMENT_ON);
175 digitalWrite(SegDp, dp);
176 break;
177
178 case 9:
179 digitalWrite(SegA, SEGMENT_ON);
180 digitalWrite(SegB, SEGMENT_ON);
181 digitalWrite(SegC, SEGMENT_ON);
182 digitalWrite(SegD, SEGMENT_ON);
183 digitalWrite(SegE, SEGMENT_OFF);
184 digitalWrite(SegF, SEGMENT_ON);
185 digitalWrite(SegG, SEGMENT_ON);
186 digitalWrite(SegDp, dp);
187 break;
188 }
189
190 }else{
191 // matikan semua 7 segment
192 for(byte d=0; d<sizeof(SEGMENT); d++){
193 digitalWrite(SEGMENT[d], SEGMENT_OFF);
194 }
195 brightness_last = brightness_now;
196 }
197 }
198 // tambahan untuk membuat delay non blocking
199 unsigned long nonblocking_time = millis();
200 unsigned long nonblocking_last = millis();
201 boolean nonblocking_delay(long milidetik){
202 nonblocking_time = millis();
203 if(nonblocking_time – nonblocking_last >= milidetik){
204 nonblocking_last = nonblocking_time;
205 return true;
206 }
207 return false;
208 }

Cara kerja program di atas adalah :

1. Pilih jenis seven segment, apakah CC atau CA (lihat baris 14 – 15). Beda tipe beda cara mengaktifkan
seven segment (lihat bari s 42 – 47).
2. Set semua segment sebagai output (lihat baris 51)
3. Data pada variabel counter akan berubah setiap detik dengan delay responsive (lihat baris 58)
4. Angka yang akan ditampilkan dari 0 – 9, jika data counter > 9, maka reset ke 0 lagi (lihat baris 60).
5. Menampilkan angka dengan fungsi Digit (angka,dp,kecerahan). Angka adalah angka yang ditampilkan,
dp adalah logika untuk titik (segment DP), dan kecerahan adalah angka untuk tingkat kecerahan LED
(lihat baris 64).
6. Dalam fungsi Digit(), masing-masing angka punya cara tersendiri untuk menampilkannya. Contohnya be
gini, jika kita ingin menampilkan angka 1, maka segmen yang harus nyala adalah segment B dan C. Degan
demikian, hanya segmen B dan C yang dinyalakan (lihat baris 91 – 99). Untuk menampilkan angka yang
lain, maka segment yang harus dinyalakan juga berbeda.

7. Brightness terkait dengan berapa lama waktu LED segment nyala dan mati. Anda bisa mengamati baris
76 untuk pengecekan lama segment nyala dan baris 192 – 193 untuk segment OFF seluruhnya. Silakan
coba ubah-ubah angkanya supaya Anda bisa bisa memahaminya lebih baik.
Seven Segment 4 Digit

Seven segment 4 digit memiliki 12 kaki. 8 kaki untuk segment, dan 4 untuk digit D1, D2, D3, dan D4. Cara
kerjanya sama dengan seven segment 1 digit. Hanya saja, untuk menampilkan angka di semua digit, kita
harus melakukan scanning untuk setiap digit. Jadi ke-4 digit harus gantian nyala.

Rangkaian Seven Segment 4 Digit

Peralatan dan rangkaian yang perlu disiapkan :

1. Arduino x 1
2. Display 7 Segment 4 Digit CC x 1
3. Project board x 1
4. Resistor dengan nilai yang seragam x 4
5. Kabel jumper secukupnya
Rangkaian pin Arduino dan 7 segment 4 digit :
Program Seven Segment 4 Digit

1 /*
2 * INTERACTIVE ROBOTICS
3 * Program Seven Segment 4 Digit
4 */
5
6 // definisikan CC, CA, ON, dan Brightness
7 #define COMMON_ANODE HIGH
8 #define COMMON_CATHODE LOW
9 #define ON HIGH
10 #define BRIGHTNESS 100
11
12 // konfigurasi seven segment CC
13 // CC : active low
14 boolean COMMON = COMMON_CATHODE;
15 boolean SEGMENT_ON = LOW;
16 boolean SEGMENT_OFF = !SEGMENT_ON;
17 boolean DIGIT_ON = HIGH;
18 boolean DIGIT_OFF = !DIGIT_ON;
19
20 // pin 2-9 untuk segmen A - DP
21 const byte SegA = 2; // A
22 const byte SegB = 3; // B
23 const byte SegC = 4; // C
24 const byte SegD = 5; // D
25 const byte SegE = 6; // E
26 const byte SegF = 7; // F
27 const byte SegG = 8; // G
28 const byte SegDp = 9; // DP
29
30 // pin A0-A3 untuk digit 1-4
31 const byte Digit1 = A0;
32 const byte Digit2 = A1;
33 const byte Digit3 = A2;
34 const byte Digit4 = A3;
35
36 // jadikan array biar mudah
37 const byte SEGMENT[] = {SegA, SegB, SegC, SegD, SegE, SegF, SegG,
38 SegDp};
39 const byte DIGIT[] = {Digit1, Digit2, Digit3, Digit4};
40 // digit terpilih - 0 dari digit satuan (kanan)
41 byte DIGIT_SELECT = 0;
42
43 // pengaturan untuk brightness
44 unsigned long brightness_now = 0;
45 unsigned long brightness_last = 0;
46 unsigned long brightness_limit = 0;
47
48 // counter dari -50
49 int counter = -50;
50
51 // string angka
52 String str_data_last = “”;
53
54 void setup() {
55
56 // sesuaikan active low/high
57 // dengan tipe Common Anode atau Common Cathode
58 if( COMMON == COMMON_ANODE ){
59 SEGMENT_ON = !ON;
60 DIGIT_ON = ON;
61 } else {
62 SEGMENT_ON = ON;
63 DIGIT_ON = !ON;
64 }
65 SEGMENT_OFF = !SEGMENT_ON;
66 DIGIT_OFF = !DIGIT_ON;
67
68 // set pin segment sebagai output
69 for(byte i=0; i<sizeof(SEGMENT); i++){
70 pinMode(SEGMENT[i],OUTPUT);
71 }
72 }
73
74 void loop() {
75
76 // counter data setiap 100 ms
77 // jika lebih besar dr 200, reset ke -50
78 if( nonblocking_delay(100) ){
79 counter++;
80 if(counter > 200) counter = -50;
81 }
82
83 // tampilkan angka di seven segment
84 Digit(counter, SEGMENT_OFF, BRIGHTNESS);
85
86 }
87
88 void Digit(int data, boolean dp, int brightness){
89
90 // delay nyala segment, efeknya pada brigthness
91 brightness_limit = constrain(brightness,1,100);
92 brightness_limit = map(brightness_limit,1,100,1,5000);
93
94 // konversi angka menjadi string
95 // lalu cek lebar angkannya
96 String str_data = String(data);
97 byte len_data = str_data.length();
98
99 brightness_now = micros();
100 if(brightness_now - brightness_last < brightness_limit){
101
102 // replace data sesuai digit yang terpilih
103 if( DIGIT_SELECT < len_data ){
104
105 // jika data < 0, berarti ada tanda - di depan
106 if( data < 0 && DIGIT_SELECT == 0){
107 data = ‘-’;
108 } else {
109 // ambil data sesuai index digitnya
110 data = (str_data.substring(DIGIT_SELECT,DIGIT_SELECT+1)).toInt();
111 }
112
113 // nyalakan digit yang terpilih
114 digitalWrite(DIGIT[DIGIT_SELECT],DIGIT_ON);
115 }
116
117 // nyalakan 7 segmen sesuai angka
118 switch(data){
119 case 0:
120 digitalWrite(SegA, SEGMENT_ON);
121 digitalWrite(SegB, SEGMENT_ON);
122 digitalWrite(SegC, SEGMENT_ON);
123 digitalWrite(SegD, SEGMENT_ON);
124 digitalWrite(SegE, SEGMENT_ON);
125 digitalWrite(SegF, SEGMENT_ON);
126 digitalWrite(SegG, SEGMENT_OFF);
127 digitalWrite(SegDp, dp);
128 break;
129
130 case 1:
131 digitalWrite(SegA, SEGMENT_OFF);
132 digitalWrite(SegB, SEGMENT_ON);
133 digitalWrite(SegC, SEGMENT_ON);
134 digitalWrite(SegD, SEGMENT_OFF);
135 digitalWrite(SegE, SEGMENT_OFF);
136 digitalWrite(SegF, SEGMENT_OFF);
137 digitalWrite(SegG, SEGMENT_OFF);
138 digitalWrite(SegDp, dp);
139 break;
140
141 case 2:
142 digitalWrite(SegA, SEGMENT_ON);
143 digitalWrite(SegB, SEGMENT_ON);
144 digitalWrite(SegC, SEGMENT_OFF);
145 digitalWrite(SegD, SEGMENT_ON);
146 digitalWrite(SegE, SEGMENT_ON);
147 digitalWrite(SegF, SEGMENT_OFF);
148 digitalWrite(SegG, SEGMENT_ON);
149 digitalWrite(SegDp, dp);
150 break;
151
152 case 3:
153 digitalWrite(SegA, SEGMENT_ON);
154 digitalWrite(SegB, SEGMENT_ON);
155 digitalWrite(SegC, SEGMENT_ON);
156 digitalWrite(SegD, SEGMENT_ON);
157 digitalWrite(SegE, SEGMENT_OFF);
158 digitalWrite(SegF, SEGMENT_OFF);
159 digitalWrite(SegG, SEGMENT_ON);
160 digitalWrite(SegDp, dp);
161 break;
162
163 case 4:
164 digitalWrite(SegA, SEGMENT_OFF);
165 digitalWrite(SegB, SEGMENT_ON);
166 digitalWrite(SegC, SEGMENT_ON);
167 digitalWrite(SegD, SEGMENT_OFF);
168 digitalWrite(SegE, SEGMENT_OFF);
169 digitalWrite(SegF, SEGMENT_ON);
170 digitalWrite(SegG, SEGMENT_ON);
171 digitalWrite(SegDp, dp);
172 break;
173
174 case 5:
175 digitalWrite(SegA, SEGMENT_ON);
176 digitalWrite(SegB, SEGMENT_OFF);
177 digitalWrite(SegC, SEGMENT_ON);
178 digitalWrite(SegD, SEGMENT_ON);
179 digitalWrite(SegE, SEGMENT_OFF);
180 digitalWrite(SegF, SEGMENT_ON);
181 digitalWrite(SegG, SEGMENT_ON);
182 digitalWrite(SegDp, dp);
183 break;
184
185 case 6:
186 digitalWrite(SegA, SEGMENT_ON);
187 digitalWrite(SegB, SEGMENT_OFF);
188 digitalWrite(SegC, SEGMENT_ON);
189 digitalWrite(SegD, SEGMENT_ON);
190 digitalWrite(SegE, SEGMENT_ON);
191 digitalWrite(SegF, SEGMENT_ON);
192 digitalWrite(SegG, SEGMENT_ON);
193 digitalWrite(SegDp, dp);
194 break;
195
196 case 7:
197 digitalWrite(SegA, SEGMENT_ON);
198 digitalWrite(SegB, SEGMENT_ON);
199 digitalWrite(SegC, SEGMENT_ON);
200 digitalWrite(SegD, SEGMENT_OFF);
201 digitalWrite(SegE, SEGMENT_OFF);
202 digitalWrite(SegF, SEGMENT_OFF);
203 digitalWrite(SegG, SEGMENT_OFF);
204 digitalWrite(SegDp, dp);
205 break;
206
207 case 8:
208 digitalWrite(SegA, SEGMENT_ON);
209 digitalWrite(SegB, SEGMENT_ON);
210 digitalWrite(SegC, SEGMENT_ON);
211 digitalWrite(SegD, SEGMENT_ON);
212 digitalWrite(SegE, SEGMENT_ON);
213 digitalWrite(SegF, SEGMENT_ON);
214 digitalWrite(SegG, SEGMENT_ON);
215 digitalWrite(SegDp, dp);
216 break;
217
218 case 9:
219 digitalWrite(SegA, SEGMENT_ON);
220 digitalWrite(SegB, SEGMENT_ON);
221 digitalWrite(SegC, SEGMENT_ON);
222 digitalWrite(SegD, SEGMENT_ON);
223 digitalWrite(SegE, SEGMENT_OFF);
224 digitalWrite(SegF, SEGMENT_ON);
225 digitalWrite(SegG, SEGMENT_ON);
226 digitalWrite(SegDp, dp);
227 break;
228
229 case ‘-’:
230 digitalWrite(SegA, SEGMENT_OFF);
231 digitalWrite(SegB, SEGMENT_OFF);
232 digitalWrite(SegC, SEGMENT_OFF);
233 digitalWrite(SegD, SEGMENT_OFF);
234 digitalWrite(SegE, SEGMENT_OFF);
235 digitalWrite(SegF, SEGMENT_OFF);
236 digitalWrite(SegG, SEGMENT_ON);
237 digitalWrite(SegDp, dp);
238 break;
239
240 }
241 }else{
242 // matikan semua digit
243 for(byte d=0; d<sizeof(DIGIT); d++){
244 digitalWrite(DIGIT[d], DIGIT_OFF);
245 }
246
247 // matikan semua segment
248 for(byte d=0; d<sizeof(SEGMENT); d++){
249 digitalWrite(SEGMENT[d], SEGMENT_OFF);
250 }
251
252 // lanjut ke digit berikutnya
253 DIGIT_SELECT++;
254 // jika semua digit sudah ditampilkan, reset ke 0
255 if( DIGIT_SELECT >= len_data) DIGIT_SELECT = 0;
256
257 brightness_last = brightness_now;
258 }
259 }
260
261 // tambahan untuk membuat delay non blocking
262 unsigned long nonblocking_time = millis();
263 unsigned long nonblocking_last = millis();
264 boolean nonblocking_delay(long milidetik){
265 nonblocking_time = millis();
266 if(nonblocking_time - nonblocking_last >= milidetik){
267 nonblocking_last = nonblocking_time;
268 return true;
269 }
270 return false;
271 }

Program ini masih menggunakan contoh counter, namun counternya dari -50 hingga 200. Cara kerja pro-
gram di atas mirip dengan program seven segment 1 Digit. Yang berbeda adalah :

1. Ada pin digit yang harus diinisialisasi (lihat baris 31 – 34, 39, dan 69 – 71)
2. Untuk menampilkan angka, proses menampilkan angka harus satu-persatu untuk setiap digit yang
terpilih pada variabel DIGIT_SELECT.
3. Karena angka yang ditampilkan lebih dari 1 digit, maka angka akan dikonversi menjadi string
(lihat baris 96), lalu pilih satu-persatu berdasarkan posisi indeksnya dengan cara memecah string angka
tersebut (lihat baris 110). Angka yang terpilih akan dikonversi menjadi angka dan ditampilkan sesuai
angka yang cocok (lihat baris 118 – 238).
4. Untuk menampilkan angka minus, maka data harus dicek apakah < 0 atau tidak (lihat baris 106).
5. Proses pergeseran digit dipilih saat semua segment dimatikan (lihat baris 255).

SELAMAT MENCOBA ^_^

SEMANGAT!!!
*Setelah materi ini dipelajari jangan lupa untuk terus di pelajari/diulang dirumah dengan alat asli/simulator.
karena sebelum kelas di mulai di pertemuan selanjutnya, akan ada rivew atau test singkat oleh Trainer...
HEHEHEHE.... Terus Semangat ‘-’)9
MODUL RELAY
Relay adalah komponen yang dapat digunakan sebagai saklar elektronik. Secara singkat, cara kerja relay ada-
lah memanfaatkan magnet buatan untuk memicu kontaktor dari keadaan off menjadi on, atau sebaliknya.

Ibaratnya begini, jika ingin menghidupkan lampu, kita harus pencet saklar yang nempel di tembok. Tapi jika
menggunakan relay, kita bisa menghidupkan atau mematikan lampu tanpa menyentuh saklar lagi. Relay dise-
but juga sebagai saklar elektronik, yaitu saklar dapat dikontrol dengan alat elektronik lainnya seperti Arduino.

Relay umumnya punya 5 pin atau kaki., yang terdiri dari:

1. Dua kaki untuk listrik + dan GND, jika arus dan tegangannya cukup, maka relay akan aktif yang ditandai
dengan bunyi ‘Tek’.
2. Satu kaki sumber C (common), kaki ini yang akan dihubungkan ke kaki NC atau NO. Jika relay akan
digunakan untuk mengontrol lampu rumah, maka kaki C disambung ke salah satu jalur listrik dari PLN.
3. Kaki NC (Normally Close), sebelum relay aktif, kaki NC nyambung ke kaki C (perhatikan gambar). Tapi kalau
relaynya aktif, kaki NC terputus dari kaki C.
4. Kaki NO (Normally Open), sebelum relay aktif, kaki NO tidak nyambung ke mana-mana. Tapi ketika relay
aktif, kaki NO terhubung ke kaki C.
Sebelum mencoba relay yang sudah dirangkai dalam sebuah modul, istilah yang perlu kita pahami yaitu :
Active Low dan Active High. Active Low artinya, relay akan aktif kalau input diberi logika LOW atau GND. Se-
dangkan Active High artinya, relay akan aktif apabila input diberi logika HIGH atau +5v.

Active Low atau Active High

Relay Active Low atau Active High bisa dicek pad spesifikasi yang telah ditentukan oleh pabriknya. Jika
Anda ragu, Anda bisa cek langsung modul relaynya dengan beberapa komponen dan power supply yang
cocok.

Selain untuk menentukan Active Low atau Active High, cara ini bisa kita gunakan untuk menentukan apa-
kah relay berfungsi dengan baik atau tidak. Untuk relay Active Low, relay akan aktif jika input dihubungkan ke
GND. Jika relay Active High, relay aktif jika input dihubungkan ke VCC.

Namun jika relay tidak merespon ketika diberi input GND atau VCC, pastikan kabel-kabelnya terhubung
dengan benar. Kalau semua sudah benar, tapi tetap tidak ada respon. Kemungkinan besar ada komponen
yang rusak.
Cara Kerja Relay
Relay dapat bekerja karena adanya medan magnet yang digunakan untuk menggerakkan saklar. Saat kump-
aran diberikan tegangan sebesar tegangan kerja relay maka akan timbul medan magnet pada kumparan
karena adanya arus yang mengalir pada lilitan kawat. Kumparan yang bersifat sebagai elektromagnet ini
kemudian akan menarik saklar dari kontak NC ke kontak NO. Jika tegangan pada kumparan dimatikan maka
medan magnet pada kumparan akan hilang sehingga pegas akan menarik saklar ke kontak NC.

Prinsip kerja dari relay ini yaitu: pada C1 dan C2 terdapat kumparan sebagai driver. ketika C1 dan C2 belum
dilewati arus, maka terminal Com dan No akan tersambung, dan ketika C1 dan C2 dilewati arus maka plat
Com akan berpindah sehingga terminal Com dan No akan tersambung.
EXERCISE
Skema Rangkaian.

Setelah meyusun rangkaian seperti pada gambar, buka IDE Arduino dan buat coding berikut :

1 /*
2 * INTERACTIVE ROBOTICS
3 * Program Control Relay dengan Communication Serial
4 */
5
6 int Relay = 10;
7 int deteksi;
8
9 void setup()
10 {
11 pinMode(Relay, OUTPUT);
12 [Link](9600);
13 }
14
15 void loop()
16 {
17 if([Link]() > 0){
18 deteksi = [Link]();
19 }
20
21 // Jika Deteksi bernilai ‘1’ maka Relay menyala
22 if (deteksi == ‘1’) {
23 digitalWrite(Relay, HIGH);
24 }
25
26 else if(deteksi==’2’) {
27 digitalWrite(Relay, LOW);
28 }
29 }

Jika sudah berhasil. Coba kerjakan Challange (Soal Tantangan) berikut :

CHALANGE !
1. Tambahkan Pin Relay yang lain untuk mengontrol lampu lain atau alat elektronik lain.

PERHATIAN..!!!
Jangan Gunakan Langsung terhubung dengan Listrik Tegangan 220 V kalau belum benar-benar faham. Ikuti
Instruksi Trainer / bertanya pada Trainer bila masih kurang paham dalam proses merangkai project

SELAMAT MENCOBA ^_^

SEMANGAT!!!
*Setelah materi ini dipelajari jangan lupa untuk terus di pelajari/diulang dirumah dengan alat asli/simulator.
karena sebelum kelas di mulai di pertemuan selanjutnya, akan ada rivew atau test singkat oleh Trainer...
HEHEHEHE.... Terus Semangat ‘-’)9
 L298 adalah jenis IC driver motor yang dapat mengendalikan arah putaran dan ke-
cepatan motor DC ataupun Motor stepper. Mampu mengeluarkan output tegan-
gan untuk Motor dc dan motor stepper sebesar 5 volt. IC l298 terdiri dari tran-
sistor-transistor logik (TTL) yang memudahkan dalam menentukan arah putaran
suatu motor DC. dan hanya dapat mengendalikan 2 Motor Dc. Penggunaannya
paling sering untuk robot line follower. Bentuknya yang kecil memungkinkan da-
pat meminimalkan pembuatan robot line follower.

Fungsi-fungsi Pin Driver Motor DC IC L298

1. Pin EN (Enable, ENA, ENB) berfungsi untuk mengijinkan driver menerima perintah untuk menggerakkan
motor DC.
2. Pin In (Input, In1, In2,In3, In4) adalah pin input sinyal kendali motor DC.
3. Pin Out (Output, OUT1, OUT2, OUT3, OUT4) adalah jalur output masing-masing driver yang dihubungkan
ke motor DC.
4. Pin VCC (VCC, 5V) adalah jalur input tegangan sumber driver motor DC, dimana VCC adalah jalur input
sumber tegangan rang kaian kontrol dirver dan V5 adalah jalur input sumber tegangan untuk motor DC
yang dikendalikan.
5. Pin GND (Ground) adalah jalur yang harus dihubungkan ke ground.
EXERCISE + CHALANGE :

1. Susun dan rangkai rangkaina Driver Motor tanpa skema namun sesuai dengan keterangan pin yang su-
dah diberikan.

2. Program dengan coding sebagai berikut

1 /*
2 * INTERACTIVE ROBOTICS
3 * Program Control Motor DC L298 IC
4 */
5
6 int motor1Pin1 = 3; // pin In1 Arduino
7 int motor1Pin2 = 4; // pin In2 Arduino
8 int motor2Pin1 = 8; // pin In3 Arduino
9 int motor2Pin2 = 9; // pin In4 Arduino
10 int state;
11 int flag = 0; // Memastikan serial komunikasi hanya mengirim satu
12 perintah
13 int stateStop = 0;
14
15 void setup() {
16
17 // set pin sebagai OOUTPUT
18 pinMode(motor1Pin1, OUTPUT);
19 pinMode(motor1Pin2, OUTPUT);
20 pinMode(motor2Pin1, OUTPUT);
21 pinMode(motor2Pin2, OUTPUT);
22
23 // Menginisialisasi komunikasi serial pada Boud rate 9600
24 [Link](9600);
25 }
26
27 void loop() {
28 // Jika beberapa saat dikirimkan perintah, maka akan membaca dan
29 menyimpan dalam sebuah keadaan tertentu.
30 if([Link]() > 0){
31 state = [Link]();
32 flag=0;
33 }
34
35 // Jika menerima perintah ‘1’ motor DC akan maju
36 if (state == ‘1’) {
37 digitalWrite(motor1Pin1, HIGH);
38 digitalWrite(motor1Pin2, LOW);
39 digitalWrite(motor2Pin1, LOW);
40 digitalWrite(motor2Pin2, HIGH);
41 if(flag == 0){
42 [Link](“MAJUUUU!!!!”);
43 flag=1;
44 }
45 }
46
47 // Jika menerima perintah ‘2’ motor DC akan Belok Kiri
48 else if (state == ‘2’) {
49 digitalWrite(motor1Pin1, HIGH);
50 digitalWrite(motor1Pin2, LOW);
51 digitalWrite(motor2Pin1, LOW);
52 digitalWrite(motor2Pin2, LOW);
53 if(flag == 0){
54 [Link](“BELOK KIRI!!”);
55 flag=1;
56 }
57
58 delay(1500);
59 state=3;
60 stateStop=1;
61 }
62
63 // Jika menerima perintah ‘3’ motor DC akan Berhenti
64 else if (state == ‘3’ || stateStop == 1) {
65 digitalWrite(motor1Pin1, LOW);
66 digitalWrite(motor1Pin2, LOW);
67 digitalWrite(motor2Pin1, LOW);
68 digitalWrite(motor2Pin2, LOW);
69 if(flag == 0){
70 [Link](“BERHENTI!!”);
71 flag=1;
72 }
73 stateStop=0;
74 }
75
76 // Jika menerima perintah ‘4 ‘ motor DC akan Belok Kanan.
77 else if (state == ‘4’) {
78 digitalWrite(motor1Pin1, LOW);
79 digitalWrite(motor1Pin2, LOW);
80 digitalWrite(motor2Pin1, LOW);
81 digitalWrite(motor2Pin2, HIGH);
82 if(flag == 0){
83 [Link](“BELOKKANAN!!”);
84 flag=1;
85 }
86 delay(1500);
87 state=3;
88 stateStop=1;
89 }
90
91 // jika menerima perintah ‘5 ‘ motor DC akan Mundur
92 else if (state == ‘5’) {
93 digitalWrite(motor1Pin1, LOW);
94 digitalWrite(motor1Pin2, HIGH);
95 digitalWrite(motor2Pin1, HIGH);
96 digitalWrite(motor2Pin2, LOW);
97 if(flag == 0){
98 [Link](“MUNDUR!!”);
99 flag=1;
100 }
101 }
 Line Follower Robot – sebuah jenis robot yang termasuk kedalam
kategori robot mobile yang di desain untuk bekerja secara autonomous
dan memiliki kemampuan dapat mendeteksi dan bergerak mengikuti
(follows) garis yang ada di permukaan. Sistem kendali yang digunakan
dirancang untuk bisa merasakan jalur garis yang ada dan melakukan
manuver gerakan agar tetap bisa mengikuti garis tersebut.

Sensor Pada Robot Line Follower

Sensor, dapat dianalogikan sebagai “mata” sebuah robot yang berfungsi untuk membaca garis hitam dari
track robot. Sehingga robot mampu mengetahui kapan dia akan berbelok ke kanan, kapan dia berbelok ke
kiri dan kapan dia berhenti. Sensor yang digunakan adalah sensor cahaya yang dipasang di bagian depan
bawah robot, sehingga mampu mengetahui garis terang dari latar belakang gelap atau sebaliknya. Sensor
yang dipakai biasanya photo reflector,LDR (Light Dependent Resistor), Photo Dioda, dan Photo Transistor –
yang dipasang dua atau lebih dibagian depan bawah robotline follower. Ada juga yang menggunakan kamera
sebagi sensor (atau image sensor) agar resolusi pembacaan garis lebih tinggi, sehingga menjadikan gerakan
robot lebih akurat.

Ketika transmitter (infrared) memancarkan cahaya ke bidang berwarna putih, cahaya akan dipantulkan
hampir semuanya oleh bidang berwarna putih tersebut. Sebaliknya, ketika transmitter memancarkan cahaya
ke bidang berwarna gelap atau hitam, maka cahaya akan banyak diserap oleh bidang gelap tersebut, sehing-
ga cahaya yang sampai ke receiver tinggal sedikit. Nah, artinya kita sudah bisa membedakan pembacaan garis
dari sensor bukan? Kalau kita sudah tahu, perbedaan cahaya yang diterima oleh receiver akan menyebabkan
hambatan yang berbeda-beda di dalam receiver (photo dioda) tersebut. Ilustrasinya seperti gambar di bawah
ini.
Kalau cahaya yang dipancarkan ke bidang putih, sensor akan :

Sebaliknya, kalau cahaya yang dipantulkan oleh bidang hitam, maka sensor akan :
EXERCISE + CHALANGE :
1. Susun/rangkai rangkaian Line Follower Robot dengan Arduino dan coding sesuai instruksi pada modul ini.
Keterangan Rangkaian :

1. Bisa Menggunakan Segala Jenis Arduino (UNO, NANO, MEGA, MINI, dll), karena penomoran pinnya sama.
Tinggal cocokkan Saja nomor Pin-Pin nya.
2. Pin Modul Sensor no. 1 ==> Pin A5 Arduino
3. Pin Modul Sensor no. 2 ==> Pin A4 Arduino
4. Pin Modul Sensor no. 3 ==> Pin A3 Arduino
5. Pin Modul Sensor no. 4 ==> Pin A2 Arduino
6. Pin In1 Driver Motor ==> Pin 7 Arduino
7. Pin In2 Driver Motor ==> Pin 6 Arduino
8. Pin In3 Driver Motor ==> Pin 5 Arduino
9. Pin In4 Driver Motor ==> Pin 4 Arduino
10. Pin ENA-bawah Driver Motor ==> Pin 9 Arduino
11. Pin ENB-bawah Driver Motor ==> Pin 9 Arduino
12. Pin ENA-atas Driver Motor ==> Pin 5V Arduino
13. Pin ENB-atas Driver Motor ==> Pin 5V Arduino
14. OUT1 dan OUT2 Driver Motor ==> Motor 1
15. OUT3 dan OUT4 Driver Motor ==> Motor 2
16. Pin 12V Driver Motor ==> Hubungkan ke baterai
17. Pin GND Driver Motor ==> Hubungkan ke Ground(-) Baterai dan Ground(GND) Arduino
18. Kaki vcc pada masing-masing komponen hubungkan ke sumber power positif 5v (bisa dari 5v Arduino)
19. Kaki gnd/ground pada masing-masing komponen hubungkan ke sumber negatif power (dihubungkan ke
pin gnd Arduino)
CODING :

1 /*
2 * INTERACTIVE ROBOTICS
3 * Program Line Follower Robot 4 sensor
4 */
5
6 // inialisasi pin sensor garis 1 sampai 4
7 // sensor1 dan snsor2 = sensor sebelah kanan
8 // sensor3 dan sensor4 = sensor sebelah kiri
9 const int sensor1 = A5;
10 const int sensor2 = A4;
11 const int sensor3 = A3;
12 const int sensor4 = A2;
13
14 // inialisasi pin motor kanan dan motor kiri
15 // motor1 dan motor2 = motor kanan
16 // motor3 dan motor4 = motor kiri
17 const int motor1 = 7;
18 const int motor2 = 6;
19 const int motor3 = 5;
20 const int motor4 = 4;
21
22 // inialisasi pin speed motor
23 // wajib pin support PWM
24 const int pinSpeed = 9;
25
26 // inialisasi variabel data 1 sampai 4
27 int data1, data2, data3, data4;
28
29 // inialisasi nilai kecepatan motor
30 // range nilai antara 0 sampai 255
31 int speedMotor = 255;
32
33 // ---------- program dfault/setting awal ---------- //
34
35 void setup() {
36 // inialisasi pin motor sebagai output
37 pinMode(motor1, OUTPUT);
38 pinMode(motor2, OUTPUT);
39 pinMode(motor3, OUTPUT);
40 pinMode(motor4, OUTPUT);
41
42 // inialisasi pin sensor sebagai input
43 pinMode(sensor1, INPUT);
44 pinMode(sensor2, INPUT);
45 pinMode(sensor3, INPUT);
46 pinMode(sensor4, INPUT);
47
48 // inialisasi pin speed motor sebagai output
49 pinMode(pinSpeed, OUTPUT);
50 }
51
52 // ------ program utama, looping/berulang terus-menerus ------ //
53
54 void loop () {
55 // masing2 variabel data menyimpan hasil pembacaan sensor
56 // berupa logic LOW/HIGH
57 data1 = digitalRead(sensor1);
58 data2 = digitalRead(sensor2);
59 data3 = digitalRead(sensor3);
60 data4 = digitalRead(sensor4);
61
62 // mengatur kecepatan motor
63 analogWrite(pinSpeed, speedMotor);
64
65 // ---- pengaturan jalannya robot sesuai pembacaan sensor ---- //
66
67 if (data1 == LOW && data2 == LOW && data3 == LOW && data4 == LOW)
68 {
69 // maju
70 digitalWrite(motor1, HIGH);
71 digitalWrite(motor2, LOW);
72 digitalWrite(motor3, HIGH);
73 digitalWrite(motor4, LOW);
74 }
75
76 else if (data1 == HIGH && data2 == HIGH && data3 == HIGH && data4
77 == LOW)
78 {
79 // kanan
80 digitalWrite(motor1, LOW);
81 digitalWrite(motor2, HIGH);
82 digitalWrite(motor3, HIGH);
83 digitalWrite(motor4, LOW);
84 }
85
86 else if (data1 == LOW && data2 == HIGH && data3 == HIGH && data4 ==
87 HIGH)
88 {
89 // kiri
90 digitalWrite(motor1, HIGH);
91 digitalWrite(motor2, LOW);
92 digitalWrite(motor3, LOW);
93 digitalWrite(motor4, HIGH);
94 }
95
96 else if (data1 == HIGH && data2 == HIGH && data3 == LOW && data4 ==
97 LOW)
98 {
99 // kanan
100 digitalWrite(motor1, LOW);
101 digitalWrite(motor2, HIGH);
102 digitalWrite(motor3, HIGH);
103 digitalWrite(motor4, LOW);
104 }
105
106 else if (data1 == LOW && data2 == LOW && data3 == HIGH && data4 ==
107 HIGH)
108 {
109 // kiri
110 digitalWrite(motor1, HIGH);
111 digitalWrite(motor2, LOW);
112 digitalWrite(motor3, LOW);
113 digitalWrite(motor4, HIGH);
114 }
115
116 else if (data1 == HIGH && data2 == LOW && data3 == LOW && data4 ==
117 LOW)
118 {
119 // kanan
120 digitalWrite(motor1, LOW);
121 digitalWrite(motor2, HIGH);
122 digitalWrite(motor3, HIGH);
123 digitalWrite(motor4, LOW);
124 }
125
126 else if (data1 == LOW && data2 == LOW && data3 == LOW && data4 ==
127 HIGH)
128 {
129 // kiri
130 digitalWrite(motor1, HIGH);
131 digitalWrite(motor2, LOW);
132 digitalWrite(motor3, LOW);
133 digitalWrite(motor4, HIGH);
134 }
135
136 else if (data1 == HIGH && data2 == LOW && data3 == HIGH && data4 ==
137 LOW)
138 {
139 // kanan
140 digitalWrite(motor1, LOW);
141 digitalWrite(motor2, HIGH);
142 digitalWrite(motor3, HIGH);
143 digitalWrite(motor4, LOW);
144 }
145
146 else if (data1 == LOW && data2 == HIGH && data3 == LOW && data4 ==
147 HIGH)
148 {
149 // kiri
150 digitalWrite(motor1, HIGH);
151 digitalWrite(motor2, LOW);
152 digitalWrite(motor3, LOW);
153 digitalWrite(motor4, HIGH);
154 }
155
156 else if (data1 == LOW && data2 == HIGH && data3 == LOW && data4 ==
157 LOW)
158 {
159 // kanan
160 digitalWrite(motor1, LOW);
161 digitalWrite(motor2, HIGH);
162 digitalWrite(motor3, HIGH);
163 digitalWrite(motor4, LOW);
164 }
165
166
167 else if (data1 == LOW && data2 == LOW && data3 == HIGH && data4 ==
168 LOW)
169 {
170 // kiri
171 digitalWrite(motor1, HIGH);
172 digitalWrite(motor2, LOW);
173 digitalWrite(motor3, LOW);
174 digitalWrite(motor4, HIGH);
175 }
176
177 else if (data1 == LOW && data2 == HIGH && data3 == HIGH && data4 ==
178 LOW)
179 {
180 //maju
181 digitalWrite(motor1, HIGH);
182 digitalWrite(motor2, LOW);
183 digitalWrite(motor3, HIGH);
184 digitalWrite(motor4, LOW);
185 }
186
187 else if (data1 == HIGH && data2 == HIGH && data3 == HIGH && data4
188 == HIGH)
189 {
190 // maju
191 digitalWrite(motor1, HIGH);
192 digitalWrite(motor2, LOW);
193 digitalWrite(motor3, HIGH);
194 digitalWrite(motor4, LOW);
195 }
196 }

SELAMAT MENCOBA ^_^

SEMANGAT!!!

*Setelah materi ini dipelajari jangan lupa untuk terus di pelajari/diulang dirumah dengan alat asli/simulator.
karena sebelum kelas di mulai di pertemuan selanjutnya, akan ada rivew atau test singkat oleh Trainer...
HEHEHEHE.... Terus Semangat ‘-’)9
 Apa itu Robot Avoider? Seperti apa cara kerja robot tersebut?.

Robot Avoider adalah robot halang rintang karena pada dasarnya robot ini
menggunakan sensor yang membuat robot dapat merubah haluan gerakn-
ya. Robot Avoider ini menggunakan sensor ultrasonic sensor, apabila robot
mendeteksi benda atau dinding dalam jarak tertentu maka secara otomatis
robot akan berputar ke kanan atau ke kiri bisa juga mundur. Maka dari itu
robot ini disebut sebagai Robot Halang Rintang.

Aplikasi dari sistem Robot ini cukup banyak, dari mulai Robot penyapu/
pembersih lantai sederhana, Robot penjelajah dan sistemnya juga dipakai
pada sistem pengereman otomatis pada beberapa produk mobil saat ini.

EXERCISE + CHALANGE :

1. Susun dan rangkai Avoider Robot tanpa skema namun sesuai dengan keterangan pin yang sudah ada
pada Coding.

2. Program dengan coding sebagai berikut

1 /*
2 * INTERACTIVE ROBOTICS
3 * Program Avoider Robot 3 Sensor
4 */
5
6 #define rightMotor_Dir 4 // arah putar (Motor 1 / kanan)
7 #define rightMotor_Vel 5 // kontrol kecepatan (Motor 1 / Kiri)
8 #define leftMotor_Vel 6
9 #define leftMotor_Dir 7
10 #define fullspeed 255
11 #define nospeed 0
12 #define lowspeed1 50
13 #define lowspeed2 75
14 #define lowspeed3 100
15 #define lowspeed4 150
16 #define lowspeed5 175
17 #define highspeed1 225
18 #define highspeed2 176
19 #define highspeed3 200
20 #define highspeed4 215
21 #define highspeed5 250
22
23 int tengah ;
24 int kiri;
25 int kanan;
26
27 #include<NewPing.h>
28 #define TRIGGER_PIN 19
29 #define ECHO_PIN 18
30 #define MAX_DISTANCE 500
31 NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
32
33 #define TRIGGER_PIN1 17
34 #define ECHO_PIN1 16
35 NewPing sonar1(TRIGGER_PIN1, ECHO_PIN1, MAX_DISTANCE);
36
37 #define TRIGGER_PIN2 15
38 #define ECHO_PIN2 14
39 NewPing sonar2(TRIGGER_PIN2, ECHO_PIN2, MAX_DISTANCE);
40
41 void maju() {
42 //Motor diberi HIGH untuk bergerak CW
43 digitalWrite(rightMotor_Dir,HIGH);
44 //Motor diberi HIGH agar EN=full speed
45 analogWrite(rightMotor_Vel,60);
46 //Motor diberi HIGH untuk bergerak CW
47 digitalWrite(leftMotor_Dir,HIGH);
48 //Motor diberi HIGH agar EN=full speed
49 analogWrite(leftMotor_Vel,60);
50 }
51
52 void mundur() {
53 //Motor diberi HIGH untuk bergerak CW
54 digitalWrite(rightMotor_Dir,LOW);
55 //Motor diberi HIGH agar EN=full speed
56 analogWrite(rightMotor_Vel,50);
57 //Motor diberi HIGH untuk bergerak CW
58 digitalWrite(leftMotor_Dir,LOW);
59 //Motor diberi HIGH agar EN=full speed
60 analogWrite(leftMotor_Vel,50);
61 }
62
63 void berhenti() {
64 //Motor diberi HIGH untuk bergerak CW
65 digitalWrite(rightMotor_Dir,LOW);
66 //Motor diberi HIGH agar EN=full speed
67 analogWrite(rightMotor_Vel,nospeed);
68 //Motor diberi HIGH untuk bergerak CW
69 digitalWrite(leftMotor_Dir,LOW);
70 //Motor diberi HIGH agar EN=full speed
71 analogWrite(leftMotor_Vel,nospeed);
72 }
73
74 void belok kanan() {
75 //Motor diberi HIGH untuk bergerak CW
76 digitalWrite(rightMotor_Dir,HIGH);
77 //Motor diberi HIGH agar EN=full speed
78 analogWrite(rightMotor_Vel,50);
79 //Motor diberi HIGH untuk bergerak CW
80 digitalWrite(leftMotor_Dir,LOW);
81 //Motor diberi HIGH agar EN=full speed
82 analogWrite(leftMotor_Vel,90);
83 delay(200);
84 }
85
86 void belok kiri() {
87 //Motor diberi HIGH untuk bergerak CW
88 digitalWrite(rightMotor_Dir,HIGH);
89 //Motor diberi HIGH agar EN=full speed
90 analogWrite(rightMotor_Vel,90);
91 //Motor diberi HIGH untuk bergerak CW
92 digitalWrite(leftMotor_Dir,LOW);
93 //Motor diberi HIGH agar EN=full speed
94 analogWrite(leftMotor_Vel,50);
95 delay(200);
96 }
97
98 void setup() {
99 pinMode (4,OUTPUT); //Setting pin 4 sebagai output
100 pinMode (5,OUTPUT); //Setting pin 5 sebagai output
101 pinMode (6,OUTPUT); //Setting pin 6 sebagai output
102 pinMode (7,OUTPUT); //Setting pin 7 sebagai output
103 [Link](115200);
104 }
105
106 void loop() {
107 delay(100);
108 tengah = sonar.ping_cm();
109 kanan = sonar1.ping_cm();
110 kiri = sonar2.ping_cm();
111
112 if (tengah == 0 ) {
113 tengah = MAX_DISTANCE;
114 }
115 if (kanan == 0 ){
116 kanan = MAX_DISTANCE;
117 }
118 if (kiri == 0 ){
119 kiri = MAX_DISTANCE;
120 }
121
122 [Link](“ hasil pengukuran “);
123 [Link](tengah);
124 [Link](“ cm”);
125 [Link](kanan);
126 [Link](“ cm”);
127 [Link](kiri);
128 [Link](“ cm”);
129
130 if(kiri<=10 && tengah<=10 && kanan <=10) {
131 mundur();
132 }
133
134 else if((tengah <=10) && (kiri <=10)) {
135 belokkanan();
136 }
137
138 else if ((tengah <=10) && (kanan <=10)) {
139 belokkiri();
140 }
141
142 else if(kiri <=10) {
143 belokkanan();
144 }
145
146 else if(kanan <=10){
147 belokkiri();
148 }
149
150 else if (tengah <=10){
151 belokkanan();
152 }
153
154 else {
155 maju();
156 }
157 }
Jika terjadi kesulitan dan ada hal yang kurang/tidak dipahami, segera bertanya pada Trainer dan ikuti instruksi
Trainer, demi keamanan dalam pembuatan project dan menghindari resiko kerusakan fatal pada alat yang
digunakan dalam pembuatan project.

SELAMAT MENCOBA ^_^

SEMANGAT!!!

*Setelah materi ini dipelajari jangan lupa untuk terus di pelajari/diulang dirumah dengan alat asli/simulator.
karena sebelum kelas di mulai di pertemuan selanjutnya, akan ada rivew atau test singkat oleh Trainer...
HEHEHEHE.... Terus Semangat ‘-’)9
 Bluetooth adalah suatu protokol komunikasi wireless yang bek-
erja pada frekuensi radio 2.4 GHz untuk pertukaran data pada per-
angkat seperti hanphone,laptop,dan perangkat lainnya . Sama halnya
di dalam menggunakan mikrokontroller,seringkali kita memerlukan
suatu protokol komunikasi yang dapat digunakan untuk mengirimkan
dan menerima data,untuk itu bluetooth adalah salah satu alat yang
sangat efektif untuk komunikasi di ruang lingkup/area yang bersifat
lokal.

Bluetooth HC-05 adalah salah satu modul bluetooth yag sering digunakan oleh kebanyakan user mik-
rokontroller seperti arduino dikarenakan pemakaiannya yang mudah,harganya murah,dan banyak tersedia di
pasaran. Kelebihan dari modul bluetooth HC-05 ini adalah bisa digunakan sebagai master maupun digunakan
sebagai slave,berbeda dengan bluetooth tipe HC-06 yang hanya bisa digunakan sebagai slave.

Sebelum menggunakan bluetooth HC-05 alangkah baiknya dilakukan konfigurasi terlebih dahulu ,yaitu
masuk ke mode [Link] itu AT Command? AT Command adalah perintah-perintah yang digunakan
dalam komunikasi dengan serial port,hal ini juga berlaku untuk modul HC 05 sehingga user bisa mengubah
status master dan slave,nama bluetooth,baud rate,dan pasword nya.
Cara masuk ke AT command ini sangat mudah dan simpel dikarenakan tidak membutuhkan program ataupun
software khusus.

EXERCISE :

Rangkaialah seperti gambar di bawah ini :

*hubungkan pin RX ke RX
*hubungkan pin TX ke TX
*hubungkan VCC ke 5 volt DC dari arduino
*hubungkan GND ke gnd arduino
***untuk masuk ke mode AT command ini , RX hubungkan ke RX TX hubungkan ke TX
Setelah itu masukkan program kosong dari arduino IDE ke board arduino seperti di bawah ini :

*setelah selesai,cabut kabel arduino

*tekan dan tahan tombol pada modul bluetooth HC-05 dan pasang kabel arduino
ke port usb komputer/laptop anda.
*lepas setelah terpasang selama 3 detik
*maka lampu pada modul bluetooth akan berkedip secara perlahan
*kemudian masuklah ke serial monitor arduino ide di pojok kanan atas

*setting seperti di bawah ini yaitu plih Both NL & CR dan 38400 baud
*ketik AT kemudian send

*akan muncul pesan error,tapi itu bukan masalah .Ketik saja lagi AT

*akan muncul pesan OK

Daftar perintah di AT Command :

AT+ROLE “untuk cek baud status master atau slave”

AT+NAME “untuk cek nama”
AT+UART “untuk cek baud rate”
AT+ROLE=0 “mengeset modul ke mode slave”
AR+ROLE=1 “mengeset modul ke mode master ”
AT+PSWD=(password kamu) “mengeset pasword ke pasword yang diinginkan”
AT+UART=9600,0,0 “mengeset baud rate ke 9600”

Untuk lebih jelasnya bisa dilihat di datasheet Modul bluetooth HC-05 itu sendiri.
CHALANGE :

1. Cobalah ubah Nama Bluetooth tersebut.

2. Buatlah sebuah rangkian dimana disana terdapat 3 buah rangkaian led dan rangkaian Bluetooth seperti
gambar dibawah, lalu cobalah buat program serial Available agar rangkaian LED dapat di control dengan
Android.

SKEMA RANGKAIAN
HINT SOURCE CODE :

1 /*
2 * INTERACTIVE ROBOTICS
3 * Program controling dengan Android
4 */
5
6 int lampu1=13;
7 int lampu2=12;
8 int lampu3=11;
9 int melihat;
10
11 void setup() {
12 pinMode(lampu1, OUTPUT);
13 digitalWrite(lampu1,LOW);
14 digitalWrite(lampu2,LOW);
15 digitalWrite(lampu3,LOW);
16 [Link](9600);
17 }
18
19 void loop() {
20 if([Link]()>0){
21 melihat=[Link]();
22 }
23 if(melihat==’1’){
24 digitalWrite(lampu1,HIGH);
25 }
26 else if(melihat==’2’){
27 digitalWrite(lampu1,LOW);
28 }

SELAMAT MENCOBA ^_^

SEMANGAT!!!
*Setelah materi ini dipelajari jangan lupa untuk terus di pelajari/diulang dirumah dengan alat asli/simulator.
karena sebelum kelas di mulai di pertemuan selanjutnya, akan ada rivew atau test singkat oleh Trainer...
HEHEHEHE.... Terus Semangat ‘-’)9
 RFID atau Radio Frequency Identification, merupakan suatu
teknologi yang memanfaatkan frekuensi radio sebagai identifikasi
terhadap suatu objek. RFID tag adalah sebuah benda kecil, misalnya
berupa stiker adesif, dan dapat ditempelkan pada suatu barang atau
produk. Maka dari itu RFID dapat dipandang sebagai salah satu cara
dalam pelabelan object (product). RFID TAG berisi antena yang me-
mungkinkan mereka untuk menerima dan merespon terhadap suatu
query yang dipancarkan oleh suatu RFID transceiver. Pelabelan dalam
hal ini menggunakan sebuah kartu RFID atau TAG yg ditempatkan
pada objek yg diindentifikasi. Fungsi TAG sama dengan fungsi barcode
label akan tetapi RFID mempunyai kelebihan daripada label barcode