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?.

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.
| Fitur | Nilai |
|---|---|
| Chip | NXP PCA9685 |
| Jumlah kanal | 16 output PWM independen |
| Resolusi | 12 bit (4096 langkah per periode) |
| Frekuensi PWM | Sekitar 24–1526 Hz (50 Hz untuk servo) |
| Komunikasi | I2C, sampai 1 MHz |
| Alamat default | 0x40 (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 output | 25 mA sink, 10 mA source per kanal (hanya untuk sinyal) |
| Di board | Kebanyakan modul punya resistor pull-up SDA/SCL dan resistor seri 220 Ω di output |
| Lebar pulsa | Tick @ 50 Hz | Posisi servo tipikal |
|---|---|---|
| 0,5 ms (500 µs) | ≈ 102 | Sekitar 0° untuk SG90 |
| 1,0 ms (1000 µs) | ≈ 205 | 0° standar (servo dengan rentang sempit) |
| 1,5 ms (1500 µs) | ≈ 307 | Posisi tengah (90°) |
| 2,0 ms (2000 µs) | ≈ 410 | 180° standar |
| 2,4 ms (2400 µs) | ≈ 492 | Sekitar 180° untuk SG90 |
Pengkabelan PCA9685: Arduino Uno, ESP32, dan Pico
| Pin PCA9685 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| GND | GND | GND | GND |
| VCC (logika) | 5V | 3V3 | 3V3(OUT) |
| SDA | A4 | GPIO 21 | GP4 |
| SCL | A5 | GPIO 22 | GP5 |
| OE | Biarkan kosong (di board sudah ditarik ke GND) | Biarkan kosong | Biarkan kosong |
| V+ (terminal sekrup) | Positif catu daya eksternal 5–6 V | Positif catu daya eksternal 5–6 V | Positif 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) |
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.
| Servo | Diam | Bergerak | Tertahan (stall) | Catu daya |
|---|---|---|---|---|
| SG90 (9 g, gear plastik) | ≈ 10 mA | 100–250 mA | ≈ 650 mA | 4,8–6 V |
| MG90S (gear logam) | ≈ 10 mA | 150–300 mA | ≈ 700 mA | 4,8–6 V |
| MG996R (ukuran standar) | ≈ 10 mA | 500–900 mA | ≈ 2,5 A | 4,8–7,2 V |
Langkah demi langkah percobaan pertama: putar 4 servo bersamaan
- Buka Library Manager di Arduino IDE, cari library Adafruit PWM Servo Driver, lalu instal.
- Hubungkan pin VCC, GND, SDA, dan SCL board ke Arduino seperti di tabel di atas; biarkan pin OE kosong.
- 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.
- Hubungkan catu daya eksternal 5 V ke terminal sekrup: positif ke V+, negatif ke GND.
- 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.
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.
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 disambung | Alamat | Contoh penggunaan |
|---|---|---|
| Tidak ada | 0x40 | Board 1 (servo 0–15) |
| A0 | 0x41 | Board 2 (servo 16–31) |
| A1 | 0x42 | Board 3 |
| A0 + A1 | 0x43 | Board 4 |
| A2 | 0x44 | Board 5 |
| Semua A0–A5 | 0x7F | Alamat terakhir |
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.
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.
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.
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
| Gejala | Kemungkinan penyebab | Solusi |
|---|---|---|
| Servo sama sekali tidak bergerak | Tidak ada catu V+, atau setPWMFreq belum dipanggil | Hubungkan daya eksternal ke terminal dan pastikan setPWMFreq(50) ada di setup |
| Servo bergetar dan melompat acak | Arus catu daya kurang, kabel terlalu tipis | Pakai catu daya yang lebih kuat, kabel tebal, dan kapasitor 470–1000 µF di jalur V+ |
| Arduino reset ketika servo bergerak | Servo diberi daya dari pin 5V Arduino | Beri daya servo hanya dari V+ dan satukan GND-nya |
| Servo berdengung dan panas di ujung gerakan | SERVO_MIN atau SERVO_MAX melewati batas mekanis | Cari batasnya dengan kode kalibrasi dan beri jarak 5–10 tick ke dalam |
| Kode macet atau board tidak ditemukan | Alamat salah, SDA dan SCL tertukar, dua board di alamat yang sama | Jalankan scanner I2C dan cek jumper alamat |
| Servo menyentak keras begitu dinyalakan | Semua servo menuju posisinya bersamaan | Mulai servo satu per satu dengan jeda singkat di antaranya |
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.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
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.

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.

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.

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…

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.

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.

Servo 360 Derajat dari Motor Stepper
Ajari motor stepper biasa untuk pergi ke sudut mana pun yang kamu mau, satu lingkaran penuh.
Artikel lainnya
Aplikasi BlueGrays
Rakit rangkaian ini langkah demi langkah di ponselmu
Skema pengkabelan, kode, dan daftar komponen dalam satu layar. 500+ proyek Arduino, ESP32, dan Pico siap dibuat.
Pindai dengan ponselmu
Arahkan kamera ke kode ini dan toko aplikasi di ponselmu akan terbuka.
atau buka toko aplikasi

