2020

Memprogram Robot Line

Follower untuk Pemula

MODUL KELAS ONLINE JAGO ROBOTIKA V1.0

AHMAD ATAKA

JAGO ROBOTIKA
1. Apa itu Robot?

Robot terdiri dari 3 (tiga) komponen:

a. Controller, yang digunakan untuk membuat keputusan

b. Sensor, yang digunakan untuk mendeteksi kondisi robot dan lingkungannya
c. Aktuator, yang digunakan untuk menggerakkan robot

Jadi, robot memiliki kemampuan untuk mendeteksi kondisi robot dan sekeliling dengan
sensor, kemudian menggunakan informasi ini untuk melakukan tindakan tertentu melalui
actuator.

2. Apa itu Simulator Robot dan mengapa kita menggunakan simulator robot?

Simulator robot adalah software-software yang bisa digunakan untuk mensimulasikan gerakan
robot di dalam komputer. Beberapa contoh simulator robot yang banyak digunakan di antaranya
Gazebo, V-Rep, Webots, dan lain-lain. Menggunakan simulator robot memiliki banyak sekali
keuntungan. Beberapa di antaranya:

• Agar kita bisa mencoba berbagai varian komponen robot tanpa perlu merakitnya

• Mencoba berbagai metode untuk mengendalikan robot dengan mudah

• Mengetes robot di berbagai lingkungan yang berbeda dengan mudah

• Tidak perlu khawatir robotnya rusak

• Ongkosnya lebih murah

3. Mengapa kita memilih simulator Webots?

Webots adalah salah satu contoh simulator robot yang banyak digunakan saat ini. Di antara
berbagai simulator robot yang ada, Webots termasuk yang memiliki fitur lengkap bersama
dengan simulator Gazebo. Di kelas online ini, kita memilih simulator Webots karena beberapa
alasan:

1
©Jago Robotika
• Gratis / Open Source: simulator Webots sejak beberapa tahun yang lalu bisa didownload secara
gratis. Sebelumnya, pengguna diharuskan untuk membayar / berlangganan untuk
menggunakannya.
• Graphical User Interface (GUI) yang user-friendly: Webots dilengkapi dengan tampilan yang
cukup sederhana dan mudah digunakan untuk pemula.
• Webots dilengkapi dengan berbagai macam robot, sensor, dan aktuator yang bisa digunakan
untuk mensimulasikan berbagai jenis robot, mulai dari robot beroda, berkaki, humanoid, robot
terbang, dan lain-lain.
• Webots dilengkapi dengan berbagai lingkungan/environment yang bisa digunakan untuk
mengetes kinerja robot kita. Ada lingkungan rumah, pabrik, bahkan tiruan planet Mars.
• Robot-robot yang ada di Webots bisa diprogram dengan berbagai macam Bahasa pemrograman
seperti C, C++, Python, Java, MATLAB, dan lain-lain.
• Webots bisa digunakan di berbagai Operating Systems: Windows, Ubuntu, macOS
• Kita bisa juga merakit robot kita sendiri di Webots dengan menggunakan objek-objek yang
tersedia.
• Webots termasuk simulator yang stabil dan memiliki performa yang baik karena sudah
beroperasi sejak 1998.

4. Apa itu Robot Line Follower?

Robot Line follower adalah salah satu contoh robot beroda yang didesain untuk bergerak
mengikuti lintasan berupa garis hitam. Robot line follower cukup popular karena termasuk robot
yang sederhana dan mudah dibuat, sehingga cocok untuk pemula tapi juga bisa digunakan untuk
berbagai macam keperluan. Sebagaimana halnya robot-robot yang lain, robot line follower juga
terdiri atas actuator, controller, dan sensor:
• Aktuator: terdiri atas 2 motor DC yang masing-masing terhubung ke roda kanan dan kiri.
• Controller: terdiri atas sebuah chip microcontroller yang digunakan untuk menuliskan kode
program untuk memerintahkan Gerakan robot mengikuti garis. Umumnya banyak menggunakan
chip-chip murah seperti ATMEL, Arduino, dan lain-lain.
• Sensor: terdiri atas sensor garis untuk mendeteksi garis hitam. Sensor ini lah yang membedakan
robot line follower dengan robot beroda lainnya. Sensor garis ini biasanya tersusun atas 2
komponen:
• Sumber cahaya seperti lampu LED (light-emitting diode)
• Detektor cahaya seperti komponen LDR (Light dependent resistor) atau photo-transistor

Sensor garis pada robot line follower diarahkan ke bawah, menghadap permukaan dari lintasan
robot. Sensor garis bekerja seperti berikut:
• Sumber cahaya memancarkan cahaya ke permukaan lintasan.
• Cahaya yang mengenai permukaan hitam / gelap, mayoritas intensitasnya akan diserap, hanya
sedikit yang dipantulkan. Akibatnya, detektor cahaya hanya mendeteksi sedikit cahaya pantulan.
• Cahaya yang mengenai permukaan putih / terang, mayoritas intensitasnya akan dipantulkan,
hanya sedikit yang diserap. Akibatnya, detektor cahaya mendeteksi cahaya pantulan dengan
intensitas kuat.
• Nilai yang dideteksi sensor cahaya ini lah yang dibaca oleh mikrokontroller lalu digunakan untuk
mengambil keputusan.

2
©Jago Robotika
5. Menggunakan Webots

Sebelum kita memprogram Gerakan robot line follower kita, kita akan membahas terlebih dahulu
tentang bagaimana menggunakan Webots. Berikut adalah contoh tampilan grafis simulator Webots
ketika dibuka:

Scene
Tree

Code Editor

3D View

Console

Ada beberapa Window dalam simulator Webots:

• Scene Tree: berada di sebelah kiri atas, berisi deskripsi tentang lingkungan tempat robot
Scene Tree
berada, seperti objek-objek yang ada di lingkungan, pencahayaan, dan lain-lain.
• 3D View: berada di tengah, berisi tampilan robot dan lingkungannya.
• Code Editor: berada di kanan atas, tempat kita menuliskan baris kode program untuk
memerintahkan kerja robot.
• Console: di bagian bawah, tempat kita bisa menampilkan status ataupun variable tertentu
dari program kita.

Untuk membuat project baru di Webots, ikuti instruksi di bawah:

• Klik menu Wizards, New Project Directory

3
©Jago Robotika
 • Akan muncul tampilan New Project Creation. Klik Next.
• Pilih direktori tempat kamu akan menyimpan projectmu dan pilih nama projectmu. Secara
otomatis, nama project “my_project” akan digunakan dan akan diletakkan di direktori
Document seperti berikut: C:\Users\ataka\Documents\my_project. Klik Next.
• Akan muncul Window bertuliskan World Setting. Klik Next.
• Muncul Windows bertuliskan Conclusion. Klik Finish. Project-mu berhasil dibuat.

Selanjutnya, untuk membuka lingkungan berisi robot line follower dan lintasan yang sudah
disediakan, ikuti instruksi berikut:

• Buka direktori tempat project-mu tersimpan. Buka folder “Worlds”.

• Copy 3 file berkestensi “wbt” yang kami kirimkan via email ke lokasi ini. Ketiga file tersebut
adalah “e-puck_line.wbt”, “e-puck_square.wbt”, dan “e-puck_square_zigzag.wbt”.
• Di Webots-mu yang sudah berisi project, klik menu File, Open World. Pilih “e-
puck_line.wbt”.
• Di bagian 3D Window akan muncul robot line follower beserta lintasannya yang siap
digunakan.
6. Program Sensor Garis

Sekarang kita akan mencoba membuat program sederhana untuk mengetes sensor garis yang ada di
bagian depan robot kita. Untuk membuat program baru, ikuti instruksi berikut:

• Klik menu Wizards, New Robot Controller.

• Window New Controller Creation akan muncul. Klik Next.
• Pada bagian Language Selection, pilih C.
• Pada bagian IDE Selection, pilih Webots (gcc/Makefile).
• Pilih nama programmu. Jangan gunakan spasi atau simbol-simbol aneh. Contoh nama
program di sini: “demo_sensor_garis”.

4
©Jago Robotika
• Akan muncul Window Conclusion. Pilih Finish. Akan muncul window baru di bagian code
editor.
• Tuliskan program di bawah ini di bagian editor. Penjelasan detailnya silakan mengacu pada
file slide yang akan dibagikan setelah sesi Goggle Meet usai.

#include <webots/robot.h>
#include <stdio.h>
#include <webots/distance_sensor.h>

#define TIME_STEP 64

int main(int argc, char **argv) {

wb_robot_init();
char printing[40];
int sensor_kiri;
int sensor_kanan;
int sensor_tengah;

WbDeviceTag sensor_garis_0 = wb_robot_get_device("gs0");

WbDeviceTag sensor_garis_1 = wb_robot_get_device("gs1");
WbDeviceTag sensor_garis_2 = wb_robot_get_device("gs2");
wb_distance_sensor_enable(sensor_garis_0, TIME_STEP);
wb_distance_sensor_enable(sensor_garis_1, TIME_STEP);
wb_distance_sensor_enable(sensor_garis_2, TIME_STEP);

while (wb_robot_step(TIME_STEP) != -1) {

sensor_kiri = wb_distance_sensor_get_value(sensor_garis_0);
sensor_tengah = wb_distance_sensor_get_value(sensor_garis_1);
sensor_kanan = wb_distance_sensor_get_value(sensor_garis_2);

sprintf(printing, "%d %d %d \n", sensor_kiri,sensor_tengah,sensor_kanan);

printf(printing);
};
wb_robot_cleanup();

return 0;
}

• Klik ikon “Build the current project” di sebelah atas code editor seperti gambar di bawah
untuk meng-compile program. Jika ada error, akan muncul peringatan berwarna merah di
window Console di bagian bawah simulator.

5
©Jago Robotika
• Jika tidak ada error, kita bisa menjalankan program tersebut di robot kita. Caranya, klik ikon
“>” sebelum label “DEF EPUCK E-puck” di bagian Scene Tree untuk memilih robot kita. Akan
muncul property dari robot kita seperti gambar di bawah

6
©Jago Robotika
• Klik bagian “controller”. Akan muncul window untuk memilih controller untuk memprogram
robot kita. Klik Select.

• Pilih demo_sensor_garis. Klik OK.

7
©Jago Robotika
• Di bagian controller, akan terupdate menjadi “demo_sensor_garis”.

• Klik tombol “Run the simulation in real-time” seperti gambar di bawah untuk menjalankan
simulasi.

8
©Jago Robotika
 • Di bagian console akan muncul tampilan bacaan sensor garis:

• Untuk mengubah lokasi robot, klik ikon “Pause the simulation”, lalu klik robotmu di bagian
3D window, kemudian drag robotmu sambil menekan tombol Shift. Selanjutnya, jalankan
kembali simulasi dan bandingkan tampilan bacaan sensor garisnya!

Bagaimana bacaan sensor yang mendeteksi garis hitam? Bagaimana bacaan sensor yang
mendeteksi permukaan putih? Coba gerakkan robotmu ke beberapa posisi yang berbeda di sekitar
lintasan garis hitam dan bandingkan bacaan sensornya!

Apa kegunaan dari perintah #include? Apa kegunaan perintah #define? Bagaimana cara
mendeklarasi variable?

7. Tentang tipe data

Di bagian sebelumnya, kamu telah menggunakan perintah “int sensor_kiri” untuk mendefinisikan
sebuah variable bernama “sensor_kiri” dengan tipe data “int” atau integer. Tipe data integer adalah
satu di antara sekian banyak tipe data yang disediakan oleh Bahasa pemrograman C. Yang
membedakan antara satu tipe data dengan lainnya adalah jenis data yang digunakan (apakah
berupa bilangan bulat, bilangan desimal, teks atau karakter, dan lain-lain) dan juga range data yang
akan digunakan (apakah berupa bilangan ratusan atau ribuan, dst). Beberapa tipe data yang
digunakan bisa dirangkum sebagai berikut:

Tipe Data Digunakan untuk Range

char Karakter atau bilangan bulat -128 sampai 127
unsigned char Karakter atau bilangan bulat 0 sampai 255
int Bilangan bulat -32768 sampai 32767
unsigned int Bilangan bulat 0 sampai 65535
float Bilangan desimal -3.4 x 1038 sampai 3.4 x 1038

9
©Jago Robotika
8. Program Gerakan Dasar Robot

Sekarang, buat controller baru bernama “demo_aktuator” dan tuliskan program berikut:

#include <webots/robot.h>
#include <webots/motor.h>

#define TIME_STEP 64

int main(int argc, char **argv) {

wb_robot_init();

WbDeviceTag motor_kanan = wb_robot_get_device("right wheel motor");

WbDeviceTag motor_kiri = wb_robot_get_device("left wheel motor");

wb_motor_set_position(motor_kanan, INFINITY);
wb_motor_set_position(motor_kiri, INFINITY);
while (wb_robot_step(TIME_STEP) != -1) {
wb_motor_set_velocity(motor_kanan, 5.0);
wb_motor_set_velocity(motor_kiri, -5.0);
};

wb_robot_cleanup();

return 0;
}

Jangan lupa meng-compile programmu dengan mengklik ikon “Build the current project” lalu ubah
controller robotmu di bagian Scene Tree menjadi “demo_aktuator”. Selalu lakukan langkah ini!

Amati apa yang terjadi pada robotmu! Coba ubah kecepatan roda kanan dan kiri motormu dengan
mengubah nilai kecepatan pada perintah wb_motor_set_velocity(motor_kanan, 5.0). Bagaimana
cara membuat robot maju, mundur, berputar, dan berbelok?

9. Program Dasar Line Follower

Setelah mempelajari bagaimana menggunakan sensor garis dan actuator pada robot, kita akan
mencoba memprogram robot kita untuk mengikuti lintasan garis. Buat controller baru dan tuliskan
program di bawah ini.

10
©Jago Robotika
#include <webots/robot.h>
#include <stdio.h>
#include <webots/distance_sensor.h>
#include <webots/motor.h>

#define TIME_STEP 64
#define BATAS 500

int main(int argc, char **argv) {

wb_robot_init();
int sensor_kiri, sensor_kanan, sensor_tengah;
float kecepatan_kanan, kecepatan_kiri;
float kecepatan = 3.0;
WbDeviceTag motor_kanan = wb_robot_get_device("right wheel motor");
WbDeviceTag motor_kiri = wb_robot_get_device("left wheel motor");
WbDeviceTag sensor_garis_0 = wb_robot_get_device("gs0");
WbDeviceTag sensor_garis_1 = wb_robot_get_device("gs1");
WbDeviceTag sensor_garis_2 = wb_robot_get_device("gs2");
wb_distance_sensor_enable(sensor_garis_0, TIME_STEP);
wb_distance_sensor_enable(sensor_garis_1, TIME_STEP);
wb_distance_sensor_enable(sensor_garis_2, TIME_STEP);

wb_motor_set_position(motor_kanan, INFINITY);
wb_motor_set_position(motor_kiri, INFINITY);

while (wb_robot_step(TIME_STEP) != -1) {

sensor_kiri = wb_distance_sensor_get_value(sensor_garis_0);
sensor_tengah = wb_distance_sensor_get_value(sensor_garis_1);
sensor_kanan = wb_distance_sensor_get_value(sensor_garis_2);

if(sensor_kiri<BATAS)
{
kecepatan_kanan = kecepatan;
kecepatan_kiri = -kecepatan;
}
else if(sensor_tengah<BATAS)
{
kecepatan_kanan = kecepatan;
kecepatan_kiri = kecepatan;
}
else if(sensor_kanan<BATAS)
{
kecepatan_kanan = -kecepatan;
kecepatan_kiri = kecepatan;
}
else
{
kecepatan_kanan = 0.0;
kecepatan_kiri = 0.0;
}

wb_motor_set_velocity(motor_kanan, kecepatan_kanan);
wb_motor_set_velocity(motor_kiri, kecepatan_kiri);
};
wb_robot_cleanup();

return 0;
}
11
©Jago Robotika
 Jalankan program di atas pada robotmu! Apa yang terjadi?

Prinsip kerja sederhana dari program line follower di atas adalah sebagai berikut:

• Jika sensor kiri mendeteksi warna hitam, maka robot berputar di tempat ke arah kiri

• Jika sensor kanan mendeteksi warna hitam, maka robot berputar di tempat ke arah kanan

• Jika sensor tengah mendeteksi warna hitam, maka robot bergerak maju

• Jika tidak ada sensor yang mendeteksi hitam, maka robot akan berhenti

Kondisi-kondis di atas diimplementasikan lewat fitur “if-else” yang ada di Bahasa C seperti contoh di
atas. Ini adalah salah satu cara untuk mengikuti garis hitam. Selanjutnya, kita akan mencoba
beberapa cara lain.

10. Konsep Struct:

Sebelum mencoba strategi lain untuk memprogram robot line follower kita, kita akan membahas
sebuah konsep di Bahasa pemrograman C yang akan sangat berguna. Konsep ini dikenal sebagai
“struct”.

Sebuah struct berisi beberapa variabel yang dikelompokkan ke dalam 1 nama baru. Dengan
menggunakan struct, seolah-olah kita membuat tipe data sendiri seperti halnya tipe data “integer”,
“float” dan “char” yang telah kita singgung sebelumnya.

Contoh:

• Struct bernama “siswa” berisi beberapa variable seperti “nama lengkap”, “alamat”, “tanggal
lahir”. Artinya, jika kita mendefinisikan sebuah struct “siswa” bernama “ataka”, maka
“ataka” ini mempunyai komponen-komponen berupa “nama lengkap”, “alamat”, dan
“tanggal lahir”.

Contoh pendeklarasian struct bernama “kecepatan_robot” dengan komponen “kanan” dan “kiri”
bertipe float:

typedef struct kecepatan_robot{

float kanan;
float kiri;
} kecepatan_robot;

Contoh pendeklarasian variable bernama “kecepatan” bertipe “kecepatan_robot” dan bagaimana

menggunakan komponen-komponennya:
kecepatan_robot kecepatan;
[Link] = 3.0;
[Link] = 5.0;

12
©Jago Robotika
11. Program Line Follower dengan kendali proporsional

Salah satu kekurangan dari program line follower versi sebelumnya, gerakan robot cenderung
patah-patah saat berbelok di tikungan. Hal ini dikarenakan kita selalu memutar robot ketika
berbelok (nilai kecepatan roda kanan dan kiri sama tapi arahnya berlawanan). Di sini, kita akan
memperbaiki kekurangan ini dengan menggunakan sebuah metode kendali yang sangat populer di
robotika yaitu kendali proporsional. Prosedurnya adalah seperti ini:

• Jika tidak ada sensor yang mendeteksi hitam, robot berhenti

• Jika ada salah satu sensor mendeteksi hitam:

• Hitung nilai error yaitu selisih bacaan sensor kiri dan kanan: error = sensor kiri – sensor
kanan

• Set kecepatan roda kanan menjadi: kecepatan kanan = main_speed - kp*error

• Set kecepatan roda kiri menjadi: kecepatan kiri = main_speed + kp*error

• Variabel main_speed dan Kp diset untuk memiliki nilai tertentu.

13
©Jago Robotika
Berikut kode programnya:

#include <webots/robot.h>
#include <stdio.h>
#include <webots/distance_sensor.h>
#include <webots/motor.h>

#define TIME_STEP 64
#define BATAS 500

typedef struct kecepatan_robot{

float kanan;
float kiri;
} kecepatan_robot;

typedef struct sensor_robot{

unsigned short kiri;
unsigned short tengah;
unsigned short kanan;
} sensor_robot;

int main(int argc, char **argv) {

wb_robot_init();

sensor_robot nilai_sensor;
kecepatan_robot kecepatan;
short error;
float main_speed = 3.0;
float kp = 0.0058;

WbDeviceTag motor_kanan = wb_robot_get_device("right wheel motor");

WbDeviceTag motor_kiri = wb_robot_get_device("left wheel motor");
WbDeviceTag nilai_sensor_0 = wb_robot_get_device("gs0");
WbDeviceTag nilai_sensor_1 = wb_robot_get_device("gs1");
WbDeviceTag nilai_sensor_2 = wb_robot_get_device("gs2");
wb_distance_sensor_enable(nilai_sensor_0, TIME_STEP);
wb_distance_sensor_enable(nilai_sensor_1, TIME_STEP);
wb_distance_sensor_enable(nilai_sensor_2, TIME_STEP);

wb_motor_set_position(motor_kanan, INFINITY);
wb_motor_set_position(motor_kiri, INFINITY);

while (wb_robot_step(TIME_STEP) != -1) {

nilai_sensor.kiri = wb_distance_sensor_get_value(nilai_sensor_0);
nilai_sensor.tengah = wb_distance_sensor_get_value(nilai_sensor_1);
nilai_sensor.kanan = wb_distance_sensor_get_value(nilai_sensor_2);

if(nilai_sensor.kanan<BATAS || nilai_sensor.tengah<BATAS || nilai_sensor.kiri<BATAS)

{
error = nilai_sensor.kiri - nilai_sensor.kanan;
[Link] = main_speed - kp*error;
[Link] = main_speed + kp*error;
}
else
{
[Link] = 0.0;
[Link] = 0.0;
}

wb_motor_set_velocity(motor_kanan, [Link]);
14
wb_motor_set_velocity(motor_kiri, [Link]);
©Jago Robotika
};
wb_robot_cleanup();
 if(nilai_sensor.kanan<BATAS || nilai_sensor.tengah<BATAS || nilai_sensor.kiri<BATAS)
{
error = nilai_sensor.kiri - nilai_sensor.kanan;
[Link] = main_speed - kp*error;
[Link] = main_speed + kp*error;
}
else
{
[Link] = 0.0;
[Link] = 0.0;
}

wb_motor_set_velocity(motor_kanan, [Link]);
wb_motor_set_velocity(motor_kiri, [Link]);
};
wb_robot_cleanup();

return 0;
}

Apa makna dari strategi di atas? Idenya adalah, jika robot tepat berada di tengah lintasan garis hitam,
sensor kanan dan kiri akan sama-sama mendeteksi warna putih. Akibatnya, selisih nilai di antara
keduanya 0. Maka kedua roda akan bergerak maju dengan kecepatan yang sama, yang nilainya
adalah main_speed. Jika salah satu sensor kanan atau kiri mendeteksi warna hitam, maka akan ada
selisih nilai bacaan sensor kanan dan kiri. Misal, sensor kanan mendeteksi hitam, maka selisih bacaan
kiri dan kanan (atau error) adalah positif. Akibatnya, kecepatan roda kanan akan dikurangi dan
kecepatan roda kiri akan ditambah. Robot pun akan berbelok kanan sehingga bisa kembali berada di
posisi tengah lintasan garis.

12. Konsep Fungsi

Sebagaimana kamu amati, semakin kompleks tugas suatu robot, semakin Panjang baris kode
programnya. Untuk memudahkan kita ketika program sudah semakin kompleks, kita bisa
menggunakan sebuah fitur dalam Bahasa C yang dikenal sebagai “fungsi” atau “function”.

Program di bagian sebelumnya bisa kita ubah dengan menggunakan fungsi seperti berikut:

15
©Jago Robotika
#include <webots/robot.h>
#include <stdio.h>
#include <webots/distance_sensor.h>
#include <webots/motor.h>

#define TIME_STEP 64
#define BATAS 500

typedef struct kecepatan_robot{

float kanan;
float kiri;
} kecepatan_robot;

typedef struct sensor_robot{

unsigned short kiri;
unsigned short tengah;
unsigned short kanan;
} sensor_robot;

kecepatan_robot proportional_line_follower(sensor_robot nilai_sensor)

{
kecepatan_robot kecepatan;
short error;
float main_speed = 3.0;
float kp = 0.0058;
if(nilai_sensor.kanan<BATAS || nilai_sensor.tengah<BATAS || nilai_sensor.kiri<BATAS)
{
error = nilai_sensor.kiri - nilai_sensor.kanan;
[Link] = main_speed - kp*error;
[Link] = main_speed + kp*error;
}
else
{
[Link] = 0.0;
[Link] = 0.0;
}

return kecepatan;
}

int main(int argc, char **argv) {

wb_robot_init();
sensor_robot sensor_garis;
kecepatan_robot speed;

WbDeviceTag motor_kanan = wb_robot_get_device("right wheel motor");

WbDeviceTag motor_kiri = wb_robot_get_device("left wheel motor");
WbDeviceTag sensor_garis_0 = wb_robot_get_device("gs0");
WbDeviceTag sensor_garis_1 = wb_robot_get_device("gs1");
WbDeviceTag sensor_garis_2 = wb_robot_get_device("gs2");
wb_distance_sensor_enable(sensor_garis_0, TIME_STEP);
wb_distance_sensor_enable(sensor_garis_1, TIME_STEP);
wb_distance_sensor_enable(sensor_garis_2, TIME_STEP);

wb_motor_set_position(motor_kanan, INFINITY);
wb_motor_set_position(motor_kiri, INFINITY);

while (wb_robot_step(TIME_STEP) != -1) {

sensor_garis.kiri = wb_distance_sensor_get_value(sensor_garis_0);
16
sensor_garis.tengah = wb_distance_sensor_get_value(sensor_garis_1);
©Jago Robotika
sensor_garis.kanan = wb_distance_sensor_get_value(sensor_garis_2);

speed = advance_proportional_line_follower(sensor_garis);
 while (wb_robot_step(TIME_STEP) != -1) {
sensor_garis.kiri = wb_distance_sensor_get_value(sensor_garis_0);
sensor_garis.tengah = wb_distance_sensor_get_value(sensor_garis_1);
sensor_garis.kanan = wb_distance_sensor_get_value(sensor_garis_2);

speed = proportional_line_follower(sensor_garis);

wb_motor_set_velocity(motor_kanan, [Link]);
wb_motor_set_velocity(motor_kiri, [Link]);
};
wb_robot_cleanup();

return 0;
}

Di program di atas, proportional_line_follower() adalah sebuah fungsi yang kita gunakan untuk
menjalankan program kendali proportional pada robot line follower kita. Sebelum bisa dipakai di
program utama / main(), kita harus terlebih dahulu mendeklarasikan fungsi tersebut di bagian awal
program. Baru kemudian kita bisa memanggilnya di program utama kita sehingga program utama
kita lebih ringkas.

13. Program Line follower dengan pembobotan error

Meskipun performa Gerakan robot kita sudah semakin baik, kekurangan program sebelumnya
adalah kita tidak mengoptimalkan bacaan sensor tengah, tetapi hanya menggunakan sensor kanan
dan kiri saja. Di bagian ini, kita bisa memodifikasi program sebelumnya agar bekerja lebih baik.

Perbedaannya, terletak pada pendefinisian error. Kalau sebelumnya nilai error didefinisikan sebagai
selisih bacaan sensor kiri dan kanan, di sini kita memberikan nilai error sesuai dengan kondisi sensor
mana yang mendeteksi warna hitam:

• Jika sensor kanan saja mendeteksi hitam, artinya robot berada cukup jauh dari posisi
tengah, maka errornya harus besar: error = 10

• Jika sensor kanan dan tengah mendeteksi hitam, artinya robot berada cukup dekat dari
posisi tengah, maka errornya cukup kecil: error = 5

• Jika sensor kiri dan tengah mendeteksi hitam, artinya robot berada cukup dekat dari
posisi tengah, maka errornya juga kecil tapi negatif (karena yang mendeteksi sensor
kiri): error = -5

• Jika sensor kiri saja mendeteksi hitam, artinya robot berada cukup jauh dari posisi
tengah, maka errornya harus besar tapi negatif (karena yang mendeteksi sensor kiri):
error = -10

• Selain kondisi di atas, robot sudah stabil, maka error = 0.

Program lengkapnya bisa dilihat di bawah:

17
©Jago Robotika
#include <webots/robot.h>
#include <stdio.h>
#include <webots/distance_sensor.h>
#include <webots/motor.h>

#define TIME_STEP 64
#define BATAS 500

typedef struct kecepatan_robot{

float kanan;
float kiri;
} kecepatan_robot;

typedef struct sensor_robot{

unsigned short kiri;
unsigned short tengah;
unsigned short kanan;
} sensor_robot;

kecepatan_robot advance_proportional_line_follower(sensor_robot nilai_sensor)

{
kecepatan_robot kecepatan;
short error;
float main_speed = 3.0;
float kp = 0.25;
if(nilai_sensor.kanan<BATAS || nilai_sensor.tengah<BATAS || nilai_sensor.kiri<BATAS)
{
if(nilai_sensor.kanan<BATAS)
{
error = 10;
}
else if(nilai_sensor.kanan<BATAS && nilai_sensor.tengah<BATAS)
{
error = 5;
}
else if(nilai_sensor.kiri<BATAS && nilai_sensor.tengah<BATAS)
{
error = -5;
}
else if(nilai_sensor.kiri<BATAS)
{
error = -10;
}
else
{
error = 0;
}
[Link] = main_speed - kp*error;
[Link] = main_speed + kp*error;
}
else
{
[Link] = 0.0;
[Link] = 0.0;
}

return kecepatan;
}

int main(int argc, char **argv) { 18

wb_robot_init();
sensor_robot sensor_garis;
©Jago Robotika
kecepatan_robot speed;
int main(int argc, char **argv) {
wb_robot_init();
sensor_robot sensor_garis;
kecepatan_robot speed;

WbDeviceTag motor_kanan = wb_robot_get_device("right wheel motor");

WbDeviceTag motor_kiri = wb_robot_get_device("left wheel motor");
WbDeviceTag sensor_garis_0 = wb_robot_get_device("gs0");
WbDeviceTag sensor_garis_1 = wb_robot_get_device("gs1");
WbDeviceTag sensor_garis_2 = wb_robot_get_device("gs2");
wb_distance_sensor_enable(sensor_garis_0, TIME_STEP);
wb_distance_sensor_enable(sensor_garis_1, TIME_STEP);
wb_distance_sensor_enable(sensor_garis_2, TIME_STEP);

wb_motor_set_position(motor_kanan, INFINITY);
wb_motor_set_position(motor_kiri, INFINITY);

while (wb_robot_step(TIME_STEP) != -1) {

sensor_garis.kiri = wb_distance_sensor_get_value(sensor_garis_0);
sensor_garis.tengah = wb_distance_sensor_get_value(sensor_garis_1);
sensor_garis.kanan = wb_distance_sensor_get_value(sensor_garis_2);

speed = advance_proportional_line_follower(sensor_garis);

wb_motor_set_velocity(motor_kanan, [Link]);
wb_motor_set_velocity(motor_kiri, [Link]);
};
wb_robot_cleanup();

return 0;
}

14. Tantangan: melewati tikungan siku

Dengan menggunakan konsep-konsep yang telah kamu pelajari, bisakah kamu memprogram
robotmu melewati tikungan siku (90 derajat)? Modifikasi programmu dan coba ujikan program
tersebut di lingkungan berisi tikungan siku. Gunakan world file lain yang telah kami sediakan
yaitu “e-puck_square.wbt”, dan “e-puck_square_zigzag.wbt” untuk mengetes kinerja robot line
follower-mu di lintasan yang lebih menantang.

Contoh program yang bisa digunakan untuk program siku akan dikirimkan usai kelas
berlangsung.

19
©Jago Robotika