TUGAS informatika Konsep Karya Skala Mini Berbasis Arduino

SURYO_GARAGE December 02, 2025

TUGAS KLS X OTO AV AKL MPLB 

✅ 1. Konsep Karya Skala Mini Berbasis Arduino



Nama proyek:
“Mini Robotic Sorting Workcell – Arduino Uno”

Fungsi:

  • Robot lengan mini mengambil objek (contoh: balok warna).

  • Menempatkan objek ke posisi tertentu berdasarkan sensor (warna/benda).

  • Terdapat conveyor kecil untuk menggerakkan benda.

  • Dikendalikan oleh Arduino Uno.

Fitur utama:

  • Mini robotic arm 4 DOF.

  • Sensor objek (warna / IR / ultrasonik).

  • Conveyor mini berbahan akrilik + motor DC.

  • Panel kontrol sederhana.

✅ 2. Tujuan Pembelajaran

Cocok untuk siswa TBSM karena:

  • Belajar dasar robotika & aktuator.

  • Memahami sistem kontrol terbuka/tertutup.

  • Integrasi sensor–motor–mikrokontroler.

  • Pengenalan ke otomasi industri skala kecil.

✅ 3. Komponen Hardware

A. Struktur Mekanik

✔ Mini Robotic Arm (4–5 servo)
– Bahan akrilik/alumunium
– Servo: MG996R (lengan) + SG90 (gripper)

✔ Conveyor mini
– Motor DC + gearbox
– Belt dari karet O-ring atau 3D printed
– Rangka akrilik/L-bracket

✔ Dudukan objek
– Tempat balok warna / benda kecil

B. Elektronik & Sensor

Sistem Komponen
Otak utama Arduino Uno R3
Servo controller PCA9685 (wajib jika servo > 3)
Conveyor Motor DC + driver L298N
Deteksi warna (opsional) Sensor TCS3200/TCS34725
Deteksi benda Sensor IR / Photodiode
Safety Emergency button
Power Adapter 5V 5A untuk servo, 12V untuk motor DC

✅ 4. Diagram Blok Rangkaian

          [Sensor Warna]
                 |
                 v
Arduino Uno --- PCA9685 ----> Servo Lengan 1
       |                      Servo Lengan 2
       |                      Servo Lengan 3
       |                      Servo Gripper
       |
       ---> L298N ----> Motor Conveyor
       |
       ---> Sensor IR (deteksi benda)

Power supply:

  • Servo → 5V 5–6A (jangan dari Arduino)

  • Arduino → USB/5V

  • Motor conveyor → 12V

✅ 5. Rencana Mekanik (Fisik Alat)

Ukuran keseluruhan: 30 cm × 20 cm
Bahan: papan akrilik 3–5 mm

Layout:

--------------------------------------------
|   [Robot Arm]      [Sensor Warna]        |
|                                           
|              [Conveyor Mini]              |
|-------------------------------------------|
|          Panel Kontrol Sederhana          |
| (On/Off, Emergency Stop, Mode Otomatis)   |
--------------------------------------------

✅ 6. Mode Operasi Sistem

1. Mode Manual

  • Siswa menggerakkan lengan lewat joystick atau tombol.

  • Conveyor dapat dinyalakan manual.

2. Mode Otomatis (Seperti di Foto)

Alur kerja:

  1. Conveyor membawa objek.

  2. Sensor IR mendeteksi objek masuk area kerja.

  3. Conveyor berhenti.

  4. Sensor warna membaca warna objek.

  5. Arduino menentukan lokasi peletakan:

    • Merah → kiri

    • Biru → tengah

    • Hijau → kanan

  6. Lengan mengambil objek dan meletakkannya sesuai.

  7. Conveyor jalan lagi.

✅ 7. Flowchart Program

Start
   |
Inisialisasi servo, sensor, motor
   |
Objek terdeteksi?
   |
Ya ---> Berhentikan conveyor
   |
Baca sensor warna
   |
Tentukan posisi peletakan
   |
Gerakkan lengan ke posisi pickup
   |
Gripper ambil objek
   |
Gerakkan ke lokasi drop
   |
Lepaskan objek
   |
Kembalikan lengan ke posisi awal
   |
Nyalakan conveyor lagi
   |
Ulangi

✅ 8. Estimasi Biaya

Komponen Harga
Arduino Uno 80–120 ribu
Servo MG996R (2–4 pcs) 200–300 ribu
Servo SG90 (gripper) 15–20 ribu
PCA9685 30–50 ribu
Motor DC + Gearbox 50–100 ribu
Driver L298N 35–60 ribu
Sensor TCS34725 60–120 ribu
Sensor IR 10 ribu
Akrilik dan baut 40–80 ribu
Power supply 50–100 ribu

Total: ± 600–900 ribu (tergantung kualitas servo)

✅ 9. Apa yang Bisa Saya Buatkan Selanjutnya?

Saya bisa buatkan:

✅ Desain PCB khusus robot arm (untuk servo dan sensor)
✅ Desain workcell (gambar 3D / layout akrilik)
✅ Diagram wiring lengkap
✅ Flowchart versi PDF
✅ Program Arduino lengkap (otomatis + manual)
✅ LKPD untuk siswa

Bapak mau saya buatkan bagian mana dulu?
– PCB?
– Wiring?
– Program Arduino?
– Desain mekanik 3D?


Bagus — ide Bapak sederhana tapi kuat: gunakan motor starter (DC/atau motor gerak besar) yang dikontrol manual lewat saklar, namun dipantau dan dapat dimatikan oleh Arduino jika ada kondisi berbahaya (overcurrent, batas lengan, emergency). Di bawah ini saya susun rencana kerja lengkap — desain pengamanan, skematik kontrol, BOM, langkah pemasangan, contoh kode Arduino, dan prosedur uji. Saya membuat asumsi wajar agar aman: motor DC besar (starter) digerakkan oleh sumber baterai/DC, dengan starter solenoid / contactor atau driver daya sebagai sakelar utama. Arduino hanya mengendalikan/monitor, tidak men-switch arus besar langsung.

Kalau motor yang Bapak maksud motor AC atau VFD, bilang saja — saya akan sesuaikan. Untuk sekarang saya rancang untuk motor DC / starter motor (automotive type) sebagai skenario umum.

1 — Prinsip kerja ringkas

  • Saklar manual (on/off) mengaktifkan starter solenoid / contactor untuk memberi tenaga besar ke motor → motor menggerakkan lengan.

  • Arduino memantau sensor (sensor arus + limit switches + emergency stop).

  • Jika kondisi aman → Arduino hanya memonitor dan menampilkan status.

  • Jika kondisi bahaya (overcurrent, limit switch tertekan, emergency) → Arduino memutus daya melalui driver/solenoid atau memblokir start dan memberi peringatan.

  • Arduino juga dapat membaca saklar on/off (status) sehingga tetap sinkron dengan kontrol manual.

Keunggulan: tetap ada kontrol manual langsung, namun ada lapisan proteksi otomatis.

2 — Diagram blok sederhana

[Battery 12V/24V] -----+----> [Starter Solenoid/Contactor] ----> [Motor Starter] ---> GND
                       |
                       +----> [Manual Switch] (opsional direct or control coil)
                       
Arduino Uno:
- Input: ManualSwitchStatus, LimitSwitchLeft, LimitSwitchRight, EmergencyStop, ACS712_CurrentSensor
- Output: DriverOutput (mengendalikan MOSFET/relay/optocoupler yang mengontrol coil solenoid)
- Indicator: LED PWR / RUN / ALARM

Catatan penting: jangan biarkan Arduino langsung mensupply coil solenoid besar atau arus motor. Gunakan driver (MOSFET + opto / relay driver / transistor + flyback) atau gunakan solenoid coil bertegangan kecil (24V DC) dan driver MOSFET untuk koil.

3 — Komponen yang direkomendasikan (BOM dasar)

(Estimasi harga lokal / IDR dalam rentang kasar)

Daya & switching

  • Starter motor (bekas/baru) — sesuai kebutuhan.

  • Starter solenoid / heavy-duty contactor 12V/24V (sesuai motor) — 150k–600k

  • Kabel tebal (25–50 mm² untuk arus besar) & terminal lug — 100k–300k

  • Fuse / circuit breaker berkapasitas sesuai arus motor — 50k–200k

Kontrol & monitoring

  • Arduino Uno R3 — 80k–150k

  • Current sensor ACS712-30A atau ACS758 (30A/50A) — 40k–250k (lebih tinggi akurasi & range lebih bagus)

  • Limit switches (micro switch roller) ×2 — 10k–30k

  • Emergency stop (mushroom, NC recommended) — 30k–60k

  • Optocoupler atau driver MOSFET board (untuk mengendalikan coil) — ULN2003/ULN2803 untuk coil kecil / MOSFET IRLZ44N/IRFZ44N + gate driver untuk beban lebih besar — 20k–100k

  • Diode flyback (1N4007) untuk coil DC (jika diperlukan) — 1k

  • LED indikator + resistor — 5k

Perlindungan & sensor tambahan

  • Current transformer (CT) untuk AC motor (jika AC) — 60k–150k

  • Sensor posisi (encoder atau potensiometer) untuk lengan (opsional) — 50k–200k

4 — Wiring & koneksi (detail aman)

Saya gunakan pendekatan: solenoid/contactor menghubungkan arus besar; Arduino mengendalikan driver MOSFET yang men-switch koil solenoid (24V DC atau 12V DC). Manual switch bisa langsung memicu coil juga (pilih konfigurasi dengan interlock).

4.1 Rangkaian power (arus besar) — contoh DC

Battery + ---- Fuse -----> SOLENOID MAIN CONTACT -----+----> Motor + 
                                                     |
Battery - -------------------------------------------+----> Motor -

Solenoid MAIN CONTACT (kontak utama) akan menutup jalur antara Battery+ dan Motor+ saat koil solenoid diaktifkan.

4.2 Rangkaian koil solenoid (kontrol)

[24V PSU+] --- EmergencyStop (NC) --- ManualStartSwitch (NO) ---+---+----> Solenoid Coil + 
                                                                |   |
                                                                |   +---> Arduino-driven MOSFET drain (opsional)
                                                                |
                                                    Arduino Driver Output -> Optocoupler -> MOSFET Gate
Solenoid Coil - ----------------------------------------------- 24V PSU-

Penjelasan:

  • ManualStartSwitch: memungkinkan operator menyalakan solenoid langsung (manual). Disarankan wiring di mode yang tidak mengabaikan Arduino: letakkan contactor coil line melalui holding circuit yang juga membutuhkan Arduino OK signal (interlock). Alternatif aman: manual switch memberi sinyal ke Arduino, kemudian Arduino mengaktifkan coil jika aman (lag untuk proteksi). Ini memberi prioritas proteksi.

4.3 Input ke Arduino

  • ManualSwitch → digital input (INPUT_PULLUP), baca state.

  • LimitSwitchLeft/Right → digital input (stop atau reverse).

  • EmergencyStop → digital input NC (baca 1 saat normal).

  • ACS712 output → analog input (A0). Gunakan pembacaan rata-rata, konversi ke arus.

4.4 Output dari Arduino

  • DriverOutput → pin digital → resistor 220Ω → optocoupler LED → opto transistor → gate MOSFET (dengan pull-down). MOSFET switching sink koil solenoid negative or connect via opto to coil positive per design.

4.5 Interlock / logika keamanan

  • Jika EmergencyStop tertekan → nonaktifkan coil langsung (hardware) dan Arduino mematikan output.

  • Jika arus > threshold (overcurrent) → Arduino memutus coil (mengirim LOW ke driver) dan menyalakan alarm.

  • Jika limit switch kanan/kiri tertekan saat operasi → stop motor dan kembalikan ke posisi aman.

5 — Pilihan implementasi saklar/manual

Ada dua opsi menggabungkan saklar manual dengan Arduino:

Opsi A — Manual melalui Arduino (disarankan)

  • Manual switch hanya memberi sinyal ke Arduino. Arduino menyalakan solenoid melalui driver jika tidak ada fault.

  • Kelebihan: semua proteksi dilakukan sebelum coil diaktifkan.

Opsi B — Manual direct + monitoring (lebih sederhana, kurang aman)

  • Manual switch menutup langsung jalur ke koil solenoid (solenoid on tanpa pengecekan Arduino).

  • Arduino hanya memantau arus & limit, lalu dapat memutus coil melalui MOSFET/relay di jalur koil jika deteksi fault.

  • Kelemahan: ada jangka waktu awal ketika coil bisa hidup sebelum Arduino memutus — hardware interlock lebih aman.

Saya sarankan Opsi A untuk keselamatan — operator menekan tombol, Arduino melakukan cek (emergency, arus, posisi), lalu menyalakan solenoid.

6 — Contoh skematik teks (Opsi A - manual via Arduino)

ManualStartBtn ----> Arduino D3 (INPUT_PULLUP)
StopBtn / Emergency (NC) ----> Arduino D4 (INPUT_PULLUP)
LimitLeft ----> Arduino D5
LimitRight ---> Arduino D6
ACS712 output ---> Arduino A0

Arduino D9 ---> 220R ---> Optocoupler ---> MOSFET Gate (IRLZ44N)
MOSFET Drain ---> Solenoid Coil - 
Solenoid Coil + ---> 24V PSU + (via EmergencyStop NC)
MOSFET Source ---> 24V PSU -
Flyback diode across coil reversed polarity

7 — Contoh kode Arduino (monitor + interlock + manual start)

Kode berikut untuk konsep: baca tombol manual, baca arus ACS712, baca limit, kendalikan driver koil. Tambahkan safety tambahan sesuai kebutuhan.

// Konfigurasi pin
const int pinStartBtn = 3;      // manual start button (active LOW)
const int pinStopBtn  = 4;      // emergency / stop (NC -> reads HIGH when OK)
const int pinLimitL   = 5;      // limit left (NC or NO as wired)
const int pinLimitR   = 6;
const int pinDriver   = 9;      // output to opto/MOSFET driver (HIGH = enable coil)
const int pinLedAlarm = 13;

const int analogCurrentPin = A0; // ACS712 analog out

// Parameter
const float ACS_ZERO = 2.5;     // middle voltage at no current (V) - refine with calibration
const int ADC_MAX = 1023;
const float VREF = 5.0;
const float ACS_SENSITIVITY = 0.066; // V/A for ACS712-30A => ~66 mV/A -> 0.066 V/A
const float CURRENT_LIMIT_A = 40.0; // threshold (ampere)

unsigned long lastDebounce = 0;
const int debounceMs = 50;

void setup(){
  pinMode(pinStartBtn, INPUT_PULLUP);
  pinMode(pinStopBtn, INPUT_PULLUP);
  pinMode(pinLimitL, INPUT_PULLUP);
  pinMode(pinLimitR, INPUT_PULLUP);
  pinMode(pinDriver, OUTPUT);
  pinMode(pinLedAlarm, OUTPUT);
  digitalWrite(pinDriver, LOW);
  digitalWrite(pinLedAlarm, LOW);
  Serial.begin(115200);
}

float readCurrent() {
  // Average multiple ADC samples for stability
  long sum = 0;
  const int N = 30;
  for(int i=0;i<N;i++){
    sum += analogRead(analogCurrentPin);
    delay(2);
  }
  float adc = sum / (float)N;
  float v = (adc / ADC_MAX) * VREF;
  float diff = v - ACS_ZERO; // signed voltage
  float current = diff / ACS_SENSITIVITY; // A
  return current;
}

void loop(){
  bool emergencyOk = digitalRead(pinStopBtn); // HIGH if ok
  if(!emergencyOk){
    // emergency pressed -> immediate shutdown
    digitalWrite(pinDriver, LOW);
    digitalWrite(pinLedAlarm, HIGH);
    Serial.println("EMERGENCY STOP!");
    delay(100);
    return;
  } else {
    digitalWrite(pinLedAlarm, LOW);
  }

  bool limitL = digitalRead(pinLimitL);
  bool limitR = digitalRead(pinLimitR);

  float currentA = readCurrent();
  Serial.print("Current (A): ");
  Serial.println(currentA, 2);

  // Overcurrent protection
  if (abs(currentA) > CURRENT_LIMIT_A) {
    digitalWrite(pinDriver, LOW);
    digitalWrite(pinLedAlarm, HIGH);
    Serial.println("OVERCURRENT! Cutting power.");
    delay(200);
    return;
  }

  // Manual start pressed?
  if (digitalRead(pinStartBtn) == LOW) { // pressed (active LOW)
    // debounce
    if (millis() - lastDebounce > debounceMs) {
      lastDebounce = millis();
      // check limits before start
      if (limitL == LOW || limitR == LOW) { // assume LOW means hit
        Serial.println("Limit switch triggered — cannot start.");
        digitalWrite(pinLedAlarm, HIGH);
      } else {
        Serial.println("Starting coil...");
        digitalWrite(pinDriver, HIGH);
      }
    }
  }

  // Auto stop: if limit triggered while running, stop
  if ((limitL == LOW || limitR == LOW)) {
    digitalWrite(pinDriver, LOW);
    Serial.println("Limit reached — stopping.");
    digitalWrite(pinLedAlarm, HIGH);
  }

  delay(100);
}

Catatan kode:

  • Sesuaikan ACS_ZERO dan ACS_SENSITIVITY sesuai jenis ACS.

  • Gunakan abs(currentA) jika sensor memberikan tanda negatif tergantung arah arus.

  • Tambahkan watchdog/timeouts/soft-start jika perlu.

  • Buat LED & buzzer notifikasi lebih jelas.

8 — Langkah pembuatan & pengujian (urutan aman)

  1. Design & assembly low-voltage first

    • Buat rangkaian kontrol Arduino + opto + MOSFET + sensor di papan breadboard/test board.

    • Uji logika on/off dan bacaan sensor tanpa solenoid/ motor.

  2. Driver solenoid terpisah

    • Siapkan MOSFET yang kuat untuk koil solenoid atau gunakan relay driver board.

    • Uji switching koil dengan beban dummy (mis. lampu) sebelum hubungkan solenoid.

  3. Pemasangan kontak daya (motor)

    • Pasang contactor/solenoid main, kabel tebal, fuse.

    • Pastikan semua sambungan ketat dan terisolasi.

  4. Uji tanpa beban motor

    • Aktifkan solenoid untuk beberapa detik dan matikan. Monitor arus koil dan logika Arduino.

  5. Uji motor tanpa beban

    • Jalankan motor dengan lengan kosong, pantau arus (should be within normal), cek limit switch positions.

  6. Uji beban bertahap

    • Tambah beban sedikit demi sedikit sampai kondisi nyata. Periksa heating pada kabel, MOSFET, solenoid.

  7. Verifikasi safety

    • Tekan Emergency hold→ sistem harus memutus daya seketika.

    • Overcurrent simulate → sistem memutus.

    • Limit -> sistem berhenti.

  8. Finalisasi

    • Pasang heatsink pada MOSFET jika diperlukan. Gunakan enclosure ter-grounding untuk papan kontrol.

    • Buat label, manual, SOP operasi & peringatan.

9 — Rekomendasi keselamatan & catatan penting

  • Jika sumbernya adalah battery automotive, hati-hati dengan short circuit => gunakan fuse dekat baterai. Pastikan kabel dan terminal sesuai rating arus start (sering > 200 A!). Untuk proyek pendidikan, lebih baik gunakan motor DC kecil atau motor gear dengan arus < 30–40 A sehingga komponen lebih aman.

  • Untuk starter motor otomotif nilai arus start sangat besar — sebaiknya jangan pakai langsung kecuali Bapak berpengalaman dalam installasi kelistrikan otomotif dan proteksi (starter motors memerlukan kabel besar & contactor automotive).

  • Gunakan contactor/solenoid untuk memutus arus besar, bukan MOSFET tunggal tanpa heatsink & perhitungan.

  • Grounding dan pemisahan sirkuit power/control harus jelas.

  • Selalu gunakan alat pelindung (kacamata, sarung tangan isolasi) dan lakukan pengujian di area aman.

10 — Apa yang saya bisa kerjakan sekarang untuk Bapak (pilih salah satu)

Saya bisa langsung membuat salah satu dari berikut sekarang (saya akan kerjakan dalam jawaban ini):

  1. Skematik kontrol (gambar/ASCII) lengkap yang siap dipakai untuk PCB.

  2. File PCB sederhana (top-copper PNG mirror) untuk modul kontrol Arduino + driver koil (single-side).

  3. Diagram wiring PDF yang jelas (kontak power, solenoid, Arduino wiring).

  4. Versi kode Arduino yang lebih lengkap: termasuk kalibrasi ACS712, logger serial, LED/buzzer alarm, dan mode manual/auto.

  5. Daftar komponen (BOM) terperinci + rekomendasi supplier lokal.

Beritahu pilihan (1/2/3/4/5). Kalau ragu, pilih 1 (skematik kontrol) dulu — saya akan sertakan gambar ASCII yang mudah diikuti dan file desain PCB sederhana.

SOAL 

Berikut 10 soal essay untuk siswa, sesuai materi Mini Robotic Sorting Workcell – Arduino Uno yang Bapak gunakan di kelas TBSM:

  1. Jelaskan perbedaan antara sistem kontrol terbuka (open loop) dan sistem kontrol tertutup (closed loop), lalu berikan contoh penerapannya pada proyek Mini Robotic Sorting Workcell berbasis Arduino Uno.

  2. Pada proyek terdapat beberapa servo motor untuk menggerakkan lengan robot. Jelaskan fungsi derajat kebebasan (DOF) pada lengan robot dan analisis mengapa lengan 4 DOF sudah cukup untuk melakukan proses sorting sederhana.

  3. Jelaskan alasan penggunaan PCA9685 servo controller pada sistem ini, termasuk keterbatasan pin PWM pada Arduino Uno jika servo dihubungkan langsung tanpa modul tambahan.

  4. Conveyor mini digerakkan oleh motor DC dengan driver L298N. Jelaskan prinsip kerja H-Bridge pada driver L298N dan bagaimana arah putaran motor dapat dikendalikan melalui Arduino.

  5. Sensor TCS34725 digunakan untuk membaca warna objek. Jelaskan cara kerja sensor tersebut dalam mendeteksi warna dan bagaimana data sensor diproses oleh Arduino untuk menentukan posisi peletakan objek.

  6. Buatlah penjelasan alur otomasi pada Mode Otomatis, mulai dari sensor IR mendeteksi objek hingga lengan robot meletakkan objek ke lokasi kiri, tengah, atau kanan.

  7. Pada sistem proteksi motor besar, digunakan sensor arus ACS712. Jelaskan cara mengonversi nilai ADC dari pin A0 Arduino menjadi satuan Ampere dan faktor apa saja yang memengaruhi akurasi pembacaan arus.

  8. Jelaskan fungsi Emergency Stop (tombol NC) pada sistem otomasi industri maupun pada proyek ini, serta konsekuensi jika tombol emergency dipasang dengan konfigurasi NO (Normally Open) alih-alih NC (Normally Closed).

  9. Gambarkan dan jelaskan flowchart program kerja lengan robot sorting, lalu identifikasi minimal 2 potensi kegagalan logika program (logic fault) yang mungkin terjadi dan solusi pencegahannya.

  10. Berdasarkan estimasi biaya yang Bapak rencanakan (±600–900 ribu), analisis komponen mana yang paling memengaruhi total biaya dan berikan rekomendasi agar biaya produksi trainer bisa ditekan tanpa mengurangi fungsi utama pembelajaran.

TUGAS DI KIRIM BY EMAL : suryofrisanmusse26@gmail.com

TULIS TANGAN DAN DI FOTO 

Post a Comment

0 Comments