Robot Penghindar Halangan Ultrasonic Car Arduino

Table Of Contents

Komponen yang Digunakan
Skema Rangkaian
Koneksi Rangkaian
Library yang Digunakan
Kode Program Lengkap
Penjelasan Fitur Menarik
Beli Robot Ini Sekarang!
Kesimpulan

Di era teknologi yang berkembang pesat, robotika menjadi bidang yang sangat menarik untuk dipelajari, terutama bagi pelajar dan penghobi elektronika. Salah satu jenis robot yang sering dijadikan proyek pembelajaran adalah robot penghindar halangan. Robot ini dapat mendeteksi objek di sekitarnya dan mengambil keputusan untuk menghindari tabrakan secara otomatis.

Penggunaan sensor ultrasonik seperti HC-SR04 memungkinkan robot untuk “melihat” objek di depannya dengan mengukur jarak menggunakan gelombang suara. Ditambah dengan motor DC yang dikontrol oleh Arduino dan driver motor L293D, robot ini dapat bergerak maju, mundur, belok kanan/kiri, bahkan melakukan manuver seperti zig-zag dan drift.

Dalam artikel ini, kita akan membuat robot penghindar halangan cerdas yang tidak hanya berhenti ketika ada halangan, tetapi juga mampu memilih arah terbaik untuk menghindar dan melakukan manuver acak agar tidak mudah terjebak. Proyek ini ideal untuk kamu yang ingin membuat robot otonom berbasis Arduino yang lebih canggih dan atraktif.

Komponen yang Digunakan

Arduino Uno / MFB ATMEL 328 micro
4x Motor DC + Roda
Motor Driver L293D (AFMotor Shield)
Sensor Ultrasonik HC-SR04
Servo Motor (untuk memutar sensor)
Kabel jumper dan baterai Li-ion 7.4V
Chassis robot 4 roda

Skema Rangkaian

Koneksi Rangkaian

Sensor Ultrasonik:

Komponen	Arduino
TRIG	A0
ECHO	A1

Motor (dengan AFMotor Shield):

Motor	Port AFMotor Shield
Motor Kiri Depan	M1
Motor Kiri Belakang	M2
Motor Kanan Depan	M3
Motor Kanan Belakang	M4

Servo:

Servo Motor	Arduino
Sinyal	D10
VCC	5V
GND	GND

Library yang Digunakan

Sebelum memulai coding, tambahkan terlebih dahulu beberapa library berikut:

Kode Program Lengkap

// PROGRAM INI DI BUAT OLEH  : MANFAHBOT INDUSTRIAL AUTOMATION
// HAK CIPTA PROGRAM/CODING  : LUKMAN HAKIM A.
// WEBSITE                   : http://manfahbot.cc

//---------------------------------------------------------
#include <AFMotor.h>
#include <NewPing.h>
#include <Servo.h>
#include <stdio.h>
//---------------------------------------------------------
#define TRIG_PIN A0
#define ECHO_PIN A1
#define MAX_DISTANCE 200
#define MIN_DISTANCE 15
#define MAX_SPEED 225
#define MAX_SPEED_OFFSET 20
#define USE_SERIAL Serial
//---------------------------------------------------------
NewPing sonar(TRIG_PIN, ECHO_PIN, MAX_DISTANCE);
AF_DCMotor motor1(1, MOTOR12_1KHZ);
AF_DCMotor motor2(2, MOTOR12_1KHZ);
AF_DCMotor motor3(3, MOTOR34_1KHZ);
AF_DCMotor motor4(4, MOTOR34_1KHZ);
Servo myservo;
//---------------------------------------------------------
boolean goesForward = false;
  int distance = 100;
  int speedSet = 0;
  int timeDriftR = 0;
  int timeDriftL = 0;
  int timeArroundR = 0;
  int timeArroundL = 0;
  int timeZigZag = 0;
  int timeZigZagRev = 0;
  int rndVar = 1500;
//----------------------------------------------------------
void setup() {
  myservo.attach(10);
  myservo.write(115);
  delay(2000);
  distance = readPing();
  delay(100);
  distance = readPing();
  delay(100);
  distance = readPing();
  delay(100);
  distance = readPing();
  delay(100);
}
//----------------------------------------------------------
void loop() {
  int distanceR = 0;
  int distanceL =  0;
  timeZigZag = random(rndVar);
  timeZigZagRev = random(rndVar);
  timeArroundR = random(rndVar);
  timeArroundL = random(rndVar);
  timeDriftR = random(rndVar);
  timeDriftL = random(rndVar);
  
  if (distance <= MIN_DISTANCE) {
    moveStop();
    delay(100);
    moveBackward();
    delay(500);
    moveStop();
    delay(200);
    distanceR = lookRight();
    delay(200);
    distanceL = lookLeft();
    delay(200);
      if (distanceR >= distanceL){
        turnRight();
        moveStop(); }
     else{
     turnLeft();
     moveStop(); } 
  }

  else{
    moveForward();
      if (timeArroundR == random(rndVar)) {
        moveStop();
          delay(500);
            arroundRight();
            distance = readPing(); }
      else if (timeZigZag == random(rndVar)) {
        moveStop();
          delay(500);
            zigZag();
            distance = readPing(); } 
      else if (timeArroundL == random(rndVar)) {
        moveStop();
          delay(500);
            arroundLeft();
            distance = readPing(); }
      else if (timeDriftR == random(rndVar)) {
        moveStop();
          delay(500);
            driftRight();
            distance = readPing(); }
     else if (timeDriftL == random(rndVar)) {
        moveStop();
          delay(500);
            driftLeft();
            distance = readPing(); }
     else if (timeZigZagRev == random(rndVar)) {
        moveStop();
          delay(500);
            zigZagReverse();
            distance = readPing(); }
  }
//----------------------------------------------------------
  distance = readPing();
    timeDriftR    = 0;
    timeDriftL    = 0;
    timeArroundR  = 0;
    timeArroundL  = 0;
    timeZigZag    = 0;
    timeZigZagRev = 0;
}
//----------------------------------------------------------
int lookRight() {
  myservo.write(50);
  delay(500);
      int distance = readPing();
      delay(100);
        myservo.write(115);
        return distance; }
int lookLeft() {
  myservo.write(170);
  delay(500);
    int distance = readPing();
    delay(100);
      myservo.write(115);
      return distance;
      delay(100); }
int readPing() {
  delay(70);
    int cm = sonar.ping_cm();
      if (cm == 0) {
        cm = 250; }
          USE_SERIAL.print("Jarak = ");
          USE_SERIAL.println(cm);
            return cm; }
void moveStop() {
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void moveForward() {
  goesForward = true;
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
  
  speedSet = MAX_SPEED;
  motor1.setSpeed(speedSet);
  motor2.setSpeed(speedSet);
  motor3.setSpeed(speedSet);
  motor4.setSpeed(speedSet);
}
void moveBackward() {
  goesForward = false;
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
  
  speedSet = MAX_SPEED;
  motor1.setSpeed(speedSet);
  motor2.setSpeed(speedSet);
  motor3.setSpeed(speedSet);
  motor4.setSpeed(speedSet);
}
void turnRight() {
  motor3.run(FORWARD);
  motor4.run(FORWARD);
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  delay(400);
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void turnLeft() {
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  delay(400);
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void zigZag() {
  for (int i = 0; i <= 5; i++) {
    motor1.run(FORWARD);
    motor2.run(FORWARD);
    delay(500);
    motor1.run(RELEASE);
    motor2.run(RELEASE);
    delay(500);
    motor3.run(FORWARD);
    motor4.run(FORWARD);
    delay(500);
    motor3.run(RELEASE);
    motor4.run(RELEASE);
    
    distance = readPing();
    if (distance <= MIN_DISTANCE) {
      i = 5;
    }
  }
}
void zigZagReverse() {
  for (int i = 0; i <= 3; i++) {
    motor1.run(BACKWARD);
    motor2.run(BACKWARD);
    delay(500);
    motor1.run(RELEASE);
    motor2.run(RELEASE);
    delay(500);
    motor3.run(BACKWARD);
    motor4.run(BACKWARD);
    delay(500);
    motor3.run(RELEASE);
    motor4.run(RELEASE);
  }
}
void arroundRight() {
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
  delay(600);
}
void arroundLeft() {
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
  delay(600);
}
void driftRight() {
  motor1.setSpeed(255);
  motor3.setSpeed(255);
  motor4.setSpeed(255);

  motor1.run(BACKWARD);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
  delay(600);
}
void driftLeft() {
  motor1.setSpeed(255);
  motor3.setSpeed(255);
  motor4.setSpeed(255);

  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(BACKWARD);
  delay(600);
}

Untuk fungsi gerakan seperti moveForward(), zigZag(), driftLeft() dan lainnya, dapat dilihat lengkap dalam source code di atas. Fungsi-fungsi ini memberikan karakter unik dalam navigasi robot yang membuatnya lebih fleksibel di berbagai medan.

Penjelasan Fitur Menarik

Zig-Zag: Robot bergerak secara zig-zag bergantian menggunakan motor kiri dan kanan.
Arround: Robot berputar setengah lingkaran ke kanan/kiri untuk menghindari area sempit.
Drift: Manuver tajam seperti “menggeser” arah dengan motor tertentu dimatikan sementara.
Random Time Trigger: Gerakan acak ini meminimalisir kemungkinan robot terjebak dalam pola berulang.

Beli Robot Ini Sekarang!

🛒 Ingin langsung memiliki robot ini tanpa perlu merakit?
Kami menyediakan robot penghindar halangan ini dalam bentuk paket jadi dan siap digunakan!

📦 Spesifikasi:

Dirakit rapi dengan casing akrilik/kustom
Full program sudah terpasang
Bisa langsung digunakan untuk pembelajaran atau lomba

🔗 Beli sekarang melalui Shopee MANFAHBOT
🔗 Atau hubungi kami via WhatsApp

untuk pemesanan langsung
(Link WA bisa diubah sesuai nomor admin yang aktif)

Kesimpulan

Robot penghindar halangan ini telah ditingkatkan dengan kemampuan manuver acak dan logika pengambilan keputusan berbasis jarak sensor. Dengan memanfaatkan library populer seperti AFMotor, Servo, dan NewPing, robot ini bisa digunakan sebagai dasar untuk proyek robotik lanjutan atau kontes robot.

Jika kamu ingin mengembangkan proyek ini lebih lanjut — seperti menambahkan sensor infrared, kamera, atau komunikasi Bluetooth — sistem yang kamu bangun sudah sangat siap untuk di-upgrade.

Ingin tahu cara menghubungkan robot ini ke aplikasi Android atau menambahkan pengenalan suara? Kirim pertanyaanmu ke tim MANFAHBOT Industrial Automation melalui situs resmi manfahbot.cc, dan kami siap bantu!

Ayo Belajari Otomasi Industri Bersama MANFAHBOT, Kami menyediakan layanan: