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?

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.
| Eigenschap | Waarde |
|---|---|
| Chip | NXP PCA9685 |
| Kanalen | 16 onafhankelijke PWM-uitgangen |
| Resolutie | 12 bit (4096 stappen per periode) |
| PWM-frequentie | Ongeveer 24–1526 Hz (50 Hz voor servo's) |
| Communicatie | I2C, tot 1 MHz |
| Standaardadres | 0x40 (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 |
| Uitgangsstroom | 25 mA sink, 10 mA source per kanaal (alleen signaal) |
| Op het board | De meeste modules hebben pull-upweerstanden op SDA/SCL en serieweerstanden van 220 Ω op de uitgangen |
| Pulsbreedte | Ticks @ 50 Hz | Typische servopositie |
|---|---|---|
| 0,5 ms (500 µs) | ≈ 102 | Ongeveer 0° bij een SG90 |
| 1,0 ms (1000 µs) | ≈ 205 | Standaard 0° (servo's met smal bereik) |
| 1,5 ms (1500 µs) | ≈ 307 | Middenpositie (90°) |
| 2,0 ms (2000 µs) | ≈ 410 | Standaard 180° |
| 2,4 ms (2400 µs) | ≈ 492 | Ongeveer 180° bij een SG90 |
Bedrading van de PCA9685: Arduino Uno, ESP32 en Pico
| PCA9685-pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| GND | GND | GND | GND |
| VCC (logica) | 5V | 3V3 | 3V3(OUT) |
| SDA | A4 | GPIO 21 | GP4 |
| SCL | A5 | GPIO 22 | GP5 |
| OE | Open laten (op het board naar GND getrokken) | Open laten | Open laten |
| V+ (schroefklem) | Plus van de externe voeding van 5–6 V | Plus van de externe voeding van 5–6 V | Plus 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) |
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.
| Servo | Rust | Bewegend | Vastgelopen | Voeding |
|---|---|---|---|---|
| SG90 (9 g, kunststof tandwielen) | ≈ 10 mA | 100–250 mA | ≈ 650 mA | 4,8–6 V |
| MG90S (metalen tandwielen) | ≈ 10 mA | 150–300 mA | ≈ 700 mA | 4,8–6 V |
| MG996R (standaardformaat) | ≈ 10 mA | 500–900 mA | ≈ 2,5 A | 4,8–7,2 V |
Eerste keer opstarten, stap voor stap: 4 servo's tegelijk laten draaien
- Open de Library Manager in de Arduino IDE, zoek de bibliotheek Adafruit PWM Servo Driver en installeer die.
- Verbind de pins VCC, GND, SDA en SCL van het board met de Arduino zoals in de tabel hierboven; laat de OE-pin open.
- 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.
- Sluit de externe voeding van 5 V aan op de schroefklem: plus op V+, min op GND.
- 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.
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.
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 jumpers | Adres | Voorbeeldgebruik |
|---|---|---|
| Geen | 0x40 | Board 1 (servo's 0–15) |
| A0 | 0x41 | Board 2 (servo's 16–31) |
| A1 | 0x42 | Board 3 |
| A0 + A1 | 0x43 | Board 4 |
| A2 | 0x44 | Board 5 |
| Alle A0–A5 | 0x7F | Laatste adres |
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.
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.
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.
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
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Servo's bewegen helemaal niet | Geen V+-voeding, of setPWMFreq is niet aangeroepen | Sluit externe voeding aan op de klem en zorg dat setPWMFreq(50) in setup staat |
| Servo's trillen en springen willekeurig | Voedingsstroom is te laag, draden zijn dun | Gebruik een sterkere voeding, dikke draden en een condensator van 470–1000 µF op de V+-lijn |
| Arduino reset als de servo's bewegen | Servo's worden gevoed vanaf de 5V-pin van de Arduino | Voed de servo's alleen via V+ en verbind de GND's |
| Servo zoemt en wordt warm aan het eind van de slag | SERVO_MIN of SERVO_MAX ligt voorbij de mechanische grens | Vind de grenzen met de kalibratiecode en blijf 5–10 ticks binnen de grens |
| Code loopt vast of het board wordt niet gevonden | Verkeerd adres, SDA en SCL verwisseld, twee boards op hetzelfde adres | Draai een I2C-scanner en controleer de adresjumpers |
| Servo's springen hard bij het inschakelen | Alle servo's gaan tegelijk naar hun positie | Start de servo's één voor één met een korte pauze ertussen |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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.

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.

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

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.

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.

360-gradenservo van een stappenmotor
Leer een gewone stappenmotor naar elke gewenste hoek te gaan, helemaal rond de cirkel.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

