PCA9685-Servotreiber

Was es ist

Der PCA9685 ist ein Servovervielfacher. Ein Mikrocontroller hat nur eine Handvoll Hardware-PWM-Kanäle – sechs Servos eines Roboterarms zu treiben, geschweige denn achtzehn eines Hexapoden, erschöpft schnell Pins und Timer. Diese kleine Platine übernimmt den Job: Sie erzeugt 16 unabhängige PWM-Signale in Hardware, und alle befiehlt man über zwei I²C-Drähte. Es ist die Platine hinter den meisten Multiservorobotern.

Wie es funktioniert

Man spricht den PCA9685 über I²C an – dieselben zwei Pins (SCL/SDA) können auch andere Sensoren tragen. Eine PWM-Frequenz für den ganzen Chip setzen (50 Hz für Hobbyservos), dann pro Kanal die Impulsbreite zur Servopositionierung. Weil der Chip alle 16 Signale in Hardware hält, sendet der Mikrocontroller nur „Kanal 3 → 1,5 ms“ und geht weiter; er muss das Timing nie selbst bitbangen. So bleibt jedes Servo weich, selbst wenn alle 16 fahren. Die Impulsbreite-zu-Winkel-Idee ist dieselbe wie auf der SG90-Servoseite.

Wann man ihn verwendet

Zum PCA9685 greifen, wann immer ein Roboter mehr Servos hat, als der Mikrocontroller PWM-Pins hat, oder wenn die Servos felsenfest stehen sollen:

• Roboterarme – mehrere Gelenkservos fahren gemeinsam (mit inverser Kinematik paaren).
• Hexapoden / Quadrupeden – ein Dutzend oder mehr Beine an Servos.
• Schwenk-Neige- und Kamerarigs – die Timer des Mikrocontrollers für andere Arbeit freigeben.

Für ein einzelnes Scanservo – etwa den Ultraschallscanner an einem Hindernisvermeider – braucht man ihn nicht; ein Servo treibt der Mikrocontroller direkt.

Verdrahtung und Fallstricke

• Zwei Stromschienen. Logik (VCC) vom Mikrocontroller; Servostrom aus der V+-Klemme. Nie den Strom von 16 Servos durch die 5 V des Arduino jagen.
• V+ auf Blockierzustand auslegen, nicht Leerlauf. Sechzehn Servos können gemeinsam mehrere Ampere ziehen; eine unterdimensionierte Versorgung bricht ein und das ganze Board zittert.
• Eindeutige Adressen setzen beim Verketten, per Lötjumper.
• Einen Kondensator über V+ legen, der die Stromspitzen beim Servoanlauf schluckt.

Pinbelegung

Drei Anschlussgruppen: eine Steuerleiste zum Mikrocontroller, sechzehn Servostecker und eine Versorgungsklemme, die man nicht mit der ersten verwechseln darf.

Die folgenreichste Tatsache auf dieser Platine: VCC und V+ sind verschiedene Schienen. VCC betreibt den Chip; V+ betreibt die Servos. Beide zu brücken jagt Servoblockierstrom durch den Regler des Mikrocontrollers – der schnellste Weg in Arduino-Brownout.

An einen Arduino verdrahten

OE ist nützlicher, als es aussieht. High gezogen schaltet es alle sechzehn Ausgänge in Hardware ab – sofort, ohne I²C-Transaktion. An einem Arm, der unter Schwerkraft fallen kann, ist das ein echter Not-Halt – und er funktioniert, selbst wenn der Code hängt.

Die Servoversorgung dimensionieren

Hier gehen die meisten PCA9685-Projekte schief, und die Rechnung ist nicht schwer.

Ein Hobbyservo zieht grob:

Vier SG90 an einem kleinen Arm, alle zugleich fahrend, sind bequem 1 A und können nahe 2,6 A spitzen, wenn alle gemeinsam blockieren – genau das geschieht, wenn der Arm seinen eigenen Rahmen trifft. Ein 1-A-Handyladegerät schafft das nicht. Auf alle Servos gleichzeitig blockiert auslegen – oder mindestens auf alle fahrend plus eines blockiert.

Das Symptom unterdimensionierter Versorgung ist markant und verwirrend: Die Servos zittern, das Board setzt sich eventuell zurück, und es sieht nach I²C- oder Codeproblem aus. Ist es nicht. Ein Messgerät an V+ hängen, während der Arm fährt, und dem Einbruch zusehen.

Einen Kondensator über V+ legen. Etwas im Bereich 470–1000 µF, nah an der Klemme. Einen Dauerblock trägt er nicht – ein 1000-µF-Kondensator, der 1 A liefert, verliert pro Millisekunde ein Volt –, aber er schluckt die scharfe Stromspitze im Servoanlaufmoment, die sich in die Logikschiene einkoppelt.

Wie das PWM wirklich erzeugt wird

Zwei Zahlen hier zu verstehen macht jedes Servotreiberproblem leichter diagnostizierbar.

Der Chip läuft mit internem 25-MHz-Oszillator und teilt per Prescaler herunter:

prescale = round(25000000 / (4096 x frequency)) - 1

Für 50 Hz, die Hobbyservos wollen, sind das round(25000000 / 204800) - 1 = 121.

Jede Periode wird dann in 4096 Schritte geteilt (12-Bit). Bei 50 Hz dauert die Periode 20 ms, ein Schritt also 20 ms / 4096 = 4,88 µs. Das übersetzt die Servoimpulsbreiten, auf die es wirklich ankommt, in die Zählwerte, die man schreibt:

Zwei Folgen ergeben sich direkt daraus. Erstens: Etwa 205 Zählwerte über volle 180° eines Servos – knapp ein Zählwert pro Grad: Die 12-Bit-Auflösung des PCA9685 begrenzt ein Hobbyservo nicht, sein eigenes Totband tut es. Zweitens: Der Prescaler lässt sich nur im Schlafmodus schreiben – weshalb jede Bibliothek MODE1 um eine Frequenzänderung toggelt.

Der Oszillator ist nicht exakt 25 MHz

Echte Platinen laufen wenige Prozent neben Nennwert, und zwar pro Platine konsistent. Bleiben Servos an beiden Enden systematisch hinter dem befohlenen Winkel zurück, ist die Lösung nicht, Impulsbreiten zu fudgen – sondern den Takt zu messen und zu korrigieren:

pwm.begin();
pwm.setOscillatorFrequency(26075000);  // measured, not the 25 MHz nominal
pwm.setPWMFreq(50);

Messen durch 50 Hz befehlen, ein Oszilloskop oder einen Logikanalysator an einen Ausgang hängen und die wahre Periode lesen. Die nominellen 25 MHz mit dem Verhältnis befohlen zu gemessen skalieren. Einmal pro Platine tun und die Zahl in einen Kommentar schreiben.

Minimal funktionierender Code

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);

// Per-servo calibration. These are NOT universal — measure your own.
const int SERVO_MIN = 150;   // counts at one end stop
const int SERVO_MAX = 600;   // counts at the other

int countsFor(int degrees) {
  return map(constrain(degrees, 0, 180), 0, 180, SERVO_MIN, SERVO_MAX);
}

void setup() {
  pwm.begin();
  pwm.setOscillatorFrequency(25000000);  // replace with your measured value
  pwm.setPWMFreq(50);                    // hobby servos want 50 Hz
  delay(10);
}

void loop() {
  for (int a = 0; a <= 180; a += 5) {    // sweep, don't jump
    pwm.setPWM(0, 0, countsFor(a));
    delay(20);
  }
  for (int a = 180; a >= 0; a -= 5) {
    pwm.setPWM(0, 0, countsFor(a));
    delay(20);
  }
}

Die SERVO_MIN/SERVO_MAX-Konstanten sind die Kalibrierung – und sie unterscheiden sich pro Servo, selbst zwischen zweien desselben Modells aus derselben Tüte. Finden durch langsames Herausschreiten von 307 und Stoppen, sobald das Servo summt ohne sich zu bewegen – es drückt dann gegen seinen eigenen Endanschlag und zieht Blockierstrom für nichts.

Außerdem das Durchfahren statt Springen beachten. setPWM ändert die befohlene Position instant, und das Servo versucht sie mit voller Drehzahl – was an einem Arm heftige Bewegung und Stromspitze heißt. Die Befehlsaufteilung ist das Bewegungsprofil des armen Mannes – und lohnt sich selbst im Testcode.

Platinen verketten

Jede Platine hat sechs Lötpads, A0 bis A5, für 64 Adressen ab 0x40. Auf jeder Platine eine andere Kombination brücken:

62 Platinen sind das dokumentierte Maximum – 0x70 ist für die I²C-General-Call-Adresse reserviert, weshalb es nicht volle 64 sind. In der Praxis kommt die Grenze weit früher: 62 Platinen sind 992 Servos, und deren Versorgung ist ein deutlich größeres Ingenieurproblem als der Bus.

Beim Verketten beachten: Jede Platine trägt eigene 10-kΩ-I²C-Pull-ups, und sie liegen parallel. Zehn Platinen ergeben 1 kΩ – was für einen 5-V-Bus schwer wird. Jenseits einer Handvoll Platinen die Pull-up-Jumper bis auf eine überall trennen.

Fehlersuche

PCA9685 oder direkte Mikrocontroller-PWM?

Die ehrliche Schwelle: Ein oder zwei Servos direkt treiben. Ein Scansensorkopf an einem Hindernisvermeider braucht diese Platine nicht. Drei oder mehr, oder irgendein Servo, dessen Weichheit zählt – und der PCA9685 zahlt sich sofort aus: nicht wegen der Pinzahl, sondern weil der Mikrocontroller aufhört, für Timing verantwortlich zu sein. Ein Servo an der Servo-Bibliothek zuckt, wann immer die Schleife hängt; eines am PCA9685 nicht.