Komponen · 10 mnt baca

Panduan PCA9685 Arduino: Tutorial Driver Servo 16 Kanal

Pengkabelan PCA9685 dengan Arduino: alamat I2C 0x40, daya eksternal untuk servo, kalibrasi lebar pulsa, dan merangkai board untuk kode lengan robot dan robot laba-laba hexapod.

PCA9685 adalah board driver PWM 12-bit yang bisa menggerakkan 16 motor servo secara independen dan bersamaan lewat satu jalur I2C. Di Arduino Uno, library Servo paling banyak hanya bisa mengelola 12 servo, dan selama itu satu timer sibuk total; pin-mu habis dan servo mulai bergetar. PCA9685 membangkitkan pulsanya dengan osilator internalnya sendiri, jadi mikrokontrolermu cukup bilang “pindahkan kanal ini ke posisi ini”. Board ini bakal kamu temukan di hampir semua proyek dengan banyak sendi: lengan robot, robot laba-laba, mata animatronik, atau dudukan kamera pan-tilt.

Di panduan ini kamu akan belajar pengkabelan PCA9685 dengan Arduino, kenapa servo harus diberi daya dari catu daya terpisah, cara mengkalibrasi lebar pulsa untuk menemukan nilai 0 dan 180 derajat yang sebenarnya dari tiap servo, dan cara merangkai board dengan jumper alamat. Setelah itu kita akan membuat robot laba-laba 18 servo dengan dua board, lengan robot yang dikendalikan potensiometer dengan ESP32, dan driver MicroPython tanpa library untuk Raspberry Pi Pico. Kalau kamu belum paham cara kerja dasar motor servo, baca dulu Apa Itu Motor Servo?.

Motor servo SG90
SG90 adalah servo yang paling sering digerakkan dengan PCA9685; setiap kanal di board ini pas langsung dengan colokan tiga pin servo ini.

Apa itu PCA9685 dan bagaimana cara kerjanya?

PCA9685 sebenarnya adalah chip yang dirancang NXP untuk menggerakkan LED, tapi karena frekuensinya bisa diatur, chip ini juga bekerja sempurna dengan servo. Di dalamnya ada osilator 25 MHz dan counter 12-bit yang dipakai bersama oleh semua kanal; satu periode PWM dibagi menjadi 4096 langkah (tick). Untuk setiap kanal kamu menulis dua angka: langkah ketika sinyal naik (ON) dan langkah ketika sinyal turun (OFF). Untuk servo, frekuensi diatur ke 50 Hz, jadi periodenya 20 ms. Satu langkah berlangsung 20 ms / 4096 ≈ 4,88 µs, jadi untuk mengubah lebar pulsa yang kamu inginkan ke tick, pakai tick = pulsa (µs) / 4,88. Misalnya, pulsa posisi tengah 1,5 ms sama dengan 1500 / 4,88 ≈ 307 tick. Begitu sebuah kanal diatur, board akan terus membangkitkan sinyal itu sendiri; bahkan ketika Arduino sibuk dengan pekerjaan lain, servo tetap diam di posisinya.

FiturNilai
ChipNXP PCA9685
Jumlah kanal16 output PWM independen
Resolusi12 bit (4096 langkah per periode)
Frekuensi PWMSekitar 24–1526 Hz (50 Hz untuk servo)
KomunikasiI2C, sampai 1 MHz
Alamat default0x40 (0x40–0x7F dengan jumper A0–A5)
Catu logika (VCC)2,3–5,5 V
Catu servo (V+)Eksternal, biasanya 5–6 V tergantung servonya
Arus output25 mA sink, 10 mA source per kanal (hanya untuk sinyal)
Di boardKebanyakan modul punya resistor pull-up SDA/SCL dan resistor seri 220 Ω di output
Lebar pulsaTick @ 50 HzPosisi servo tipikal
0,5 ms (500 µs)≈ 102Sekitar 0° untuk SG90
1,0 ms (1000 µs)≈ 2050° standar (servo dengan rentang sempit)
1,5 ms (1500 µs)≈ 307Posisi tengah (90°)
2,0 ms (2000 µs)≈ 410180° standar
2,4 ms (2400 µs)≈ 492Sekitar 180° untuk SG90

Pengkabelan PCA9685: Arduino Uno, ESP32, dan Pico

Pin PCA9685Arduino UnoESP32Raspberry Pi Pico
GNDGNDGNDGND
VCC (logika)5V3V33V3(OUT)
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
OEBiarkan kosong (di board sudah ditarik ke GND)Biarkan kosongBiarkan kosong
V+ (terminal sekrup)Positif catu daya eksternal 5–6 VPositif catu daya eksternal 5–6 VPositif catu daya eksternal 5–6 V
GND (terminal sekrup)Negatif catu daya eksternal (tersambung dengan GND di board)Negatif catu daya eksternal (tersambung dengan GND di board)Negatif catu daya eksternal (tersambung dengan GND di board)
Kesalahan yang paling sering terjadi adalah tertukar antara VCC dan V+. VCC hanyalah catu logika chip dan hanya menarik beberapa miliampere; daya untuk servo datang dari V+ di terminal sekrup. Kalau kamu mencoba memberi daya servo dari pin 5V Arduino, board akan reset, port USB terbebani, dan regulatornya panas. Di ESP32 dan Pico, selalu hubungkan VCC ke 3V3: resistor pull-up di board menarik SDA dan SCL ke VCC, jadi VCC 5 V berarti pin 3,3 V kemasukan 5 V. Negatif catu daya eksternal juga harus satu ground dengan mikrokontroler (Ground Bersama (GND)).

Daya eksternal: berapa arus yang ditarik servo?

Servo yang diam hanya menarik 5–10 mA, tapi ketika bergerak, dan terutama ketika tertahan beban (stall), arusnya melonjak. SG90 yang stall bisa menarik 600–700 mA, dan MG996R lebih dari 2 A. Ketika semua sendi lengan robot mulai bergerak bersamaan, arus puncak ini menumpuk dan tegangan catu daya yang lemah turun; hasilnya servo berkedut, melompat-lompat acak, dan Arduino terus reset. Aturan praktisnya: kalikan jumlah servo yang bergerak bersamaan dengan arus puncaknya, lalu pilih catu daya yang sanggup memberikan setidaknya setengah dari hasil itu secara terus-menerus. Adaptor 5 V 3 A cocok untuk lengan robot dengan enam SG90, dan catu daya 5–6 V 8–10 A, atau UBEC bertenaga dari dunia RC, untuk robot laba-laba 18 servo.

ServoDiamBergerakTertahan (stall)Catu daya
SG90 (9 g, gear plastik)≈ 10 mA100–250 mA≈ 650 mA4,8–6 V
MG90S (gear logam)≈ 10 mA150–300 mA≈ 700 mA4,8–6 V
MG996R (ukuran standar)≈ 10 mA500–900 mA≈ 2,5 A4,8–7,2 V
Pasang kapasitor elektrolit 470–1000 µF di antara terminal V+ dan GND, di tempat kapasitor yang kosong di board atau langsung di terminalnya; sebagai patokan kasar, hitung sekitar 100 µF per servo. Rating tegangan kapasitor sebaiknya minimal dua kali tegangan catu (16 V untuk 6 V), dan perhatikan polaritasnya. Kalau kamu cuma punya adaptor 12 V, kamu bisa menurunkannya ke 5–6 V dengan buck converter LM2596; tapi tanpa heatsink LM2596 hanya nyaman bekerja di sekitar 2 A, jadi robot yang lebih besar butuh konverter yang lebih bertenaga.

Langkah demi langkah percobaan pertama: putar 4 servo bersamaan

  1. Buka Library Manager di Arduino IDE, cari library Adafruit PWM Servo Driver, lalu instal.
  2. Hubungkan pin VCC, GND, SDA, dan SCL board ke Arduino seperti di tabel di atas; biarkan pin OE kosong.
  3. Colokkan servo ke kanal 0, 1, 2, dan 3. Kabel sinyal oranye atau kuning di colokan harus sejajar dengan baris PWM, kabel merah dengan baris V+, dan kabel cokelat atau hitam dengan baris GND.
  4. Hubungkan catu daya eksternal 5 V ke terminal sekrup: positif ke V+, negatif ke GND.
  5. Nyalakan Arduino lewat USB dulu dan upload kodenya, baru setelah itu nyalakan catu daya servo. Kalau kamu belum yakin dengan alamat board-nya, pastikan alamat 0x40 muncul dengan sketch scanner I2C.
C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();  // varsayılan adres 0x40 / default address 0x40
5
6const int SERVO_MIN = 110;   // 0 derece için tick (kalibre et) / tick for 0 degrees (calibrate)
7const int SERVO_MAX = 500;   // 180 derece için tick (kalibre et) / tick for 180 degrees (calibrate)
8
9void servoAci(uint8_t kanal, int aci) {
10  aci = constrain(aci, 0, 180);
11  int tick = map(aci, 0, 180, SERVO_MIN, SERVO_MAX);
12  pwm.setPWM(kanal, 0, tick);   // darbe 0'da başlar, tick'te biter / pulse starts at 0, ends at tick
13}
14
15void setup() {
16  pwm.begin();
17  pwm.setOscillatorFrequency(27000000);   // iç osilatör düzeltmesi / internal oscillator trim
18  pwm.setPWMFreq(50);                     // servo için 50 Hz (20 ms) / 50 Hz for servos (20 ms)
19  delay(10);
20}
21
22void loop() {
23  for (int aci = 0; aci <= 180; aci += 2) {        // 0 -> 180 derece / degrees
24    for (uint8_t k = 0; k < 4; k++) servoAci(k, aci);
25    delay(15);
26  }
27  for (int aci = 180; aci >= 0; aci -= 2) {        // 180 -> 0 derece / degrees
28    for (uint8_t k = 0; k < 4; k++) servoAci(k, aci);
29    delay(15);
30  }
31}

pwm.begin() menginisialisasi board dan setPWMFreq(50) mengatur periode menjadi 20 ms untuk servo. Baris setOscillatorFrequency(27000000) berasal dari contoh Adafruit: meski osilator internal chip di atas kertas 25 MHz, kenyataannya bervariasi antara 23 dan 27 MHz, dan library menghitung prescaler berdasarkan nilai ini. Pekerjaan utamanya dilakukan setPWM(channel, on, off); kalau on dibiarkan 0 dan jumlah tick ditulis ke off, pulsa dimulai di awal periode dan berakhir di langkah itu. Fungsi servoAci() memakai map() untuk mengubah 0–180 derajat ke rentang SERVO_MIN–SERVO_MAX. Library ini juga punya fungsi writeMicroseconds(channel, µs) yang langsung menerima pulsa dalam mikrodetik, tapi karena akurasinya bergantung pada pengaturan osilator, bekerja dengan tick dan mengkalibrasi tiap servo lebih bisa diandalkan.

Kalibrasi lebar pulsa: temukan batas asli tiap servo

Pembuat servo mencantumkan rentang standar 1–2 ms, tapi kenyataannya setiap servo berbeda: satu SG90 bisa berputar penuh 180 derajat antara 0,5 dan 2,4 ms, sementara yang lain mungkin hanya sampai 170 derajat. Kalau kamu asal memakai nilai di tabel, servo akan mentok di penahan mekanisnya di ujung gerakan, berdengung, menarik arus yang tidak perlu, dan lama-lama gear-nya aus. Kode kalibrasi di bawah mengirim nilai tick yang kamu ketik di Serial Monitor ke kanal 0. Mulai dari sekitar 300 dan turunkan nilainya per 10; catat titik ketika servo berhenti berputar atau mulai berdengung, lalu ambil 5–10 tick di atasnya sebagai SERVO_MIN. Lakukan hal yang sama ke arah sebaliknya untuk menemukan SERVO_MAX. Di lengan robot atau robot laba-laba, setiap sendi adalah servo terpisah, jadi cara paling rapi adalah mengulang pengukuran ini untuk tiap servo dan menyimpan nilainya di sebuah array.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);
5
6void setup() {
7  Serial.begin(115200);                   // Seri Monitör: 115200, Yeni satır / Serial Monitor: 115200, Newline
8  pwm.begin();
9  pwm.setOscillatorFrequency(27000000);
10  pwm.setPWMFreq(50);
11  pwm.setPWM(0, 0, 307);                  // yaklaşık orta konum / roughly center position
12  Serial.println(F("Tick degeri yaz (80-650) / Enter tick value (80-650)"));
13}
14
15void loop() {
16  if (Serial.available()) {
17    int ticks = Serial.parseInt();        // yazılan sayıyı oku / read the typed number
18    if (ticks >= 80 && ticks <= 650) {    // güvenli aralık / safe range
19      pwm.setPWM(0, 0, ticks);
20      Serial.print(F("Tick: "));
21      Serial.println(ticks);
22    }
23    while (Serial.available()) Serial.read();   // kalan karakterleri at / discard leftover characters
24  }
25}

Merangkai beberapa board PCA9685

Di sepanjang tepi atas setiap board ada enam jumper alamat (pad solder) dari A0 sampai A5. Kalau semuanya terbuka, alamatnya 0x40; ketika kamu menyambung sebuah pad dengan timah solder, bit yang bersangkutan menjadi 1 dan nilai bit itu ditambahkan ke alamat. Artinya, secara teori 62 board, atau 992 servo, bisa berbagi jalur I2C yang sama. Karena header 6 pin di kedua sisi board tersambung paralel, cukup pakai kabel pendek dari board pertama ke board kedua; SDA, SCL, VCC, dan GND ikut tersalur sepanjang rantai. Di kode, kamu membuat objek terpisah untuk setiap board dan memberikan alamatnya ke konstruktor. Hindari alamat 0x70, karena itu adalah alamat default “semua sekaligus” (All Call) milik chip. Untuk mempelajari pengalamatan I2C lebih dalam, lihat Apa Itu I2C?.

Jumper yang disambungAlamatContoh penggunaan
Tidak ada0x40Board 1 (servo 0–15)
A00x41Board 2 (servo 16–31)
A10x42Board 3
A0 + A10x43Board 4
A20x44Board 5
Semua A0–A50x7FAlamat terakhir
Ketika dirangkai, jalur V+ juga tersalur antar-board lewat header. Mengalirkan arus servo beberapa ampere lewat pin header yang tipis membuat pin panas dan menimbulkan jatuh tegangan, jadi tarik kabel terpisah yang tebal dari catu daya ke terminal sekrup setiap board. Kalau kamu memakai catu daya yang berbeda-beda, putuskan sambungan V+ antar-board dan biarkan hanya GND yang tersambung bersama; kalau tidak, kedua catu daya akan saling terhubung. Selain itu, karena setiap board punya resistor pull-up, merangkai banyak board menurunkan hambatan ekuivalen dan membebani jalur; dengan lebih dari 5–6 board, kamu bisa melepas solderan resistor pull-up di sebagian board.

Robot laba-laba: 18 servo dengan dua PCA9685

Pada robot laba-laba berkaki enam (hexapod), setiap kaki punya tiga sendi: pinggul (coxa) yang menempel di badan, paha (femur) yang mengangkat kaki naik-turun, dan lutut (tibia) yang ujungnya menyentuh tanah. 6 × 3 = 18 servo melebihi 16 kanal satu board, jadi dua board dirangkai: kaki kiri ke board beralamat 0x40 dan kaki kanan ke board beralamat 0x41 yang jumper A0-nya disambung. Robot laba-laba berkaki empat (quadruped) memakai 12 servo dan muat di satu board dengan sisa 4 kanal. Kode di bawah memanggil servo dengan satu nomor dari 0 sampai 17, membuat robot berdiri, lalu menggerakkan lutut secara bergiliran. Memosisikan servo satu per satu dengan jeda 100 ms di antaranya mencegah lonjakan arus yang terjadi kalau 18 servo bangkit sekaligus. Untuk berjalan sungguhan, pola langkah tripod mengangkat tiga kaki sekaligus sementara tiga kaki lainnya menopang badan.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver sol = Adafruit_PWMServoDriver(0x40);   // sol bacaklar / left legs
5Adafruit_PWMServoDriver sag = Adafruit_PWMServoDriver(0x41);   // sağ bacaklar (A0 lehimli) / right legs (A0 bridged)
6
7const int SERVO_MIN = 110;
8const int SERVO_MAX = 500;
9
10// servo no 0-17: 0-8 sol kart, 9-17 sağ kart / servo no 0-17: 0-8 left board, 9-17 right board
11void servoYaz(uint8_t no, int aci) {
12  int tick = map(constrain(aci, 0, 180), 0, 180, SERVO_MIN, SERVO_MAX);
13  if (no < 9) sol.setPWM(no, 0, tick);
14  else        sag.setPWM(no - 9, 0, tick);
15}
16
17void setup() {
18  sol.begin();
19  sol.setOscillatorFrequency(27000000);
20  sol.setPWMFreq(50);
21  sag.begin();
22  sag.setOscillatorFrequency(27000000);
23  sag.setPWMFreq(50);
24  Wire.setClock(400000);                // hızlı I2C / fast I2C
25
26  for (uint8_t i = 0; i < 18; i++) {    // ayağa kalk: tüm eklemler 90 derece / stand up: all joints at 90 degrees
27    servoYaz(i, 90);
28    delay(100);                         // akım sıçramasını azalt / reduce current surge
29  }
30}
31
32void loop() {
33  for (uint8_t bacak = 0; bacak < 6; bacak++) {   // her bacağın dizini sırayla oynat / move each leg's knee in turn
34    uint8_t diz = bacak * 3 + 2;                  // her bacağın 3. servosu / third servo of each leg
35    servoYaz(diz, 60);
36    delay(300);
37    servoYaz(diz, 90);
38    delay(300);
39  }
40}

ESP32 dan PCA9685: lengan robot yang dikendalikan potensiometer

Di ESP32, library Adafruit yang sama bekerja tanpa perubahan; pin I2C-nya GPIO 21 (SDA) dan GPIO 22 (SCL). Di contoh ini kita mengendalikan lengan robot empat sendi (pangkal, bahu, siku, gripper) dengan empat potensiometer. Hubungkan kaki luar potensiometer ke 3V3 dan GND, dan kaki tengahnya ke GPIO 34, 35, 32, dan 33 di grup ADC1; karena pin ADC2 tidak bisa dibaca ketika Wi-Fi aktif, pilihan ini juga memudahkanmu menambahkan kendali nirkabel nanti. ADC ESP32 memberikan nilai dari 0 sampai 4095. Alih-alih langsung melompatkan setiap sendi ke sudut target, kode ini mendekatkannya sebesar 10 persen dari selisih yang tersisa di setiap perulangan; penghalusan sederhana ini mengurangi sentakan dan tarikan arus mendadak. Untuk desain mekanis dan urutan sendi, Lengan Robot Arduino adalah titik awal yang bagus.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);
5
6const int SERVO_MIN = 110;                    // kalibrasyondan / from calibration
7const int SERVO_MAX = 500;
8const int POT_PINS[4] = {34, 35, 32, 33};     // taban, omuz, dirsek, kıskaç / base, shoulder, elbow, gripper
9float konum[4] = {90, 90, 90, 90};            // anlık açılar / current angles
10
11void setup() {
12  Wire.begin(21, 22);                         // SDA, SCL
13  pwm.begin();
14  pwm.setOscillatorFrequency(27000000);
15  pwm.setPWMFreq(50);
16}
17
18void loop() {
19  for (int i = 0; i < 4; i++) {
20    int hedef = map(analogRead(POT_PINS[i]), 0, 4095, 0, 180);    // 12 bit ADC -> açı / 12-bit ADC -> angle
21    konum[i] += (hedef - konum[i]) * 0.1f;                        // yumuşak geçiş / smoothing
22    int tick = map((long)konum[i], 0, 180, SERVO_MIN, SERVO_MAX);
23    pwm.setPWM(i, 0, tick);
24  }
25  delay(20);                                  // her 20 ms'de bir güncelle / update every 20 ms
26}

Raspberry Pi Pico dan PCA9685 dengan MicroPython

MicroPython tidak punya driver PCA9685 bawaan di intinya, tapi chip ini begitu mudah dikendalikan dengan beberapa register sehingga kamu bisa menulis driver-nya sendiri. Register MODE1 (0x00) membangunkan chip, register PRESCALE (0xFE) mengatur frekuensi, dan register ON/OFF empat byte milik tiap kanal dimulai di alamat 0x06 lalu maju empat-empat. Nilai prescaler dihitung dengan prescale = osilator / (4096 × frekuensi) − 1 dan hanya bisa ditulis ketika chip dalam mode sleep. Beri daya board dari pin 3V3(OUT) Pico, lalu hubungkan SDA ke GP4 dan SCL ke GP5. Kalau kamu baru mengenal MicroPython, dasar-dasar MicroPython akan membantu.

MicroPython
1from machine import Pin, I2C
2import time
3
4class PCA9685:
5    def __init__(self, i2c, addr=0x40):
6        self.i2c = i2c
7        self.addr = addr
8        self._yaz(0x00, 0x00)                   # MODE1: uykudan çık / wake up
9        time.sleep_ms(5)
10
11    def _yaz(self, reg, deger):
12        self.i2c.writeto_mem(self.addr, reg, bytes([deger]))
13
14    def _oku(self, reg):
15        return self.i2c.readfrom_mem(self.addr, reg, 1)[0]
16
17    def frekans(self, hz, osc=27000000):        # Adafruit ile aynı osilatör varsayımı / same oscillator assumption as Adafruit
18        prescale = int(osc / (4096 * hz) + 0.5) - 1
19        eski = self._oku(0x00)
20        self._yaz(0x00, (eski & 0x7F) | 0x10)   # uyku kipi / sleep mode
21        self._yaz(0xFE, prescale)               # ön bölücü / prescaler
22        self._yaz(0x00, eski)
23        time.sleep_ms(5)
24        self._yaz(0x00, eski | 0xA0)            # yeniden başlat + otomatik artış / restart + auto-increment
25
26    def pwm(self, kanal, on, off):
27        reg = 0x06 + 4 * kanal                  # LEDn_ON_L yazmacı / LEDn_ON_L register
28        self.i2c.writeto_mem(self.addr, reg, bytes([on & 0xFF, on >> 8, off & 0xFF, off >> 8]))
29
30SERVO_MIN = 110                                 # 0 derece / 0 degrees
31SERVO_MAX = 500                                 # 180 derece / 180 degrees
32
33def servo_aci(pca, kanal, aci):
34    aci = max(0, min(180, aci))
35    tick = SERVO_MIN + (SERVO_MAX - SERVO_MIN) * aci // 180
36    pca.pwm(kanal, 0, tick)
37
38i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
39pca = PCA9685(i2c)
40pca.frekans(50)                                 # servo için 50 Hz / 50 Hz for servos
41
42while True:
43    for aci in range(0, 181, 2):                # 0 -> 180 derece / degrees
44        for k in range(4):
45            servo_aci(pca, k, aci)
46        time.sleep_ms(15)
47    for aci in range(180, -1, -2):              # 180 -> 0 derece / degrees
48        for k in range(4):
49            servo_aci(pca, k, aci)
50        time.sleep_ms(15)

Ide proyek dengan PCA9685

  • Lengan robot: kendalikan lengan 4–6 sendi dengan potensiometer atau joystick, lalu simpan gerakannya ke EEPROM untuk diputar ulang.
  • Robot laba-laba: buat robot berjalan dengan 12 servo di empat kaki atau 18 servo di enam kaki; di level mahir, pakai kinematika invers untuk menghitung koordinat ujung kaki.
  • Mata dan wajah animatronik: gerakkan 6–8 servo kecil secara sinkron untuk kelopak mata, pupil, dan alis.
  • Dudukan kamera pan-tilt: putar modul ESP32-CAM secara horizontal dan vertikal dengan dua servo, lalu arahkan lewat Wi-Fi.
  • Koreografi servo: gerakkan 32 servo yang disusun melingkar dengan dua board dalam pola gelombang dan spiral.
  • Dimmer LED 16 kanal: PCA9685 sebenarnya adalah driver LED; naikkan frekuensinya ke 1000 Hz dan atur kecerahan 16 LED tanpa kedipan. Logika PWM yang sama juga kamu pakai di sini.

Kesalahan umum dan cara mengatasinya

GejalaKemungkinan penyebabSolusi
Servo sama sekali tidak bergerakTidak ada catu V+, atau setPWMFreq belum dipanggilHubungkan daya eksternal ke terminal dan pastikan setPWMFreq(50) ada di setup
Servo bergetar dan melompat acakArus catu daya kurang, kabel terlalu tipisPakai catu daya yang lebih kuat, kabel tebal, dan kapasitor 470–1000 µF di jalur V+
Arduino reset ketika servo bergerakServo diberi daya dari pin 5V ArduinoBeri daya servo hanya dari V+ dan satukan GND-nya
Servo berdengung dan panas di ujung gerakanSERVO_MIN atau SERVO_MAX melewati batas mekanisCari batasnya dengan kode kalibrasi dan beri jarak 5–10 tick ke dalam
Kode macet atau board tidak ditemukanAlamat salah, SDA dan SCL tertukar, dua board di alamat yang samaJalankan scanner I2C dan cek jumper alamat
Servo menyentak keras begitu dinyalakanSemua servo menuju posisinya bersamaanMulai servo satu per satu dengan jeda singkat di antaranya
Sebagian besar getaran servo berasal dari catu daya, bukan dari software. Ukur tegangan V+ dengan multimeter ketika servo sedang bergerak; kalau turun di bawah 4,5 V, catu dayamu tidak sanggup. Untuk langkah diagnosis yang lebih rinci, lihat Masalah Servo Bergetar. Kalau kamu ingin servo tetap lemas ketika robot diam, kamu bisa mematikan output sebuah kanal sepenuhnya dengan setPWM(channel, 0, 4096); servo yang tidak menerima pulsa tidak memberikan torsi dan tidak menarik arus.

Begitu servomu lebih dari dua atau tiga, PCA9685 adalah board murah dan tangguh yang membuat proyekmu rapi: setelah dayanya kamu atur dengan benar dan tiap servo sudah dikalibrasi, sisanya tinggal menulis sudut. Untuk sendi yang lebih kuat, kamu bisa mencolokkan servo MG996R ke board yang sama, dan servo FS90R untuk roda yang berputar terus. Di aplikasi BlueGrays kamu akan menemukan proyek seperti koreografi lingkaran 32 servo, kendali servo dengan potensiometer dan joystick, serta kunci pintu RFID ESP32, lengkap dengan skema rangkaian dan kode langkah demi langkah.

Pertanyaan umum

Berapa banyak servo yang bisa dikendalikan dengan PCA9685?

Satu board PCA9685 menggerakkan 16 servo secara independen. Karena sampai 62 board bisa dirangkai di jalur I2C yang sama dengan jumper alamat, secara teori 992 servo bisa dikendalikan. Pada praktiknya, batasnya bukan board-nya, melainkan arus yang bisa diberikan catu dayamu ke servo.

Kenapa servo yang tersambung ke PCA9685 bergetar?

Penyebab paling umum adalah catu daya yang kurang kuat; tegangan V+ turun ketika servo bergerak. Penyebab kedua adalah nilai SERVO_MIN dan SERVO_MAX yang belum dikalibrasi sehingga servo mendorong batas mekanisnya. Catu daya yang kuat, kabel tebal, kapasitor besar di jalur V+, dan nilai batas yang tepat biasanya menyelesaikan masalah ini.

Apa beda VCC dan V+ di PCA9685?

VCC adalah catu logika chip; dihubungkan ke 5V di Arduino Uno dan ke 3V3 di ESP32 dan Pico, dan arus yang ditariknya sangat kecil. V+ adalah jalur daya servo dan diberi catu dari sumber eksternal 5–6 V. Kalau keduanya tertukar, board tidak bekerja atau mikrokontrolernya reset.

Bagaimana cara mengganti alamat I2C PCA9685?

Sambungkan satu atau beberapa pad solder A0–A5 di board dengan timah solder. Kalau tidak ada yang disambung, alamatnya 0x40; menyambung A0 menghasilkan 0x41 dan menyambung A1 menghasilkan 0x42. Di kode, cukup buat objek dengan alamat baru, misalnya Adafruit_PWMServoDriver(0x41).

Apakah PCA9685 bisa dipakai dengan ESP32?

Bisa, library Adafruit PWM Servo Driver bekerja di ESP32 tanpa perubahan. Hubungkan SDA ke GPIO 21 dan SCL ke GPIO 22, lalu beri daya VCC board dari 3V3 supaya jalur I2C tetap di 3,3 V. Sinyal servonya jadi 3,3 V; kebanyakan servo standar bisa membaca level ini tanpa masalah.

Selain servo, PCA9685 bisa dipakai untuk apa?

Chip ini sebenarnya adalah driver LED 16 kanal; kalau frekuensinya dinaikkan ke sekitar 1000 Hz, kamu bisa mengatur kecerahan LED dalam 4096 tingkat. Chip ini juga bisa mengendalikan kecepatan motor DC kecil lewat transistor atau MOSFET. Kanal-kanalnya tidak menggerakkan beban besar secara langsung; kanal hanya menghasilkan sinyal kendali.

Lihat semua proyek
Koreografi Lingkaran Servo - Pola Animasi dengan 32 Servo
AR-97Mahir
Premium

Koreografi Lingkaran Servo - Pola Animasi dengan 32 Servo

Proyek animasi visual dengan 32 motor servo yang disusun melingkar di Arduino Mega. Servo-servo dikelola dalam satu array, tersambung ke pin 22-53 Mega, dan menampilkan empat urutan gerak: getaran kacau ketika semua servo bergerak ke sudut acak, sapuan serempak ketika semuanya bergerak bersamaan, gelombang yang berputar halus mengelilingi lingkaran, dan terakhir jarum kompas yang berayun ke kiri dan kanan.

4.5(40)
62
Menggunakan Motor Servo
AR-35Pemula
Premium

Menggunakan Motor Servo

Lengan motor servo kecil berputar ke tiga posisi bergantian: penuh ke awal, tepat ke tengah, dan penuh ke akhir, menunggu dua detik di setiap perhentian.

4.7(48)
67
Menggerakkan Motor Servo dengan Potensiometer
AR-36Pemula
Premium

Menggerakkan Motor Servo dengan Potensiometer

Ketika kamu memutar kenop potensiometer, lengan motor servo ikut berputar: satu ujung kenop berarti nol derajat, ujung lainnya berarti setengah putaran.

4.6(37)
53
Kendali Servo dengan Joystick
AR-60Menengah
Premium

Kendali Servo dengan Joystick

Arahkan dua motor dengan joystick, persis seperti memutar kamera keamanan. Dorong tuas ke kiri atau kanan dan servo bawah berputar perlahan, dorong ke atas atau bawah dan servo atas mendongak dan…

4.7(42)
58
Motor Servo ESP32 (Kendali Potensiometer)
ES-16Menengah
Premium

Motor Servo ESP32 (Kendali Potensiometer)

Di proyek ini, kita mengendalikan motor servo SG90 memakai potensiometer. Kita mengatur sudut servo dengan memetakan nilai analog yang dibaca dari potensiometer ke rentang 0–180 derajat. Library ESP32Servo menghasilkan sinyal servo di pin GPIO ESP32 yang sesuai dan bisa menjadi output; proyek ini memakai GPIO 18. Ini metode kendali dasar untuk lengan robot, gimbal kamera, dan mekanisme pintu otomatis.

4.3(29)
42
Kunci Pintu RFID ESP32 (RC522 + Servo + OLED + Buzzer + LED)
ES-35Mahir
Premium

Kunci Pintu RFID ESP32 (RC522 + Servo + OLED + Buzzer + LED)

Kita membuat kunci pintu pintar dengan ESP32, modul RFID RC522, motor servo SG90, layar OLED SSD1306, buzzer aktif, dan 2 LED. Ketika sebuah kartu dipindai, UID-nya dibandingkan dengan daftar kartu resmi yang disimpan di kode; jika resmi, motor servo berputar untuk membuka kunci (LED hijau + 2 bunyi bip pendek), dan pintu otomatis terkunci lagi setelah 5 detik. Untuk kartu tidak resmi, LED merah menyala, peringatan diberikan dengan 3 bunyi bip cepat, dan UID yang terbaca ditampilkan di layar.

4.8(9)
16
Servo 360 Derajat dari Motor Stepper
AR-68Menengah
Premium

Servo 360 Derajat dari Motor Stepper

Ajari motor stepper biasa untuk pergi ke sudut mana pun yang kamu mau, satu lingkaran penuh.

4.5(22)
33