PCA9685 Arduino Kullanımı: 16 Kanal Servo Sürücü Rehberi
PCA9685 Arduino bağlantısı: I2C adresi 0x40, servolar için harici güç, darbe genişliği kalibrasyonu, kart zincirleme ile robot kol ve örümcek robot kodları.
PCA9685, tek bir I2C hattı üzerinden 16 servo motoru aynı anda ve birbirinden bağımsız sürebilen, 12 bit çözünürlüklü bir PWM sürücü kartıdır. Arduino Uno'da Servo kütüphanesi en fazla 12 servoyu yönetebilir ve bunu yaparken bir zamanlayıcıyı tamamen meşgul eder; pinler biter, servolar titremeye başlar. PCA9685 ise darbeleri kendi içindeki osilatörle üretir, mikrodenetleyicine yalnızca "şu kanalı şu konuma getir" demek kalır. Robot kol, örümcek robot, animatronik göz ya da pan-tilt kamera yuvası gibi çok eklemli projelerin neredeyse hepsinde bu kartı görürsün.
Bu rehberde PCA9685 Arduino bağlantısını, servoları neden ayrı bir güç kaynağıyla beslemen gerektiğini, her servonun gerçek 0 ve 180 derece değerlerini bulmak için darbe genişliği kalibrasyonunu ve kartların adres köprüleriyle nasıl zincirlendiğini öğreneceksin. Ardından iki kartla 18 servolu bir örümcek robot, ESP32 ile potansiyometre kontrollü bir robot kol ve Raspberry Pi Pico için kütüphanesiz bir MicroPython sürücüsü yazacağız. Servo motorların temel çalışma mantığına yabancıysan önce Servo Motor Nedir? yazısına göz atabilirsin.

PCA9685 nedir, nasıl çalışır?
PCA9685 aslında NXP'nin LED sürmek için tasarladığı bir yongadır, ama frekansı ayarlanabildiği için servolarla da mükemmel çalışır. İçinde 25 MHz'lik bir osilatör ve tüm kanalların ortak kullandığı 12 bitlik bir sayaç bulunur; bir PWM periyodu 4096 adıma (tick) bölünür. Her kanala iki sayı yazarsın: sinyalin yükseldiği adım (ON) ve düştüğü adım (OFF). Servolar için frekans 50 Hz seçilir, yani periyot 20 ms olur. Bir adımın süresi 20 ms / 4096 ≈ 4,88 µs eder; dolayısıyla istediğin darbe genişliğini adıma çevirmek için tick = darbe (µs) / 4,88 formülünü kullanırsın. Örneğin 1,5 ms'lik orta konum darbesi 1500 / 4,88 ≈ 307 adımdır. Kanal bir kez ayarlandıktan sonra kart bu sinyali kendi başına üretmeye devam eder; Arduino başka işlerle meşgulken bile servo yerinde sabit durur.
| Özellik | Değer |
|---|---|
| Yonga | NXP PCA9685 |
| Kanal sayısı | 16 bağımsız PWM çıkışı |
| Çözünürlük | 12 bit (periyot başına 4096 adım) |
| PWM frekansı | Yaklaşık 24–1526 Hz (servo için 50 Hz) |
| Haberleşme | I2C, 1 MHz'e kadar |
| Varsayılan adres | 0x40 (A0–A5 köprüleriyle 0x40–0x7F) |
| Mantık beslemesi (VCC) | 2,3–5,5 V |
| Servo beslemesi (V+) | Harici, servoya göre genellikle 5–6 V |
| Çıkış akımı | Kanal başına 25 mA çekme, 10 mA verme (yalnızca sinyal için) |
| Kart üzerinde | Çoğu modülde SDA/SCL pull-up dirençleri ve çıkışlarda 220 Ω seri direnç |
| Darbe genişliği | Adım (tick) @ 50 Hz | Tipik servo konumu |
|---|---|---|
| 0,5 ms (500 µs) | ≈ 102 | SG90 için yaklaşık 0° |
| 1,0 ms (1000 µs) | ≈ 205 | Standart 0° (dar aralıklı servolar) |
| 1,5 ms (1500 µs) | ≈ 307 | Orta konum (90°) |
| 2,0 ms (2000 µs) | ≈ 410 | Standart 180° |
| 2,4 ms (2400 µs) | ≈ 492 | SG90 için yaklaşık 180° |
PCA9685 bağlantısı: Arduino Uno, ESP32 ve Pico
| PCA9685 pini | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| GND | GND | GND | GND |
| VCC (mantık) | 5V | 3V3 | 3V3(OUT) |
| SDA | A4 | GPIO 21 | GP4 |
| SCL | A5 | GPIO 22 | GP5 |
| OE | Boş bırak (kartta GND'ye çekili) | Boş bırak | Boş bırak |
| V+ (vida klemensi) | Harici 5–6 V kaynağın artısı | Harici 5–6 V kaynağın artısı | Harici 5–6 V kaynağın artısı |
| GND (vida klemensi) | Harici kaynağın eksisi (kartta GND ile ortak) | Harici kaynağın eksisi (kartta GND ile ortak) | Harici kaynağın eksisi (kartta GND ile ortak) |
Harici güç: servolar ne kadar akım çeker?
Bir servo boştayken yalnızca 5–10 mA çeker, ama hareket ederken ve özellikle yük altında zorlanırken (stall) akım birden yükselir. Bir SG90 zorlandığında 600–700 mA'e, bir MG996R ise 2 A'in üzerine çıkabilir. Robot kolun bütün eklemleri aynı anda hareket etmeye başladığında bu tepe akımlar toplanır ve zayıf bir kaynağın gerilimi düşer; sonuç titreyen, rastgele sıçrayan servolar ve resetlenen bir Arduino olur. Pratik kural şudur: aynı anda hareket edecek servo sayısını tepe akımla çarp ve çıkan değerin en az yarısını sürekli verebilen bir kaynak seç. Altı SG90'lık bir robot kol için 5 V 3 A'lik bir adaptör, 18 servolu bir örümcek robot için 5–6 V 8–10 A'lik bir kaynak ya da RC dünyasındaki güçlü UBEC'ler iyi seçimdir.
| Servo | Boşta | Hareket hâlinde | Zorlanınca (stall) | Besleme |
|---|---|---|---|---|
| SG90 (9 g, plastik dişli) | ≈ 10 mA | 100–250 mA | ≈ 650 mA | 4,8–6 V |
| MG90S (metal dişli) | ≈ 10 mA | 150–300 mA | ≈ 700 mA | 4,8–6 V |
| MG996R (standart boy) | ≈ 10 mA | 500–900 mA | ≈ 2,5 A | 4,8–7,2 V |
Adım adım ilk çalıştırma: 4 servoyu birlikte döndür
- Arduino IDE'de Kütüphane Yöneticisi'ni aç, Adafruit PWM Servo Driver kütüphanesini ara ve kur.
- Kartın VCC, GND, SDA ve SCL pinlerini yukarıdaki tablodaki gibi Arduino'ya bağla; OE pinini boş bırak.
- Servoları 0, 1, 2 ve 3 numaralı kanallara tak. Fişin turuncu ya da sarı sinyal kablosu PWM sırasına, kırmızısı V+ sırasına, kahverengi ya da siyahı GND sırasına gelmeli.
- Harici 5 V kaynağı vida klemensine bağla: artı uç V+'ya, eksi uç GND'ye.
- Önce Arduino'yu USB ile çalıştırıp kodu yükle, ardından servo beslemesini aç. Kartın adresinden emin değilsen bir I2C tarayıcı koduyla 0x40 adresinin göründüğünü doğrula.
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() kartı başlatır, setPWMFreq(50) periyodu servolar için 20 ms yapar. setOscillatorFrequency(27000000) satırı Adafruit örneklerinden gelir: yonganın iç osilatörü kâğıt üzerinde 25 MHz olsa da gerçekte 23–27 MHz arasında değişir ve kütüphane ön bölücüyü bu değere göre hesaplar. Asıl işi setPWM(kanal, on, off) yapar; on değerini 0 bırakıp off değerine tick sayısını yazınca darbe periyodun başında başlar ve o adımda biter. servoAci() fonksiyonu map() ile 0–180 dereceyi SERVO_MIN–SERVO_MAX aralığına çevirir. Kütüphanede darbeyi doğrudan mikrosaniyeyle veren writeMicroseconds(kanal, µs) fonksiyonu da vardır; ama bu fonksiyonun doğruluğu osilatör ayarına bağlı olduğu için tick ile çalışıp her servoyu kalibre etmek daha güvenilirdir.
Darbe genişliği kalibrasyonu: her servonun gerçek sınırlarını bul
Servo üreticileri 1–2 ms'lik standart aralığı verir, ama gerçekte her servo farklıdır: bir SG90 0,5–2,4 ms arasında tam 180 derece dönerken bir başkası 170 derecede kalabilir. Tablodaki değerleri körü körüne kullanırsan servo uç noktada mekanik durdurucuya dayanır, vızıldar, gereksiz akım çeker ve dişlileri zamanla aşınır. Aşağıdaki kalibrasyon kodu Seri Monitör'den yazdığın tick değerini 0 numaralı kanala gönderir. 300 civarından başla, değeri 10'ar 10'ar azalt; servonun dönmeyi bıraktığı ya da vızıldamaya başladığı noktanın 5–10 adım üstünü SERVO_MIN olarak not et. Aynısını yukarı doğru yapıp SERVO_MAX'ı bul. Robot kol ya da örümcek robotta her eklem ayrı bir servo olduğu için bu ölçümü her servo için tekrarlayıp değerleri bir diziye yazman en temiz yöntemdir.
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}Birden fazla PCA9685 kartını zincirleme
Her kartın üst kenarında A0'dan A5'e kadar altı adres köprüsü (lehim pedi) vardır. Hepsi açıkken adres 0x40'tır; bir pedi lehimle kısa devre ettiğinde ilgili bit 1 olur ve adrese o bitin değeri eklenir. Böylece aynı I2C hattına teoride 62 kart, yani 992 servo bağlanabilir. Kartların iki yanındaki 6 pinli başlıklar birbirine paralel olduğu için ikinci kartı birinciye kısa bir kabloyla bağlaman yeterlidir; SDA, SCL, VCC ve GND böylece zincir boyunca taşınır. Kodda her kart için ayrı bir nesne oluşturur ve adresini yapıcıya verirsin. 0x70 adresi varsayılan olarak yonganın "hepsine birden" (All Call) adresi olduğu için bu adresi kullanmaktan kaçın. I2C adreslemeyi daha derinlemesine öğrenmek için I2C Nedir? yazısına bakabilirsin.
| Lehimlenen köprüler | Adres | Örnek kullanım |
|---|---|---|
| Hiçbiri | 0x40 | 1. kart (servo 0–15) |
| A0 | 0x41 | 2. kart (servo 16–31) |
| A1 | 0x42 | 3. kart |
| A0 + A1 | 0x43 | 4. kart |
| A2 | 0x44 | 5. kart |
| A0–A5 hepsi | 0x7F | Son adres |
Örümcek robot: iki PCA9685 ile 18 servo
Altı bacaklı bir örümcek robotta (hexapod) her bacakta üç eklem vardır: gövdeye bağlı kalça (coxa), bacağı yukarı aşağı kaldıran uyluk (femur) ve ucu yere basan diz (tibia). 6 × 3 = 18 servo tek kartın 16 kanalını aştığı için iki kart zincirlenir: sol bacaklar 0x40 adresli karta, sağ bacaklar A0 köprüsü lehimlenmiş 0x41 adresli karta bağlanır. Dört bacaklı bir örümcek robot (quadruped) ise 12 servoyla tek karta sığar ve 4 kanal boşta kalır. Aşağıdaki kod servoları 0–17 arasında tek bir numarayla adresler, robotu ayağa kaldırır ve dizleri sırayla oynatır. Servoları tek tek, aralarında 100 ms bekleyerek konumlandırmak, 18 servonun aynı anda kalkmasıyla oluşacak akım sıçramasını önler. Gerçek yürüyüş için üçlü (tripod) adım düzeninde aynı anda üç bacak kaldırılır, diğer üç bacak gövdeyi taşır.
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 ve PCA9685 ile potansiyometre kontrollü robot kol
ESP32'de aynı Adafruit kütüphanesi değişiklik olmadan çalışır; I2C pinleri GPIO 21 (SDA) ve GPIO 22 (SCL)'dir. Bu örnekte dört eklemli bir robot kolu (taban, omuz, dirsek, kıskaç) dört potansiyometreyle yönetiyoruz. Potansiyometrelerin dış uçlarını 3V3 ile GND'ye, orta bacaklarını ADC1 grubundaki GPIO 34, 35, 32 ve 33'e bağla; ADC2 pinleri Wi-Fi açıkken okunamadığı için bu seçim ileride kablosuz kontrol eklemeni de kolaylaştırır. ESP32'nin ADC'si 0–4095 arası değer verir. Kod her eklemi hedef açıya birden atlatmak yerine her döngüde aradaki farkın yüzde 10'u kadar yaklaştırır; bu basit yumuşatma kolun sarsılmasını ve ani akım çekişini azaltır. Mekanik tasarım ve eklem sıralaması için Arduino Robot Kol yazısı iyi bir başlangıçtır.
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 ve MicroPython ile PCA9685
MicroPython'un çekirdeğinde hazır bir PCA9685 sürücüsü yoktur, ama yongayı birkaç yazmaçla yönetmek o kadar kolaydır ki sürücüyü kendin yazabilirsin. MODE1 yazmacı (0x00) yongayı uyandırır, PRESCALE yazmacı (0xFE) frekansı belirler ve her kanalın dört baytlık ON/OFF yazmaçları 0x06 adresinden başlayıp dörder dörder ilerler. Ön bölücü değeri prescale = osilatör / (4096 × frekans) − 1 formülüyle hesaplanır ve yalnızca yonga uyku kipindeyken yazılabilir. Kartı Pico'nun 3V3(OUT) pininden besle, SDA'yı GP4'e, SCL'yi GP5'e bağla. MicroPython'a yeniysen MicroPython Temelleri yazısı işini kolaylaştırır.
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)PCA9685 ile proje fikirleri
- Robot kol: 4–6 eklemli bir kolu potansiyometrelerle ya da bir joystick ile yönet, hareketleri EEPROM'a kaydedip tekrar oynat.
- Örümcek robot: 12 servolu dört bacaklı ya da 18 servolu altı bacaklı yürüyen bir robot yap; ileri seviyede ters kinematikle bacak ucunun koordinatını hesapla.
- Animatronik göz ve yüz: Göz kapakları, göz bebekleri ve kaşlar için 6–8 küçük servoyu senkron hareket ettir.
- Pan-tilt kamera yuvası: İki servoyla bir ESP32-CAM modülünü yatay ve dikey çevir, Wi-Fi üzerinden yönlendir.
- Servo koreografisi: Bir çembere dizilmiş 32 servoyu iki kartla dalga ve spiral desenlerinde hareket ettir.
- 16 kanallı LED dimmer: PCA9685 aslında bir LED sürücüdür; frekansı 1000 Hz'e çıkarıp 16 LED'in parlaklığını titreşimsiz ayarla. PWM mantığını burada da birebir kullanırsın.
Sık yapılan hatalar ve çözümleri
| Belirti | Olası sebep | Çözüm |
|---|---|---|
| Servolar hiç hareket etmiyor | V+ beslemesi yok ya da setPWMFreq çağrılmamış | Klemense harici güç bağla, setup içinde setPWMFreq(50) olduğundan emin ol |
| Servolar titriyor, rastgele sıçrıyor | Kaynağın akımı yetersiz, kablolar ince | Daha güçlü kaynak, kalın kablo ve V+ hattına 470–1000 µF kondansatör |
| Servolar hareket edince Arduino resetleniyor | Servolar Arduino'nun 5V pininden besleniyor | Servo gücünü yalnızca V+'dan ver, GND'leri ortakla |
| Servo uç noktada vızıldıyor ve ısınıyor | SERVO_MIN ya da SERVO_MAX mekanik sınırın dışında | Kalibrasyon koduyla sınırları bul, 5–10 adım içeride kal |
| Kod donuyor ya da kart bulunamıyor | Yanlış adres, SDA ve SCL ters, iki kart aynı adreste | I2C tarayıcı çalıştır, adres köprülerini kontrol et |
| Açılışta servolar sertçe sıçrıyor | Tüm servolar aynı anda konuma gidiyor | Servoları sırayla ve aralarında kısa beklemeyle başlat |
PCA9685, servo sayısı ikiyi üçü geçtiği anda projeyi düzene sokan, ucuz ve sağlam bir karttır: bir kez doğru beslemeyi kurup her servoyu kalibre ettiğinde gerisi yalnızca açı yazmaktan ibarettir. Daha güçlü eklemler için MG996R, sürekli dönen tekerlekler için FS90R servoları da aynı karta takabilirsin. BlueGrays uygulamasında 32 servolu çember koreografisi, potansiyometre ve joystick ile servo kontrolü ve ESP32 RFID kapı kilidi gibi projeleri adım adım devre şeması ve kodlarıyla bulabilirsin.
Sıkça sorulan sorular
PCA9685 ile kaç servo kontrol edilebilir?
Tek bir PCA9685 kartı 16 servoyu bağımsız olarak sürer. Adres köprüleriyle 62 karta kadar aynı I2C hattında zincirlenebildiği için teoride 992 servo yönetilebilir. Pratikte sınırı kartlar değil, servoları besleyecek güç kaynağının verebildiği akım belirler.
PCA9685'e bağlı servo neden titrer?
En yaygın sebep yetersiz güç kaynağıdır; servolar hareket ederken V+ gerilimi düşer. İkinci sebep, kalibre edilmemiş SERVO_MIN ve SERVO_MAX değerleri yüzünden servonun mekanik sınırına dayanmasıdır. Güçlü bir kaynak, kalın kablo, V+ hattına büyük bir kondansatör ve doğru sınır değerleri sorunu çoğu zaman çözer.
PCA9685'te VCC ile V+ arasındaki fark nedir?
VCC yonganın mantık beslemesidir; Arduino Uno'da 5V'a, ESP32 ve Pico'da 3V3'e bağlanır ve çok az akım çeker. V+ ise servoların güç hattıdır ve harici bir 5–6 V kaynaktan beslenir. İkisini karıştırmak ya kartın çalışmamasına ya da mikrodenetleyicinin resetlenmesine yol açar.
PCA9685 I2C adresi nasıl değiştirilir?
Kartın üzerindeki A0–A5 lehim pedlerinden birini ya da birkaçını lehimle kısa devre edersin. Hiçbiri lehimli değilken adres 0x40'tır; A0 lehimlenirse 0x41, A1 lehimlenirse 0x42 olur. Kodda nesneyi Adafruit_PWMServoDriver(0x41) gibi yeni adresle oluşturman yeterlidir.
PCA9685 ESP32 ile çalışır mı?
Evet, Adafruit PWM Servo Driver kütüphanesi ESP32'de değişiklik gerektirmeden çalışır. SDA'yı GPIO 21'e, SCL'yi GPIO 22'ye bağla ve kartın VCC'sini 3V3'ten besle ki I2C hatları 3,3 V'ta kalsın. Servo sinyali bu durumda 3,3 V olur; standart servoların çoğu bu seviyeyi sorunsuz algılar.
PCA9685 servo dışında ne için kullanılır?
Yonga aslında 16 kanallı bir LED sürücüdür; frekansı 1000 Hz civarına çıkararak LED'lerin parlaklığını 4096 kademede ayarlayabilirsin. Transistör ya da MOSFET üzerinden küçük DC motorların hızını kontrol etmek için de kullanılır. Kanallar büyük yükleri doğrudan sürmez, yalnızca kontrol sinyali üretir.
Bu yazıdan sonra yapabileceğin projeler
Tüm projeleri gör
Servo Çember Koreografisi — 32 Servo ile Animasyonlu Desenler
Arduino Mega üzerinde çember şeklinde dizilmiş 32 servo motorla çalışan görsel bir animasyon projesi. Servolar tek bir dizide yönetilir, Mega'nın 22–53 numaralı pinlerine bağlanır ve dört hareket dizisi sergiler: rastgele açılarla kaotik bir titreşim, senkron bir süpürme, çember etrafında dönen bir dalga ve sağa sola sallanan bir pusula ibresi.

Servo Motor Kullanım
Küçük bir servo motorun kolu sırayla üç konuma döner: en başa, tam ortaya ve en sona, her durakta iki saniye bekleyerek.

Potansiyometre İle Servo Motor Kullanım
Potansiyometrenin düğmesini çevirdikçe servo motorun kolu da onunla birlikte döner; düğmenin bir ucu sıfır dereceye, öbür ucu yarım tura karşılık gelir.

Joystick İle Servo Kontrol
Bir oyun kolu çubuğuyla iki motoru yönet, tıpkı bir güvenlik kamerasını çevirir gibi.

ESP32 Servo Motor (Potansiyometre Kontrolü)
Bu projede potansiyometre ile SG90 servo motoru kontrol ediyoruz. Potansiyometreden okunan analog değeri 0-180 derece aralığına map'leyerek servo açısını ayarlıyoruz. ESP32Servo kütüphanesi, ESP32'nin çıkış verebilen uygun GPIO'larında servo sinyali üretir; bu projede GPIO 18 kullanılır. Bu, robotik kollar, kamera gimbal'ları ve otomatik kapı mekanizmaları için temel bir kontrol yöntemidir.

ESP32 RFID Kapı Kilidi (RC522 + Servo + OLED + Buzzer + LED)
ESP32 ile RC522 RFID modülü, SG90 servo motor, SSD1306 OLED ekran, aktif buzzer ve 2 LED kullanarak akıllı bir kapı kilidi yapıyoruz. Kart okutulduğunda UID, kodda tanımlı yetkili kartlarla karşılaştırılır; yetkiliyse servo kilidi açar (yeşil LED + 2 kısa bip) ve 5 saniye sonra otomatik kilitler. Yetkisiz kartta kırmızı LED yanar, 3 hızlı bip çalar ve OLED'de okunan UID gösterilir.

Step Motordan 360 Derecelik Servo Motor Yapımı
Sıradan bir step motora istediğin açıya gitmeyi öğret, üstelik tam bir tur boyunca.
Diğer yazılar
BlueGrays uygulaması
Bu devreyi telefonunda adım adım kur
Devre şeması, kod ve parça listesi tek ekranda. 500'den fazla Arduino, ESP32 ve Pico projesi seni bekliyor.
Telefonunla tara
Kamerayı koda tut; telefonunun uygulama mağazası açılır.
ya da mağazada aç

