Sistem Navigasi Penakut Cahaya Otonom menggunakan Raspberry Pi 4B

Adidan Ari Sena Putra¹, Faris Abdurrahman Hilmi Kusuma², Muhammad Jihar Mumtaz Attaya³, Rafa Rizky Wijaya⁴

Jurusan Teknik Elektro, Prodi Teknologi Rekayasa Elektronika, Politeknik Negeri Semarang

Jl. Prof. Soedarto, Tembalang, Kec. Tembalang, Kota Semarang, Jawa Tengah, 50275

¹adidan.43423001@mhs.polines.ac.id
²faris.43423007@mhs.polines.ac.id
³jihar.43423013@mhs.polines.ac.id
⁴rafa.43423019@mhs.polines.ac.id

INTISARI

Penelitian ini mengembangkan robot penakut cahaya (photophobic robot) berbasis Raspberry Pi 4B untuk melindungi material sensitif dari paparan cahaya di lingkungan industri. Sistem ini mengintegrasikan sensor LDR untuk deteksi cahaya dan sensor ultrasonik HC-SR04 untuk penghindaran rintangan otonom. Dengan pendekatan pemrograman state-based berbasis Python, robot akan bermanuver menjauhi sumber cahaya atau halangan dan berhenti secara otomatis saat mencapai area gelap. Hasil penelitian menunjukkan bahwa integrasi antara unit pemrosesan, sensor, dan aktuator mampu menciptakan sistem navigasi otonom yang andal untuk menjaga robot tetap berada di zona aman.

Kata Kunci: Robot Penakut Cahaya, Raspberry Pi 4B, Fototaksis Negatif, Navigasi Otonom, Sensor Ultrasonik.

I. PENDAHULUAN

A. Latar Belakang

Di era industri modern, kontrol kondisi lingkungan kerja sangat krusial pada sektor-sektor sensitif seperti manufaktur semikonduktor (photolithography), penyimpanan obat photolabile, dan pelestarian arsip sejarah, di mana paparan cahaya intens dapat memicu degradasi material dan kerusakan sirkuit mikro. Sebagai studi awal otomasi pada area tersebut, penelitian ini menerapkan konsep fototaksis negatif melalui perancangan Robot Penakut Cahaya berbasis Raspberry Pi 4B dan platform Smart Car Trainer Kit. Menggunakan sensor LDR untuk mendeteksi sinyal analog dari sumber cahaya kuat, sistem ini dikondisikan untuk bergerak menjauh secara mandiri menuju area gelap. Mengingat navigasi berbasis visi konvensional tidak efektif dalam ruang gelap total, robot ini diintegrasikan dengan sensor ultrasonik HC-SR04 untuk mendeteksi halangan pada jarak kurang dari 5 cm, memastikan kemampuan menghindari tabrakan (autonomous obstacle avoidance) yang andal selama proses bermanuver melindungi diri dari paparan cahaya.

II. METODOLOGI PENELITIAN

Penelitian ini menggunakan metode pengembangan eksperimental melalui tahapan perancangan sistem, implementasi perangkat keras, pengembangan perangkat lunak, dan pengujian performa robot.

1. Perancangan Sistem (System Design)

Tahapan ini melibatkan penentuan arsitektur sistem yang membagi alur kerja menjadi tiga subsistem utama:

Subsistem Persepsi: Mengolah input analog dari sensor LDR untuk deteksi cahaya dan input pulsa dari sensor ultrasonik HC-SR04 untuk deteksi jarak.
Subsistem Kontrol: Raspberry Pi 4B berfungsi sebagai central processing unit yang menjalankan logika pengambilan keputusan (decision-making).
Subsistem Aktuasi: Mengendalikan driver motor DC untuk pergerakan roda, serta output pendukung berupa buzzer dan LED sebagai indikator status sistem.

2. Implementasi Perangkat Keras (Hardware Implementation)

Perangkat keras dirakit di atas platform Smart Car Trainer Kit dengan konfigurasi teknis sebagai berikut:

Antarmuka ADC: Mengingat Raspberry Pi tidak memiliki pin ADC bawaan, digunakan modul eksternal (misal: MCP3008) untuk mengonversi sinyal analog LDR menjadi data digital.
Sensor Ultrasonik: Pemasangan sensor HC-SR04 pada bagian depan chassis untuk mencakup area deteksi halangan dengan threshold jarak di bawah 5 cm.
Sistem Daya & Motor: Integrasi Motor Driver (misal: L298N) untuk mengatur arah putar dan kecepatan motor DC berdasarkan perintah dari GPIO Raspberry Pi.

3. Pengembangan Perangkat Lunak (Software Implementation)

Pengembangan perangkat lunak menggunakan bahasa pemrograman Python dengan pendekatan state-based programming:

Konfigurasi I/O: Inisialisasi pustaka GPIO untuk mengelola komunikasi data antara sensor and aktuator.
Logika Perilaku: Implementasi dua mode utama:
- Mode Aman: Robot berhenti saat intensitas cahaya di bawah ambang batas (area gelap).
- Mode Panik: Robot aktif mencari arah menjauh (belok/mundur) ketika sensor LDR menangkap intensitas cahaya tinggi.
Navigasi Darurat: Algoritma prioritas (interrupt-driven) di mana sensor HC-SR04 akan memicu manuver emergency bypass (mundur dan berbelok acak) jika mendeteksi objek < 5 cm, mengabaikan kondisi cahaya sementara waktu.
Efisiensi Terminal: Implementasi state tracking variabel untuk memastikan informasi status sistem hanya muncul di terminal SSH saat terjadi perubahan kondisi, guna mencegah log spamming.

4. Prosedur Pengujian (Testing & Validation)

Pengujian dilakukan untuk memastikan keandalan sistem dalam berbagai kondisi lingkungan:

Uji Sensitivitas LDR: Kalibrasi nilai threshold cahaya agar robot mampu membedakan area dengan paparan cahaya tinggi dan area gelap secara akurat.
Uji Navigasi Otonom: Pengujian kemampuan robot bergerak menjauh dari sumber cahaya (fototaksis negatif) dalam ruang tertutup.
Uji Obstacle Avoidance: Pengujian validasi jarak pemicu emergency untuk memastikan robot tidak menabrak objek saat melakukan manuver penghindaran.
Uji Stabilitas Sistem: Observasi penggunaan resource CPU pada Raspberry Pi untuk memastikan durasi operasional yang stabil tanpa adanya bottleneck pada skrip Python yang berjalan.

III. HASIL DAN PEMBAHASAN

A. Cara Kerja Sistem

Inisialisasi Sistem: Proses diawali dengan tahap "Mulai", di mana sistem melakukan inisialisasi pada seluruh pin GPIO Raspberry Pi yang digunakan sebagai antarmuka input dan output.
Akuisisi Data Sensor: Setelah inisialisasi, sistem menjalankan proses pembacaan logika sensor LDR untuk mendeteksi intensitas cahaya, diikuti dengan proses konversi nilai dari sensor ultrasonik HC-SR04 untuk menentukan jarak objek di depan robot.
Pengambilan Keputusan (Logika Kondisional): Sistem kemudian mengevaluasi kondisi lingkungan dengan pertanyaan: "Apakah terkena cahaya?" (cahaya terdeteksi = True) dan "Apakah jarak objek < 5 cm?".
Mode Menghindar & Mode Aman: Jika kondisi cahaya terdeteksi (cahaya = True) atau terdeteksi adanya halangan dalam jarak dekat, maka robot akan masuk ke fase "Menghindar" dengan melakukan manuver mundur dan belok acak, kemudian motor maju kembali untuk mencari area gelap. Apabila kondisi cahaya tidak terdeteksi (kondisi gelap), maka sistem akan menjalankan perintah "Motor Berhenti" agar robot tetap bersembunyi di area gelap tersebut, yang kemudian mengakhiri siklus operasional sistem.

B. Diagram Blok Sistem

Gambar 1. Diagram Blok Sistem

Masukan: Bagian ini berfungsi untuk mengumpulkan data lingkungan melalui sensor LDR yang mendeteksi cahaya dan sensor ultrasonik yang mendeteksi jarak halangan.
Proses: Bagian ini bertanggung jawab dalam menyediakan daya melalui baterai dan modul step down, serta mengolah seluruh logika keputusan sistem melalui Raspberry Pi 4B.
Keluaran: Bagian ini berperan sebagai eksekutor yang menggerakkan motor melalui driver serta memberikan umpan balik visual dan audio melalui LED dan buzzer.

C. Diagram Alir

Gambar 2. Diagram Alir Sistem

D. Kode Program Utama

"""
========================================================================
Pemrogram       : Kelompok RE-3A/1
1. 01-Adidan Ari Sena Putra     NIM:4.34.23.0.01
2. 07-Faris Abdurrahman H       NIM:4.34.23.0.07
3. 13-M. Jihar Mumtaz A         NIM:4.34.23.0.13
4. 19-Rafa Rizky W              NIM:4.34.23.0.19
Tgl.Praktikum   : Jumat, 12 Juni 2026
========================================================================

Proyek Robot Penakut Cahaya
Robot_Penakut_Cahaya.py
Program robot untuk mencari tempat gelap dan menghindari rintangan
========================================================================

Materi baru:
- Pengendalian Motor DC menggunakan Driver L298N Mini
- Pembacaan sensor jarak Ultrasonik (HC-SR04) dengan fungsi waktu
- Pembacaan input digital dari modul sensor cahaya (LDR)
- Implementasi logika percabangan dan pemilihan arah acak (random)
========================================================================

Komponen:
- 1x Raspberry Pi 4
- 1x Modul Driver Motor L298N Mini
- 2x Motor DC (Kanan & Kiri)
- 1x Sensor Ultrasonik HC-SR04
- 1x Modul Sensor Cahaya LDR (Output Digital)
- 1x Active Buzzer
- 1x LED 5mm & Resistor 220Ω
- 1x Resistor 1kΩ & 1x Resistor 2kΩ (Untuk Voltage Divider Echo)
- Baterai dan Modul Step-Down DC-DC
========================================================================
"""

# Mengimpor library RPi.GPIO untuk mengendalikan pin GPIO pada Raspberry Pi
import RPi.GPIO as GPIO
# Mengimpor library time untuk keperluan jeda waktu (delay) dan perhitungan jarak
import time
# Mengimpor library random untuk mengacak arah belok saat robot menemui jalan buntu
import random

# ========================================================================
# KONFIGURASI PIN GPIO (Ganti nomor sesuai wiring di kit kamu)
# Gunakan penomoran BCM (Broadcom SOC channel)
# ========================================================================

# Pin Motor Kanan (Motor A)
IN1 = 17  # Pin pengontrol arah maju motor kanan
IN2 = 27  # Pin pengontrol arah mundur motor kanan

# Pin Motor Kiri (Motor B)
IN3 = 22  # Pin pengontrol arah maju motor kiri
IN4 = 23  # Pin pengontrol arah mundur motor kiri

# Pin Sensor Ultrasonic HC-SR04
TRIG = 5  # Pin pemancar gelombang ultrasonik
ECHO = 6  # Pin penerima pantulan gelombang ultrasonik

# Pin Sensor LDR (Cahaya) dan Indikator
LDR_PIN = 13     # Pin output digital dari modul LDR
BUZZER_PIN = 19  # Pin untuk mengontrol Buzzer
LED_PIN = 26     # Pin untuk mengontrol LED peringatan


# ========================================================================
# SETUP AWAL
# ========================================================================

# Mematikan peringatan (warnings) bawaan dari library GPIO
GPIO.setwarnings(False)

# Trik untuk mencegah error "lgpio GPIO not allocated" pada OS Bookworm

# Lakukan cleanup DULUAN untuk mereset pin yang nyangkut
try:
    GPIO.cleanup()
except:
    pass

# Mengatur mode penomoran pin menggunakan standar BCM (HARUS SETELAH CLEANUP)
GPIO.setmode(GPIO.BCM)

# Mengatur pin motor sebagai OUTPUT
GPIO.setup(IN1, GPIO.OUT)
GPIO.setup(IN2, GPIO.OUT)
GPIO.setup(IN3, GPIO.OUT)
GPIO.setup(IN4, GPIO.OUT)

# Mengatur pin sensor ultrasonik (TRIG sebagai OUTPUT, ECHO sebagai INPUT)
GPIO.setup(TRIG, GPIO.OUT)
GPIO.setup(ECHO, GPIO.IN)

# Mengatur pin indikator sebagai OUTPUT
GPIO.setup(BUZZER_PIN, GPIO.OUT)
GPIO.setup(LED_PIN, GPIO.OUT)

# Mengatur pin sensor LDR sebagai INPUT
GPIO.setup(LDR_PIN, GPIO.IN)

# Memastikan kondisi awal TRIG adalah LOW (mati)
GPIO.output(TRIG, False)
print("Menunggu sensor HC-SR04 stabil...")
# Memberikan waktu 2 detik agar sensor stabil sebelum loop dimulai
time.sleep(2)


# ========================================================================
# FUNGSI-FUNGSI PENGENDALI (FUNGSI MOTOR & SENSOR)
# ========================================================================

def get_distance():
    # Mengirimkan sinyal ultrasonik selama 10 mikrodetik
    GPIO.output(TRIG, True)
    time.sleep(0.00001)
    GPIO.output(TRIG, False)
    
    pulse_start = time.time()  # Variabel awal untuk mencatat waktu
    pulse_end = time.time()    # Variabel akhir untuk mencatat waktu
    
    # Mencatat waktu saat ECHO mulai menerima sinyal (menjadi HIGH)
    while GPIO.input(ECHO) == 0:
        pulse_start = time.time()
        
    # Mencatat waktu saat sinyal ECHO selesai (kembali menjadi LOW)
    while GPIO.input(ECHO) == 1:
        pulse_end = time.time()
        
    # Menghitung durasi pantulan gelombang
    pulse_duration = pulse_end - pulse_start
    # Menghitung jarak berdasarkan kecepatan suara (34300 cm/s) dibagi 2 (bolak-balik)
    distance = pulse_duration * 17150
    # Mengembalikan nilai jarak dengan pembulatan 2 angka di belakang koma
    return round(distance, 2)

def move_forward():
    # Menggerakkan kedua motor ke depan (IN1 & IN3 HIGH, sisanya LOW)
    GPIO.output(IN1, True)
    GPIO.output(IN2, False)
    GPIO.output(IN3, True)
    GPIO.output(IN4, False)

def move_backward():
    # Menggerakkan kedua motor ke belakang (IN2 & IN4 HIGH, sisanya LOW)
    GPIO.output(IN1, False)
    GPIO.output(IN2, True)
    GPIO.output(IN3, False)
    GPIO.output(IN4, True)

def turn_left():
    # Belok kiri: Motor kanan maju, Motor kiri mundur (pivot)
    GPIO.output(IN1, True)
    GPIO.output(IN2, False)
    GPIO.output(IN3, False)
    GPIO.output(IN4, True)

def turn_right():
    # Belok kanan: Motor kiri maju, Motor kanan mundur (pivot)
    GPIO.output(IN1, False)
    GPIO.output(IN2, True)
    GPIO.output(IN3, True)
    GPIO.output(IN4, False)

def stop_motor():
    # Menghentikan semua motor dengan memberi logika LOW ke semua pin
    GPIO.output(IN1, False)
    GPIO.output(IN2, False)
    GPIO.output(IN3, False)
    GPIO.output(IN4, False)

def alarm_panic(state):
    # Jika state True, nyalakan buzzer dan LED. Jika False, matikan.
    if state:
        GPIO.output(BUZZER_PIN, True)
        GPIO.output(LED_PIN, True)
    else:
        GPIO.output(BUZZER_PIN, False)
        GPIO.output(LED_PIN, False)


# ========================================================================
# LOOP UTAMA (LOGIKA PERILAKU ROBOT)
# ========================================================================

print("Program Robot Penakut Cahaya Dimulai! Tekan CTRL+C untuk berhenti.")

# Variabel untuk melacak status sebelumnya agar print tidak spam
status_setbelumnya = ""

try:
    # Memulai perulangan tanpa henti (infinite loop)
    while True:
        # Membaca nilai dari sensor cahaya LDR
        # Catatan: Asumsi modul mengeluarkan logika '0' saat Terang, dan '1' saat Gelap
        # Sesuaikan (ganti '== 0' menjadi '== 1') jika modulmu kebalikannya
        cahaya_terdeteksi = GPIO.input(LDR_PIN) == 0
        
        if cahaya_terdeteksi:
            # --- ROBOT DALAM MODE PANIK (TERKENA CAHAYA) ---
            
            # Cek apakah status sebelumnya bukan PANIK
            if status_setbelumnya != "PANIK":
                print("Status: PANIK! Mencari tempat gelap...")
                status_setbelumnya = "PANIK"  # Update status
                
            alarm_panic(True)  # Nyalakan indikator kepanikan
            
            # Cek jarak halangan di depan menggunakan ultrasonik
            jarak = get_distance()
            
            if jarak < 5.0:
                # Jika jarak halangan kurang dari 20 cm, robot harus menghindar
                stop_motor()         # Berhenti sejenak agar tidak menabrak
                time.sleep(0.2)
                move_backward()      # Mundur sedikit untuk memberi ruang
                time.sleep(0.5)      # Mundur selama 0.5 detik
                
                # Memilih arah belok secara acak (kiri atau kanan) untuk menghindari pola berulang
                if random.choice(["kiri", "kanan"]) == "kiri":
                    turn_left()
                else:
                    turn_right()
                time.sleep(0.4)      # Berputar selama 0.4 detik
                
            else:
                # Jika tidak ada halangan di depan, lari lurus ke depan
                move_forward()
                
            # Jeda singkat agar pembacaan sensor ultrasonik tidak tumpang tindih
            time.sleep(0.1)
            
        else:
            # --- ROBOT DALAM MODE AMAN (BERADA DI TEMPAT GELAP) ---
            
            # Cek apakah status sebelumnya bukan AMAN
            if status_setbelumnya != "AMAN":
                print("Status: Aman. Bersembunyi di tempat gelap...")
                status_setbelumnya = "AMAN"  # Update status
                
            alarm_panic(False)  # Matikan indikator kepanikan
            stop_motor()        # Diam di tempat bersembunyi
            time.sleep(0.5)     # Jeda pembacaan LDR agar tidak membebani CPU

# Blok exception ini berfungsi untuk menangkap interups keyboard (CTRL+C)
except KeyboardInterrupt:
    print("\nProgram dihentikan oleh pengguna.")

# Blok finally akan selalu dieksekusi, baik program selesai maupun error
finally:
    # Mengembalikan semua pin GPIO ke kondisi aman (LOW/INPUT)
    stop_motor()
    alarm_panic(False)
    GPIO.cleanup()
    print("GPIO telah dibersihkan. Selesai.")

Cari Blog Ini

belajarmikrokontroler2024