PCA9685 Arduino: 16 Servos mit Servotreiber ansteuern
PCA9685 am Arduino anschließen: I2C-Adresse 0x40, externe Stromversorgung, Pulsbreiten kalibrieren, Boards verketten – mit Code für Roboterarm und Hexapod.
Der PCA9685 ist ein PWM-Treiberboard mit 12 Bit Auflösung, das über eine einzige I2C-Leitung 16 Servomotoren gleichzeitig und unabhängig voneinander ansteuern kann. Am Arduino Uno verwaltet die Servo-Bibliothek höchstens 12 Servos und belegt dabei einen Timer komplett; die Pins werden knapp und die Servos fangen an zu zittern. Der PCA9685 erzeugt die Impulse dagegen mit seinem eigenen Oszillator, dein Mikrocontroller muss nur noch sagen: "Bring diesen Kanal in diese Position." Bei Roboterarmen, Spinnenrobotern, animatronischen Augen oder Pan-Tilt-Kamerahalterungen, also fast allen Projekten mit vielen Gelenken, wirst du dieses Board finden.
In dieser Anleitung lernst du den Anschluss des PCA9685 am Arduino, warum du die Servos mit einem separaten Netzteil versorgen musst, wie du die Pulsbreite kalibrierst, um die echten 0- und 180-Grad-Werte jedes Servos zu finden, und wie du Boards über die Adressbrücken verkettest. Danach bauen wir einen Spinnenroboter mit 18 Servos an zwei Boards, einen Roboterarm mit Potentiometern am ESP32 und einen Treiber ohne Bibliothek in MicroPython für den Raspberry Pi Pico. Wenn dir die Grundlagen von Servomotoren noch fremd sind, wirf zuerst einen Blick auf Was ist ein Servomotor?.

Was ist der PCA9685 und wie funktioniert er?
Der PCA9685 ist eigentlich ein Chip, den NXP für die LED-Ansteuerung entwickelt hat, aber da sich seine Frequenz einstellen lässt, funktioniert er auch hervorragend mit Servos. Er enthält einen 25-MHz-Oszillator und einen 12-Bit-Zähler, den alle Kanäle gemeinsam nutzen; eine PWM-Periode wird in 4096 Schritte (Ticks) geteilt. Für jeden Kanal schreibst du zwei Zahlen: den Schritt, an dem das Signal steigt (ON), und den, an dem es fällt (OFF). Für Servos wählt man 50 Hz, die Periode beträgt also 20 ms. Ein Schritt dauert 20 ms / 4096 ≈ 4,88 µs; um eine gewünschte Pulsbreite in Ticks umzurechnen, nutzt du die Formel Tick = Puls (µs) / 4,88. Der 1,5-ms-Impuls für die Mittelstellung entspricht zum Beispiel 1500 / 4,88 ≈ 307 Schritten. Ist ein Kanal einmal gesetzt, erzeugt das Board das Signal von selbst weiter; der Servo bleibt stehen, selbst wenn der Arduino mit anderen Dingen beschäftigt ist.
| Eigenschaft | Wert |
|---|---|
| Chip | NXP PCA9685 |
| Kanalanzahl | 16 unabhängige PWM-Ausgänge |
| Auflösung | 12 Bit (4096 Schritte pro Periode) |
| PWM-Frequenz | Etwa 24–1526 Hz (50 Hz für Servos) |
| Kommunikation | I2C, bis 1 MHz |
| Standardadresse | 0x40 (0x40–0x7F über die Brücken A0–A5) |
| Logikversorgung (VCC) | 2,3–5,5 V |
| Servoversorgung (V+) | Extern, je nach Servo meist 5–6 V |
| Ausgangsstrom | 25 mA Senke, 10 mA Quelle pro Kanal (nur für das Signal) |
| Auf dem Board | Bei den meisten Modulen Pull-up-Widerstände an SDA/SCL und 220-Ω-Serienwiderstände an den Ausgängen |
| Pulsbreite | Schritte (Ticks) @ 50 Hz | Typische Servoposition |
|---|---|---|
| 0,5 ms (500 µs) | ≈ 102 | Beim SG90 etwa 0° |
| 1,0 ms (1000 µs) | ≈ 205 | Standard-0° (Servos mit engem Bereich) |
| 1,5 ms (1500 µs) | ≈ 307 | Mittelstellung (90°) |
| 2,0 ms (2000 µs) | ≈ 410 | Standard-180° |
| 2,4 ms (2400 µs) | ≈ 492 | Beim SG90 etwa 180° |
PCA9685 anschließen: Arduino Uno, ESP32 und Pico
| PCA9685-Pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| GND | GND | GND | GND |
| VCC (Logik) | 5V | 3V3 | 3V3(OUT) |
| SDA | A4 | GPIO 21 | GP4 |
| SCL | A5 | GPIO 22 | GP5 |
| OE | Offen lassen (auf dem Board mit GND verbunden) | Offen lassen | Offen lassen |
| V+ (Schraubklemme) | Pluspol des externen 5–6-V-Netzteils | Pluspol des externen 5–6-V-Netzteils | Pluspol des externen 5–6-V-Netzteils |
| GND (Schraubklemme) | Minuspol des externen Netzteils (auf dem Board mit GND verbunden) | Minuspol des externen Netzteils (auf dem Board mit GND verbunden) | Minuspol des externen Netzteils (auf dem Board mit GND verbunden) |
Externe Stromversorgung: Wie viel Strom ziehen Servos?
Ein Servo im Leerlauf zieht nur 5–10 mA, doch bei Bewegung und vor allem unter Last (Stall) steigt der Strom plötzlich an. Ein SG90 kann beim Blockieren 600–700 mA ziehen, ein MG996R über 2 A. Wenn sich alle Gelenke eines Roboterarms gleichzeitig bewegen, addieren sich diese Spitzenströme und die Spannung eines schwachen Netzteils bricht ein; das Ergebnis sind zitternde, zufällig springende Servos und ein Arduino, der neu startet. Als Faustregel gilt: Multipliziere die Zahl der gleichzeitig bewegten Servos mit dem Spitzenstrom und wähle ein Netzteil, das davon dauerhaft mindestens die Hälfte liefern kann. Für einen Roboterarm mit sechs SG90 ist ein 5-V-3-A-Netzteil gut geeignet, für einen Spinnenroboter mit 18 Servos ein 5–6-V-Netzteil mit 8–10 A oder ein kräftiges UBEC aus dem RC-Bereich.
| Servo | Leerlauf | In Bewegung | Blockiert (Stall) | Versorgung |
|---|---|---|---|---|
| SG90 (9 g, Kunststoffgetriebe) | ≈ 10 mA | 100–250 mA | ≈ 650 mA | 4,8–6 V |
| MG90S (Metallgetriebe) | ≈ 10 mA | 150–300 mA | ≈ 700 mA | 4,8–6 V |
| MG996R (Standardgröße) | ≈ 10 mA | 500–900 mA | ≈ 2,5 A | 4,8–7,2 V |
Schritt für Schritt zur Inbetriebnahme: 4 Servos gemeinsam drehen
- Öffne in der Arduino IDE den Bibliotheksverwalter, suche nach Adafruit PWM Servo Driver und installiere die Bibliothek.
- Verbinde VCC, GND, SDA und SCL des Boards wie in der Tabelle oben mit dem Arduino; lass den OE-Pin offen.
- Stecke die Servos auf die Kanäle 0, 1, 2 und 3. Das orange oder gelbe Signalkabel gehört in die PWM-Reihe, das rote in die V+-Reihe, das braune oder schwarze in die GND-Reihe.
- Schließe das externe 5-V-Netzteil an die Schraubklemme an: Pluspol an V+, Minuspol an GND.
- Starte zuerst den Arduino über USB und lade den Code hoch, schalte danach die Servoversorgung ein. Wenn du dir bei der Adresse nicht sicher bist, prüfe mit einem I2C-Scanner, ob 0x40 erscheint.
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() initialisiert das Board, setPWMFreq(50) stellt die Periode für Servos auf 20 ms ein. Die Zeile setOscillatorFrequency(27000000) stammt aus den Adafruit-Beispielen: Der interne Oszillator des Chips hat auf dem Papier 25 MHz, liegt in Wirklichkeit aber zwischen 23 und 27 MHz, und die Bibliothek berechnet den Vorteiler anhand dieses Werts. Die eigentliche Arbeit macht setPWM(Kanal, on, off); lässt du on auf 0 und schreibst die Tick-Zahl in off, beginnt der Impuls am Periodenanfang und endet bei diesem Schritt. Die Funktion servoAci() rechnet mit map() 0–180 Grad in den Bereich SERVO_MIN–SERVO_MAX um. Die Bibliothek hat auch die Funktion writeMicroseconds(Kanal, µs), die den Impuls direkt in Mikrosekunden angibt; da ihre Genauigkeit aber von der Oszillatoreinstellung abhängt, ist es zuverlässiger, mit Ticks zu arbeiten und jeden Servo zu kalibrieren.
Pulsbreite kalibrieren: die echten Grenzen jedes Servos finden
Servohersteller geben den Standardbereich von 1–2 ms an, doch in der Praxis ist jeder Servo anders: Ein SG90 dreht zwischen 0,5 und 2,4 ms volle 180 Grad, ein anderer bleibt bei 170 Grad stehen. Verwendest du die Werte aus der Tabelle blind, läuft der Servo am Endpunkt gegen den mechanischen Anschlag, brummt, zieht unnötig Strom und seine Zahnräder verschleißen mit der Zeit. Der folgende Kalibriercode sendet den im Seriellen Monitor eingegebenen Tick-Wert an Kanal 0. Beginne bei etwa 300 und verringere den Wert in Schritten von 10; notiere den Wert 5–10 Schritte oberhalb des Punkts, an dem der Servo nicht mehr dreht oder zu brummen beginnt, als SERVO_MIN. Mach dasselbe in die andere Richtung, um SERVO_MAX zu finden. Da bei Roboterarm oder Spinnenroboter jedes Gelenk ein eigener Servo ist, ist es am saubersten, diese Messung für jeden Servo zu wiederholen und die Werte in ein Array zu schreiben.
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}Mehrere PCA9685-Boards verketten
Am oberen Rand jedes Boards sitzen sechs Adressbrücken (Lötpads) von A0 bis A5. Sind alle offen, lautet die Adresse 0x40; verbindest du ein Pad per Lötzinn, wird das entsprechende Bit 1 und der Wert dieses Bits wird zur Adresse addiert. So lassen sich theoretisch 62 Boards, also 992 Servos, an dieselbe I2C-Leitung hängen. Da die 6-poligen Stiftleisten an beiden Seiten des Boards parallel geschaltet sind, genügt ein kurzes Kabel vom ersten zum zweiten Board; SDA, SCL, VCC und GND werden so durch die Kette geführt. Im Code legst du für jedes Board ein eigenes Objekt an und übergibst die Adresse dem Konstruktor. Vermeide die Adresse 0x70, denn sie ist beim Chip standardmäßig die "All-Call"-Adresse. Wenn du I2C-Adressierung genauer verstehen möchtest, lies Was ist I2C?.
| Gelötete Brücken | Adresse | Beispielnutzung |
|---|---|---|
| Keine | 0x40 | 1. Board (Servo 0–15) |
| A0 | 0x41 | 2. Board (Servo 16–31) |
| A1 | 0x42 | 3. Board |
| A0 + A1 | 0x43 | 4. Board |
| A2 | 0x44 | 5. Board |
| A0–A5 alle | 0x7F | Letzte Adresse |
Spinnenroboter: 18 Servos mit zwei PCA9685
Bei einem sechsbeinigen Spinnenroboter (Hexapod) hat jedes Bein drei Gelenke: die Hüfte (Coxa) am Körper, den Oberschenkel (Femur), der das Bein hebt und senkt, und das Knie (Tibia), dessen Spitze den Boden berührt. 6 × 3 = 18 Servos überschreiten die 16 Kanäle eines Boards, daher werden zwei Boards verkettet: Die linken Beine kommen an das Board mit Adresse 0x40, die rechten an das Board 0x41 mit gelöteter A0-Brücke. Ein vierbeiniger Spinnenroboter (Quadruped) kommt mit 12 Servos an einem Board aus, vier Kanäle bleiben frei. Der folgende Code adressiert die Servos mit einer einzigen Nummer von 0 bis 17, stellt den Roboter auf und bewegt nacheinander die Knie. Die Servos einzeln mit 100 ms Pause dazwischen zu positionieren, verhindert die Stromspitze, die entstünde, wenn alle 18 Servos gleichzeitig anlaufen. Für einen echten Gang im Tripod-Schema werden drei Beine gleichzeitig angehoben, während die anderen drei den Körper tragen.
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}Roboterarm mit Potentiometern am ESP32 und PCA9685
Am ESP32 läuft dieselbe Adafruit-Bibliothek ohne Änderungen; die I2C-Pins sind GPIO 21 (SDA) und GPIO 22 (SCL). In diesem Beispiel steuern wir einen Roboterarm mit vier Gelenken (Basis, Schulter, Ellbogen, Greifer) über vier Potentiometer. Schließe die äußeren Anschlüsse der Potentiometer an 3V3 und GND an, die Mittelanschlüsse an GPIO 34, 35, 32 und 33 der ADC1-Gruppe; da ADC2-Pins bei aktivem WLAN nicht gelesen werden können, erleichtert diese Wahl später auch eine drahtlose Steuerung. Der ADC des ESP32 liefert Werte von 0 bis 4095. Der Code lässt jedes Gelenk nicht auf einmal zum Zielwinkel springen, sondern nähert es in jedem Durchlauf um 10 Prozent der Differenz an; diese einfache Glättung verringert das Ruckeln des Arms und plötzliche Stromspitzen. Für Mechanik und Gelenkreihenfolge ist Arduino Roboterarm ein guter Einstieg.
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 und MicroPython mit dem PCA9685
Im MicroPython-Kern gibt es keinen fertigen PCA9685-Treiber, aber den Chip über ein paar Register anzusteuern ist so einfach, dass du den Treiber selbst schreiben kannst. Das Register MODE1 (0x00) weckt den Chip auf, das Register PRESCALE (0xFE) legt die Frequenz fest, und die vierbytigen ON/OFF-Register jedes Kanals beginnen bei Adresse 0x06 und gehen in Vierer-Schritten weiter. Der Vorteilerwert wird mit der Formel prescale = Oszillator / (4096 × Frequenz) − 1 berechnet und kann nur geschrieben werden, solange der Chip im Schlafmodus ist. Versorge das Board über den 3V3(OUT)-Pin des Pico, verbinde SDA mit GP4 und SCL mit GP5. Wenn du neu bei MicroPython bist, hilft dir MicroPython Grundlagen.
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)Projektideen mit dem PCA9685
- Roboterarm: Steuere einen Arm mit 4–6 Gelenken über Potentiometer oder einen Joystick und speichere die Bewegungen im EEPROM, um sie wieder abzuspielen.
- Spinnenroboter: Baue einen laufenden Roboter mit vier Beinen und 12 Servos oder sechs Beinen und 18 Servos; für Fortgeschrittene: berechne die Koordinaten der Beinspitze mit inverser Kinematik.
- Animatronische Augen und Gesicht: Bewege 6–8 kleine Servos für Augenlider, Pupillen und Augenbrauen synchron.
- Pan-Tilt-Kamerahalterung: Drehe ein ESP32-CAM-Modul mit zwei Servos horizontal und vertikal und steuere es per WLAN.
- Servo-Choreografie: Bewege 32 im Kreis angeordnete Servos mit zwei Boards in Wellen- und Spiralmustern.
- 16-Kanal-LED-Dimmer: Der PCA9685 ist eigentlich ein LED-Treiber; stelle die Frequenz auf 1000 Hz und dimme 16 LEDs flackerfrei. Das Prinzip von PWM nutzt du hier eins zu eins.
Häufige Fehler und ihre Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Servos bewegen sich gar nicht | Keine V+-Versorgung oder setPWMFreq wurde nicht aufgerufen | Externe Spannung an die Klemme legen, prüfen, dass setPWMFreq(50) in setup steht |
| Servos zittern, springen zufällig | Zu wenig Strom vom Netzteil, dünne Kabel | Stärkeres Netzteil, dicke Kabel und ein 470–1000-µF-Kondensator an der V+-Leitung |
| Arduino startet neu, wenn sich Servos bewegen | Servos hängen am 5V-Pin des Arduino | Servostrom nur über V+ liefern, GNDs verbinden |
| Servo brummt am Endpunkt und wird heiß | SERVO_MIN oder SERVO_MAX liegt außerhalb des mechanischen Anschlags | Grenzen mit dem Kalibriercode finden, 5–10 Schritte Abstand halten |
| Code hängt oder Board wird nicht gefunden | Falsche Adresse, SDA und SCL vertauscht, zwei Boards mit gleicher Adresse | I2C-Scanner ausführen, Adressbrücken prüfen |
| Servos ruckeln beim Start heftig | Alle Servos fahren gleichzeitig in Position | Servos nacheinander mit kurzer Pause starten |
Der PCA9685 ist ein günstiges und robustes Board, das Ordnung ins Projekt bringt, sobald du mehr als zwei, drei Servos hast: Hast du einmal die Stromversorgung richtig aufgebaut und jeden Servo kalibriert, besteht der Rest nur noch darin, Winkel zu schreiben. Für kräftigere Gelenke kannst du auch den MG996R, für Räder mit Dauerdrehung den FS90R an dasselbe Board stecken. In der BlueGrays-App findest du Projekte wie die 32-Servo-Kreischoreografie, Servosteuerung mit Potentiometer und Joystick und ein ESP32-RFID-Türschloss, Schritt für Schritt mit Schaltplan und Code.
Häufige Fragen
Wie viele Servos kann man mit dem PCA9685 steuern?
Ein einzelnes PCA9685-Board steuert 16 Servos unabhängig voneinander. Da sich über die Adressbrücken bis zu 62 Boards an derselben I2C-Leitung verketten lassen, sind theoretisch 992 Servos möglich. In der Praxis begrenzt nicht die Zahl der Boards, sondern der Strom, den dein Netzteil liefern kann.
Warum zittert ein Servo am PCA9685?
Die häufigste Ursache ist ein zu schwaches Netzteil; bei Bewegung bricht die V+-Spannung ein. Die zweite Ursache sind unkalibrierte Werte für SERVO_MIN und SERVO_MAX, sodass der Servo gegen seinen mechanischen Anschlag läuft. Ein kräftiges Netzteil, dicke Kabel, ein großer Kondensator an V+ und korrekte Grenzwerte lösen das Problem meistens.
Was ist der Unterschied zwischen VCC und V+ beim PCA9685?
VCC ist die Logikversorgung des Chips; sie wird beim Arduino Uno an 5V, beim ESP32 und Pico an 3V3 angeschlossen und zieht sehr wenig Strom. V+ ist die Stromleitung der Servos und wird aus einem externen 5–6-V-Netzteil gespeist. Verwechselst du beide, funktioniert entweder das Board nicht oder der Mikrocontroller wird neu gestartet.
Wie ändere ich die I2C-Adresse des PCA9685?
Du verbindest eines oder mehrere der Lötpads A0–A5 auf dem Board mit Lötzinn. Ist keines gelötet, lautet die Adresse 0x40; mit gelötetem A0 wird sie 0x41, mit A1 0x42. Im Code erzeugst du das Objekt einfach mit der neuen Adresse, etwa Adafruit_PWMServoDriver(0x41).
Funktioniert der PCA9685 mit dem ESP32?
Ja, die Adafruit-PWM-Servo-Driver-Bibliothek läuft am ESP32 ohne Änderungen. Verbinde SDA mit GPIO 21, SCL mit GPIO 22 und versorge VCC des Boards aus 3V3, damit die I2C-Leitungen auf 3,3 V bleiben. Das Servosignal hat dann 3,3 V; die meisten Standardservos erkennen diesen Pegel problemlos.
Wofür kann man den PCA9685 außer für Servos nutzen?
Der Chip ist eigentlich ein 16-Kanal-LED-Treiber; bei einer Frequenz um 1000 Hz kannst du die Helligkeit von LEDs in 4096 Stufen einstellen. Über Transistoren oder MOSFETs eignet er sich auch zur Drehzahlregelung kleiner Gleichstrommotoren. Die Kanäle treiben große Lasten nicht direkt, sie erzeugen nur das Steuersignal.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Servo-Kreis-Choreografie - Animierte Muster mit 32 Servos
Ein visuelles Animationsprojekt mit 32 kreisförmig angeordneten Servomotoren an einem Arduino Mega. Die Servos werden in einem einzigen Array verwaltet, hängen an den Pins 22–53 des Mega und zeigen vier Bewegungsabläufe: ein chaotisches Zittern in zufälligen Winkeln, einen synchronen Schwenk, eine um den Kreis laufende Welle und eine hin und her pendelnde Kompassnadel.

Verwendung von Servomotoren
Der Arm eines kleinen Servomotors dreht sich nacheinander in drei Stellungen: ganz an den Anfang, genau in die Mitte und ganz ans Ende, mit jeweils zwei Sekunden Pause.

Servomotorbetrieb mit Potentiometer
Während du am Knopf des Potentiometers drehst, dreht sich der Arm des Servomotors einfach mit: Das eine Ende des Knopfes bedeutet null Grad, das andere eine halbe Umdrehung.

Servo-Steuerung mit Joystick
Steuere zwei Motoren mit einem Joystick, genau wie beim Schwenken einer Überwachungskamera.

ESP32-Servomotor (Steuerung über Potentiometer)
In diesem Projekt steuern wir einen SG90-Servomotor mit einem Potentiometer. Wir stellen den Servowinkel ein, indem wir den vom Potentiometer gelesenen Analogwert auf den Bereich von 0 bis 180 Grad abbilden. Die ESP32Servo-Bibliothek erzeugt Servosignale an geeigneten GPIO-Pins des ESP32, die als Ausgang verwendet werden können; in diesem Projekt wird GPIO 18 verwendet. Dies ist eine grundlegende Steuerungsmethode für Roboterarme, Kamera-Gimbals und automatische Türmechanismen.

ESP32-RFID-Türschloss (RC522 + Servo + OLED + Summer + LED)
Wir bauen ein smartes Türschloss mit ESP32, RFID-Modul RC522, Servo SG90, SSD1306-OLED, aktivem Summer und 2 LEDs. Die UID einer gescannten Karte wird mit den im Code hinterlegten Karten verglichen; passt sie, öffnet der Servo das Schloss (grüne LED + 2 kurze Pieptöne) und verriegelt nach 5 Sekunden wieder. Bei einer fremden Karte leuchtet die rote LED, es piept 3-mal schnell und das OLED zeigt die UID.

360-Grad-Servo aus einem Schrittmotor bauen
Bring einem gewöhnlichen Schrittmotor bei, jeden gewünschten Winkel anzufahren, und zwar rund um den ganzen Kreis.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

