Componenten · 10 min leestijd

360-gradenservo (FS90R): snelheid en richting met Arduino

Hoe werkt de FS90R 360-gradenservo? Stoppen met write(90), snelheid en richting regelen, de stoptrimmer, gebruik als robotwiel, PWM-code voor ESP32 en Pico.

Een 360-gradenservo heet misschien een servo, maar eigenlijk is het een kleine motor met tandwielkast die blijft draaien in plaats van naar een hoek te gaan en daar te stoppen. De bekendste is de FEETECH FS90R: hij heeft hetzelfde formaat en dezelfde drie draden als een SG90, maar het signaal dat je stuurt bepaalt zijn draaisnelheid en draairichting in plaats van een hoek. Omdat hij zonder motordriver direct op een Arduino-pin past, is hij erg handig voor kleine robotwielen, draaitafels en toepassingen zoals een voerautomaat voor huisdieren.

In deze gids leer je wat er in de FS90R anders is dan in een gewone servo, waarom het commando write(90) de motor stopt, hoe je snelheid en richting instelt met pulsbreedte en hoe je met de stoptrimmer een servo repareert die blijft kruipen. Daarna stuur je een kleine robot aan met twee FS90R's, regel je de snelheid met een potentiometer en probeer je hetzelfde op een ESP32 en een Raspberry Pi Pico. Tot slot zie je waarom deze servo geen positieregeling kan en wat je dan beter kiest.

FS90R 360-gradenservo met continue rotatie
FS90R-servo met continue rotatie: formaat SG90, 9 gram. Het signaal bepaalt snelheid en draairichting, niet de hoek.

Wat is een 360-gradenservo en hoe verschilt hij van een gewone servo?

Een gewone servo bevat een kleine gelijkstroommotor, een tandwielkast, een regelschakeling en een potentiometer die aan de uitgaande as is gekoppeld. De regelschakeling vergelijkt de hoek die de binnenkomende puls vraagt met de werkelijke hoek die de potentiometer meet en laat de motor draaien tot het verschil nul is; zodra de as het doel bereikt, stopt hij. Bij een servo met continue rotatie is deze terugkoppeling verbroken: de potentiometer is losgekoppeld van de as en vastgezet in zijn middenstand, en de mechanische aanslag in de tandwielen is verwijderd. De schakeling berekent nog steeds het "verschil tussen doel en werkelijke positie", maar omdat de werkelijke positie nooit verandert, wordt dat verschil nooit kleiner. Het gevolg: hoe groter het verschil, hoe sneller de motor draait, en het teken van het verschil bepaalt de richting.

EigenschapSG90 (180° servo)FS90R (continue rotatie 360°)
Wat bepaalt het signaal?De hoek van de as (0–180°)Draaisnelheid en draairichting
Puls van 1500 µsGaat naar het midden (90°) en blijft daarStopt
1000 µs / 2000 µsGaat naar het ene of het andere uiteindeVolle snelheid in de ene of de andere richting
Interne terugkoppelingPotentiometer gekoppeld aan de asGeen; de potentiometer bepaalt alleen het stoppunt
Mechanische aanslagJaNee, hij draait eindeloos door
Positie vasthoudenHoudt zijn hoek aan onder belastingKan niet; hij weet niet waar hij gestopt is
Typisch gebruikArmen, deksels, besturingWielen, draaitafels, schroeftransporteurs

Specificaties van de FS90R

EigenschapWaarde
Voedingsspanning4,8–6 V
Snelheid zonder belastingOngeveer 100–110 tpm bij 4,8 V, ongeveer 130 tpm bij 6 V
BlokkeermomentOngeveer 1,3 kg·cm bij 4,8 V, ongeveer 1,5 kg·cm bij 6 V
Stroom100–130 mA zonder belasting, tot 800 mA bij 6 V als hij geblokkeerd is
Stuursignaal50 Hz PWM; stop bij 1500 µs, bruikbaar bereik ongeveer 900–2100 µs
SignaalniveauWerkt met signalen van 5 V en 3,3 V
RichtingBoven 1500 µs de ene kant op, eronder de andere kant (gezien vanaf de uitgaande as is boven 1500 µs tegen de klok in)
Gewicht en afmetingen9 g, ongeveer 23 × 12 × 22 mm (dezelfde behuizing als de SG90)
DradenBruin GND, rood VCC, oranje signaal
Niet elk product dat verkopers een "360-gradenservo" noemen, is een servo met continue rotatie. Sommige servo's houden een positie aan tussen 0 en 360° (of 0–270°); ze draaien niet eindeloos door zoals de FS90R, maar gaan naar de gevraagde hoek en stoppen. Zoek in de productbeschrijving naar continue rotatie. Houd er ook rekening mee dat je de motor en de plastic tandwielen verpest als je een FS90R lang geblokkeerd forceert, met de hand of tegen een obstakel.

Bedrading van de FS90R: Arduino Uno, ESP32 en Pico

ServodraadFunctieArduino UnoESP32Raspberry Pi Pico
BruinGNDGNDGNDGND
RoodVoeding 4,8–6 V5V (één servo) of externe 5 VVIN / 5V of externe 5 VVBUS (5 V) of externe 5 V
OranjePWM-signaalD9GPIO 18GP15

De 5V-pin van de Uno is genoeg om één FS90R zonder belasting te laten draaien. Zodra het wiel van de servo de grond raakt of twee servo's tegelijk starten, springt de stroom naar enkele honderden milliampères; de USB-spanning zakt in, de Arduino kan resetten of de servo's trillen. Voed de servo's in een robot daarom uit een aparte 5V-bron (4 NiMH-cellen, een 5V-regelaar of een geschikte voeding), verbind de GND van de servovoeding altijd met de GND van de Arduino en plaats een condensator van 470 µF vlak bij de servodraden. Het 3,3V-signaal van de ESP32 en de Pico is genoeg voor de FS90R; de servo zelf moet nog steeds op 5 V worden gevoed, niet op de 3,3V-pin.

write(90) = stop: hoe wordt pulsbreedte snelheid?

Het stuursignaal van de servo is een puls die 50 keer per seconde (elke 20 ms) wordt verstuurd, en wat telt is de lengte van de puls. Bij de FS90R betekent 1500 µs "stop". Wordt de puls langer dan 1500 µs, dan gaat de servo steeds sneller in de ene richting; wordt hij korter, dan sneller in de andere richting; rond 1000 µs en 2000 µs bereikt hij volle snelheid, en daarbuiten neemt de snelheid nauwelijks toe. Daarom betekent write(90) in de Servo-bibliotheek van Arduino stop, en betekenen write(0) en write(180) volle snelheid in elke richting. Er zit een kleine valkuil in: standaard rekent de bibliotheek 0–180 om naar het bereik 544–2400 µs, waardoor write(90) in werkelijkheid 1472 µs uitstuurt. Dat verschil kan genoeg zijn om de servo zelfs bij write(90) te laten kruipen. De oplossing is het bereik te verkleinen met attach(9, 1000, 2000) of direct writeMicroseconds(1500) te gebruiken.

PulsGelijkwaardig met Servo.write (met attach(pin, 1000, 2000))Gedrag van de FS90R
1000 µswrite(0)Volle snelheid, met de klok mee
1300 µswrite(54)Gemiddelde snelheid, met de klok mee
1461 µswrite(83)Heel langzaam, met de klok mee
1500 µswrite(90)Stop (als de trimmer goed is ingesteld)
1538 µswrite(97)Heel langzaam, tegen de klok in
1700 µswrite(126)Gemiddelde snelheid, tegen de klok in
2000 µswrite(180)Volle snelheid, tegen de klok in

Eerste sketch: vooruit, stop, achteruit

C++ (Arduino IDE)
1// FS90R ilk test: ileri, dur, geri / FS90R first test: forward, stop, backward
2#include <Servo.h>
3
4Servo teker;                         // sürekli dönüş servosu / continuous rotation servo
5
6void setup() {
7  teker.attach(9, 1000, 2000);       // write(0..180) artık 1000..2000 µs üretir / write(0..180) now outputs 1000..2000 µs
8}
9
10void loop() {
11  teker.write(180);                  // tam hız bir yöne / full speed one way
12  delay(2000);
13  teker.write(90);                   // 1500 µs: dur / 1500 µs: stop
14  delay(1000);
15  teker.write(0);                    // tam hız ters yöne / full speed the other way
16  delay(2000);
17  teker.write(110);                  // yavaş / slow
18  delay(2000);
19  teker.writeMicroseconds(1500);     // durmanın en kesin yolu / the most precise way to stop
20  delay(1000);
21}

De sketch koppelt de servo aan D9 en zet met attach(9, 1000, 2000) de write()-schaal om naar het bereik dat de FS90R echt gebruikt, zodat write(90) precies 1500 µs is. De snelheid volgt de puls niet lineair: vlak rond 1500 µs ligt een dode zone van enkele tientallen microseconden waarin de servo niet beweegt, binnen 1500 ± 300 µs stijgt de snelheid snel en richting de uiteinden blijft hij vrijwel constant. Wil je langzame, precieze bewegingen, houd de waarden dan dicht bij 1500 µs. Het algemene idee van pulsbreedte staat in Wat is PWM, en hoekregeling met gewone servo's in Wat is een servomotor.

De stoptrimmer (middenpunt) afstellen

  1. Upload de kalibratiesketch hieronder; de servo krijgt een signaal van 1500 µs en hoort dan normaal te stoppen.
  2. Als de servo kruipt, zoek dan het kleine gaatje aan de zijkant van de behuizing bij de kabeluitgang; daarin zit de trimmer die het stoppunt instelt.
  3. Draai de trimmer heel weinig met een klein plat of kruiskopschroevendraaiertje; als de servo langzamer gaat, draai je de goede kant op.
  4. Ga in kleine stapjes door tot de servo helemaal stilstaat en zelfs het zwakke gezoem verdwijnt. De trimmer is erg gevoelig; zelfs een kwartslag is te veel.
  5. Wil je de trimmer niet aanraken, stuur dan + en - via de Serial Monitor om de pulswaarde te vinden waarbij de servo stopt, en gebruik die waarde in je code in plaats van 1500.
C++ (Arduino IDE)
1// Durma noktası ayarı: Serial Monitor'den µs değeri gönder
2// Stop point calibration: send a µs value from the Serial Monitor
3#include <Servo.h>
4
5Servo teker;
6int darbe = 1500;                    // başlangıç: teorik durma noktası / start: theoretical stop point
7
8void setup() {
9  Serial.begin(9600);
10  teker.attach(9);
11  teker.writeMicroseconds(darbe);
12  Serial.println(F("Sayi yaz (900-2100) ya da + / - gonder"));
13  Serial.println(F("Type a number (900-2100) or send + / -"));
14}
15
16void loop() {
17  if (Serial.available()) {
18    char c = Serial.peek();
19    if (c == '+') { Serial.read(); darbe += 5; }          // 5 µs artır / add 5 µs
20    else if (c == '-') { Serial.read(); darbe -= 5; }     // 5 µs azalt / subtract 5 µs
21    else if (isDigit(c)) darbe = Serial.parseInt();       // doğrudan değer / direct value
22    else { Serial.read(); return; }                       // satır sonu vb. atla / skip line endings etc.
23
24    darbe = constrain(darbe, 900, 2100);
25    teker.writeMicroseconds(darbe);
26    Serial.print(F("Darbe / pulse: "));
27    Serial.print(darbe);
28    Serial.println(F(" us"));
29  }
30}
Het stoppunt kan een paar microseconden verschuiven met de voedingsspanning en de temperatuur; schrik dus niet als de servo weer licht gaat kruipen wanneer de batterijen leeg raken. Voor lange pauzes waarin de servo helemaal stil moet staan, kun je het signaal volledig afsnijden met detach(): een FS90R zonder signaal stopt en verbruikt bijna geen stroom. Roep gewoon weer attach() aan wanneer hij moet bewegen.

Snelheid en richting regelen met een potentiometer

C++ (Arduino IDE)
1// Potansiyometreyle hız ve yön: ortada dur, sağa ileri, sola geri
2// Speed and direction with a pot: centre = stop, right = forward, left = backward
3#include <Servo.h>
4
5const int POT_PIN = A0;
6const int OLU_BOLGE = 40;            // ortadaki ±40 adım: kesin dur / ±40 steps in the middle: solid stop
7Servo teker;
8
9void setup() {
10  teker.attach(9);
11}
12
13void loop() {
14  int okuma = analogRead(POT_PIN) - 512;                   // -512 ... +511
15  int darbe = 1500;                                        // varsayılan: dur / default: stop
16  if (okuma > OLU_BOLGE) {
17    darbe = map(okuma, OLU_BOLGE, 511, 1540, 2000);        // ileri, yavaştan hızlıya / forward, slow to fast
18  } else if (okuma < -OLU_BOLGE) {
19    darbe = map(okuma, -OLU_BOLGE, -512, 1460, 1000);      // geri / backward
20  }
21  teker.writeMicroseconds(darbe);
22  delay(20);                                               // servo periyodu kadar / one servo period
23}

Met de potentiometer aangesloten tussen 5V, A0 en GND betekent de middenstand stop, naar rechts draaien vooruit en naar links draaien achteruit. De code definieert in het midden een dode zone van ±40 stappen, zodat de servo betrouwbaar stopt, ook als de potentiometer niet exact gecentreerd staat of de metingen een beetje schommelen. Buiten de dode zone wordt de waarde omgezet naar 1540–2000 µs of 1460–1000 µs, zodat een klein draaiing aan de knop de servo langzaam laat draaien en helemaal omdraaien volle snelheid geeft. Hetzelfde idee kun je toepassen met een joystick; de bedrading van de potentiometer staat in Wat is een potentiometer.

De FS90R als klein robotwiel

De FS90R is zo populair in robots omdat hij simpel is: met de ingebouwde tandwielkast en driverschakeling heb je geen aparte motordriver, H-brug of encoder nodig; één signaalpin per wiel is genoeg. De twee servo's worden als spiegelbeeld aan weerszijden van het chassis gemonteerd, dus om vooruit te rijden moet de ene met de klok mee draaien en de andere tegen de klok in. De code hieronder regelt dit in de functie surus(); jij geeft alleen een snelheid tussen -100 en +100. Een wiel van 60 mm dat bij 6 V met 130 tpm draait, legt ongeveer 0,4 meter per seconde af; bij 4,8 V zakt dat naar ongeveer 0,3 m/s.

C++ (Arduino IDE)
1// İki FS90R ile küçük robot: tekerlekler ayna gibi takılır
2// A small robot with two FS90Rs: the wheels are mounted as mirror images
3#include <Servo.h>
4
5Servo sol, sag;
6const int DUR_SOL = 1500;            // kalibrasyonla bulduğun değerler / values you found during calibration
7const int DUR_SAG = 1500;
8
9// hiz: -100 (tam geri) ... +100 (tam ileri) / speed: -100 (full back) ... +100 (full forward)
10void surus(int hizSol, int hizSag) {
11  sol.writeMicroseconds(DUR_SOL + hizSol * 5);             // sol teker normal yönde / left wheel normal direction
12  sag.writeMicroseconds(DUR_SAG - hizSag * 5);             // sağ teker ters takılı / right wheel is mounted reversed
13}
14
15void setup() {
16  sol.attach(9);
17  sag.attach(10);
18  surus(0, 0);
19  delay(1000);
20}
21
22void loop() {
23  surus(80, 80);    delay(1500);     // ileri / forward
24  surus(0, 0);      delay(500);      // dur / stop
25  surus(-60, 60);   delay(600);      // yerinde sola dön / spin left in place
26  surus(60, 60);    delay(1000);
27  surus(30, 80);    delay(1500);     // sola doğru yay çiz / curve to the left
28  surus(-80, -80);  delay(1000);     // geri / backward
29  surus(0, 0);      delay(2000);
30}

Twee servo's draaien nooit exact even snel; als je robot naar één kant afwijkt in plaats van rechtdoor te rijden, kalibreer dan het stopwaarde van elke servo (DUR_SOL, DUR_SAG) apart en verlaag de factor van de snellere iets. Het koppel van 1,5 kg·cm van de FS90R past bij kleine robots van niet meer dan een paar honderd gram; voor een zwaarder chassis of grote wielen zijn een gelijkstroommotor met een L298N of motoren met tandwielkast een betere keuze. Op batterijen geven 4 NiMH-cellen (4,8 V) de ideale spanning; 4 nieuwe alkalinecellen kunnen 6,4 V halen en de limiet van de servo overschrijden. Voor een volledig chassis en sensoropbouw, zie Een Arduino-robotauto bouwen.

Met een FS90R kun je geen positieregeling doen. Omdat er in de servo niets meer is dat meet waar de as staat, kun je niet zeggen "draai 90 graden en stop"; ook tijdgebaseerde bewegingen zoals "draai 1 seconde" geven elke keer een ander resultaat, afhankelijk van batterijspanning, belasting en temperatuur. Heb je een bepaalde hoek nodig, gebruik dan een gewone servo, een stappenmotor voor nauwkeurige stap-voor-stapdraaiing, of voeg een encoder aan het wiel toe om de omwentelingen te tellen. Welke motor je wanneer kiest, lees je in Gelijkstroommotor, servo of stappenmotor.

FS90R met de ESP32

De Servo-bibliotheek van Arduino werkt niet op de ESP32; installeer in plaats daarvan de bibliotheek ESP32Servo via de Library Manager. Het gebruik is bijna hetzelfde, behalve dat je 50 Hz expliciet instelt met setPeriodHertz(50). Bijna elke GPIO die PWM kan uitsturen werkt voor het signaal; alleen GPIO 34–39, die uitsluitend ingang zijn, kun je hiervoor niet gebruiken. Sluit de rode draad van de servo aan op de VIN-pin (USB 5 V) van de ESP32 of op een externe 5V-voeding, niet op de 3V3-pin. De code hieronder laat de servo zachtjes optrekken van stilstand tot volle snelheid, vertraagt hem daarna en laat hem omkeren; de Serial Monitor toont bij elke stap de pulslengte.

C++ (Arduino IDE)
1// ESP32 + FS90R: ESP32Servo kütüphanesiyle hız rampası
2// ESP32 + FS90R: a speed ramp with the ESP32Servo library
3#include <ESP32Servo.h>
4
5const int SERVO_PIN = 18;            // PWM verebilen herhangi bir GPIO / any PWM-capable GPIO
6Servo teker;
7
8void setup() {
9  Serial.begin(115200);
10  teker.setPeriodHertz(50);          // standart servo frekansı / standard servo frequency
11  teker.attach(SERVO_PIN, 1000, 2000);
12  teker.writeMicroseconds(1500);     // dur / stop
13  delay(1000);
14}
15
16void loop() {
17  for (int us = 1500; us <= 2000; us += 25) {   // yavaşça hızlan / speed up gently
18    teker.writeMicroseconds(us);
19    Serial.println(us);
20    delay(200);
21  }
22  for (int us = 2000; us >= 1000; us -= 25) {   // yavaşla, dur, ters yöne hızlan / slow down, stop, reverse
23    teker.writeMicroseconds(us);
24    Serial.println(us);
25    delay(200);
26  }
27  teker.writeMicroseconds(1500);
28  delay(2000);
29}

FS90R met de Raspberry Pi Pico en MicroPython

Op de Pico heb je geen extra bibliotheek nodig: stel het machine.PWM-object in op 50 Hz en geef de pulslengte in nanoseconden op met duty_ns(). De functie hiz() in de code zet een waarde tussen -100 en +100 om naar 1000–2000 µs; zet gewoon de stopwaarde die je bij je eigen kalibratie hebt gevonden op de regel DUR_US. Wordt het programma met Ctrl+C gestopt, dan stopt ook de servo; anders blijft de PWM met de laatste waarde doorlopen en blijft het wiel draaien. Voed de servo vanuit de VBUS-pin van de Pico (de 5 V van de USB). Ben je nieuw met MicroPython, lees dan eerst MicroPython-basis.

MicroPython
1# Raspberry Pi Pico (MicroPython) + FS90R: hız -100 ... +100
2# Raspberry Pi Pico (MicroPython) + FS90R: speed -100 ... +100
3from machine import Pin, PWM
4import time
5
6servo = PWM(Pin(15))
7servo.freq(50)                        # 20 ms periyot / 20 ms period
8DUR_US = 1500                         # kalibrasyonla bulduğun durma noktası / your calibrated stop point
9
10def hiz(yuzde):
11    yuzde = max(-100, min(100, yuzde))
12    us = DUR_US + yuzde * 5           # -100 -> 1000 µs, +100 -> 2000 µs
13    servo.duty_ns(us * 1000)
14
15try:
16    while True:
17        for h in (50, 100, 0, -50, -100, 0):
18            hiz(h)
19            print("Hiz / speed:", h)
20            time.sleep(2)
21except KeyboardInterrupt:
22    hiz(0)                            # durdurunca teker dönmeye devam etmesin / stop the wheel on exit
23    servo.deinit()

Projectideeën met een 360-gradenservo

  • Mini-lijnvolger: Een licht chassis met twee FS90R's en twee infraroodsensoren; de logica staat in lijnvolgrobot.
  • Obstakelvermijdende robot: Plaats voorop een HC-SR04, zodat hij ter plekke draait en van richting verandert zodra hij een obstakel ziet.
  • Auto bestuurd met je telefoon: Stuur commando's vanaf je telefoon met een HC-05 Bluetooth-module.
  • Voerautomaat voor huisdieren: Laat de FS90R een transportschroef draaien, zodat er op ingestelde tijden voer valt via een timer.
  • Draaitafel voor presentaties: Een heel langzaam draaiend platform voor productfoto's of time-lapse-opnamen; stel de snelheid in met waarden dicht bij 1500 µs.
  • Kleine lier of gordijnopener: Wikkel een licht koord op, met twee eindschakelaars aan de uiteinden om de motor op de juiste plek te stoppen.

Veelvoorkomende problemen en oplossingen

SymptoomWaarschijnlijke oorzaakOplossing
Hij kruipt langzaam, zelfs met write(90)De standaardschaal geeft 1472 µs of de stoptrimmer staat verkeerdGebruik attach(pin, 1000, 2000) of writeMicroseconds(1500), stel de trimmer bij
De servo draait helemaal nietVerkeerde signaalpin, GND niet gedeeld, of het product is eigenlijk een positieservoControleer het pinnummer en de GND-verbinding, zorg dat het een servo met continue rotatie is
De servo trilt en de Arduino resetDe USB-voeding kan de stroompieken niet aanVoed de servo's uit een externe 5V-voeding, verbind de GND's en voeg een condensator van 470 µF toe
De puls veranderen van 1000 µs naar 1200 µs verandert de snelheid nauwelijksBij de uiteinden draait de servo al op volle snelheid; de snelheid verzadigtGebruik voor fijne snelheidsregeling het bereik 1500 ± 300 µs
De robot rijdt niet rechtdoorDe twee servo's verschillen in snelheid en stoppuntKalibreer elke servo apart, verlaag de factor van de snellere
De servo wordt heet en zoemt maar draait nietDe as is geblokkeerd of de belasting is te zwaarVerwijder het obstakel, verminder de belasting; blokkeren verpest de tandwielen en de motor
Compilatiefout of geen signaal op de ESP32De Servo-bibliotheek die alleen voor AVR is, is gebruikt of GPIO 34–39 is gekozenInstalleer de ESP32Servo-bibliotheek, kies een GPIO die kan uitsturen

De FS90R is de makkelijkste manier om een continu draaiend mechanisme met één pin en zonder motordriver aan te sturen: hij stopt bij 1500 µs, draait beide kanten op met de snelheid die je wilt en is een kant-en-klare wielmotor voor kleine robots. Stel het stoppunt één keer in, denk eraan voor klussen die positieregeling nodig hebben over te stappen op een gewone servo of een stappenmotor, en hij werkt lang probleemloos. In de BlueGrays-app vind je de basis van servo's, servobesturing met een potentiometer en een joystick, een 360-gradenservo maken van een stappenmotor en projecten met robotauto's, met bedradingsschema's stap voor stap en kant-en-klare code.

Veelgestelde vragen

Hoe stop je een 360-gradenservo?

Servo's met continue rotatie zoals de FS90R stoppen wanneer ze een puls van 1500 µs krijgen; op Arduino gebruik je writeMicroseconds(1500), of write(90) nadat je hebt gekoppeld met attach(pin, 1000, 2000). Kruipt hij bij die waarde nog steeds, stel dan de kleine trimmer op de behuizing af met een schroevendraaier of gebruik in je code de waarde waarbij jouw servo echt stopt.

Wat is het verschil tussen een 360-gradenservo en een gewone servo?

Een gewone servo gaat volgens het signaal naar een bepaalde hoek en blijft daar, omdat de potentiometer erin de positie van de as meet. Een 360-gradenservo met continue rotatie heeft zo'n terugkoppeling niet; het signaal bepaalt snelheid en richting in plaats van een hoek, en de servo draait eindeloos door.

Kan een 360-gradenservo hoeken regelen?

Nee. De FS90R weet niet waar zijn as staat, dus hij kan niet naar een bepaalde hoek gaan en daar stoppen. Hem een bepaalde tijd laten draaien geeft een benaderend resultaat, maar dat varieert met spanning en belasting. Heb je een hoek nodig, gebruik dan een gewone servo, een stappenmotor of een motor met encoder.

Op welke spanning werkt de FS90R?

De FS90R werkt op 4,8–6 V; in Arduino-projecten wordt hij meestal gevoed met 5 V. Zijn signaallijn accepteert zowel 5V- als 3,3V-niveaus, dus hij is direct te gebruiken met de ESP32 en Raspberry Pi Pico, maar de voeding moet nog steeds 5 V zijn.

Hoeveel FS90R's kan ik op een Arduino aansluiten?

De Servo-bibliotheek ondersteunt tot 12 servo's op een Arduino Uno, maar de echte limiet is de stroom. Elke FS90R kan onder belasting enkele honderden milliampères trekken en tot 800 mA als hij geblokkeerd is, dus voed meer dan twee servo's altijd uit een externe 5V-voeding en verbind de GND's.

Kan een SG90 worden omgebouwd tot een 360-gradenservo?

Ja, maar het is een blijvende wijziging. Je opent de servo, knipt de mechanische aanslag van het tandwiel af en koppelt de potentiometer los van de as, door hem te vervangen door twee gelijke weerstanden of hem in zijn middenstand vast te zetten. Het resultaat werkt als een FS90R, maar de garantie vervalt en de servo kan nooit meer een hoek vasthouden; een kant-en-klare FS90R kopen is meestal minder gedoe.

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
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
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
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
Auto met Bluetooth-besturing en L298N
AR-80Gevorderd
Premium

Auto met Bluetooth-besturing en L298N

Verander je telefoon in een afstandsbediening en bestuur je eigen robotauto. De Arduino ontvangt via een Bluetooth-module commando's van een afstandsbedieningsapp op je telefoon en laat de wielen…

5.0(39)
66
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