Componenten · 11 min leestijd

PCA9685 met Arduino: gids voor de 16-kanaals servodriver

PCA9685 met Arduino: bedrading, I2C-adres 0x40, externe servovoeding, pulsbreedte kalibreren en boards koppelen voor code van een robotarm en een spinrobot.

De PCA9685 is een 12-bits PWM-driverboard dat 16 servomotors onafhankelijk en tegelijk kan aansturen via één I2C-bus. Op een Arduino Uno beheert de Servo-bibliotheek maximaal 12 servo's en houdt ze daarbij een timer volledig bezet; je komt pins tekort en de servo's gaan trillen. De PCA9685 genereert de pulsen met een eigen interne oscillator, zodat je microcontroller alleen hoeft te zeggen: "zet dit kanaal op deze positie". Je vindt dit board in bijna elk project met meerdere gewrichten: robotarmen, spinrobots, animatronische ogen of pan-tilt-camerahouders.

In deze gids leer je de bedrading van de PCA9685 met Arduino, waarom je servo's van een aparte voeding moet voorzien, hoe je de pulsbreedte kalibreert om de echte waarden voor 0 en 180 graden van elke servo te vinden en hoe je boards koppelt met de adresjumpers. Daarna bouwen we een spinrobot met 18 servo's en twee boards, een robotarm met potmeters en een ESP32, en een bibliotheekvrije MicroPython-driver voor de Raspberry Pi Pico. Ben je nieuw met de werking van servomotoren, lees dan eerst Wat is een servomotor?

SG90 servo motor
De SG90 is de servo die het vaakst met de PCA9685 wordt aangestuurd; elk kanaal op het board past direct op de driepolige stekker van deze servo.

Wat is de PCA9685 en hoe werkt hij?

De PCA9685 is eigenlijk een chip die NXP ontwierp voor het aansturen van leds, maar omdat de frequentie instelbaar is, werkt hij ook prima met servo's. Binnenin zit een oscillator van 25 MHz en een 12-bits teller die door alle kanalen wordt gedeeld; één PWM-periode wordt verdeeld in 4096 stappen (ticks). Voor elk kanaal schrijf je twee getallen: de stap waarop het signaal hoog wordt (ON) en de stap waarop het laag wordt (OFF). Voor servo's stel je de frequentie in op 50 Hz, dus de periode is 20 ms. Eén stap duurt 20 ms / 4096 ≈ 4,88 µs; om de gewenste pulsbreedte om te rekenen naar ticks gebruik je dus tick = puls (µs) / 4,88. De middenpuls van 1,5 ms is bijvoorbeeld 1500 / 4,88 ≈ 307 ticks. Zodra een kanaal is ingesteld, blijft het board zelf het signaal genereren; ook als de Arduino met ander werk bezig is, houdt de servo zijn positie vast.

EigenschapWaarde
ChipNXP PCA9685
Kanalen16 onafhankelijke PWM-uitgangen
Resolutie12 bit (4096 stappen per periode)
PWM-frequentieOngeveer 24–1526 Hz (50 Hz voor servo's)
CommunicatieI2C, tot 1 MHz
Standaardadres0x40 (0x40–0x7F met de jumpers A0–A5)
Logicavoeding (VCC)2,3–5,5 V
Servovoeding (V+)Extern, meestal 5–6 V afhankelijk van de servo
Uitgangsstroom25 mA sink, 10 mA source per kanaal (alleen signaal)
Op het boardDe meeste modules hebben pull-upweerstanden op SDA/SCL en serieweerstanden van 220 Ω op de uitgangen
PulsbreedteTicks @ 50 HzTypische servopositie
0,5 ms (500 µs)≈ 102Ongeveer 0° bij een SG90
1,0 ms (1000 µs)≈ 205Standaard 0° (servo's met smal bereik)
1,5 ms (1500 µs)≈ 307Middenpositie (90°)
2,0 ms (2000 µs)≈ 410Standaard 180°
2,4 ms (2400 µs)≈ 492Ongeveer 180° bij een SG90

Bedrading van de PCA9685: Arduino Uno, ESP32 en Pico

PCA9685-pinArduino UnoESP32Raspberry Pi Pico
GNDGNDGNDGND
VCC (logica)5V3V33V3(OUT)
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
OEOpen laten (op het board naar GND getrokken)Open latenOpen laten
V+ (schroefklem)Plus van de externe voeding van 5–6 VPlus van de externe voeding van 5–6 VPlus van de externe voeding van 5–6 V
GND (schroefklem)Min van de externe voeding (gemeenschappelijk met GND op het board)Min van de externe voeding (gemeenschappelijk met GND op het board)Min van de externe voeding (gemeenschappelijk met GND op het board)
De meest gemaakte fout is VCC en V+ door elkaar halen. VCC is alleen de logicavoeding van de chip en neemt een paar milliampère op; de stroom voor de servo's komt van V+ op de schroefklem. Probeer je de servo's te voeden vanaf de 5V-pin van de Arduino, dan reset het board, wordt de USB-poort overbelast en wordt de regelaar heet. Sluit VCC op de ESP32 en de Pico altijd aan op 3V3: de pull-upweerstanden op het board trekken SDA en SCL omhoog naar VCC, dus een VCC van 5 V zou 5 V op pins van 3,3 V zetten. De min van de externe voeding moet ook massa delen met de microcontroller (gemeenschappelijke GND).

Externe voeding: hoeveel stroom nemen servo's op?

Een servo in rust neemt maar 5–10 mA op, maar tijdens het bewegen, en vooral als hij onder belasting vastloopt (stall), schiet de stroom omhoog. Een vastlopende SG90 kan 600–700 mA opnemen en een MG996R meer dan 2 A. Als alle gewrichten van een robotarm tegelijk gaan bewegen, tellen deze piekstromen op en zakt de spanning van een zwakke voeding in; het gevolg is trillende, willekeurig springende servo's en een Arduino die reset. Een praktische vuistregel: vermenigvuldig het aantal servo's dat tegelijk beweegt met de piekstroom en kies een voeding die continu minstens de helft daarvan kan leveren. Een 5V-adapter van 3 A is goed voor een robotarm met zes SG90's, en voor een spinrobot met 18 servo's heb je een voeding van 5–6 V en 8–10 A nodig, of een krachtige UBEC uit de RC-wereld.

ServoRustBewegendVastgelopenVoeding
SG90 (9 g, kunststof tandwielen)≈ 10 mA100–250 mA≈ 650 mA4,8–6 V
MG90S (metalen tandwielen)≈ 10 mA150–300 mA≈ 700 mA4,8–6 V
MG996R (standaardformaat)≈ 10 mA500–900 mA≈ 2,5 A4,8–7,2 V
Plaats een elco van 470–1000 µF over de klemmen V+ en GND, op de lege condensatorplek op het board of direct op de klem; als vuistregel reken je ongeveer 100 µF per servo. De spanningswaarde van de condensator moet minstens het dubbele van de voedingsspanning zijn (16 V voor 6 V) en let op de polariteit. Heb je alleen een adapter van 12 V, dan kun je die met een LM2596-stepdownconverter terugbrengen naar 5–6 V; maar zonder koelplaat draait de LM2596 comfortabel op ongeveer 2 A, dus grotere robots hebben een krachtigere converter nodig.

Eerste keer opstarten, stap voor stap: 4 servo's tegelijk laten draaien

  1. Open de Library Manager in de Arduino IDE, zoek de bibliotheek Adafruit PWM Servo Driver en installeer die.
  2. Verbind de pins VCC, GND, SDA en SCL van het board met de Arduino zoals in de tabel hierboven; laat de OE-pin open.
  3. Steek de servo's in kanaal 0, 1, 2 en 3. De oranje of gele signaaldraad van de stekker moet op de PWM-rij liggen, de rode op de V+-rij en de bruine of zwarte op de GND-rij.
  4. Sluit de externe voeding van 5 V aan op de schroefklem: plus op V+, min op GND.
  5. Voed eerst de Arduino via USB en upload de code, en schakel daarna de servovoeding in. Weet je het adres van het board niet zeker, controleer dan met een I2C-scannersketch of 0x40 verschijnt.
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() initialiseert het board en setPWMFreq(50) stelt de periode voor servo's in op 20 ms. De regel setOscillatorFrequency(27000000) komt uit de Adafruit-voorbeelden: hoewel de interne oscillator van de chip op papier 25 MHz is, varieert hij in werkelijkheid tussen 23 en 27 MHz, en de bibliotheek berekent de prescaler uit deze waarde. Het echte werk doet setPWM(channel, on, off); laat je on op 0 staan en schrijf je het aantal ticks naar off, dan begint de puls aan het begin van de periode en eindigt hij op die stap. De functie servoAci() gebruikt map() om 0–180 graden om te rekenen naar het bereik SERVO_MIN–SERVO_MAX. De bibliotheek heeft ook een functie writeMicroseconds(channel, µs) die de puls direct in microseconden aanneemt, maar omdat de nauwkeurigheid daarvan afhangt van de oscillatorinstelling, is werken in ticks en elke servo kalibreren betrouwbaarder.

Pulsbreedte kalibreren: vind de echte grenzen van elke servo

Servofabrikanten geven het standaardbereik van 1–2 ms op, maar in werkelijkheid is elke servo anders: de ene SG90 draait een volle 180 graden tussen 0,5 en 2,4 ms, terwijl een andere misschien maar 170 graden haalt. Gebruik je blindelings de waarden uit de tabel, dan botst de servo aan het eind van de slag tegen zijn mechanische aanslag, zoemt hij, neemt hij onnodig stroom op en slijten na verloop van tijd zijn tandwielen. De kalibratiecode hieronder stuurt de tickwaarde die je in de Serial Monitor typt naar kanaal 0. Begin rond 300 en verlaag de waarde in stappen van 10; noteer het punt waarop de servo niet meer draait of begint te zoemen, en neem 5–10 ticks erboven als SERVO_MIN. Doe hetzelfde in de andere richting om SERVO_MAX te vinden. In een robotarm of spinrobot is elk gewricht een aparte servo, dus de schoonste methode is deze meting voor elke servo te herhalen en de waarden in een array op te slaan.

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}

Meerdere PCA9685-boards koppelen

Langs de bovenrand van elk board zitten zes adresjumpers (soldeerpads) van A0 tot A5. Met alle open is het adres 0x40; als je een pad met soldeer overbrugt, wordt het bijbehorende bit 1 en wordt de waarde van dat bit bij het adres opgeteld. Dat betekent dat in theorie 62 boards, oftewel 992 servo's, dezelfde I2C-bus kunnen delen. Omdat de 6-pins headers aan beide kanten van de boards parallel zijn geschakeld, volstaat een korte kabel van het eerste naar het tweede board; SDA, SCL, VCC en GND lopen door de keten. In de code maak je voor elk board een apart object en geef je het adres mee aan de constructor. Vermijd adres 0x70, omdat dat het standaard "All Call"-adres van de chip is. Wil je meer weten over I2C-adressering, lees dan Wat is I2C?.

Overbrugde jumpersAdresVoorbeeldgebruik
Geen0x40Board 1 (servo's 0–15)
A00x41Board 2 (servo's 16–31)
A10x42Board 3
A0 + A10x43Board 4
A20x44Board 5
Alle A0–A50x7FLaatste adres
Bij het koppelen wordt de V+-lijn ook via de headers tussen de boards doorgegeven. Meerdere ampères servostroom door dunne headerpins sturen verhit ze en veroorzaakt spanningsval, dus leg aparte, dikke draden van de voeding naar de schroefklem van elk board. Gebruik je verschillende voedingen, verbreek dan de V+-verbinding tussen de boards en houd alleen GND gemeenschappelijk; anders worden de twee voedingen met elkaar verbonden. Omdat elk board pull-upweerstanden heeft, verlaagt het koppelen van veel boards bovendien de equivalente weerstand en belast het de bus; bij meer dan 5–6 boards kun je de pull-ups van een aantal ervan eraf solderen.

Spinrobot: 18 servo's met twee PCA9685-boards

Bij een zespotige spinrobot (hexapod) heeft elke poot drie gewrichten: de heup (coxa) aan het lichaam, het bovenbeen (femur) dat de poot omhoog en omlaag beweegt en de knie (tibia) waarvan de punt de grond raakt. 6 × 3 = 18 servo's is meer dan de 16 kanalen van één board, dus worden twee boards gekoppeld: de linkerpoten gaan naar het board op adres 0x40 en de rechterpoten naar het board op 0x41 met overbrugde A0-jumper. Een viervoetige spinrobot (quadruped) gebruikt 12 servo's en past op één board met 4 kanalen over. De code hieronder spreekt de servo's aan met één getal van 0 tot 17, zet de robot rechtop en beweegt de knieën om de beurt. De servo's één voor één positioneren met 100 ms wachttijd ertussen voorkomt de stroompiek die zou ontstaan als alle 18 servo's tegelijk omhoog gaan. Voor echt lopen tilt een tripodgang drie poten tegelijk op terwijl de andere drie het lichaam dragen.

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}

ESP32 en PCA9685: robotarm met potmeters

Op de ESP32 werkt dezelfde Adafruit-bibliotheek ongewijzigd; de I2C-pins zijn GPIO 21 (SDA) en GPIO 22 (SCL). In dit voorbeeld sturen we een robotarm met vier gewrichten (basis, schouder, elleboog, grijper) aan met vier potmeters. Sluit de buitenste pinnen van de potmeters aan op 3V3 en GND en de middelste pinnen op GPIO 34, 35, 32 en 33 in de ADC1-groep; omdat ADC2-pins niet gelezen kunnen worden terwijl Wi-Fi aan staat, maakt deze keuze het ook makkelijker om later draadloze bediening toe te voegen. De ADC van de ESP32 geeft waarden van 0 tot 4095. In plaats van elk gewricht direct naar de doelhoek te laten springen, verplaatst de code het bij elke lus 10 procent van het resterende verschil dichter naar het doel; deze eenvoudige afvlakking vermindert schokken en plotselinge stroompieken. Voor het mechanische ontwerp en de volgorde van de gewrichten is Arduino-robotarm een goed beginpunt.

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 en PCA9685 met MicroPython

MicroPython heeft in de kern geen kant-en-klare PCA9685-driver, maar de chip is met een paar registers zo makkelijk aan te sturen dat je de driver zelf kunt schrijven. Het MODE1-register (0x00) wekt de chip, het PRESCALE-register (0xFE) stelt de frequentie in en de ON/OFF-registers van vier bytes per kanaal beginnen op adres 0x06 en lopen per vier op. De prescalerwaarde wordt berekend met prescale = oscillator / (4096 × frequentie) − 1 en kan alleen worden geschreven terwijl de chip in slaapstand staat. Voed het board via de pin 3V3(OUT) van de Pico en sluit SDA aan op GP4 en SCL op GP5. Ben je nieuw met MicroPython, dan helpt MicroPython-basis je op weg.

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)

Projectideeën met de PCA9685

  • Robotarm: bedien een arm met 4–6 gewrichten met potmeters of een joystick en sla de bewegingen op in het EEPROM om ze af te spelen.
  • Spinrobot: bouw een lopende robot met 12 servo's op vier poten of 18 servo's op zes poten; op gevorderd niveau gebruik je inverse kinematica om de coördinaten van de pootpunt te berekenen.
  • Animatronische ogen en gezicht: beweeg 6–8 kleine servo's synchroon voor oogleden, pupillen en wenkbrauwen.
  • Pan-tilt-camerahouder: draai een ESP32-CAM-module horizontaal en verticaal met twee servo's en bestuur hem via Wi-Fi.
  • Servochoreografie: beweeg 32 servo's in een cirkel met twee boards in golf- en spiraalpatronen.
  • Ledbediening met 16 kanalen: de PCA9685 is eigenlijk een leddriver; verhoog de frequentie naar 1000 Hz en stel de helderheid van 16 leds in zonder flikkeren. Je gebruikt hier dezelfde PWM-logica.

Veelvoorkomende fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
Servo's bewegen helemaal nietGeen V+-voeding, of setPWMFreq is niet aangeroepenSluit externe voeding aan op de klem en zorg dat setPWMFreq(50) in setup staat
Servo's trillen en springen willekeurigVoedingsstroom is te laag, draden zijn dunGebruik een sterkere voeding, dikke draden en een condensator van 470–1000 µF op de V+-lijn
Arduino reset als de servo's bewegenServo's worden gevoed vanaf de 5V-pin van de ArduinoVoed de servo's alleen via V+ en verbind de GND's
Servo zoemt en wordt warm aan het eind van de slagSERVO_MIN of SERVO_MAX ligt voorbij de mechanische grensVind de grenzen met de kalibratiecode en blijf 5–10 ticks binnen de grens
Code loopt vast of het board wordt niet gevondenVerkeerd adres, SDA en SCL verwisseld, twee boards op hetzelfde adresDraai een I2C-scanner en controleer de adresjumpers
Servo's springen hard bij het inschakelenAlle servo's gaan tegelijk naar hun positieStart de servo's één voor één met een korte pauze ertussen
De meeste servotrillingen komen van de voeding, niet van de software. Meet de V+-spanning met een multimeter terwijl de servo's bewegen; zakt hij onder 4,5 V, dan is je voeding niet berekend op de taak. Voor een uitgebreidere diagnose zie je Probleem met servotrilling. Wil je dat de servo's slap blijven als de robot stilstaat, dan kun je de uitgang van een kanaal volledig uitschakelen met setPWM(channel, 0, 4096); een servo die geen pulsen ontvangt, oefent geen koppel uit en neemt geen stroom op.

Zodra je meer dan twee of drie servo's hebt, is de PCA9685 een goedkoop en robuust board dat orde brengt in je project: als je de voeding goed hebt opgezet en elke servo hebt gekalibreerd, hoef je alleen nog hoeken te schrijven. Voor sterkere gewrichten kun je MG996R-servo's op hetzelfde board aansluiten, en FS90R-servo's voor continu draaiende wielen. In de BlueGrays-app vind je projecten zoals een choreografie met 32 servo's in een cirkel, servobediening met een potmeter en joystick en een ESP32-RFID-deurslot, met schakelschema's en code stap voor stap.

Veelgestelde vragen

Hoeveel servo's kun je aansturen met een PCA9685?

Eén PCA9685-board stuurt 16 servo's onafhankelijk aan. Omdat je met de adresjumpers tot 62 boards op dezelfde I2C-bus kunt koppelen, zijn in theorie 992 servo's te bedienen. In de praktijk is niet het aantal boards de limiet, maar de stroom die je voeding aan de servo's kan leveren.

Waarom trilt een servo die op een PCA9685 is aangesloten?

De meest voorkomende oorzaak is een ontoereikende voeding; de V+-spanning zakt in terwijl de servo's bewegen. De tweede oorzaak zijn ongekalibreerde waarden voor SERVO_MIN en SERVO_MAX, waardoor de servo tegen zijn mechanische grens duwt. Een sterke voeding, dikke draden, een grote condensator op de V+-lijn en juiste grenswaarden lossen het probleem meestal op.

Wat is het verschil tussen VCC en V+ op de PCA9685?

VCC is de logicavoeding van de chip; die sluit je op een Arduino Uno aan op 5V en op de ESP32 en Pico op 3V3, en hij neemt zeer weinig stroom op. V+ is de voedingslijn van de servo's en wordt gevoed door een externe voeding van 5–6 V. Als je ze door elkaar haalt, werkt het board niet meer of reset de microcontroller.

Hoe verander je het I2C-adres van de PCA9685?

Je overbrugt een of meer van de soldeerpads A0–A5 op het board. Zonder overbrugging is het adres 0x40; overbrug je A0, dan wordt het 0x41 en bij A1 wordt het 0x42. In de code maak je gewoon het object aan met het nieuwe adres, zoals Adafruit_PWMServoDriver(0x41).

Werkt de PCA9685 met de ESP32?

Ja, de bibliotheek Adafruit PWM Servo Driver werkt ongewijzigd op de ESP32. Sluit SDA aan op GPIO 21 en SCL op GPIO 22 en voed de VCC van het board vanaf 3V3, zodat de I2C-lijnen op 3,3 V blijven. Het servosignaal is dan 3,3 V; de meeste standaardservo's herkennen dit niveau zonder problemen.

Waar kun je de PCA9685 nog meer voor gebruiken dan voor servo's?

De chip is eigenlijk een leddriver met 16 kanalen; als je de frequentie verhoogt naar ongeveer 1000 Hz, kun je de ledhelderheid in 4096 stappen instellen. Hij kan ook de snelheid van kleine gelijkstroommotoren regelen via een transistor of MOSFET. De kanalen sturen geen grote belastingen direct aan; ze leveren alleen een stuursignaal.

Alle projecten bekijken
Servocirkelchoreografie: geanimeerde patronen met 32 servo's
AR-97Gevorderd
Premium

Servocirkelchoreografie: geanimeerde patronen met 32 servo's

Een visueel animatieproject met 32 servomotoren in een cirkel op een Arduino Mega. De servo's worden in één array beheerd, zijn aangesloten op pin 22–53 van de Mega en voeren vier bewegingsreeksen uit: een chaotische trilling met willekeurige hoeken, een gesynchroniseerde zwaai, een golf die rond de cirkel loopt en een kompasnaald die heen en weer zwaait.

4.5(40)
62
Een servomotor gebruiken
AR-35Beginner
Premium

Een servomotor gebruiken

De arm van een kleine servomotor draait na elkaar naar drie standen: helemaal naar het begin, precies naar het midden en helemaal naar het einde, en wacht bij elke stop twee seconden.

4.7(48)
67
Servomotor aansturen met een potentiometer
AR-36Beginner
Premium

Servomotor aansturen met een potentiometer

Als je aan de knop van de potentiometer draait, draait de arm van de servomotor mee: het ene uiteinde van de knop staat voor nul graden, het andere voor een halve slag.

4.6(37)
53
Servo's bedienen met joystick
AR-60Gemiddeld
Premium

Servo's bedienen met joystick

Stuur twee motoren aan met een joystick, net als bij het draaien van een bewakingscamera.

4.7(42)
58
ESP32-servomotor (bediening met potentiometer)
ES-16Gemiddeld
Premium

ESP32-servomotor (bediening met potentiometer)

In dit project bedien je een SG90-servomotor met een potentiometer. De analoge waarde van de potentiometer zet je om naar het bereik van 0–180 graden en zo stel je de servohoek in. De ESP32Servo-bibliotheek maakt het servosignaal op geschikte GPIO-pinnen van de ESP32 die als uitgang kunnen dienen; dit project gebruikt GPIO 18. Dit is een basismethode voor robotarmen, cameragimbals en automatische deurmechanismen.

4.3(29)
42
ESP32 RFID-deurslot (RC522 + servo + OLED + buzzer + LED)
ES-35Gevorderd
Premium

ESP32 RFID-deurslot (RC522 + servo + OLED + buzzer + LED)

We bouwen een slim deurslot met een ESP32, een RC522 RFID-module, een SG90-servo, een SSD1306 OLED-display, een actieve buzzer en 2 leds. Bij het scannen van een kaart wordt de UID vergeleken met de geautoriseerde kaarten in de code; bij een match ontgrendelt de servo (groene led + 2 korte piepjes) en vergrendelt na 5 seconden weer. Een onbekende kaart laat de rode led branden, geeft 3 snelle piepjes en toont de UID op de OLED.

4.8(9)
16
360-gradenservo van een stappenmotor
AR-68Gemiddeld
Premium

360-gradenservo van een stappenmotor

Leer een gewone stappenmotor naar elke gewenste hoek te gaan, helemaal rond de cirkel.

4.5(22)
33