Bauteile · 10 Min. Lesezeit

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

SG90 Servomotor
Der SG90 ist der am häufigsten am PCA9685 betriebene Servo; jeder Kanal des Boards passt direkt zu seinem dreipoligen Stecker.

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.

EigenschaftWert
ChipNXP PCA9685
Kanalanzahl16 unabhängige PWM-Ausgänge
Auflösung12 Bit (4096 Schritte pro Periode)
PWM-FrequenzEtwa 24–1526 Hz (50 Hz für Servos)
KommunikationI2C, bis 1 MHz
Standardadresse0x40 (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
Ausgangsstrom25 mA Senke, 10 mA Quelle pro Kanal (nur für das Signal)
Auf dem BoardBei den meisten Modulen Pull-up-Widerstände an SDA/SCL und 220-Ω-Serienwiderstände an den Ausgängen
PulsbreiteSchritte (Ticks) @ 50 HzTypische Servoposition
0,5 ms (500 µs)≈ 102Beim SG90 etwa 0°
1,0 ms (1000 µs)≈ 205Standard-0° (Servos mit engem Bereich)
1,5 ms (1500 µs)≈ 307Mittelstellung (90°)
2,0 ms (2000 µs)≈ 410Standard-180°
2,4 ms (2400 µs)≈ 492Beim SG90 etwa 180°

PCA9685 anschließen: Arduino Uno, ESP32 und Pico

PCA9685-PinArduino UnoESP32Raspberry Pi Pico
GNDGNDGNDGND
VCC (Logik)5V3V33V3(OUT)
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
OEOffen lassen (auf dem Board mit GND verbunden)Offen lassenOffen lassen
V+ (Schraubklemme)Pluspol des externen 5–6-V-NetzteilsPluspol des externen 5–6-V-NetzteilsPluspol 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)
Der häufigste Fehler ist, VCC und V+ zu verwechseln. VCC ist nur die Logikversorgung des Chips und zieht ein paar Milliampere; die Leistung für die Servos kommt von V+ an der Schraubklemme. Versuchst du, die Servos über den 5V-Pin des Arduino zu versorgen, wird das Board zurückgesetzt, der USB-Port überlastet und der Regler heiß. Schließe VCC beim ESP32 und beim Pico unbedingt an 3V3 an: Die Pull-ups auf dem Board ziehen SDA und SCL auf VCC; bei 5 V lägen also 5 V an den 3,3-V-Pins. Außerdem muss der Minuspol des externen Netzteils mit der Masse des Mikrocontrollers verbunden sein (gemeinsame Masse).

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.

ServoLeerlaufIn BewegungBlockiert (Stall)Versorgung
SG90 (9 g, Kunststoffgetriebe)≈ 10 mA100–250 mA≈ 650 mA4,8–6 V
MG90S (Metallgetriebe)≈ 10 mA150–300 mA≈ 700 mA4,8–6 V
MG996R (Standardgröße)≈ 10 mA500–900 mA≈ 2,5 A4,8–7,2 V
Setze an die Klemmen V+ und GND, auf den freien Elko-Platz des Boards oder direkt an die Klemme, einen 470–1000-µF-Elektrolytkondensator; grob kannst du 100 µF pro Servo rechnen. Die Spannungsfestigkeit sollte mindestens das Doppelte der Versorgungsspannung betragen (16 V bei 6 V); achte auf die Polung. Hast du ein 12-V-Netzteil, kannst du die Spannung mit einem LM2596-Step-down-Wandler auf 5–6 V senken; ohne Kühlkörper arbeitet der LM2596 aber nur bis etwa 2 A zuverlässig, für größere Roboter brauchst du einen stärkeren Wandler.

Schritt für Schritt zur Inbetriebnahme: 4 Servos gemeinsam drehen

  1. Öffne in der Arduino IDE den Bibliotheksverwalter, suche nach Adafruit PWM Servo Driver und installiere die Bibliothek.
  2. Verbinde VCC, GND, SDA und SCL des Boards wie in der Tabelle oben mit dem Arduino; lass den OE-Pin offen.
  3. 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.
  4. Schließe das externe 5-V-Netzteil an die Schraubklemme an: Pluspol an V+, Minuspol an GND.
  5. 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.
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() 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.

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}

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ückenAdresseBeispielnutzung
Keine0x401. Board (Servo 0–15)
A00x412. Board (Servo 16–31)
A10x423. Board
A0 + A10x434. Board
A20x445. Board
A0–A5 alle0x7FLetzte Adresse
Bei der Verkettung wird auch die V+-Leitung über die Stiftleisten von Board zu Board geführt. Mehrere Ampere Servostrom durch die dünnen Stiftleistenpins zu schicken, erhitzt die Pins und erzeugt Spannungsabfall; führe deshalb zur Schraubklemme jedes Boards separate, dicke Kabel vom Netzteil. Wenn du verschiedene Netzteile verwendest, trenne die V+-Verbindung zwischen den Boards und lass nur GND gemeinsam; sonst werden die beiden Netzteile miteinander verbunden. Außerdem hat jedes Board Pull-up-Widerstände, sodass bei vielen verketteten Boards der Ersatzwiderstand sinkt und die Leitung belastet; ab 5–6 Boards kannst du bei einigen Boards die Pull-ups entfernen.

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.

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}

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.

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

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)

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

SymptomMögliche UrsacheLösung
Servos bewegen sich gar nichtKeine V+-Versorgung oder setPWMFreq wurde nicht aufgerufenExterne Spannung an die Klemme legen, prüfen, dass setPWMFreq(50) in setup steht
Servos zittern, springen zufälligZu wenig Strom vom Netzteil, dünne KabelStärkeres Netzteil, dicke Kabel und ein 470–1000-µF-Kondensator an der V+-Leitung
Arduino startet neu, wenn sich Servos bewegenServos hängen am 5V-Pin des ArduinoServostrom nur über V+ liefern, GNDs verbinden
Servo brummt am Endpunkt und wird heißSERVO_MIN oder SERVO_MAX liegt außerhalb des mechanischen AnschlagsGrenzen mit dem Kalibriercode finden, 5–10 Schritte Abstand halten
Code hängt oder Board wird nicht gefundenFalsche Adresse, SDA und SCL vertauscht, zwei Boards mit gleicher AdresseI2C-Scanner ausführen, Adressbrücken prüfen
Servos ruckeln beim Start heftigAlle Servos fahren gleichzeitig in PositionServos nacheinander mit kurzer Pause starten
Der Großteil des Servozitterns kommt nicht von der Software, sondern von der Stromversorgung. Miss mit einem Multimeter die V+-Spannung, während sich die Servos bewegen; fällt sie unter 4,5 V, reicht dein Netzteil nicht aus. Genauere Diagnoseschritte findest du im Beitrag Servo zittert: Ursachen und Lösungen. Wenn die Servos im Stillstand locker bleiben sollen, kannst du den Ausgang eines Kanals mit setPWM(Kanal, 0, 4096) komplett abschalten; ein Servo ohne Impulse übt kein Drehmoment aus und zieht keinen Strom.

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.

Alle Projekte ansehen
Servo-Kreis-Choreografie - Animierte Muster mit 32 Servos
AR-97Fortgeschritten
Premium

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.

4.5(40)
62
Verwendung von Servomotoren
AR-35Anfänger
Premium

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.

4.7(48)
67
Servomotorbetrieb mit Potentiometer
AR-36Anfänger
Premium

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.

4.6(37)
53
Servo-Steuerung mit Joystick
AR-60Mittel
Premium

Servo-Steuerung mit Joystick

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

4.7(42)
58
ESP32-Servomotor (Steuerung über Potentiometer)
ES-16Mittel
Premium

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.

4.3(29)
42
ESP32-RFID-Türschloss (RC522 + Servo + OLED + Summer + LED)
ES-35Fortgeschritten
Premium

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.

4.8(9)
16
360-Grad-Servo aus einem Schrittmotor bauen
AR-68Mittel
Premium

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.

4.5(22)
33