PENGGOYANG UNTUK PELARUTAN PAPAN RANGKAIAN TERCETAK SECARA OTOMATIS

 

PENGGOYANG UNTUK PELARUTAN PAPAN RANGKAIAN TERCETAK SECARA OTOMATIS

KELAS RE-3D, KELOMPOK 4

Aqilla Fadia Haya¹, Habib Muhammad Zihni Miftah², Muhammad Zidni Ilma³, Santo Nugroho⁴

Program Studi Teknologi Rekayasa Elektronika, Jurusan Teknik Elektro, Politeknik Negeri Semarang 2025/2026
Jl. Prof. Soedarto, Tembalang, Kec. Tembalang, Kota Semarang, Jawa Tengah, 50275

---

ABSTRAK - Dalam masa kini banyak mahasiswa khususnya Mahasiswa elektronika yang sering mengeluhkan saat pembuatan pcb harus melalui prosedur melarutkan kedalam larutan FeCl3 dengan yang terjadi jika larutan tersebut mengenai pakaian atau mengenai tangan larutan tersebut akan susah menghilang. Penelitian ini bertujuan untuk membuat penggoyang Papan Rangkaian Tercetak yang dapat melarutkan pcb tanpa terkena larutan FeCl3 Atau yang sering disebut Ferrit Klorida. Alat ini akan bergerak maju dan mundur pada waktu yang telah ditentukan menggunakan input biner dan bisa digunakan pada mode manual jika ditekan tombol start saat biner menunjukan angka 0 dan berhenti jika tombol stop ditekan, dan jika Potensiometer diputar maka dapat mengubah kecepatan penggerak penggoyang pcb.

Kata Kunci: Raspberry Pi Pico; Penggoyang Papan Rangkaian Tercetak otomatis; Implementasi Raspberry Pi Pico.

 

      I.          PENDAHULUAN

           Perkembangan teknologi yang semakin pesat mendorong kebutuhan akan sistem yang lebih efisien dan praktis di berbagai bidang, termasuk elektronika. Kemajuan pada bidang ini telah menghasilkan berbagai sistem kendali digital yang mampu mengotomasi pekerjaan manusia sehingga proses kerja menjadi lebih mudah, cepat, dan akurat [1]. Salah satu penerapan teknologi tersebut adalah pengembangan penggoyang otomatis berbasis mikrokontroler.

                        Dalam proses pembuatan Papan Rangkaian Tercetak (PRT), tahap pelarutan lapisan tembaga yang tidak diperlukan umumnya dilakukan dengan merendam PRT ke dalam larutan etching sambil menggerakkan wadah secara manual. Metode tersebut memerlukan tenaga dan waktu yang cukup banyak serta dapat menyebabkan hasil pelarutan yang kurang konsisten. Oleh karena itu, diperlukan suatu sistem otomatis yang mampu menggerakkan wadah etching secara teratur sehingga proses pembuatan PCB menjadi lebih efektif dan menghasilkan kualitas yang lebih baik.

                        Pada penelitian ini dikembangkan alat penggoyang menggunakan Raspberry Pi Pico sebagai pengendali utama sistem. Raspberry Pi Pico dipilih karena memiliki performa yang baik, konsumsi daya yang rendah, serta jumlah pin input-output yang memadai untuk kebutuhan sistem kendali. Alat ini dilengkapi dengan tiga push button yang digunakan sebagai antarmuka pengguna, yaitu tombol pengaturan waktu (timer), tombol mulai (start), dan tombol berhenti (stop). Tombol timer berfungsi untuk menentukan durasi operasi alat yang ditampilkan melalui indikator LED, sedangkan tombol start digunakan untuk mengaktifkan motor penggerak dan tombol stop berfungsi menghentikan proses kerja sebelum waktu yang ditentukan berakhir. Dengan penerapan sistem berbasis Raspberry Pi Pico ini, diharapkan proses etching PCB dapat berlangsung secara otomatis, lebih efisien, dan memberikan hasil yang lebih konsisten.

   II.          METODOLOGI

            Pada penelitian ini digunakan mikrokontroler Raspberry Pi Pico sebagai pusat pengendali sistem dengan bahasa pemrograman MicroPython. Proses pemrograman dilakukan menggunakan perangkat lunak Thonny IDE yang berfungsi untuk menulis, mengunggah, dan menguji program pada Raspberry Pi Pico. Sistem terdiri dari tiga push button sebagai masukan, empat LED sebagai indikator keluaran, sebuah motor DC sebagai penggerak mekanisme penggoyang PCB, serta sebuah potensiometer yang digunakan untuk mengatur kecepatan putaran motor.

                        Perancangan perangkat keras dilakukan dengan menghubungkan pin GPIO Raspberry Pi Pico sesuai kebutuhan sistem. Push button counter, start, dan stop dihubungkan ke pin GP3, GP4, dan GP5 sebagai masukan digital dengan konfigurasi pull-up internal. Empat LED indikator dihubungkan ke pin GP6, GP7, GP8, dan GP9 untuk menampilkan nilai waktu dalam bentuk bilangan biner. Motor DC dikendalikan menggunakan MOSFET yang terhubung pada pin GP2 dengan metode Pulse Width Modulation (PWM). Selain itu, potensiometer dihubungkan ke pin GP26 (ADC0) untuk memberikan masukan analog yang digunakan dalam pengaturan kecepatan motor secara real-time.

 

 III.          TINJAUAN PUSTAKA

A.    KOMPONEN

1.     Papan mikrokontroler Raspberry Pi Pico (RP2040)

    Raspberry Pi Pico merupakan papan mikrokontroler yang menggunakan chip RP2040 sebagai unit pemroses utama. Mikrokontroler ini bersifat fleksibel, serta mendukung berbagai bahasa pemrograman seperti MicroPython dan C/C++. Raspberry Pi Pico memiliki prosesor dual-core ARM Cortex-M0+ dengan frekuensi kerja hingga 133 MHz, memori SRAM sebesar 264 KB, serta memori flash sebesar 2 MB untuk penyimpanan program. Selain itu, Raspberry Pi Pico menyediakan 26 pin General Purpose Input Output (GPIO) yang dapat digunakan sebagai input maupun output digital, beberapa kanal Analog to Digital Converter (ADC), antarmuka komunikasi seperti UART, I²C, dan SPI, serta dukungan Pulse Width Modulation (PWM) pada sebagian besar pin GPIO. Dengan spesifikasi tersebut, Raspberry Pi Pico banyak digunakan dalam berbagai aplikasi sistem kendali, otomasi, dan Internet of Things (IoT) karena memiliki performa yang baik serta konsumsi daya yang relatif rendah

Gambar 3.1 Arduino Uno. 

2.     Light Emitting Diode (LED)

    Dioda emisi cahaya atau dikenal dengan singkatan LED merupakan Solid State Lamp yang merupakan piranti elektronik gabungan antara elektronik dengan optik, sehingga dikategorikan pada keluarga “Optoelectronic”. Bahan dasar yang digunakan dalam pembuatan LED adalah bahan Galium Arsenida (GaAs) atau Galium Arsenida Phospida (GaAsP) atau juga Galium Phospida (GaP), bahan-bahan ini memancarkan cahaya dengan warna yang berbeda-beda. Bahan GaAs memancarkan cahaya infra-merah, Bahan GaAsP memancarkan cahaya merah atau kuning, sedangkan bahan GaP memancarkan cahaya merah atau hijau.Seperti halnya piranti elektronik lainnya , LED mempunyai nilai besaran terbatas dimana tegangan majunya dibedakan atas jenis warna [2]

Gambar 3.2 Light Emitting Diode. 

3.     Saklar Tekan (Push Button)

    Berikutnya adalah push button, tombol tekan adalah salah satu komponen elektronika yang fungsinya memutus hubungan atas suatu aliran. Pemutusan ini terjadi akibat dampak dari pengalihan dari satu konduktor ke konduktor lainnya. [3]

Gambar 3.3 Saklar Tekan.

4.     Modul Driver Mosfet

    Modul driver MOSFET merupakan rangkaian elektronika yang digunakan untuk mengendalikan beban dengan arus yang lebih besar menggunakan sinyal kontrol berarus kecil dari mikrokontroler. MOSFET bekerja sebagai saklar elektronik yang dapat menghubungkan atau memutus aliran daya ke beban, seperti motor DC. Pada penelitian ini, modul driver MOSFET digunakan untuk mengendalikan kecepatan motor DC melalui metode Pulse Width Modulation (PWM) yang dihasilkan oleh Raspberry Pi Pico, sehingga kecepatan putaran motor dapat diatur sesuai kebutuhan..

Gambar 3.4 Mdoul Mosfet.

5.     Potensiometer

    Potensiometer merupakan komponen elektronika pasif yang berfungsi sebagai resistor variabel. Nilai resistansinya dapat diubah dengan memutar poros potensiometer sehingga menghasilkan perubahan tegangan keluaran. Dalam sistem mikrokontroler, potensiometer sering digunakan sebagai input analog untuk mengatur parameter tertentu, seperti kecepatan motor, intensitas cahaya LED, maupun pengaturan nilai sensor [5].

Gambar 3.5 Potensiometer.

6.     Motor Gearbox DC

    Motor DC adalah sebuah alat listrik yang dapat mengubah elergi listrik menjadi energi mekanis dalam bentuk putaran, perputaran ini dimanfaatkan sebagai penggerak utama sistem penggoyang PCB. Motor ini telah dilengkapi dengan serangkaian gearbox yang akan meningkatkan torsi motor. 

Gambar 3.6 Motor Gearbox DC N20.

 

7.     Modul Stepdown LM2596

    Modul ini dapat menurunkan tegangan dengan cara menghidupkan dan mematikan tegangan sumber berdasarkan interval tertentu untuk mendapatkan tegangan yang diinginkan, pada proyek ini modul stepdown LM2596 digunakan untuk menurunkan tegangan masukan 12v sehingga bertegangan 5v yang dapat diterima oleh Arduino dan Relay yang digunakan.

Gambar 3.7 Modul Stepdown LM2596. 

8.     Adaptor 12V DC

    Alat ini digunakan sebagai pemberi suplai tegangan pada sistem, keluaran tegangan pada alat ini sebesar 12V yang akan dihubungkan ke beban Motor DC sebagai penggerak utama.

Gambar 3.8 Adaptor 12V DC

B.    DIAGRAM BLOK RANGKAIAN

Gambar 3.9 Diagram Blok Rangkaian

  

C.    DIAGRAM ALUR PROGRAM

   

Gambar 3.10 Diagram Alur Program

D.    SKEMATIK RANGKAIAN

Gambar 3.11 Skematik Rangkaian

 

 

 

 

 

E.    PROGRAM ASSEMBLY

"""===========================================================================

Pemrogram      : Kelompok RE-3D/4 

1. 04-Aqilla Fadil Haya       NIM:4.34.23.3.04     

2. 10-Habib Muhammad Zihni M. NIM:4.34.23.3.10      

3. 16-Muhammad Zidni Ilma     NIM:4.34.23.3.16      

4. 22-Santo Nugroho           NIM:4.34.23.3.22   

 

Tgl.Praktikum  : Rabu, 13 Mei 2026

=============================================================================

Proyek - Kendali Motor Shaker PCB

ShakePCB.py

- Program untuk mengendalikan motor DC shaker papan PCB

  menggunakan MOSFET sebagai saklar PWM, potensiometer sebagai

  pengatur kecepatan, tombol tekan sebagai kendali, dan LED

  sebagai penampil biner waktu yang diatur

  ---------------------------------------------------------------------------

Materi:

- Keluaran PWM untuk kendali motor DC via MOSFET

- Masukan ADC dari potensiometer untuk mengatur kecepatan

- Masukan digital tombol tekan dengan debounce 2 tahap

- Tampilan biner 4-bit menggunakan LED PWM

- Mesin keadaan: standby, manual, timer

  ---------------------------------------------------------------------------

Komponen:

- 1x Motor DC N20

- 1x MOSFET N-channel IRFZ44N sebagai driver motor

- 1x Potensiometer 10kΩ

- 4x LED + 4x Resistor 330Ω

- 3x Tombol tekan 

  ========================================================================="""

#=== Pustaka ===

from machine import Pin, PWM, ADC       #Pin, PWM, ADC dari pustaka machine

import time                             #fungsi waktu dari pustaka time

#=== Deklarasi Pin ===

PIN_ADC  = 26                           #potensiometer di GP26 (ADC0)

PIN_PWM  = 2                            #gate MOSFET di GP2 (PWM motor)

PIN_LED  = [9, 8, 7, 6]                 #LED biner di GP6-GP9 (bit 0-3)

PIN_BTN  = [3, 4, 5]                    #tombol START, SET, STOP

#=== Deklarasi Konstanta ===

FREK_PWM      = 1000                    #frekuensi PWM motor (Hz)

FREK_LED      = 1000                    #frekuensi PWM LED (Hz)

TERANG_LED    = 16383                   #kecerahan LED 25% (dari 65535)

PITA_MATI     = 80                      #toleransi noise ADC (deadband)

MS_DEBOUNCE   = 30                      #waktu tunggu debounce tahap-1 (ms)

MS_COOLDOWN   = 150                     #waktu kunci setelah tombol valid (ms)

MS_TAHAN      = 500                     #lama tahan sebelum auto-naik (ms)

MS_ULANG      = 180                     #jeda antar auto-increment (ms)

#=== Pengesetan Awal ===

adc = ADC(Pin(PIN_ADC))                 #ADC potensiometer

pwm = PWM(Pin(PIN_PWM))                 #PWM motor

pwm.freq(FREK_PWM)                      #atur frekuensi motor

pwm.duty_u16(0)                         #motor mati saat mulai

led = [PWM(Pin(p)) for p in PIN_LED]    #daftar objek LED

for l in led:                           #atur semua LED

  l.freq(FREK_LED)                      #frekuensi PWM LED

  l.duty_u16(0)                         #LED mati saat mulai

btn = [Pin(p, Pin.IN, Pin.PULL_UP) for p in PIN_BTN]  #tombol pull-up

#=== Deklarasi Variabel ===

keadaan       = 'standby'               #keadaan sistem saat ini

waktu_set     = 0                       #nilai timer yang diatur (0-15 detik)

duty          = 0                       #duty cycle motor saat ini

cetak_terakhir = 0                      #waktu terakhir cetak status

btn_stabil    = [1, 1, 1]               #keadaan stabil terakhir tiap tombol

btn_turun_t   = [0, 0, 0]               #waktu falling edge terdeteksi

btn_turun     = [False, False, False]   #sedang menunggu konfirmasi?

btn_siap_t    = [0, 0, 0]               #waktu terakhir tombol valid (cooldown)

set_tahan_sejak = 0                     #waktu mulai ditahan

set_mengulang   = False                 #sudah masuk fase auto-repeat?

set_ulang_t     = 0                     #waktu auto-increment terakhir

#=== Fungsi Debounce ===

def tombol_ditekan(i):

  global btn_stabil, btn_turun_t, btn_turun, btn_siap_t

  skrg = time.ticks_ms()                #waktu sekarang

  val  = btn[i].value()                 #baca nilai pin

  if val == 0 and btn_stabil[i] == 1 and not btn_turun[i]:

    btn_turun[i]   = True               #tandai sedang jatuh

    btn_turun_t[i] = skrg               #catat waktu jatuh

  if val == 1:                          #pin naik lagi sebelum konfirmasi

    btn_stabil[i] = 1                   #reset stabil

    btn_turun[i]  = False               #batalkan (bounce)

  if btn_turun[i] and time.ticks_diff(skrg, btn_turun_t[i]) >= MS_DEBOUNCE:

    btn_turun[i]  = False               #selesai tahap tunggu

    btn_stabil[i] = 0                   #tandai stabil rendah

    if btn[i].value() == 0 and time.ticks_diff(skrg, btn_siap_t[i]) >= MS_COOLDOWN:

      btn_siap_t[i] = skrg              #perbarui waktu cooldown

      return True                       #tombol valid!

  return False                          #belum valid

def polling_stop():

  for i in [0, 2]:                      #cek BTN START dan STOP

    if btn[i].value() == 0:             #ada yang ditekan?

      time.sleep_ms(MS_DEBOUNCE)        #tunggu settle

      if btn[i].value() == 0:           #masih ditekan? valid

        while btn[i].value() == 0:      #tunggu dilepas

          time.sleep_ms(10)

        return True                     #sinyal stop

  return False                          #tidak ada stop

#=== Fungsi LED ===

def tampil_biner(nilai):

  for i in range(4):                    #cek tiap bit

    bit = (nilai >> i) & 1              #ambil bit ke-i

    led[i].duty_u16(TERANG_LED if bit else 0)  #nyalakan atau matikan

def led_kedip(kali=2, ms=120):

  for _ in range(kali):                 #ulangi sebanyak kali

    for l in led: l.duty_u16(TERANG_LED)#semua nyala

    time.sleep_ms(ms)

    for l in led: l.duty_u16(0)         #semua mati

    time.sleep_ms(ms)

#=== Fungsi Motor ===

def motor_jalan():

  global duty

  raw = adc.read_u16()                  #baca ADC (0-65535)

  if abs(raw - duty) > PITA_MATI:       #cukup berubah?

    duty = raw                          #perbarui duty

  pwm.duty_u16(duty)                    #set motor

def motor_berhenti()

  global duty

  pwm.duty_u16(0)                       #duty 0 = motor mati

  duty = 0                              #reset duty

#=== Fungsi Tombol SET Timer (ketuk + tahan-ulang) ===

def tangani_set_timer():

  global waktu_set, set_tahan_sejak, set_mengulang, set_ulang_t

  skrg    = time.ticks_ms()

  ditekan = btn[1].value() == 0         #cek apakah sedang ditekan

  if tombol_ditekan(1):                 #ketukan valid terdeteksi

    waktu_set = (waktu_set + 1) % 16    #tambah 1, wrap 0-15

    tampil_biner(waktu_set)             #tampilkan di LED

    cetak_kejadian(f'SET timer -> {waktu_set}s')

    set_tahan_sejak = skrg              #mulai hitung tahan

    set_mengulang   = False             #reset fase repeat

  if ditekan:                           #tombol masih ditekan

    if set_tahan_sejak == 0:

      set_tahan_sejak = skrg

    lama = time.ticks_diff(skrg, set_tahan_sejak)

    if lama >= MS_TAHAN:                #sudah cukup lama ditahan?

      if not set_mengulang:

        set_mengulang = True            #masuk fase auto-repeat

        set_ulang_t   = skrg

      if time.ticks_diff(skrg, set_ulang_t) >= MS_ULANG:

        waktu_set = (waktu_set + 1) % 16 #otomatis tambah

        tampil_biner(waktu_set)

        cetak_kejadian(f'SET timer -> {waktu_set}s (tahan)')

        set_ulang_t = skrg

  else:                                 #tombol dilepas

    set_tahan_sejak = 0

    set_mengulang   = False

#=== Fungsi Debug Terminal ===

def cetak_kejadian(pesan):

  print(f"\n  [{time.ticks_ms()//1000:5d}s] >> {pesan}")

def cetak_status(tambahan=''):

  raw     = adc.read_u16()

  persen  = raw / 65535 * 100

  bar     = int(persen / 5)

  str_led = ''.join('1' if l.duty_u16() > 0 else '0' for l in led)

  str_btn = ''.join(str(1 - b.value()) for b in btn)

  print(

    f"  [{keadaan:<8}]  TMR:{waktu_set:2d}s  "

    f"ADC:{raw:5d}  SPD:{persen:5.1f}%  "

    f"[{'#'*bar}{'.'*(20-bar)}]  "

    f"LED:{str_led}  BTN:{str_btn}"

    + (f"  {tambahan}" if tambahan else ''),

    end='\r'

  )

#=== Program Utama ===

print('\n' + '='*52)

print('  PCB Etching Shaker')

print('='*52)

print(f'  ADC GP{PIN_ADC}   PWM GP{PIN_PWM} @ {FREK_PWM}Hz')

print(f'  LED GP{PIN_LED}')

print(f'  BTN GP{PIN_BTN[0]}=START  GP{PIN_BTN[1]}=SET  GP{PIN_BTN[2]}=STOP')

print('='*52)

print('  START : mulai motor (manual atau timer)')

print('  SET   : atur timer (ketuk +1 / tahan naik)')

print('  STOP  : hentikan motor')

print('='*52 + '\n')

led_kedip(2)                            #kedip tanda siap

tampil_biner(0)                         #tampilkan 0000

while True:

  skrg = time.ticks_ms()

  if keadaan == 'standby':

    tangani_set_timer()                 #proses tombol SET

    if tombol_ditekan(0):               #tombol START ditekan

      if waktu_set == 0:                #timer tidak diset = mode manual

        keadaan = 'manual'

        motor_jalan()

        cetak_kejadian('START — mode MANUAL')

      else:                             #timer diset = mode timer

        keadaan = 'timer'

        cetak_kejadian(f'START — mode TIMER {waktu_set}s')

    if tombol_ditekan(2):               #tombol STOP ditekan saat standby

      tampil_biner(waktu_set)           #refresh tampilan LED

    time.sleep_ms(5)

  elif keadaan == 'manual':

    motor_jalan()                       #perbarui kecepatan dari potensiometer

    if tombol_ditekan(2) or tombol_ditekan(0):  #STOP atau START = berhenti

      motor_berhenti()

      keadaan = 'standby'

      tampil_biner(waktu_set)

      cetak_kejadian('STOP — kembali standby')

    time.sleep_ms(5)

  elif keadaan == 'timer':

    hitung_mundur = waktu_set           #mulai hitungan mundur

    motor_jalan()                       #nyalakan motor

    cetak_kejadian(f'TIMER mulai — {hitung_mundur}s')

    tik_terakhir = time.ticks_ms()

    dihentikan   = False

    while hitung_mundur > 0:            #selama masih ada sisa waktu

      tampil_biner(hitung_mundur)       #tampilkan sisa waktu di LED

      while time.ticks_diff(time.ticks_ms(), tik_terakhir) < 1000:

        motor_jalan()                   #perbarui kecepatan tiap iterasi

        if polling_stop():              #cek tombol STOP/START

          dihentikan = True

          break

        skrg_dalam = time.ticks_ms()

        if time.ticks_diff(skrg_dalam, cetak_terakhir) >= 100:

          cetak_status(f'CTD:{hitung_mundur}s')

          cetak_terakhir = skrg_dalam

        time.sleep_ms(10)

      if dihentikan:                    #keluar dari loop jika dihentikan

        break

      tik_terakhir  = time.ticks_add(tik_terakhir, 1000)

      hitung_mundur -= 1                #kurangi sisa waktu

      cetak_kejadian(f'tik — sisa {hitung_mundur}s')

    motor_berhenti()                    #matikan motor

    if dihentikan:

      cetak_kejadian('S

      TOP — timer dibatalkan')

    else:

      cetak_kejadian('SELESAI — motor mati otomatis')

      led_kedip(3, 80)                  #kedip 3x tanda selesai

    keadaan = 'standby'

    tampil_biner(waktu_set)             #kembalikan tampilan ke nilai set

  if time.ticks_diff(skrg, cetak_terakhir) >= 100:

    cetak_status()

    cetak_terakhir = skrg

 

F.     DIAGRAM PENGAWATAN

Gambar 3.13 Diagram Pengawatan

 IV.          HASIL DAN PEMBAHASAN

A.    CARA KERJA RANGKAIAN

    Sistem penggoyang PCB otomatis bekerja menggunakan Raspberry Pi Pico sebagai mikrokontroler utama dengan memanfaatkan tiga pin masukan yang terhubung ke tombol push button, yaitu tombol counter, start, dan stop. Selain itu, sistem menggunakan empat LED sebagai indikator biner waktu, sebuah modul driver MOSFET untuk mengendalikan motor DC, serta potensiometer sebagai pengatur kecepatan motor. Cara kerja sistem diawali dengan menekan tombol counter untuk menentukan waktu operasi yang diinginkan. Nilai waktu akan ditampilkan dalam bentuk bilangan biner melalui LED indikator.

Gambar 4.1 Alat Dalam Mode Otomatis.

   Setelah waktu ditentukan, tombol start ditekan untuk menjalankan sistem. Raspberry Pi Pico akan mengaktifkan motor DC melalui modul driver MOSFET dan LED mulai menampilkan hitungan mundur sesuai waktu yang telah dipilih. Selama proses berlangsung, motor akan terus bergerak hingga hitungan mencapai nol. Ketika waktu habis, motor akan berhenti secara otomatis dan sistem kembali ke kondisi awal dengan menampilkan nilai waktu yang telah dipilih sebelumnya.

Gambar 4.2 Alat dalam Mode Manual.

    Pengaturan kecepatan motor dilakukan menggunakan potensiometer yang terhubung ke pin ADC Raspberry Pi Pico. Nilai tegangan yang dihasilkan potensiometer akan dibaca oleh mikrokontroler dan digunakan untuk mengatur sinyal PWM yang diberikan ke modul driver MOSFET. Dengan metode ini, kecepatan motor dapat diubah secara langsung selama alat beroperasi tanpa perlu menghentikan proses terlebih dahulu. Modul driver MOSFET berfungsi sebagai saklar elektronik yang menghubungkan daya ke motor DC sesuai sinyal PWM yang diberikan oleh mikrokontroler..

B.    FOTO PROTOTIPE ALAT

Gambar 4.3 Tampilan samping Alat

 

Gambar 4.4 Tampilan Atas Alat

 

    V.          KESIMPULAN

            Berdasarkan hasil perancangan dan pengujian, alat penggoyang PCB otomatis berbasis Raspberry Pi Pico dapat bekerja sesuai dengan fungsi yang diharapkan. Sistem mampu mengatur waktu operasi menggunakan push button, menampilkan nilai waktu melalui LED biner, serta mengendalikan motor DC untuk menggerakkan wadah etching secara otomatis.

            Penggunaan alat ini membantu mempermudah proses etching PCB karena pengguna tidak perlu lagi menggerakkan wadah secara manual. Motor dapat bekerja selama waktu yang telah ditentukan dan akan berhenti secara otomatis ketika hitungan mundur selesai. Selain itu, kecepatan motor dapat diatur menggunakan potensiometer sehingga proses penggoyangan dapat disesuaikan dengan kebutuhan.

            Penerapan Raspberry Pi Pico, modul driver MOSFET, dan motor DC pada alat ini menunjukkan bahwa sistem otomatis dapat dibuat dengan komponen yang relatif sederhana dan mudah diperoleh. Alat yang dirancang mampu meningkatkan kenyamanan penggunaan, mengurangi kontak langsung dengan larutan kimia, serta membantu membuat proses pembuatan PCB menjadi lebih praktis dan efisien.

 VI.          REFERENSI

[1]       Raspberry Pi Foundation. (2024). RP2040 Datasheet. Cambridge, United Kingdom: Raspberry Pi Trading Ltd.

[2]       Raspberry Pi Foundation. (2024). Getting Started with Raspberry Pi Pico. Cambridge, United Kingdom: Raspberry Pi Press.

[3]       Sedra, AS, & Smith, KC. (2020). Microelectronic Circuits (8th Edition). New York: Oxford University Press.

[4]       Horowitz, P, & Hill, W. (2015). The Art of Electronics (3rd Edition). Cambridge: Cambridge University Press.

[5]       Monk, S. (2023). Programming Raspberry Pi Pico in MicroPython. New York: McGraw-Hill Education. 

VII.          LAMPIRAN

A.    TAUTAN DEMONSTRASI ALAT

https://youtu.be/Zgqt7-NdmJg?si=Ht7Ds6HJ1OIfW_Bk

B.     TAUTAN PRESENTASI

https://canva.link/dl13flpz6lluoee