Componenten · 15 min leestijd

MG996R-servo met Arduino: koppel, stroom, voeding en code

De MG996R-servo gebruiken: 11 kg·cm koppel en 2,5 A blokkeerstroom, externe voeding van 5–6 V, condensator, bereik van 500–2500 µs, trillen verhelpen, PCA9685 en SG90.

De MG996R-servo is dé servo voor zware klussen in Arduino-projecten, dankzij de metalen tandwielen en een koppel tot 11 kg·cm bij 6 V. Met een behuizing van 55 gram kan hij de schouder van een robotarm optillen, een zwaar deksel openen of een pan-tilt-camerahouder bewegen. Die kracht heeft wel een prijs: onder belasting trekt de MG996R tot 2,5 A. Anders dan een SG90 kun je hem dus niet gewoon op de 5V-pin van de Arduino aansluiten; hij heeft een externe voeding van 5–6 V nodig, een gemeenschappelijke GND en een condensator dicht bij de servo. Negeer je deze regels, dan trilt de servo, blijft de Arduino resetten en kan je computer zelfs de USB-poort uitschakelen.

In deze gids leer je de koppel- en stroomwaarden van de MG996R te interpreteren met echte getallen, de juiste voeding te kiezen, het bereik van 500–2500 µs te gebruiken met de Servo-bibliotheek om de grenzen van je eigen servo te vinden en trillen en resets te voorkomen. Daarna gaan we verder met code voor ESP32 en Raspberry Pi Pico, de PCA9685-module die 16 servo's aanstuurt via twee draden, het kiezen van servo's voor een robotarm en een vergelijking met de SG90 en MG90S.

MG996R-servomotor met metalen tandwielen
MG996R: behuizing van 40,7 × 19,7 × 42,9 mm, metalen tandwielen, dubbel kogellager en een uitgaande as met 25 tanden. De bruine draad is GND, rood is plus en oranje is het signaal.

Wat is de MG996R-servo en hoe werkt hij?

De MG996R is een verbeterde versie van de oudere MG995 van TowerPro: het herontworpen stuurprintje en de tandwielen centreren betrouwbaarder en hebben minder speling. In de behuizing zit een kleine gelijkstroommotor, een metalen tandwielkast die de motor vertraagt en het koppel vermenigvuldigt, een potentiometer die de hoek van de uitgaande as meet en een printplaat die alles aanstuurt. De print leest elke 20 ms (50 Hz) de breedte van de puls op de signaaldraad, vergelijkt de gevraagde hoek met de hoek die de potentiometer meldt en draait de motor totdat het verschil verdwenen is. Een puls van ongeveer 1500 µs betekent de middenstand; kortere pulsen draaien de as de ene kant op, langere de andere kant op. De dode band van 5 µs in de datasheet betekent dat de servo veranderingen kleiner dan dat negeert. Hoe servomotoren in het algemeen werken, leggen we uit in Wat is een servomotor?.

EigenschapWaarde
Werkspanning4,8–7,2 V (in de praktijk 5–6 V)
Blokkeerkoppel9,4 kg·cm (4,8 V), 11 kg·cm (6 V) ≈ 0,92–1,08 N·m
Snelheid (per 60°)0,17 s (4,8 V), 0,14 s (6 V)
RustverbruikOngeveer 10 mA (zonder belasting, as stilstaand)
Stroom tijdens bewegen500–900 mA (6 V, tijdens bewegen)
Blokkeerstroom2,5 A (6 V)
Dode band5 µs
DraaibereikOngeveer 120° met 1000–2000 µs, bijna 180° met 500–2500 µs (verschilt per exemplaar)
Signaal50 Hz (periode van 20 ms), positie bepaald door pulsbreedte
Tandwielen en lagerMetalen tandwielen, dubbel kogellager
Uitgaande as25 tanden (25T-spline)
Gewicht en afmetingen55 g, 40,7 × 19,7 × 42,9 mm
KabelOngeveer 30 cm; bruin GND, rood plus, oranje signaal
Werktemperatuur0–55 °C

Wat betekent koppel? De kg·cm-waarde goed lezen

Koppel is het vermogen van de servo om een last op een bepaalde afstand van zijn as te draaien en wordt gemeten als kracht × afstand. 11 kg·cm betekent dat hij 11 kg kan houden op 1 cm van de as, of 1,1 kg op 10 cm; verdubbel je de afstand, dan halveert de last die hij aankan. Om om te rekenen naar newtonmeter vermenigvuldig je met 0,098: 11 kg·cm ≈ 1,08 N·m. Let op dit belangrijke detail: de waarde in de datasheet is het blokkeerkoppel, de grens waarop de as stilvalt, de stroom piekt en de servo warm wordt. Bij continu gebruik houdt maximaal de helft van die waarde de servo koel, vermindert het trillen en gaan de tandwielen langer mee.

Armlengte (as tot last)Blokkeergrens (6 V)Veilige continue last (50%)
2,5 cm (uiteinde van de servohoorn)4,4 kg2,2 kg
5 cm2,2 kg1,1 kg
10 cm1,1 kg550 g
15 cmOngeveer 730 gOngeveer 365 g
20 cm550 g275 g

De tabel houdt alleen rekening met de last aan het uiteinde. In een echt mechanisme tellen het gewicht van de arm zelf, de andere servo's erop en de gripper allemaal mee in het koppel; je moet de massa van elk onderdeel vermenigvuldigen met zijn afstand tot de as en alles optellen. Draagt een arm van 15 cm bijvoorbeeld een gripper van 150 g en een voorwerp van 100 g aan het uiteinde, dan komen alleen die twee al op 0,25 × 15 = 3,75 kg·cm; met het eigen gewicht van de arm kan het totaal 5 kg·cm bereiken. Dat is net onder de helft van het blokkeerkoppel van de MG996R bij 6 V, dus dat is de juiste keuze. Een koppelberekening per onderdeel met een voorbeeld vind je in de gids Arduino-robotarm.

Stroom: waarom kan de MG996R niet draaien op de 5V-pin van de Arduino?

In rust zonder belasting trekt de MG996R slechts ongeveer 10 mA (een last vasthouden verhoogt dit met de last), maar tijdens het bewegen stijgt de stroom naar 0,5–0,9 A, en als de as belast is en tijdens de eerste milliseconden van elke start komt hij in de buurt van 2,5 A. Als een Arduino Uno op USB draait, wordt de totale stroom die je uit de 5V-pin kunt halen beperkt door de zekering van 500 mA op het board, en het board zelf gebruikt daar een deel van. Op het moment dat de servo start, zakt de 5V-lijn enkele milliseconden merkbaar in, wordt de processor instabiel en herstart het board. De computer kan ook een USB-poort uitschakelen die een tijdlang te veel stroom ziet.

De draden zijn ook deel van het probleem. De dunne jumperdraden en breadboardcontacten die je op een breadboard gebruikt, tellen makkelijk op tot 0,2 Ω. Reken het uit met de wet van Ohm: bij een piek van 2,5 A gaat 2,5 × 0,2 = 0,5 V verloren in de bedrading alleen, dus een voeding van 5 V komt als 4,5 V bij de servo aan, en de servo wordt zwakker en trilt. Breadboardcontacten zijn bovendien ontworpen voor ongeveer 1 A. Sluit de voedingsdraden van de MG996R daarom direct aan op een schroefklem of een gesoldeerde verdeelrail in plaats van op het breadboard, en gebruik draad van 20–22 AWG.

Aantal servo'sTijdens bewegenSlechtste geval (alle geblokkeerd)Aanbevolen voeding
1 MG996R0,5–0,9 A2,5 A5–6 V, minstens 3 A
2 servo's1–1,8 A5 A5–6 V, 5 A
4 servo's2–3,6 A10 A5–6 V, schakelende adapter van 6–10 A
6 servo's (robotarm)3–5,4 A15 A6 V, 10 A plus code die de servo's om de beurt beweegt
16 servo's (PCA9685)8–14 A40 AMeerdere aparte 6V-lijnen of een voeding van 20 A of meer

Goed van stroom voorzien: externe 5–6 V, gemeenschappelijke GND en een condensator

  1. Kies de voeding: Gebruik een schakelende adapter van 5 V of 6 V die de stroom uit bovenstaande tabel kan leveren voor jouw aantal servo's. Voor draagbare projecten werken 4 AA NiMH-cellen (4,8 V) of een 2S-LiPo met een step-downregelaar (UBEC) ingesteld op 6 V goed.
  2. Voed alleen de servo met de plus: Sluit de plus van de voeding aan op de rode draad van de MG996R; sluit hem niet aan op de 5V-pin van de Arduino.
  3. Verbind de massa's: Sluit de min van de voeding aan op zowel de bruine draad van de servo als de GND-pin van de Arduino. Het signaal is een spanning gemeten ten opzichte van GND, dus zonder gemeenschappelijke GND kan de servo de pulsen niet begrijpen.
  4. Sluit het signaal aan: Sluit de oranje draad aan op pin D9 van de Arduino Uno (GPIO 18 op de ESP32, GP15 op de Pico).
  5. Voeg een condensator toe: Plaats een elco van 470–1000 µF / 16 V over de voedingsaansluitingen van de servo, zo dicht mogelijk bij de servo; het pootje met de streep gaat naar min. Reken bij meerdere servo's op ongeveer 100 µF per servo.
  6. Voed de Arduino apart: Laat het board draaien op USB of de DC-jack. Zo bereiken de spanningsdips van de servo de processor niet.
Sluit een 2S-LiPo (8,4 V als hij vol is) niet direct aan op de MG996R; dat overschrijdt het maximum van 7,2 V en kan de printplaat doorbranden. Een 9V-batterij kan daarentegen de stroom helemaal niet leveren. Een elco verkeerd om aansluiten kan hem laten opwarmen en barsten; de spanningswaarde moet minstens twee keer de spanning van de lijn zijn (16 V voor 6 V). Waarom een gemeenschappelijke GND essentieel is, leggen we uit in Wat is GND? en hoe je condensatoren kiest in Wat is een condensator?.
AansluitingArduino UnoESP32Raspberry Pi Pico
Oranje draad (signaal)D9GPIO 18GP15
Rode draad (plus)Externe 5–6 V plusExterne 5–6 V plusExterne 5–6 V plus
Bruine draad (GND)Min van voeding + Arduino GNDMin van voeding + ESP32 GNDMin van voeding + Pico GND
Condensator (470–1000 µF)Over de plus en min van de servoOver de plus en min van de servoOver de plus en min van de servo
Potentiometer (ESP32-voorbeeld)—Sleper naar GPIO 34, buitenste pootjes naar 3V3 en GND—
Elektrolytische condensatoren
Een elco levert de plotselinge stroom die de servo bij het starten vraagt uit zijn eigen lading, voordat de voeding kan reageren. De streep op de behuizing markeert het min-pootje; 470–1000 µF / 16 V is een goed beginpunt voor de MG996R.
Heb je een adapter van 12 V, dan kun je de uitgang met een LM2596-module op 6 V instellen. De LM2596 levert echter maximaal 3 A en wordt zonder koelplaat al bij ongeveer 2 A heet, dus hij is geschikt voor één MG996R, wiens blokkeerstroom van 2,5 A al in de buurt van die grens komt. Kies voor meer servo's een converter van 5 A of meer, of direct een krachtige adapter van 5–6 V. Voor projecten op batterijen kun je de looptijd schatten met de batterijduurcalculator.

De Servo-bibliotheek en het bereik van 500–2500 µs

De Servo-bibliotheek van Arduino zit bij de IDE. Als je servo.attach(9) schrijft, gebruikt de bibliotheek een standaardbereik van 544–2400 µs en koppelt write(0) en write(180) aan die twee uiteinden; veel MG996R's halen in dit bereik net geen 180 graden. Om het te verbreden schrijf je servo.attach(9, 500, 2500). Dit detail is belangrijk, want ook writeMicroseconds() kan niet voorbij de grenzen die aan attach zijn meegegeven: schrijf je writeMicroseconds(2500) zonder de grenzen in te stellen, dan kapt de bibliotheek dat stilletjes af op 2400. Bovendien behandelt write() getallen onder 544 als een hoek en grotere getallen als microseconden.

Op de Arduino Uno ondersteunt de Servo-bibliotheek maximaal 12 servo's, en omdat hij Timer1 gebruikt, werkt analogWrite niet op pin 9 en 10 zolang er een servo is aangesloten. De mechanische grens van elke MG996R is ook net anders: de datasheet van de fabrikant geeft ongeveer 120 graden draaiing bij standaardpulsen van 1000–2000 µs, terwijl de meeste servo's met het bredere bereik dicht bij 180 graden komen. Een servo die voorbij zijn grens wordt gedrukt, loopt tegen zijn interne aanslag aan, trekt blokkeerstroom, zoemt en wordt warm. De eerste taak is dus om met de sketch hieronder het veilige pulsbereik van je eigen servo te vinden.

C++ (Arduino IDE)
1#include <Servo.h>
2
3const byte SERVO_PIN = 9;          // turuncu sinyal kablosu / orange signal wire
4Servo servo;
5int pulseUs = 1500;                // orta konum / center position
6
7void setup() {
8  Serial.begin(115200);
9  servo.writeMicroseconds(pulseUs);      // önce darbe, sonra attach / pulse first, then attach
10  servo.attach(SERVO_PIN, 500, 2500);    // aralığı genişlet / widen the range
11  Serial.println(F("500-2500 arasi bir deger yaz / type a value between 500 and 2500"));
12}
13
14void loop() {
15  if (Serial.available()) {
16    long value = Serial.parseInt();             // yazılan sayıyı oku / read the typed number
17    while (Serial.available()) Serial.read();   // satır sonunu temizle / clear the line ending
18    if (value >= 500 && value <= 2500) {
19      int step = (value > pulseUs) ? 10 : -10;  // 10 µs adımlarla yavaşça git / move slowly in 10 µs steps
20      while (abs(value - pulseUs) >= 10) {
21        pulseUs += step;
22        servo.writeMicroseconds(pulseUs);
23        delay(5);
24      }
25      pulseUs = value;
26      servo.writeMicroseconds(pulseUs);
27      Serial.print(F("Darbe / pulse: "));
28      Serial.print(pulseUs);
29      Serial.println(F(" us"));
30    }
31  }
32}
  1. Upload de sketch, open de Serial Monitor op 115200 baud en stel het regeleinde in op New Line.
  2. Typ 1500; de servo gaat naar het midden. Monteer de servohoorn op dit moment zo dat hij naar de middenpositie van je mechanisme wijst.
  3. Werk in stappen van 50 µs naar de ondergrens toe met waarden als 1000, 800 en 700. Beweegt de servo niet meer of begint hij te zoemen, ga dan 30–50 µs terug ten opzichte van de laatste waarde en noteer dat getal als MIN_US.
  4. Doe hetzelfde voor de bovengrens met waarden als 2000, 2200 en 2300 om MAX_US te vinden. Deze twee getallen gebruik je in de volgende sketches.

Soepele beweging: code die stroompieken en schokken vermindert

Een enkel commando als servo.write(160) gooit de servo op volle snelheid naar zijn doel en legt bij 6 V 60 graden af in 0,14 seconde. Ondertussen trekt de motor bijna zijn blokkeerstroom, schokt het mechanisme en kan het vastgehouden voorwerp vallen. De beweging opdelen in kleine stappen vermindert zowel de stroompieken als de mechanische schok. De sketch hieronder laat de servo elke 15 ms 1 graad vooruitgaan (ongeveer 67°/s), en omdat hij millis() gebruikt, kun je tegelijkertijd andere dingen doen.

C++ (Arduino IDE)
1#include <Servo.h>
2
3const byte SERVO_PIN = 9;
4const int MIN_US = 550;            // kalibrasyonda bulduğun alt sınır / lower limit from calibration
5const int MAX_US = 2450;           // kalibrasyonda bulduğun üst sınır / upper limit from calibration
6const byte STEP_MS = 15;           // derece başına süre: 15 ms ≈ 67°/sn / time per degree: 15 ms ≈ 67°/s
7
8const int POSES[] = {20, 160, 90, 45, 135};    // sırayla gidilecek açılar / angles to visit in order
9const byte POSE_COUNT = sizeof(POSES) / sizeof(POSES[0]);
10
11Servo servo;
12int current = 90;                  // şu anki açı / current angle
13int target = 90;                   // hedef açı / target angle
14byte poseIndex = 0;
15unsigned long lastStep = 0;
16unsigned long arrivedAt = 0;
17
18int angleToUs(int angle) {
19  return map(angle, 0, 180, MIN_US, MAX_US);   // açıyı darbeye çevir / angle to pulse width
20}
21
22void setup() {
23  servo.writeMicroseconds(angleToUs(current)); // önce konum, sonra attach / position first, then attach
24  servo.attach(SERVO_PIN, MIN_US, MAX_US);
25  arrivedAt = millis();
26}
27
28void loop() {
29  unsigned long now = millis();
30
31  // Hedefe 1 derecelik adımlarla yaklaş / approach the target in 1-degree steps
32  if (current != target && now - lastStep >= STEP_MS) {
33    lastStep = now;
34    current += (target > current) ? 1 : -1;
35    servo.writeMicroseconds(angleToUs(current));
36    if (current == target) arrivedAt = now;
37  }
38
39  // Hedefte 1 sn bekle, sonra sıradaki poza geç / wait 1 s at the target, then take the next pose
40  if (current == target && now - arrivedAt >= 1000) {
41    target = POSES[poseIndex];
42    poseIndex = (poseIndex + 1) % POSE_COUNT;
43  }
44
45  // Burada başka işler de yapılabilir / other tasks can run here too
46}

De functie angleToUs() koppelt de hoek aan de waarden MIN_US en MAX_US die je tijdens de kalibratie hebt gevonden, zodat 0 en 180 graden de echte, veilige eindpunten van de servo worden. Een servo onthoudt zijn positie niet als hij uit staat en gaat op volle snelheid naar de opgegeven hoek zodra hij de eerste puls ontvangt. Als je writeMicroseconds() aanroept vóór attach(), slaat de bibliotheek zijn standaardpuls van 1500 µs over en stuurt direct je beginhoek; breng je het mechanisme vóór het uitschakelen terug in dezelfde beginstand, dan verdwijnt de sprong bij het opstarten bijna helemaal. Stel de snelheid in met STEP_MS: 30 ms geeft een trage, soepele beweging, 5 ms een snelle maar schokkerige. Wil je de servo aansturen met een potentiometer, zet dan de meetwaarde om naar een hoek en schrijf die naar de variabele target.

Trillen en resets van de Arduino: oorzaken en oplossingen

SymptoomWaarschijnlijke oorzaakOplossing
De Arduino reset en de USB-verbinding valt weg als de servo beweegtDe servo wordt gevoed vanaf de 5V-pin van de Arduino en zijn aanloopstroom trekt de spanning omlaagExterne voeding van 5–6 V, gemeenschappelijke GND en een condensator van 470–1000 µF
De servo trilt of zoemt terwijl hij stilstaatZwakke voeding, dunne draden of een last dicht bij het blokkeerkoppelGebruik dikke draden en een condensator, kort de arm in of verminder de last
Hij blijft schokken als hij met een potentiometer wordt aangestuurdRuis van enkele stappen in de analoge metingVoeg een afvlakfilter en een dode band van 2 graden toe
De servo beweegt willekeurig of reageert helemaal nietDe GND van de externe voeding is niet verbonden met de ArduinoSluit de min van de voeding aan op de GND-pin van de Arduino
Hij zoemt en wordt warm aan de uiteindenHet pulsbereik overschrijdt de mechanische grens van de servoVerklein MIN_US en MAX_US via kalibratie
Hij schokt bij gebruik met NeoPixel-, SoftwareSerial- of IR-bibliothekenDeze bibliotheken schakelen kort interrupts uit, waardoor de pulslengte afwijktVerplaats de servo naar een PCA9685 of gebruik een board met hardware-PWM
De ESP32 geeft "Brownout detector was triggered" en herstartDe servo en de ESP32 delen dezelfde zwakke voedingVoed de servo met een aparte voeding en verbind de massa's
Klikken en slippen onder belastingEen tand van een tandwiel is gebroken of de kunststof servohoorn is doorgedraaidVervang de tandwielset, gebruik een metalen 25T-servohoorn en de middenschroef
Koppel ver onder de opgegeven waardeEen namaak van slechte kwaliteit of een te lage voedingsspanningProbeer 6 V, koop bij een betrouwbare verkoper en houd 50% marge aan
Hoeft de servo geen last te houden, dan kun je het signaal afkappen met servo.detach() zodra hij het doel bereikt; de servo wordt stil en trekt bijna geen stroom. Zonder signaal verliest hij echter ook zijn houdkoppel, dus gebruik detach niet op dragende gewrichten zoals de schouder van een robotarm. Alle oorzaken van resets en een diagnosesketch vind je in Arduino blijft resetten, en het ESP32-equivalent in ESP32-brownoutfout.

De MG996R aansturen met een ESP32

De standaard Servo-bibliotheek van Arduino werkt niet op de ESP32; installeer de bibliotheek ESP32Servo via de Library Manager. Hij wordt bijna hetzelfde gebruikt: je stelt de periode in met setPeriodHertz(50), en de bibliotheek accepteert geen grenzen buiten 500–2500 µs. De signaaluitgang van de ESP32 is 3,3 V en de overgrote meerderheid van de MG996R's leest dat zonder problemen; reageert je servo niet of gedraagt hij zich grillig, voeg dan een niveauconverter toe aan de signaallijn. In het voorbeeld hieronder draait een potentiometer op GPIO 34 de servo. Omdat de ADC van de ESP32 12 bit is, lopen de metingen van 0 tot 4095 en zijn ze wat ruisig, daarom gebruikt de code filtering en een dode band.

C++ (Arduino IDE)
1#include <ESP32Servo.h>
2
3const int SERVO_PIN = 18;          // servo sinyali / servo signal
4const int POT_PIN = 34;            // pot orta bacağı (ADC1) / pot wiper (ADC1)
5const int MIN_US = 500;            // ESP32Servo bu aralığın dışına çıkmaz / ESP32Servo stays within 500–2500
6const int MAX_US = 2500;
7
8Servo servo;
9float smooth = 0;                  // süzülmüş pot değeri / filtered pot value
10int lastAngle = -1;
11
12void setup() {
13  Serial.begin(115200);
14  ESP32PWM::allocateTimer(0);              // servo için zamanlayıcı ayır / reserve a timer for the servo
15  servo.setPeriodHertz(50);                // 50 Hz = 20 ms periyot / 20 ms period
16  servo.attach(SERVO_PIN, MIN_US, MAX_US);
17  smooth = analogRead(POT_PIN);
18}
19
20void loop() {
21  smooth += (analogRead(POT_PIN) - smooth) * 0.1;   // ADC gürültüsünü süz / filter ADC noise
22  int angle = map((int)smooth, 0, 4095, 0, 180);    // 12 bit ADC: 0–4095
23  if (abs(angle - lastAngle) >= 2) {                // ölü bant: titremeyi keser / deadband stops jitter
24    servo.write(angle);
25    lastAngle = angle;
26    Serial.println(angle);
27  }
28  delay(20);
29}

MG996R met de Raspberry Pi Pico (MicroPython)

Op de Raspberry Pi Pico heb je geen extra bibliotheek nodig: stel de PWM in op 50 Hz en geef de pulsbreedte in nanoseconden op met duty_ns(); 500 µs betekent 500000 ns. Het signaal van de Pico is ook 3,3 V. Voed de servo niet via de pin VBUS of VSYS van de Pico; de stroom op deze pins komt van de USB-poort van de computer, en de piekstroom van de MG996R laat de Pico herstarten. Voed de servo met een externe voeding en verbind de massa's. De code hieronder beweegt de servo soepel, graad voor graad, tussen drie posities.

MicroPython
1from machine import Pin, PWM
2import time
3
4MIN_NS = 500000                   # 500 µs = 0 derece / 0 degrees
5MAX_NS = 2500000                  # 2500 µs = 180 derece / 180 degrees
6
7servo = PWM(Pin(15))              # turuncu kablo GP15'e / orange wire to GP15
8servo.freq(50)                    # 50 Hz servo sinyali / 50 Hz servo signal
9
10def write_angle(angle):
11    angle = max(0, min(180, angle))                           # 0–180 ile sınırla / clamp to 0–180
12    servo.duty_ns(MIN_NS + (MAX_NS - MIN_NS) * angle // 180)  # açıyı darbeye çevir / angle to pulse
13
14def move_slow(start, end, ms_per_degree=15):
15    step = 1 if end > start else -1
16    for a in range(start, end + step, step):  # 1 derecelik adımlar / 1-degree steps
17        write_angle(a)
18        time.sleep_ms(ms_per_degree)
19
20write_angle(90)                   # ortadan başla / start at the center
21time.sleep(1)
22
23while True:
24    move_slow(90, 170)
25    time.sleep(1)
26    move_slow(170, 10)
27    time.sleep(1)
28    move_slow(10, 90)
29    time.sleep(1)

16 servo's met een PCA9685: veel MG996R's via twee draden

Groeit het aantal servo's, of werk je met bibliotheken die interrupts uitschakelen, dan maakt de PCA9685-module het leven makkelijker. Dit board is een PWM-generator met 16 kanalen en 12 bit die via I2C met de Arduino praat met alleen de draden SDA en SCL. Omdat hij de pulsen met zijn eigen klok genereert, blijft het signaal stabiel, ook als de processor met ander werk bezig is. Het standaardadres is 0x40; door het adres te wijzigen met de soldeerbruggen A0–A5 op het board kun je 62 boards op dezelfde bus aansluiten, wat in theorie 992 servo's betekent. Bij 50 Hz wordt de periode van 20 ms verdeeld in 4096 stappen, en één stap is ongeveer 4,9 µs: 500 µs is ongeveer 102 stappen en 2500 µs ongeveer 512.

PCA9685-pinArduino UnoESP32Raspberry Pi Pico
GNDGNDGNDGND
VCC (alleen voeding van de chip)5V3V33V3
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
V+-klem (servovoeding)Externe 5–6 VExterne 5–6 VExterne 5–6 V
OENiet aansluitenNiet aansluitenNiet aansluiten
C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver(0x40);   // varsayılan adres / default address
5
6const byte SERVO_COUNT = 16;
7const uint16_t MIN_US = 500;       // kalibrasyonla daralt / narrow it after calibration
8const uint16_t MAX_US = 2500;
9
10uint16_t angleToUs(float angle) {
11  return MIN_US + (uint16_t)(angle * (MAX_US - MIN_US) / 180.0);
12}
13
14void setup() {
15  pca.begin();
16  pca.setOscillatorFrequency(27000000);   // kartın gerçek saatine yakın / close to the real board clock
17  pca.setPWMFreq(50);                     // servolar için 50 Hz / 50 Hz for servos
18  delay(10);
19  for (byte ch = 0; ch < SERVO_COUNT; ch++) {
20    pca.writeMicroseconds(ch, angleToUs(90));   // hepsini ortala / center them all
21    delay(200);                                 // sırayla başlat: akım darbesini dağıt / one by one: spread the current surge
22  }
23}
24
25void loop() {
26  // Dalga: her servo komşusundan biraz geride / wave: each servo slightly behind its neighbour
27  float t = millis() / 1000.0;
28  for (byte ch = 0; ch < SERVO_COUNT; ch++) {
29    float angle = 90 + 40 * sin(t * 2.0 - ch * 0.4);   // 50–130° arası / between 50° and 130°
30    pca.writeMicroseconds(ch, angleToUs(angle));
31  }
32  delay(20);
33}

Om de sketch te draaien installeer je de bibliotheek Adafruit PWM Servo Driver via de Library Manager. De regel setOscillatorFrequency(27000000) is belangrijk: op papier is de interne klok van de PCA9685 25 MHz, maar in werkelijkheid varieert hij tussen ongeveer 23 en 27 MHz, en de voorbeelden van Adafruit gebruiken 27 MHz. Zonder deze instelling kunnen de pulsen die je met writeMicroseconds() instelt enkele procenten afwijken. Door de servo's tijdens setup één voor één te starten, met 200 ms ertussen, trekken niet alle 16 tegelijk hun aanloopstroom. Heeft elke servo andere grenzen, maak van MIN_US en MAX_US dan arrays van 16 elementen en kalibreer elk kanaal. De sketch draait ook ongewijzigd op de ESP32, omdat de Wire-bibliotheek daar standaard GPIO 21 en 22 gebruikt.

De PCA9685 heeft twee aparte voedingsingangen: VCC voedt alleen de chip, terwijl de servo's worden gevoed via de ingang V+ op de schroefklem. Blijft V+ leeg, dan verschijnt het board wel op I2C maar bewegen de servo's niet; voed V+ nooit vanaf de 5V-pin van de Arduino. De dunne printsporen op goedkope modules zijn niet ontworpen om tientallen ampères te voeren: gebruik je meer dan 4–6 MG996R's, sluit dan de plus- en minraden van de servo's aan op een dikke verdeelrail en neem alleen het signaal van het board. Voeg ook ongeveer 100 µF capaciteit per servo toe aan de V+-lijn.

MG996R vs SG90 vs MG90S

EigenschapSG90MG90SMG996R
Blokkeerkoppel1,8 kg·cm (4,8 V)1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V)9,4 kg·cm (4,8 V), 11 kg·cm (6 V)
Snelheid (per 60°)0,10 s (4,8 V)0,10 s (4,8 V), 0,08 s (6 V)0,17 s (4,8 V), 0,14 s (6 V)
Gewicht9 g13,4 g55 g
Afmetingen22,2 × 11,8 × 31 mm22,8 × 12,2 × 28,5 mm40,7 × 19,7 × 42,9 mm
TandwielenKunststofMetalMetaal, dubbel lager
Werkspanning4,8–6 V4,8–6 V4,8–7,2 V
BlokkeerstroomOngeveer 0,6–0,75 AOngeveer 0,7–1 A2,5 A (6 V)
Vanaf de 5V-pin van de ArduinoEén servo, lichte lastEén servo, lichte lastNee, altijd een externe voeding
Typisch gebruikEerste experimenten, pan-tilt, gripperPols, gripper, kleine robotsSchouder van een robotarm, zwaar deksel, besturing

De last en de armlengte bepalen het. Draai je een onderdeel van een paar gram of experimenteer je gewoon, dan is de SG90 genoeg. Wil je dezelfde grootte met schokbestendige metalen tandwielen, kies dan de MG90S. Overschrijdt het koppel dat je nodig hebt 1 kg·cm, bijvoorbeeld 100 g dragen aan het uiteinde van een arm van 10 cm, stap dan over op de MG996R. De MG996R heeft ongeveer vijf keer het koppel van de SG90, maar is langzamer, zes keer zwaarder en trekt drie tot vier keer meer stroom, dus plan de voeding en de mechanische montage daarop. Is 11 kg·cm nog steeds niet genoeg, kijk dan naar grotere servo's uit de klasse van 20 kg·cm, zoals de DS3218.

SG90
SG90
MG90S
MG90S
MG996R
MG996R

Servo's kiezen voor een robotarm

  • Basis: MG996R. Leg niet het hele gewicht van de arm op de as van de servo; voeg een lager toe aan de basis zodat de servo hem alleen hoeft te draaien.
  • Schouder: Dit is het gewricht dat het zwaarst belast wordt. Gebruik een MG996R; is de arm langer dan 20 cm, voeg dan een servo uit de klasse van 20 kg·cm of een tegengewicht toe.
  • Elleboog: MG996R. De zware servo naar schouderhoogte verplaatsen en de elleboog met een duwstang aandrijven vermindert de belasting op de schouder.
  • Pols en polsrotatie: Een MG90S is genoeg; een MG996R hier gebruiken voegt alleen gewicht toe dat de schouder moet dragen.
  • Gripper: SG90 of MG90S. Stel de sluithoek in op het punt waar de vingers het voorwerp net raken; een servo die blijft proberen te knijpen, trekt blokkeerstroom.
  • Montage: Monteer een metalen servohoorn op de as met 25 tanden van de MG996R en zet hem vast met de middenschroef; kunststof servohoorns slijten bij dit koppel snel door.

Projectideeën met de MG996R

  • Robotarm: Een arm met 6 servo's met MG996R's bij de basis, schouder en elleboog en MG90S-servo's bij de pols en gripper; zie de robotarmgids voor de bouw.
  • Pan-tilt-camera: Draai een ESP32-CAM-module horizontaal en verticaal met twee MG996R's.
  • Zonnevolger: Bepaal de richting van het licht met vier LDR's en draai een klein paneel naar de zon met een MG996R; details in het artikel over de zonnevolger.
  • Slimme prullenbak: Een slimme prullenbak die een zwaar deksel opent als er een hand nadert.
  • Kaartdeurslot: Trek een grendel open met een MG996R wanneer de juiste kaart wordt gescand op een RFID RC522.
  • Kraan met joystick: Een kleine kraan of graafmachine die op twee assen beweegt met een joystick.
  • Continue aandrijving: Een langzaam maar krachtig wiel met de 360-gradenversie van de MG996R; het verschil wordt uitgelegd in het artikel over de 360-gradenservo.

Goed van stroom voorzien is de MG996R een robuuste, goedkope motor die gemakkelijk klussen aankan waar kleine servo's niet tegen opgewassen zijn. Onthoud de regels: een externe voeding van 5–6 V, een gemeenschappelijke GND, een condensator dicht bij de servo, een gekalibreerd pulsbereik en soepele beweging, en een PCA9685 zodra het aantal servo's groeit. In de BlueGrays-app vind je projecten zoals servobesturing met een potentiometer en een joystick, een ESP32-RFID-deurslot met een servo en een choreografie met 32 servo's, elk met een schakelschema stap voor stap en kant-en-klare code.

Veelgestelde vragen

Hoeveel gewicht kan een MG996R tillen?

Het koppel van de MG996R is 11 kg·cm bij 6 V, wat 11 kg betekent op 1 cm van de as of 1,1 kg op 10 cm. Dat is de blokkeergrens waarop de servo stilvalt, dus reken voor continu gebruik op de helft. Met andere woorden: hij houdt gemakkelijk ongeveer 500 g vast aan het uiteinde van een arm van 10 cm.

Welke spanning heeft de MG996R nodig en kan ik 12 V gebruiken?

Volgens de datasheet is het werkbereik 4,8–7,2 V; in de praktijk gebruikt men 5 V of 6 V, en 6 V geeft meer koppel en snelheid. 12 V, of een 2S-LiPo van 8,4 V als hij vol is, brandt de printplaat van de servo door. Heb je een bron met een hogere spanning, breng die dan terug naar 6 V met een step-downconverter zoals de LM2596.

Hoeveel ampère trekt de MG996R en welke voeding heb ik nodig?

Hij trekt ongeveer 10 mA in rust zonder belasting, 0,5–0,9 A tijdens bewegen en tot 2,5 A onder belasting en bij het starten. Kies een adapter van 5–6 V die minstens 3 A levert voor één servo en 6–10 A voor vier servo's. Vergeet niet de min van de voeding aan te sluiten op de GND-pin van de Arduino.

Draait de MG996R 180 graden en bestaat er een 360-gradenversie?

De standaard MG996R is een positieservo: de fabrikant geeft ongeveer 120 graden op met standaardpulsen, en met een bereik van 500–2500 µs komen de meeste exemplaren dicht bij 180 graden. De 360-gradenversie die onder dezelfde naam wordt verkocht, gaat niet naar een hoek; hij draait continu en wisselt van snelheid en richting naargelang het signaal. Controleer bij het kopen of er in de advertentie 180° of 360° staat.

Waarom trilt mijn MG996R-servo of reset hij de Arduino?

De oorzaak is bijna altijd de voeding: wordt de servo gevoed via de 5V-pin van de Arduino, dan trekt zijn piekstroom de spanning omlaag en herstart het board. Gebruik een externe voeding van 5–6 V, een gemeenschappelijke GND en een condensator van 470–1000 µF dicht bij de servo. Gebruik tegen trillen in stilstand dikke draden, vlak de potentiometermetingen af en houd het pulsbereik binnen de mechanische grenzen van de servo.

Wat is het verschil tussen de MG996R en de MG995?

Beide servo's hebben dezelfde afmetingen en worden op dezelfde manier aangesloten; de MG996R is een verbeterde versie van de MG995. Dankzij het herontworpen stuurprintje en de tandwielen heeft hij een smallere dode band, stabielere centrering en iets meer koppel. Kies de MG996R voor nieuwe projecten; hij is een directe vervanger voor een oude MG995.

Alle projecten bekijken
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
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
Obstakelvermijdende robot
AR-81Gevorderd
Premium

Obstakelvermijdende robot

Zin om een slim voertuig te bouwen dat zelf zijn weg vindt? De obstakelvermijdende robot scant voortdurend zijn omgeving dankzij de ultrasone sensor voorop.

5.0(38)
49