Gidsen · 13 min leestijd

Servomotor trilt: zo los je het op bij Arduino, ESP32 en Pico

Trilt je servomotor, draait hij uit zichzelf of reset je Arduino? Los het op met de juiste voeding, gemeenschappelijke GND, condensatoren en PWM-instellingen voor ESP32 en Pico.

Een trillende servomotor is een van de meest voorkomende en meest verwarrende fouten in Arduino-projecten: de servo zoemt en schudt terwijl hij stil zou moeten staan, draait uit zichzelf zonder commando, of op het moment dat hij beweegt reset de Arduino en begint je code opnieuw. Het goede nieuws is dat deze verschijnselen meestal niet betekenen dat de servo kapot is; ze komen voort uit vijf basisoorzaken: onvoldoende voeding, een ontbrekende gemeenschappelijke GND, een ontbrekende condensator, signaalruis of een bibliotheekconflict.

In deze gids leggen we uit waarom elke oorzaak optreedt, hoe je haar met een multimeter opspoort en hoe je haar blijvend oplost. Je vindt stroomberekeningen voor de meestgebruikte servo's (SG90, MG90S en MG996R), de juiste bedrading, Arduino-code die trillen in software onderdrukt, PWM-instellingen met LEDC op de ESP32 en een MicroPython-oplossing voor de Raspberry Pi Pico. Ken je de basis van de werking van een servo nog niet, bekijk dan eerst Wat is een servomotor?.

Trillende SG90-servomotor
SG90-microservo: bruin is GND, rood is voeding, oranje is de signaaldraad. De meeste trilproblemen draaien om hoe deze drie draden worden gevoed.

Waarom trilt een servo? Zo werkt het

In een hobbyservo zit een kleine gelijkstroommotor, een tandwielkast, een potmeter op de uitgaande as en een regelschakeling. De Arduino stuurt de servo elke 20 milliseconden (50 Hz) een puls; de pulsbreedte bepaalt de gewenste hoek: ongeveer 0,5–1 ms betekent 0 graden, 1,5 ms betekent 90 graden en 2–2,4 ms betekent 180 graden. De regelschakeling vergelijkt deze puls met de werkelijke stand die ze van de potmeter aflezen en stuurt de motor aan om een verschil te corrigeren als dat er is. Door deze gesloten lus ziet de servo elke kleine variatie in pulsbreedte als een nieuw commando. Als de puls een paar microseconden afwijkt, de voedingsspanning zakt of er zelfs maar wat interferentie wordt opgevangen, blijft de servo zichzelf corrigeren; dat is het zoemen dat je hoort en het trillen dat je ziet. Servo's zoals de SG90 hebben een dode zone van ongeveer 10 µs; zodra de variatie in het signaal die overschrijdt, gaat de motor bewegen.

EigenschapSG90MG90SMG996R
Bedrijfsspanning4,8–6 V4,8–6 V4,8–7,2 V
TandwielenKunststofMetalMetal
Koppel (4,8 V)Ongeveer 1,8 kg·cmOngeveer 1,8 kg·cmOngeveer 9,4 kg·cm
Stroom tijdens bedrijf100–250 mA150–300 mA500–900 mA
BlokkeerstroomOngeveer 650–750 mAOngeveer 0,7–1 AOngeveer 2,5 A
Aanbevolen voeding (één servo)5 V 1 A5 V 1 A6 V 3 A

Symptomen en waarschijnlijke oorzaken

SymptoomWaarschijnlijke oorzaakEerste actie
Servo zoemt constant en schudt licht in rustRuisend signaal, springerige potmeterwaarde, duwen tegen een mechanische aanslagVoeg een filter en dode zone toe in de code, beperk het hoekbereik tot 5–175 graden
Arduino reset als de servo beweegtDe voedingsspanning stort in (brownout)Voed de servo met een externe voeding van 5–6 V
Servo draait willekeurig uit zichzelfGeen gemeenschappelijke GND, of de signaaldraad zweeftVerbind de GND van de externe voeding met de GND van de Arduino
Servo springt plotseling bij het opstartenHet 90-gradencommando bij attach(), bootpinnen op de ESP32Stel een starthoek in, kies een veilige pin zoals GPIO 18 op de ESP32
Servo trilt alleen als een andere module draaitEen bibliotheek schakelt interrupts uit, of er is een timerconflictZoek de conflicterende bibliotheek, gebruik zo nodig een PCA9685-driver
Servo spant en wordt warm aan één uiteindeHet pulsbereik overschrijdt de mechanische grens van de servoKalibreer het pulsbereik met attach(pin, min, max)
Een 360-gradenservo kruipt als hij zou moeten stoppenHet middelpunt (ongeveer 1500 µs) is verschovenDraai aan de trimpot op de servo of stel de stopwaarde bij

Oorzaak 1: onvoldoende voeding en Arduino-resets

De nummer één oorzaak van trillende servo's en resets is de servo voeden vanaf de 5V-pin van de Arduino. Een SG90 neemt tijdens het wachten maar enkele milliampères op, maar in de eerste milliseconden van een beweging, vooral onder belasting of als de as ergens tegenaan loopt, kan hij boven 650 mA uitkomen. Wordt een Arduino Uno via USB gevoed, dan wordt de 5V-lijn begrensd door de USB-poort van de computer en de zelfherstellende zekering van 500 mA op het board. Bij een plotselinge stroomvraag kan de 5V-lijn onder 4 V zakken. Hoewel de brownout-beveiliging van de ATmega328P pas bij ongeveer 2,7 V ingrijpt, heeft die dip de regelschakeling van de servo, sensoren en seriële communicatie al verstoord. Zakt de spanning ver genoeg, dan start de microcontroller opnieuw op, draait de code weer vanaf setup(), gaat de servo terug naar zijn startpositie, trekt opnieuw stroom en zit je vast in een lus. Dit is het klassieke geval van een Arduino die uit zichzelf reset.

Het probleem bevestigen is eenvoudig: sluit een multimeter aan tussen 5V en GND en beweeg de servo. Zakt de gemeten spanning onder 4,6 V of springt de waarde heen en weer terwijl de servo beweegt, dan is de voeding de oorzaak. Voed de servo's om dit op te lossen via een aparte voeding en baseer je stroomberekening op de blokkeerstroom: voor een robotarm met vier SG90's is 4 × 0,7 A = 2,8 A, dus een adapter van minstens 5 V 3 A of een LM2596 step-downconverter is verstandig. Reken bij krachtige servo's zoals de MG996R op 2,5 A per servo. Op batterijen werken 4 AA-cellen (ongeveer 6 V met alkaline, 4,8 V met NiMH) of 6 V teruggebracht van een 2S Li-ion-pack goed; met de batterijduurcalculator zie je vooraf hoe lang je project meegaat.

Voed de servo niet met een 9V-batterij of via de VIN-pin van de Arduino. Een 9V-batterij kan de piekstroom van de servo niet leveren en de spanning ligt boven de limiet van 6 V van de SG90, waardoor de regelschakeling van de servo beschadigd kan raken. Om één kleine SG90 zonder belasting te testen is de 5V-pin vaak genoeg, maar elke toepassing met twee of meer servo's of met enige belasting heeft een externe voeding nodig.

Juiste bedrading: externe voeding en gemeenschappelijke GND

ServodraadArduino UnoESP32Raspberry Pi PicoExterne voeding 5–6 V
Bruin / zwart (GND)GNDGNDGNDMin (-)
Rood (V+)Niet aangeslotenNiet aangeslotenNiet aangeslotenPlus (+)
Oranje / geel (signaal)D9GPIO 18GP15Niet aangesloten
GND van de externe voedingGND (gemeenschappelijk)GND (gemeenschappelijk)GND (gemeenschappelijk)Min (-)

De belangrijkste rij in deze tabel is de laatste. De servo meet de puls op de signaaldraad ten opzichte van zijn eigen GND. Als de min van de externe voeding niet met de GND van de Arduino is verbonden, heeft het signaal geen referentiepunt; de servo leest dan strooispanningen op de draden en via het net binnenkomende interferentie als willekeurige pulsen en begint uit zichzelf te draaien. In het artikel GND en gemeenschappelijke massa hebben we uitgebreid uitgelegd waarom een gemeenschappelijke massa essentieel is. Werk je op een breadboard, dan is de MB102-voedingsmodule een handige manier om de servorail te voeden; de regelaar is in de praktijk echter beperkt tot ongeveer 700–800 mA, dus hij is hooguit geschikt voor een of twee kleine servo's.

Verbind de plus (+) van de externe voeding nooit met de 5V-pin van de Arduino; twee verschillende bronnen zouden elkaar tegenwerken en kunnen stroom terug de USB-poort in duwen. De enige lijn die je verbindt is GND. Het is een goede gewoonte om eerst GND aan te sluiten, dan de voeding en als laatste de signaaldraad.

Een condensator toevoegen: welke waarde en waar?

Ook met een externe voeding ontstaan er elke keer dat de servomotor start stroompulsen van enkele milliseconden. Zijn de draden dun en lang, dan veroorzaken deze pulsen kortstondige dips in de spanning; de regelschakeling van de servo wordt tijdens die dips instabiel en het trillen begint. De oplossing is een lokale energiebuffer op de servovoedingslijn: sluit zo dicht mogelijk bij de servoconnector een 470–1000 µF elektrolytische condensator aan tussen plus en min, met een keramische condensator van 100 nF parallel. De elco levert de grote, kortdurende stroomvraag, terwijl de keramische condensator de hoogfrequente ruis van de motorborstels wegfiltert. De spanningswaarde van de condensator moet minstens 1,5–2 keer de voedingsspanning zijn; voor een servolijn van 5–6 V is een condensator van 10 V of 16 V geschikt. Bij meerdere servo's werkt een aparte 470 µF naast elke servo beter dan één grote condensator.

Het lange pootje van een elco is plus (+) en het pootje aan de kant met de streep op de behuizing is min (-). Een verkeerd om aangesloten condensator wordt warm en kan openbarsten. Om opdrukken zoals "104" op keramische condensatoren te ontcijferen kun je de condensatorcodecalculator gebruiken; 104 betekent 100 nF.

Signaalruis en draadlay-out

  • Houd draden kort: Maak de signaaldraad van de servo liever niet langer dan 50 cm. Moet je hem verlengen, draai dan de signaal- en GND-draad in elkaar (twisted pair).
  • Voeg een serieweerstand toe: Een weerstand van 220–470 Ω tussen de boardpin en de signaaldraad van de servo vermindert reflecties en rinkelen op lange lijnen; hij beschermt de pin ook tegen kortsluiting.
  • Scheid voeding en signaal: Leg draden met motor- of relaisstroom niet parallel aan de servosignaallijn; moeten ze elkaar kruisen, kruis ze dan haaks.
  • Controleer het breadboardcontact: Losse jumperdraden en versleten breadboardcontacten veroorzaken kortstondige uitval; verandert het trillen als je een draad aanraakt, dan is het contact de oorzaak.
  • Potmeterruis: Stuur je de servo aan met een potmeter, dan schommelt de analogRead-waarde met een paar eenheden en die schommeling gaat rechtstreeks in de hoek. Een condensator van 100 nF tussen de loper van de potmeter en GND, plus een filter in de code, lost dit op.
  • 3,3V-signaal: De ESP32 en Pico genereren pulsen van 3,3 V. De meeste servo's, zoals de SG90 en MG996R, herkennen die zonder problemen; voor de zeldzame servo die onbetrouwbaar reageert, kan een logische niveauconverter worden gebruikt.

Trillen voorkomen in code: filter en dode zone

Ook als de hardware in orde is, kan software een servo laten trillen. De meest gemaakte fouten zijn attach() aanroepen bij elke ronde van loop(), de ruwe potmeterwaarde rechtstreeks aan write() geven en de servo helemaal tot zijn fysieke grenzen (0 of 180 graden) duwen. Bij goedkope servo's ligt de mechanische aanslag vaak iets binnen 0 en 180 graden; de servo kan het doel niet bereiken, blijft duwen, zoemt en wordt warm. De onderstaande code neemt drie maatregelen tegelijk: ze maakt de meting vlak met een exponentieel gemiddelde, houdt de hoek binnen 5–175 graden en stuurt de servo pas een nieuw commando als de hoek minstens 2 graden is veranderd. Voor een bredere blik op filtermethoden zie het artikel over sensordata filteren.

C++ (Arduino IDE)
1#include <Servo.h>
2
3const int SERVO_PIN = 9;     // servo sinyal pini / servo signal pin
4const int POT_PIN = A0;      // potansiyometre orta ucu / potentiometer wiper
5const int DEADBAND = 2;      // derece cinsinden ölü bölge / dead band in degrees
6
7Servo servo;
8float filtered = 0;          // filtrelenmiş okuma / filtered reading
9int lastAngle = -1;          // son gönderilen açı / last angle sent
10
11void setup() {
12  servo.write(90);              // attach öncesi başlangıç açısı (AVR) / start angle before attach (AVR)
13  servo.attach(SERVO_PIN);      // yalnızca bir kez / only once
14  filtered = analogRead(POT_PIN);
15}
16
17void loop() {
18  int raw = analogRead(POT_PIN);
19  filtered = filtered * 0.9 + raw * 0.1;            // üstel ortalama / exponential moving average
20  int angle = map((int)filtered, 0, 1023, 5, 175);  // sınırlara dayanma / stay away from end stops
21
22  if (lastAngle < 0 || abs(angle - lastAngle) >= DEADBAND) {
23    servo.write(angle);         // yalnızca belirgin değişimde / only on a real change
24    lastAngle = angle;
25  }
26  delay(15);
27}
Regel / commandoWat het doet
servo.write(90) (vóór attach)Zorgt dat de eerste puls bij 90 graden begint in de standaard AVR Servo-bibliotheek; dit verkleint de sprong bij het opstarten.
filtered = filtered * 0.9 + raw * 0.1Exponentieel voortschrijdend gemiddelde: dempt plotselinge schommelingen en laat langzame veranderingen door. Hoe kleiner de coëfficiënt 0.1, hoe sterker het filter maar hoe trager de reactie.
map(..., 5, 175)Laat de servo draaien zonder hem tegen zijn mechanische aanslagen te duwen.
DEADBAND = 2Stuurt geen nieuw commando als de hoek minder dan 2 graden is veranderd; de dode zone snijdt kleine trillingen weg.
delay(15)Geeft de servo tijd om de nieuwe positie te bereiken en beperkt de leessnelheid.
attach(pin, 500, 2400)Wordt gebruikt om het pulsbereik te kalibreren op de werkelijke grenzen van de servo; de standaardwaarden zijn 544 en 2400 µs.
servo.detach()Stopt de pulsen zodra de servo zijn doel bereikt; het zoemen stopt, maar de servo verliest zijn houdkoppel.

Bibliotheek- en timerconflicten

De standaard Servo-bibliotheek op de Arduino Uno genereert pulsen met de hardware-Timer1 en interrupts. Dankzij dit ontwerp kan één timer tot 12 servo's aansturen, maar het heeft twee bijwerkingen: het kan niet samen draaien met een andere bibliotheek die Timer1 gebruikt, en de nauwkeurigheid van de pulsen hangt ervan af dat interrupts op tijd worden uitgevoerd. Code die interrupts een paar honderd microseconden uitschakelt, rekt de puls die op dat moment wordt gegenereerd op en de servo schokt. Begint het trillen alleen als een bepaalde module actief wordt, dan heb je vrijwel zeker met deze situatie te maken.

  • analogWrite op pin 9 en 10: Als de Servo-bibliotheek wordt gebruikt, werkt PWM niet op deze twee pinnen van de Uno; verplaats een eventuele led of motordriver die hierop is aangesloten naar pin 3, 5, 6 of 11.
  • 433 MHz RF-bibliotheken: VirtualWire en de RH_ASK-driver van RadioHead gebruiken standaard ook Timer1; je krijgt compileerfouten of grillige servobewegingen. Zie het artikel over de 433 MHz RF-module voor details.
  • NeoPixel-strips: Adafruit NeoPixel en FastLED schakelen interrupts uit tijdens het versturen van data; op een lange strip duurt dit milliseconden en de servo schokt bij elke update. Gebruik je een WS2812B samen met een servo, ververs de strip dan minder vaak.
  • SoftwareSerial en DHT: Beide schakelen interrupts kort uit tijdens het ontvangen van bytes of het uitlezen van de sensor; dit is een veelvoorkomende oorzaak van het trillen bij servoarmen die met een Bluetooth-module worden bediend.
  • De blijvende oplossing: Gebruik een PCA9685-servodriver die de pulsen met zijn eigen hardware genereert; zo gaan trillingsvrije signalen naar maximaal 16 servo's, wat de Arduino ook doet.

PWM-instellingen voor servo's op de ESP32

De standaard Arduino Servo-bibliotheek werkt niet op de ESP32; je gebruikt in plaats daarvan de ESP32Servo-bibliotheek of rechtstreeks de ingebouwde LEDC-PWM-eenheid. Omdat LEDC hardwarematig is, heeft het geen last van interrupts en levert het zeer stabiele pulsen; je hoeft alleen de frequentie op 50 Hz te zetten en de resolutie op een voldoende waarde. Bij een resolutie van 14 bit wordt de periode van 20 ms in 16.384 stappen verdeeld; elke stap is ongeveer 1,22 µs, ruim nauwkeurig genoeg voor een servo. We kozen 14 bit omdat nieuwere chips zoals de ESP32-S3 en ESP32-C3 deze waarde ook ondersteunen. Omdat de LEDC-functies zijn veranderd in versie 3.x van de ESP32 Arduino-core, is de onderstaande code zo geschreven dat hij met beide versies compileert:

C++ (Arduino IDE)
1// ESP32 Arduino core 2.x ve 3.x uyumlu / compatible with ESP32 Arduino core 2.x and 3.x
2const int SERVO_PIN = 18;      // güvenli bir GPIO / a safe GPIO
3const int PWM_FREQ = 50;       // 50 Hz = 20 ms periyot / 20 ms period
4const int PWM_BITS = 14;       // ESP32, S3 ve C3 destekler / supported by ESP32, S3 and C3
5const int MIN_US = 500;        // 0 derece darbesi / 0 degree pulse
6const int MAX_US = 2400;       // 180 derece darbesi / 180 degree pulse
7
8#if ESP_ARDUINO_VERSION_MAJOR < 3
9const int PWM_CHANNEL = 0;     // 2.x için LEDC kanalı / LEDC channel for 2.x
10#endif
11
12uint32_t usToDuty(uint32_t us) {
13  return us * ((1UL << PWM_BITS) - 1) / 20000UL;  // mikrosaniyeyi duty değerine çevir / convert microseconds to duty
14}
15
16void servoWriteUs(uint32_t us) {
17#if ESP_ARDUINO_VERSION_MAJOR >= 3
18  ledcWrite(SERVO_PIN, usToDuty(us));     // 3.x: pin numarası / pin number
19#else
20  ledcWrite(PWM_CHANNEL, usToDuty(us));   // 2.x: kanal numarası / channel number
21#endif
22}
23
24void servoWriteAngle(int angle) {
25  angle = constrain(angle, 0, 180);
26  servoWriteUs(map(angle, 0, 180, MIN_US, MAX_US));
27}
28
29void setup() {
30#if ESP_ARDUINO_VERSION_MAJOR >= 3
31  ledcAttach(SERVO_PIN, PWM_FREQ, PWM_BITS);
32#else
33  ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_BITS);
34  ledcAttachPin(SERVO_PIN, PWM_CHANNEL);
35#endif
36  servoWriteAngle(90);           // başlangıç konumu / start position
37}
38
39void loop() {
40  for (int a = 30; a <= 150; a++) {   // yumuşak tarama / smooth sweep
41    servoWriteAngle(a);
42    delay(15);
43  }
44  for (int a = 150; a >= 30; a--) {
45    servoWriteAngle(a);
46    delay(15);
47  }
48}

Er zijn nog twee ESP32-specifieke valkuilen. De eerste zijn bootpinnen: pinnen zoals GPIO 0, 2, 12, 14 en 15, en ook de seriële pinnen 1 en 3, kunnen tijdens het opstarten korte pulsen geven; zit de servo op deze pinnen, dan springt hij bij elke reset. GPIO 13, 18, 19, 23, 25, 26, 27, 32 en 33 zijn veilige keuzes voor servo's; pin 34–39 zijn alleen ingang en kunnen geen servo aansturen. De tweede is gevoeligheid voor de voeding: met wifi aan trekt de ESP32 zelf al stroompulsen boven 300 mA en wordt de servo van dezelfde rail gevoed, dan zie je de melding "Brownout detector was triggered" in de Serial Monitor. De oplossing voor deze fout behandelden we in het artikel ESP32 brownout en Guru Meditation; kort gezegd: voed de servo met een aparte voeding en verbind de GND's.

Servo op de Raspberry Pi Pico (MicroPython)

Elke GPIO-pin van de Raspberry Pi Pico kan hardware-PWM genereren; de chip heeft in totaal 8 PWM-slices en 16 kanalen. Als je in MicroPython de frequentie van het PWM-object op 50 Hz zet, kun je de pulsbreedte met duty_ns() rechtstreeks in nanoseconden opgeven; dat is veel veiliger dan prutsen met percentages of 16-bit-dutyberekeningen. De onderstaande code bestuurt de servo op GP15 met de potmeter op GP26 en past precies dezelfde filter- en dodezonelogica toe als het Arduino-voorbeeld. De 3V3-uitgang van de Pico is qua spanning en stroom niet geschikt om een servo te voeden; voed de servo met een externe voeding van 5 V en maak de GND gemeenschappelijk.

MicroPython
1from machine import Pin, PWM, ADC
2import time
3
4servo = PWM(Pin(15))          # servo sinyali GP15 / servo signal on GP15
5servo.freq(50)                # 50 Hz = 20 ms
6pot = ADC(26)                 # potansiyometre GP26 (ADC0) / potentiometer on GP26 (ADC0)
7
8MIN_US = 500                  # 0 derece / 0 degrees
9MAX_US = 2400                 # 180 derece / 180 degrees
10DEADBAND = 2                  # ölü bölge (derece) / dead band (degrees)
11
12def write_angle(angle):
13    angle = max(5, min(175, angle))              # sınırlara dayanma / stay away from end stops
14    us = MIN_US + (MAX_US - MIN_US) * angle // 180
15    servo.duty_ns(us * 1000)                     # mikrosaniye -> nanosaniye / microseconds -> nanoseconds
16
17filtered = pot.read_u16()
18last = -100
19write_angle(90)               # başlangıç konumu / start position
20
21while True:
22    filtered = filtered * 0.9 + pot.read_u16() * 0.1   # üstel ortalama / exponential moving average
23    angle = int(filtered * 180 / 65535)
24    if abs(angle - last) >= DEADBAND:
25        write_angle(angle)
26        last = angle
27    time.sleep_ms(20)

Checklist stap voor stap

  1. Koppel de servo los van het board en voed hem alleen met een externe voeding van 5–6 V; zorg dat de stroom van de voeding het aantal servo's × blokkeerstroom dekt.
  2. Verbind de GND van de externe voeding met de GND van de Arduino, ESP32 of Pico; deze ene draad maakt een eind aan de meeste problemen met "uit zichzelf draaien".
  3. Meet terwijl de servo beweegt de voedingsspanning met een multimeter; zakt die onder 4,6 V, gebruik dan een sterkere voeding of dikkere draden.
  4. Plaats een elco van 470–1000 µF en een keramische condensator van 100 nF naast de servoconnector en controleer de polariteit.
  5. Maak de signaaldraad korter, voeg zo nodig een serieweerstand van 220–470 Ω toe en zorg voor stevige breadboardcontacten.
  6. Controleer in de code dat attach() alleen in setup() wordt aangeroepen, dat de hoek binnen 5–175 graden blijft en dat je een filter en dode zone gebruikt.
  7. Trilt de servo als een andere module draait, zoek dan het conflict door bibliotheken een voor een uit te schakelen; stap zo nodig over op een PCA9685.
  8. Trilt hij nog steeds, probeer dan een andere servo; servo's met een versleten potmeter of kapotte tandwielen trillen onder alle omstandigheden.

Aandachtspunten bij servoprojecten

  • Robotarm: Beweeg bij een robotarm met vier of zes servo's niet alle servo's tegelijk; laat de commando's 100–200 ms na elkaar volgen zodat de stroompieken niet opstapelen.
  • Radarproject: Draai bij projecten die continu scannen, zoals een Arduino-radar, de servo graad voor graad en wacht bij elke stap 15–30 ms; plotselinge grote sprongen betekenen zowel trillen als een stroompiek.
  • Zware belasting: Gebruik voor taken met belasting, zoals een deurslot of een cameraophanging, een MG996R met metalen tandwielen in plaats van een SG90 en kies een voeding van minstens 3 A.
  • Servo's met continue rotatie: Als 360-gradenservo's zoals de FS90R op het stoppunt kruipen, is dat geen trillen maar een kalibratieprobleem; stel de stopwaarde bij rond 1500 µs.
  • Projecten op batterijen: De servo loslaten met detach() als de beweging klaar is stopt het zoemen en verlengt de batterijduur; dit is erg effectief als het mechanisme niet doorzakt onder zijn eigen gewicht.

Een trillende servo lijkt in eerste instantie ingewikkeld, maar wordt bijna altijd in dezelfde volgorde opgelost: eerst de voeding, dan de gemeenschappelijke GND, dan de condensator, dan de bedrading en als laatste de software. Als je deze volgorde volgt, hoef je zelden de servo zelf te vervangen. Voor de details van stroomberekeningen kun je ook de gids Arduino-voeding raadplegen. In de BlueGrays-app vind je stap voor stap de schakelschema's en code voor projecten zoals servobesturing met een potmeter, joystickservo, ESP32-servo en een RFID-deurslot, zodat je wat je hier leert meteen kunt toepassen.

Veelgestelde vragen

Waarom trilt een servomotor?

De meest voorkomende oorzaak van een trillende servo is een onvoldoende of schommelende voedingsspanning; wordt de servo gevoed vanaf de 5V-pin van de Arduino, dan zakt de spanning bij plotselinge stroomvraag en wordt de regelschakeling instabiel. Een ontbrekende gemeenschappelijke GND, een ruisend signaal, springerige potmeterwaarden en de servo tegen zijn mechanische grens dwingen kunnen het ook veroorzaken. Een externe voeding van 5–6 V, een gemeenschappelijke GND en een condensator van 470–1000 µF lossen de meeste problemen op.

Waarom draait mijn servomotor uit zichzelf?

Draait de servo zonder commando, dan heeft de signaallijn meestal geen referentie: de GND van de externe voeding is niet verbonden met de GND van de Arduino, of de signaaldraad zit los. De servo behandelt interferentie op de draden dan als pulsen. Bij 360-gradenservo's komt langzaam draaien doordat de kalibratie van het middelpunt (ongeveer 1500 µs) is verschoven; dat corrigeer je met de trimpot op de servo.

Waarom reset mijn Arduino als de servo draait?

Bij het starten van een beweging kan een servo honderden milliampères trekken, en bij grote servo's meer dan 2 A. Wordt die stroom van de USB- of regelaarlijn van de Arduino genomen, dan stort de 5 V in en start de microcontroller opnieuw. Zodra je de servo met een aparte voeding voedt en alleen de GND's verbindt, stoppen de resets.

Hoeveel µF condensator moet ik voor een servo gebruiken?

Voor één SG90 of MG90S is 470 µF bij de servoconnector een goed begin; gebruik voor grote servo's zoals de MG996R een elco van 1000 µF. Een keramische condensator van 100 nF ernaast filtert ook hoogfrequente ruis. De spanningswaarde van de condensator moet minstens 10 V zijn voor een lijn van 5–6 V en de polariteit moet juist zijn aangesloten.

Kan ik een servomotor voeden vanaf de 5V-pin van de Arduino?

Om één SG90 zonder belasting te testen is de 5V-pin vaak genoeg, maar het is geen betrouwbare oplossing. De USB-lijn is beperkt tot ongeveer 500 mA en een geblokkeerde servo overschrijdt dat. Gebruik je twee of meer servo's, een servo met belasting of een MG996R, gebruik dan altijd een externe voeding.

Waarom trilt mijn servo of werkt hij niet op de ESP32?

De standaard Arduino Servo-bibliotheek werkt niet op de ESP32; je moet de ESP32Servo-bibliotheek of LEDC-PWM op 50 Hz gebruiken. Sluit je de servo aan op bootpinnen zoals GPIO 0, 2, 12 of 15, dan veroorzaakt dat sprongen bij een reset, en voeden vanaf de eigen rail van de ESP32 geeft brownout-fouten. Een veilige pin zoals GPIO 18 en een aparte voeding van 5 V lossen het probleem op.

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