Line Follower Robot [Type Arduino Nano]

Line follower robot versi ini di rancang menggunakan Arduino Nano sebagai mikrokontroler utamanya, sebelumnya sudah pernah juga dibahas mengenai robot line follower yang menggunakan kendali pid, yang ingin tahu bagaimana penerapan kontrol pid mungkin bisa dibaca terlebih dahulu Line Follower Robot Using PID Control.

Selanjutnya ini merupakan line follower versi lanjutan yang dilengkapi dengan fitur tambahan tentunya, line follower versi ini menggunakan mikrokontroler arduino jadi sangat mungkin untuk kita melakukan pengembangan pada sisi pemrograman dikarenakan dengan Arduino IDE sudah sangat dipermudah untuk melakukan akses pin input outputnya, selain itu robot ini juga dilengkapi dengan LCD 16x2 untuk mempermudah dalam penambahan fitur dengan dilengakapi 4 push button sebagai tombol navigasi menu untuk malakukan pengaturan pada robot. Robot ini menggunakan 14 sensor photo dioda serta menggunakan kontrol PID yang membuat pergerakan robot menjadi lebih responsif mengikuti garis.
Spesifikasi

• Mikrokontroler Arduino Nano
• 14 sensor
• LCD 16x2
• 4 button setting
• Dual channel H-Bridge Driver Motor (L293D)
• Motor DC 12 V
• Battery LiPo 3S (12V)
• Ext. [1]. Stick controller/Bluetooth (Control with android) [2]. Flame sensor [3]. Motor DC fan [4]. Motor servo

Fitur Line Follower Type Nano

• Menggunakan PID kontroler
• Setting kalibrasi sensor (auto scan)
• Setting kecepatan
• Mode normal
• Mode manual Joystick
• Mode manual Bluetooth (aplikasi android)
• Mode pemadam api (line follower pemdam api manual/auto)

Gallery LFRobot Type Nano

Previous Next

Wall Follower Robot dengan Kendali PID

Kali ini saya akan membagikan mengenai robot lagi nih, yah robot.. namun masih seperti robot-robot sebelumnya yang sudah pernah saya tulis di blog ini yaitu masih mobile robot atau robot yang masih menggunakan roda sebagai penggeraknya dan masih robot follower juga hehe... namun berbeda dengan yang sebelumnya untuk robot light follower bisa dibaca disini.

Jadi robot yang akan dibahas kali ini adalah Wall Follower Robot atau robot pengikut dinding, artinya robot ini dapat berjalan dengan baik mengikuti dinding atau lintasan seperti labirin dan diharapkan tanpa menabrak tentunya. Cara kerja dari robot ini dengan membaca dan mendeteksi penghalang atau dinding terhadap robot dengan menggunakan sensor jarak, robot akan mengatur jaraknya terhadap dinding agar tetap konstan dengan cara robot akan bergerak jika terjadi perubahan jaraknya untuk kemudian menyesuaikan lagi secara terus menerus.

Rancangan Mekanik Wall Follower Robot

Rancangan Elektrikal

Tampilan Hasil Rancangan Wall Follower Robot

Wall Follower Dengan PID

Untuk menghasilkan pergerakan robot yang responsif, robot ini menggunakan kendali PID, pada artikel ini saya tidak akan membahas apa itu PID atau pengertian dari kendali PID, untuk lebih jelas mengenai PID ini mungkin bisa dibaca melalui jurnal-jurnal yang berkaitan dengan sistem kendali PID karena disini hanya akan dibahas penerapan kendali PID tersebut pada robot wall follower.

Pada robot ini digunakan 3 buah sensor jarak yang diletakkan pada robot, satu sensor diletakkan serong kiri, satu serong kanan dan satu sensor diletakkan menghadap depan. Jadi kendali pid nya bagaimana? oke.. jadi pada robot ini hanya satu sensor saja yang di pid kan yaitu bisa sensor kiri maupun kanan, artinya yang menjadi feedback untuk pengendalian pid ini didapat dari sensor jarak kiri ataupun kanan, jadi skenarionya gini.. sensor mana (kiri atau kanan) yang paling mendekati dinding maka jarak dari sensor tersebut yang digunakan untuk pengendalian pid, agar robot tidak menabrak depan maka itu fungsi dari sensor yang menghadap depan, untuk kondisi ini tidak masuk ke pengendalian pid.

Diagram Blok Kendali PID Pada Wall Follower Robot

Setpoint pada robot ini saya atur 10 cm yang artinya robot akan mempertahankan posisinya di 10 cm (kondisi ideal robot) dari dinding, caranya robot akan terus bergerak ke kiri maupun ke kanan jika kondisi tidak ideal dimana akan ada nilai error, pada kondisi error output PID akan mengeluarkan hasil kendalinya sesuai dengan besarnya nilai error yang terjadi dan kemudian akan di kalkulasikan denga nilai base PWM yang menjadi kecepatan PWM motor kiri maupun kanan, jika kondisi robot ideal atau jarak sesuai dengan setpoint maka robot akan bergerak lurus.

Ilustrasi Kendali PID Pada Wall Follower Robot

Dalam menentukan nilai parameter kendali PID bisa dilakukan dengan cara try and error atau dengan cara coba-coba namun dangan cara tersebut akan lebih sulit dan membutuhkan waktu yang lama untuk mendapatkan hasil kendali yang stabil, maka dari itu dalam menentukan nilai yang tepat untuk parameter aksi kontrol proporsional, integral dan derivative bisa dilakukan dengan melakukan tuning dengan metode Ziegler-Nichols sama seperti proses tuning yang di lakukan pada robot line follower, bisa di baca disini.

Light Follower Robot Arduino Dengan LDR

Waktu itu dapat pesanan project robot sederhana dari guru salah satu sekolah smk untuk bahan pembelajaran katanya, nah robot tersebut akan yang akan di bahas kali ini, jadi robot itu adalah light follower robot atau robot pengikut cahaya, robot ini merupakan robot yang berjenis mobile robot atau robot dengan menggunakan roda.

Light follower robot ini tidak jauh beda dengan robot line follower hanya saja perbedaannya jika line follower mengikuti track garis lain halnya dengan robot light follower ini mengkuti cahaya, artinya robot akan berjalan jika diberi cahaya pada sensor, dimana robot akan berjalan  ke arah sesuai dengan sensor mana yang terkena cahaya.

Sensor yang digunakan yaitu sensor LDR (light dependent resistor) pada robot ini menggunakan 3 sensor LDR yang dipasang di depan robot dengan menghadap depan robot, samping kanan robot dan samping kiri robot, sebagai pengendali pergerakan robot dan pemeroses siyal sensor digunakan arduino sebagai mikrokontroler robot ini.

Komponen yang dibutuhkan 

• 1x Arduino Uno
• 2x Motor DC
• 1x Driver Motor H-Bridge L298N
• 3x LDR (light dependent resistor)
• 3x Resistor 10k
• 1x Switch ON/OFF
• 1x Baterai 9V (di video menggunakan 4x baterai AA)
• Kabel secukupnya
• Chasis robot (robot ini menggunakan acrylic)
• Spacer

Rangkaian/wiring robot

Jika arah putaran motor tidak sesuai, balik kabel motor yang terhubung dengan output driver motor, untuk baterai bisa menggunakan baterai 9V atau 12V.

👉 UNTUK PEMESANAN ATAU CUSTOM PROJECT 👈

Program/coding arduino langsung copy ke software arduino dan upload ke arduino

/**************************
  light follower robot v2
  www.muhilham.com
  08/01/2020
***********************/

#define pin_MOTOR_DIRL 2
#define pin_MOTOR_PWML 3
#define pin_MOTOR_DIRR 4
#define pin_MOTOR_PWMR 5

#define Kec_Min -170
#define Kec_Max  220 // Max = 255

const int8_t pinSensor[3] = {A0, A1, A2}; // array pin sensor
int16_t limitSensor[3]; // array limit sensor
int16_t correction = 100; // nilai koreksi kalibrasi sensor

void setup() {
  Serial.begin(9600);
  pinMode(pin_MOTOR_DIRL, OUTPUT);
  pinMode(pin_MOTOR_PWML, OUTPUT);
  pinMode(pin_MOTOR_DIRR, OUTPUT);
  pinMode(pin_MOTOR_PWMR, OUTPUT);

  for (byte i = 0; i < 3; i++) { // kalibrasi sensor
    pinMode(pinSensor[i], INPUT);
    limitSensor[i] = analogRead(pinSensor[i]) + correction;
    if (limitSensor[i] > 1023) limitSensor[i] = 1023;
    delay(50);
  }
}

void loop() {
  Serial.print("|");
  Serial.print(limitSensor[0]);
  Serial.print("|");
  Serial.print(limitSensor[1]);
  Serial.print("|");
  Serial.print(limitSensor[2]);
  Serial.print("| |");

  Serial.print(analogRead(pinSensor[0]));
  Serial.print("|");
  Serial.print(analogRead(pinSensor[1]));
  Serial.print("|");
  Serial.print(analogRead(pinSensor[2]));
  Serial.print("| |");

  followLight();
}

void followLight() {
  int16_t sensor = BacaSensor();

  switch (sensor) {
    case 0b000 : driveMotor(0, 0); Serial.println("|  Stop"); break;        // Belok kiri
    case 0b001 : driveMotor(Kec_Max, Kec_Max / 2); Serial.println("|  Belok Kanan"); break;       // Belok kanan
    case 0b011 : driveMotor(Kec_Max / 2, Kec_Max / 3); Serial.println("|  Serong Kanan"); break;  // Serong kanan
    case 0b010 : driveMotor(Kec_Max, Kec_Max); Serial.println("|  Lurus"); break;          // Lurus
    case 0b111 : driveMotor(Kec_Max, Kec_Max); Serial.println("|  Lurus"); break;          // Lurus
    case 0b110 : driveMotor(Kec_Max / 3, Kec_Max / 2); Serial.println("|  Serong Kiri"); break;   // Serong kiri
    case 0b100 : driveMotor(Kec_Max / 2, Kec_Max); Serial.println("|  Belok Kiri"); break;        // Belok kiri
    case 0b101 : driveMotor(Kec_Max, Kec_Max); Serial.println("|  Lurus"); break;        // Belok kiri
  }
}

int16_t BacaSensor() {
  int16_t bitSensor = 0;

  for (byte i = 0; i < 3; i++) {
    if (analogRead(pinSensor[i]) > limitSensor[i]) {
      bitSensor = bitSensor | (0b100 >> i);
      Serial.print("1");
    } else Serial.print("0");
  }

  return bitSensor;
}


void driveMotor(int16_t Left, int16_t Right) {
  if (Left > 0) {
    digitalWrite(pin_MOTOR_DIRL, LOW);
  } else {
    digitalWrite(pin_MOTOR_DIRL, HIGH);
    Left = 255 + Left;
  }
  analogWrite(pin_MOTOR_PWML, Left);

  if (Right > 0) {
    digitalWrite(pin_MOTOR_DIRR, LOW);
  } else {
    digitalWrite(pin_MOTOR_DIRR, HIGH);
    Right = 255 + Right;
  }
  analogWrite(pin_MOTOR_PWMR, Right);
}

Line Follower Robot Using PID Control

Line Follower Robot merupakan robot yang dapat mengikuti garis, sebagai peng-indera robot ini menggunakan sensor yang  berguna untuk membaca atau mendeteksi garis, warna garis yang biasa di gunakan adalah putih untuk base/dasar lapangan warna hitam dan garis hitam untuk base/dasar lapangan putih, dengan dua warna berbeda itu sensor dapat mendeteksi garis dengan cara membedakan warna yang gelap dan warna yang terang.

Untuk sensor yang biasa digunakan untuk membaca garis diantaranya sensor photodioda, phototransistor, infrared maupun sensor LDR (Light Dependent Resistor), untuk robot yang saya buat kali ini menggunakan sensor photodioda kenapa sensor itu, karena sensor ini mudah didapat yang banyak dijual di toko komponen elektronika dan harga yang juga terjangkau tentunya.

Gambar Ilustrasi Mekanisme Pembacaan Sensor Garis.

Kemudian untuk pemeroses atau otak dari robot ini menggunakan mikrokontroler, untuk robot line follower kali ini saya menggunakan mikrokontroler arduino yaitu arduino uno fungsi dari mikro untuk memproses data dari sensor dan kemudian mengontrol motor sebagai aktuator penggerak robot, mikrokontroler ini di isi dengan program atau coding yang akan mengatur robot untuk bernavigasi mengikuti garis.

Lalu bagaimana robot bisa dengan baik bernavigasi mengikuti garis, yaap.. kita masuk pada inti dari robot ini yaitu sistem kontrol PID pada robot line follower, dengan menerapkan kontroler PID yang tepat pada robot line follower pergerakan robot akan lebih halus dibandingkan menggunakan kontrol ON-OFF.

Apa itu PID?

PID singkatan dari Proporsional Integral Derivative, merupakan sebuah algoritma kontrol yang sudah lama ada dan sangat populer digunakan pada sistem kontrol di industri maupun dibidang robotic, sistem kendali ini dapat digunakan pada sistem yang memiliki umpan balik (feedback), kontrol PID ini akan menghitung nilai error, yaitu perbedaan antara nilai setpoint (nilai yang diinginkan) dan variabel prosses terukur (process variable), kontrol ini akan mencoba untuk megurangi nilai error agar menuju ke setpoint yang diinginkan.

Diagram Blok Kontrol PID

Bentuk Kontroler PID Diskrit

Diagram Blok Penerapan Kontrol PID Pada Robot Line Follower

• Setpoint, merupakan parameter nilai yang diinginkan.
• Process Variable, merupakan bobot nilai sensor yang dibaca sesuai dengan pembacaan sensor saat itu.
• Error, merupakan nilai kesalahan yang di dapat dari ( Setpoint - Process Variable ).

Kontrol PID Pada Robot Line Follower

Robot line follower yang akan di kontrol degan PID kali ini menggunakan 8 sensor, garis yang digunakan dengan lebar 2-3 cm yang memungkinkan mengenai 2 sensor kemudian lakukan mapping pada sensor untuk mendapatkan nilai process variable, untuk 8 sensor hasil mapping nilai process variable kurang lebih sebagai berikut :

    /** 1 di asusmsikan sensor mengenai garis **/
    case 0b00000001 : NilaiPosisi = -10; break;
    case 0b00000111 : NilaiPosisi = -9; break;
    case 0b00000011 : NilaiPosisi = -8; break;
    case 0b00000010 : NilaiPosisi = -7; break;
    case 0b00001110 : NilaiPosisi = -6; break;
    case 0b00000110 : NilaiPosisi = -5; break;
    case 0b00000100 : NilaiPosisi = -4; break;
    case 0b00011100 : NilaiPosisi = -3; break;
    case 0b00001100 : NilaiPosisi = -2; break;
    case 0b00001000 : NilaiPosisi = -1; break;
    case 0b00011000 : NilaiPosisi = -0; break;
    case 0b00010000 : NilaiPosisi =  1; break;
    case 0b00110000 : NilaiPosisi =  2; break;
    case 0b00111000 : NilaiPosisi =  3; break;
    case 0b00100000 : NilaiPosisi =  4; break;
    case 0b01100000 : NilaiPosisi =  5; break;
    case 0b01110000 : NilaiPosisi =  6; break;
    case 0b01000000 : NilaiPosisi =  7; break;
    case 0b11000000 : NilaiPosisi =  8; break;
    case 0b11100000 : NilaiPosisi =  9; break;
    case 0b10000000 : NilaiPosisi =  10; break;

kondisi ideal robot adalah pada saat sensor berada pada posisi 00011000 (nilai 1 di asumsikan sensor mengenai garis) atau NilaiPosisi = 0 dan Setpoint = 0 merupakan posisi ideal robot line follower jika NilaiPosisi tidak = 0 berarti robot tidak pada posisi ideal dan artinya ada nilai error, pada kondisi error output PID akan mengeluarkan hasil kendalinya sesuai dengan besaran error yang terjadi dan kemudian akan dikalkulasikan dengan nilai base PWM yang ditentukan untuk menjadi PWM ke motor kiri dan kanan.

Formula perhitungan PWM motor kiri dan kanan sebagai berikut :
motorKi = BasePWM - outPID;      ( Motor Kiri )
motorKa = BasePWM + outPID;    ( Motor Kanan )

Pada pemrograman robot line follower perhitungan PID ditulis sebagai berikut :

double Error = 0, SumError = 0, LastError = 0;
double BasePWM = 250; 
double Kp = 43;       // Proporsional 
double Ki = 0.2;      // Integral     
double Kd = 145;      // Diferensial
double Ts = 1;        // Time sampling

/**** Fungsi perhitungan PID ****/
void lineFollow() {
  robotPosition();
  int SetPoint = 0;                      // Setpoint yang diinginkan
  Error = SetPoint - NilaiPosisi;        // Error
  double DeltaError = Error - LastError; // Delta Error (Selisih error sekarang e(t) dengan error sebelumya e(t-1))
  SumError += LastError;                 // Akumulasi error
  double P = Kp * Error;                 // Kontrol proporsional
  double I = Ki * SumError * Ts;         // Kontrol integral
  double D = ((Kd / Ts) * DeltaError);   // Kontrol derivative
  LastError = Error;                     // Error sebelumnya
  outPID = P + I + D;                    // Output PID
  double motorKi = BasePWM - outPID;     // Motor Kiri
  double motorKa = BasePWM + outPID;     // Motor Kanan
  /*** Pembatasan kecepatan ***/
  if (motorKi > Kec_Max)motorKi = Kec_Max;
  if (motorKi < Kec_Min)motorKi = Kec_Min;
  if (motorKa > Kec_Max)motorKa = Kec_Max;
  if (motorKa < Kec_Min)motorKa = Kec_Min;
  driveMotor(motorKi, motorKa);
}

Tuning Kontroler PID Robot Line Follower
Proses tuning bertujuan untuk menentukan nilai yang tepat untuk parameter aksi kontrol proporsional, integral, derivative pada robot line follower, proses tuning dilakukan dengan menggunkan metode tuning Ziegler-Nichols metode ini dilakukan dengan cara memberikan kontrol proporsional pada sistem close loop dan plant di dalamnya.

Kemudian memberikan nilai Kcr (kontrol proporsional), nilai Ki = 0 (kontrol integral) dan Kd = 0 (kontrol derivative) hingga sistem memperlihatkan grafik yang berosilasi terus menerus secara teratur contoh pada gambar berikut :

Dari grafik osilasi yang berkesinambungan dan dari penguatan Kcr kemudian dapatkan nilai Pcr (periode kritis) untuk mendapatkan nilai Kp, Ki, Kd dihitung sesuai aturan Ziegler-Nichols sebagai berikut:

Setelah nilai Kp, Ki, Kd di dapatkan kemudian masukkan pada program line follower, jika semua nilai parameter sudah tepat maka robot akan bergerak mengikuti garis dengan baik dan akan didapatkan grafik yang memperlihatkan respon posisi yang selalu menuju setpoint seperti gambar berikut :

Untuk hasilnya silahkan lihat pada video berikut.

Referensi : 

• https://id.wikipedia.org/wiki/PID

Membuat Mobil Remote Control dengan Arduino [RC Car Control with Bluetooth]

Kali ini kita akan membuat sebuah Mobil Remote Control atau bisa di sebut RC Robot yang berjenis Mobile Robot (robot berroda) robot ini akan dikendalikan menggunakan sebuah smartphone Android melalui koneksi bluetooth dengan menggunakan aplikasi Arduino Bluetooth RC Car yang dapat di download secara gratis di google play store.

Untuk module bluetooth yang digunakan adalah Module Bluetooth HC-05 yang terkoneksi dengan Pin digital Arduino Uno sebagai kontrol utama, dan untuk body robot sendiri bisa di beli atau di rancang sendiri, kalau saya sendiri untuk body robotnya buat sendiri dengan bahan Acrylic yang tebalnya 3mm, untuk lebih lengkapnya ikuti langkah-langkah berikut.

Untuk komponen yang di perlukan sebagai berikut :

• Arduino Uno (satu saja)
• Driver Motor H-Bridge L298N (satu saja)
• Modul Bluetooth HC-05 (satu saja)
• Motor DC dengan Gearbox (sepasang)
• Roda (sepasang)
• Freewheel/Roda depan pakai roll on bekas parfume/freshcare (satu saja)
• Body Robot/Casis 1x (satu saja)
• Spacer (secukupnya)
• Kabel Jumper (secukupnya)
• Switch (satu saja)
• Baterai Lipo (satu saja)
• Smartphone
• Aplikasi Bluetooth RC Controller (download di sini)

Setelah semua komponen sudah lengkap selanjutnya masuk proses perakitan untuk Skema perakitan/Diagram rangkaian sebagai berikut.

• Wiring pada DRIVER MOTOR dengan MOTOR DC dan membuat kabel koneksi pada PIN INPUT yang ada di DRIVER MOTOR untuk ke PIN ARDUINO nantinya dan pasang SWITCH ON/OFF.
  
• Memasang SPACER dan menghubungkan PIN dari ARDUINO ke PIN INPUT yang ada di DRIVER MOTOR sesuai dengan diagram rangkaian, hubungkan juga 5V,GND dari DRIVER MOTOR menuju 5V,GND yang ada di ARDUINO dan letakkan BATERAI di bawah ARDUINO.
  
• Selanjutnya pasang MODULE BLUETOOTH sesuai dengan diagram rangkaian TX ke PIN 12 dan RX ke PIN 13 ARDUINO, jangan lupa hubungkan power untuk BLUETOOTH yaitu VCC ke 3.3V dan GND ke GND ARDUINO, untuk menghidupkan MODULE BLUETOOH ini dengan tegangan 3.3V sudah bisa berfungsi dengan baik.
  
• Hubungkan BATERAI dan cek kembali rangkaian coba untuk menyalakan untuk test koneksi kabel-kabel.
  
• Pasang roda FREEWHEEL.
  
• Berikutnya PROGRAMING dengan ARDUINO IDE, hubungkan kabel arduino ke PC/Laptop dan UPLOAD PROGRAM.
  

     Silahkan langsung copy coding arduino berikut ke software arduino.

/* BLUETOOTH RC CONTROLLER ANDROID 
MUHILHAM.COM  ..  2017*/

// For Motor Driver L298N
#include <SoftwareSerial.h>
SoftwareSerial mySerial(12, 13); // TX,RX
#define MR1 3  // IN1 
#define MR2 5  // IN2 
#define ML1 9  // IN4 
#define ML2 10 // IN3 

/*
int MR1 = 3;  // IN1
int MR2 = 5;  // IN2
int ML1 = 9;  // IN4
int ML2 = 10; // IN3
*/

int data=0;
int Speed=0;
boolean maju=true;
int kec[11]={0,80,100,120,140,160,180,200,220,240,255}; //array kecepatan

void setup(){
  mySerial.begin(9600); 
  pinMode(MR1,OUTPUT);
  pinMode(MR2,OUTPUT);
  pinMode(ML1,OUTPUT);
  pinMode(ML2,OUTPUT);
}

void motorOut(unsigned char lpwm, unsigned char rpwm, boolean arrow){

  if(arrow==false){
    digitalWrite(ML1,HIGH);
    digitalWrite(MR1,LOW);
    analogWrite(ML2,255-lpwm);
    analogWrite(MR2,rpwm);
    }
  else{
    digitalWrite(ML1,LOW);
    digitalWrite(MR1,HIGH);
    analogWrite(ML2,lpwm);
    analogWrite(MR2,255-rpwm);
    }
}

void loop(){
  
  /* Commands/Characters sent from APP Bluetooth RC Controller (ANDROID)
  Forward ->F
  Back  -> B
  Left  -> L
  Right -> R
  Forward Left  -> G
  Forward Righ  -> I
  Back Left -> H
  Back Right  -> J
  Stop  -> S
  Speed 10  -> 1
  Speed 20  -> 2
  Speed 30  -> 3
  Speed 40  -> 4
  Speed 50  -> 5
  Speed 60  -> 6
  Speed 70  -> 7
  Speed 80  -> 8
  Speed 90  -> 9
  Speed 100 -> q
  Stop All  -> D */
  
  if(mySerial.available()>0){
    data=mySerial.read();
    
    //penyimpan data kecepatan
    if (data =='0') { Speed=0; }
    else if (data =='1') { Speed=1;}
    else if (data =='2') { Speed=2;}
    else if (data =='3') { Speed=3;}
    else if (data =='4') { Speed=4;}
    else if (data =='5') { Speed=5;}
    else if (data =='6') { Speed=6;}
    else if (data =='7') { Speed=7;}
    else if (data =='8') { Speed=8;}
    else if (data =='9') { Speed=9;}
    else if (data =='q') { Speed=10;}
    
    if (data=='S')
    {
      motorOut(0,0,false);
    } // S=Stop
    
    if (data=='F')
    {
      motorOut(kec[Speed],kec[Speed],true);
    } // F=Maju
    
    if (data=='I')
    {
      motorOut(kec[Speed],((kec[Speed])/2),true);
    } // I=Maju sambil belok kanan
    
    if (data=='G')
    {
      motorOut(((kec[Speed])/2),kec[Speed],true);
    } // G=Maju sambil belok kiri
    
    if (data=='R')
    {
      motorOut(kec[Speed],0,true);
    } // R=Belok kanan
    
    if (data=='L')
    {
      motorOut(0,kec[Speed],true);
    } // L=Belok kiri
    
    if (data=='B')
    {
      motorOut(kec[Speed],kec[Speed],false);
    } // B=Mundur
    
    if (data=='H')
    {
      motorOut(((kec[Speed])/2),kec[Speed],false);
    } // H=Mundur sambil belok kiri
    
    if (data=='J')
    {
      motorOut(kec[Speed],((kec[Speed])/2),false);
    } // J=Mundur sambil belok kanan
  }
}

• Langkah selanjutnya coba koneksikan ROBOT dengan SMARTPHONE/ANDROID dengan cara PAIRING /SANDINGKAN telebih dahulu BLUETOOTH  HC-05 biasanya masukkan PASSWORD default PASS 1234, setelah di sandingkan buka aplikasi Bluetooth RC Controller pilih menu GEAR pilih CONNECT TO CAR.
• SELESAI. test dengan menekan tombol pada aplikasi.

Sekian artikel kali ini, semoga bisa di coba dan berhasil, jika ada yang kurang jelas ingin ditanyakan silahkan tinggalkan komentar :). semoga bermanfaat, Terimakasihh..

Oke, Untuk hasilnya lihat pada video berikut.