En servomotor går til den vinkelen du ber om, og blir stående der. Her lærer du å styre en servomotor med Arduino UNO R4 WiFi og med micro:bit. Du starter med et sveip fra 0 til 180 grader, lar en joystick bestemme vinkelen og ender med et pan-tilt-feste der to servoer peker dit du vil.
Servo.h og servo.write(90). På micro:bit bruker du blokken «servo skriv til P0 verdi 90».- Nivå
- Nybegynner til avansert
- Tid
- 2 til 3 timer i alt
- Lodding
- Nei
- Du lærer
- Servosignal, egen strømforsyning, analog joystick og jevn bevegelse
Delene du trenger
Nivå 1 og 2 klarer seg med én servo. Pan-tilt-festet på nivå 3 trenger to, og servoene følger ikke med festet. Til micro:bit-delen bruker du en egen servo med krokodilleklemmer. Den delen hopper du over om du bare har Arduino.
Mikroservo MG90S med metallgir1 stk til nivå 1 og 2, 2 stk til nivå 3MG-90S Mikroservo - 180 grader - Girkasse i metallPå lagerkr 149,00
Arduino UNO R4 WiFi1 stk, sender styresignaletUtviklingskort Arduino Uno R4 WiFi med 12 x 8 LED-matrisePå lagerkr 599,00
Batteriholder for 4 AA med bryter1 stk, strøm til servoeneBatteriholder for 4 AA (R6) batterier med deksel og bryterPå lagerkr 49,00
Koblingsbrett med 400 hull1 stk, fordeler pluss og minusLoddefritt koblingsbrett med 400 hull og 2,54mm rasterPå lagerkr 75,00
Koblingsledninger, hann og hunn1 sett, hann-hann til servoen og hunn-hann til joystickenSett med 140 ferdigbøyde breadboard-ledninger, 2–125 mmPå lagerkr 99,00
Joystickmodul med trykknapp1 stk, fra nivå 2Joystick med trykknapp – analog styremodul for mikrokontrollerePå lagerkr 89,00
Pan-tilt-feste for mikroservoer1 stk, nivå 3Toakset pan- og tilt-kamerafeste i plast for mikroservoerPå lagerkr 99,00
Servo med krokodilleklemmer1 stk, bare til micro:bit-delenServo med krokodilleklemmer – 180° rotasjon, 5 VPå lagerkr 229,00
Til micro:bit-delen trenger du også en micro:bit og en batteriholder for 3 AA. Har du ikke koblingsbrett og ledninger fra før, finner du flere størrelser under koblingsbrett og koblingsledninger. Batterier kommer i tillegg. I holderen for fire AA er oppladbare et godt valg. I holderen for tre bruker du alkaliske, fordi tre oppladbare bare gir 3,6 V. Arduino trenger dessuten en USB-C-kabel som overfører data.
Slik virker en servomotor
En servomotor er en liten likestrømsmotor (DC-motor) med gir, en vinkelsensor og en styrekrets i samme hus. Vinkelsensoren er et potensiometer på utgangsakselen. Styrekretsen sammenligner vinkelen du ber om med vinkelen den måler, og kjører motoren til de to stemmer overens. Derfor holder servoen igjen når du prøver å dytte armen ut av stilling.
Pulsbredden bestemmer vinkelen
Styresignalet er en rekke korte pulser, én omtrent hvert 20. millisekund. Det er lengden på hver puls som teller. Med Arduinos Servo-bibliotek betyr 0,54 ms 0 grader og 2,40 ms 180 grader, og vinklene imellom fordeler seg jevnt. Du trenger sjelden å tenke på tallene, for servo.write(90) regner dem ut for deg.
Tre ledninger, alltid i samme rekkefølge
Kontakten på MG90S har tre hull på rekke. Rød ligger i midten, så pluss havner riktig selv om du snur kontakten. Servoen virker likevel ikke før brun sitter på minus og oransje på signalpinnen.
Servo, trinnmotor eller DC-motor?
Motortypene løser hver sin oppgave. Velg etter hva som skal bevege seg, ikke etter hva du har liggende.
| Motor | Du bestemmer | Passer til | Du trenger i tillegg |
|---|---|---|---|
| Servomotor | Vinkel innenfor omtrent 180 grader | Armer, luker, ror, pan-tilt, gripere | Bare en signalpinne og egen strøm |
| Trinnmotor | Antall trinn, så mange omdreininger du vil | Visere, skinner, nøyaktig posisjon over flere runder | Driverkort, se guiden om trinnmotor med Arduino |
| DC-motor | Fart og retning | Hjul, vifter, pumper | Motordriver, se guiden om L298N, MOSFET og PWM |
| 360-graders servo | Fart og retning, ikke vinkel | Små hjul på lette roboter | Bare en signalpinne og egen strøm |
Strøm: egen forsyning og felles GND
Det er her de fleste servoprosjekter går galt. En mikroservo trekker bare noen milliampere når den står stille, men rundt 200 mA når den beveger seg uten last, og 700 til 800 mA hvis armen blir holdt fast. Tallene er fra databladet til en servo av samme type og størrelse. Signalpinnen på UNO R4 WiFi tåler 8 mA, og Arduino skriver i databladet at servomotorer alltid skal ha en ekstern strømforsyning.
Løsningen er enkel: Servoen får pluss og minus fra en batteriholder, og kortet sender bare signalet. Minus fra batteriet må i tillegg kobles til GND på kortet. Uten den felles forbindelsen har ikke servoen noe å måle signalet mot, og den står stille eller rykker tilfeldig.
| Strømkilde | Spenning | Passer til | Merk |
|---|---|---|---|
| 4 oppladbare AA (NiMH) | ca. 4,8 V | Én eller to mikroservoer, flyttbart | Tåler korte strømtopper godt |
| 4 alkaliske AA | ca. 6 V | Mest mulig kraft og fart | Øvre grense for MG90S ifølge produktsiden |
| 3 alkaliske AA | ca. 4,5 V | Servo sammen med micro:bit | Servoen oppfatter signalet på 3 V sikrere når den selv får lav spenning |
| 5 V-adapter med DC-kontakt | 5 V | Fast oppsett, flere servoer | Velg en som gir minst 1 A per servo |
| 5V-pinnen på Arduino | 5 V | Joystick og sensorer | Ikke til servoer |
Vil du ha et fast oppsett uten batterier, bruker du en strømadapter på 5 V og 4 A og en DC-hunnkontakt med skruterminal. Koble pluss og minus til de samme skinnene på koblingsbrettet.
Nivå 1: første sveip med servomotor og Arduino
Målet er å se armen gå rolig fra den ene ytterstillingen til den andre og tilbake. Da vet du at strømmen, signalet og biblioteket er i orden, og resten av guiden bygger på den samme koblingen.
- Sett den røde ledningen fra batteriholderen i skinnen merket pluss og den svarte i skinnen merket minus. Tvinn først de tynne trådene i den avisolerte enden stramt sammen, og stikk enden helt ned så den får god kontakt. La bryteren stå av.
- Stikk tre hann-hann-ledninger inn i servokontakten. Ledningen fra rød går til plusskinnen og ledningen fra brun til minusskinnen.
- Ledningen fra oransje går til pinne 9 på Arduino.
- Koble en ledning fra GND på Arduino til minusskinnen. Dette er den felles forbindelsen.
- Sett på en servoarm uten å skru den fast, koble til USB-kabelen og last opp programmet. Slå så på batteriholderen.
#include <Servo.h>
const int SERVO_PIN = 9; // oransje signalledning
Servo servo;
void setup() {
servo.attach(SERVO_PIN); // fra nå sender pinne 9 en puls hvert 20. ms
}
void loop() {
for (int vinkel = 0; vinkel <= 180; vinkel++) { // fra 0 til 180 grader
servo.write(vinkel);
delay(15); // 15 ms per grad
}
for (int vinkel = 180; vinkel >= 0; vinkel--) { // og tilbake igjen
servo.write(vinkel);
delay(15);
}
}
Servo.h følger med Arduino IDE 2. Finner ikke IDE-en biblioteket, installerer du «Servo» fra Library Manager. attach(9) starter pulsene på pinne 9 og sender først servoen til midten. Deretter flytter løkkene målet én grad om gangen, og delay(15) gir servoen tid til å følge med. MG90S bruker omtrent 0,1 sekund på 60 grader, så uten pausen ville armen bare ha kastet seg fra side til side.
På UNO R4 lager biblioteket pulsene med en tidtaker, så signalet trenger ikke en pinne merket med tilde (~). Pinne 9 er valgt fordi de offisielle eksemplene bruker den.
Servomotor med micro:bit
Servoen med krokodilleklemmer har metallgir og må ha strøm fra en egen kilde. Kobler du den røde klemmen til 3V på micro:biten, kan kortet ta varig skade. Prinsippet er det samme som på Arduino: Kortet gir signalet, batteriholderen gir strømmen, og minus er felles.
- Fest den gule klemmen på ringen merket 0.
- Legg den avisolerte enden av den svarte ledningen fra batteriholderen mot GND-ringen, og fest den svarte klemmen over begge.
- Fest den røde klemmen på den avisolerte enden av den røde ledningen fra batteriholderen. Pass på at den ikke kommer borti micro:biten.
- Last ned programmet til micro:biten, og slå på batteriholderen til slutt.
I MakeCode ligger servoblokken under Avansert og Tilkobling. Lag fire grupper som på tegningen: én som kjører ved start og én for hver av knappene A, B og A+B.
Bytter du til JavaScript i MakeCode, ser det samme programmet slik ut:
pins.servoWritePin(AnalogPin.P0, 90)
input.onButtonPressed(Button.A, function () {
pins.servoWritePin(AnalogPin.P0, 0)
})
input.onButtonPressed(Button.B, function () {
pins.servoWritePin(AnalogPin.P0, 180)
})
input.onButtonPressed(Button.AB, function () {
pins.servoWritePin(AnalogPin.P0, 90)
})
I MicroPython finnes det ingen ferdig servofunksjon, så du lager pulsen selv. Perioden settes til 20 ms, og funksjonen regner vinkelen om til en andel av perioden:
from microbit import *
pin0.set_analog_period(20) # én puls hvert 20. ms
def vinkel(grader):
puls = 500 + grader * 2000 / 180 # mikrosekunder, som i MakeCode
pin0.write_analog(puls * 1023 / 20000) # andel av perioden, 0 til 1023
vinkel(90)
while True:
if button_a.is_pressed() and button_b.is_pressed():
vinkel(90)
elif button_a.is_pressed():
vinkel(0)
elif button_b.is_pressed():
vinkel(180)
sleep(50)
MakeCode sender 0,5 ms for 0 grader og 2,5 ms for 180 grader, og det er nettopp området databladet til denne servoen oppgir. På micro:bit V2 endres pulsen i steg på omtrent 0,02 ms. Det tilsvarer knapt to grader, så en endring på én grad gir ikke alltid bevegelse.
Er micro:bit nytt for deg, forklarer guiden om å komme i gang med micro:bit hvordan du lager og laster ned et program.
Nivå 2: Styr servoen med joystick
Nå skal armen følge hånden din. Joysticken har ett potensiometer for hver akse, og Arduino leser spenningen fra det som et tall mellom 0 og 1023. Programmet gjør tallet om til en vinkel.
Modulen har tre kontakter med tre pinner hver. Bruk kontakten merket S-X: GND går til GND på Arduino, VCC til 5V og S-X til A0. La resten av koblingen fra nivå 1 stå.
#include <Servo.h>
const int SERVO_PIN = 9; // oransje signalledning
const int JOY_X = A0; // S-X på joysticken
const int DODSONE = 40; // slark rundt midten, av 1023
const float GLATTING = 0.15; // 0 til 1: lavere tall gir roligere bevegelse
Servo servo;
int midt = 512; // måles i setup()
float vinkel = 90;
int forrigeSendt = -1;
void setup() {
Serial.begin(9600);
delay(200);
midt = constrain(analogRead(JOY_X), 300, 700); // la spaken stå i ro
servo.attach(SERVO_PIN); // pulsene starter, servoen går til midten
servo.write(90);
Serial.print("Midtverdi: ");
Serial.println(midt);
}
void loop() {
float onsket = 90 + 90 * utslag(analogRead(JOY_X), midt);
vinkel += (onsket - vinkel) * GLATTING; // gå en del av veien mot ønsket vinkel
int send = round(vinkel);
if (send != forrigeSendt) {
servo.write(send);
forrigeSendt = send;
Serial.print("Vinkel: ");
Serial.print(send);
Serial.println(" grader");
}
delay(20); // servoen får en ny puls hvert 20. ms
}
// Gjør en avlesning om til et tall fra -1 til 1, med dødsone rundt midten
float utslag(int lest, int midtverdi) {
int avvik = lest - midtverdi;
if (abs(avvik) < DODSONE) return 0;
float u;
if (avvik > 0) {
u = float(avvik - DODSONE) / (1023 - midtverdi - DODSONE);
} else {
u = float(avvik + DODSONE) / (midtverdi - DODSONE);
}
return constrain(u, -1.0, 1.0);
}
Tre ting skiller programmet fra en ren omregning med map():
- Midten måles. En joystick hviler sjelden nøyaktig på 512. Programmet leser hvileverdien i
setup(), så la spaken stå i ro når kortet starter. - Dødsone. Utslag mindre enn 40 regnes som null. Uten den ville servoen stått og småjustert når du ikke rører spaken.
- Glatting. Hver runde går vinkelen 15 prosent av veien mot den ønskede vinkelen. Bevegelsen starter raskt og bremser mykt, i stedet for å hogge.
Åpne Serial Monitor og velg 9600 baud. Skyver du spaken raskt helt ut, ser linjene omtrent slik ut:
Midtverdi: 507 Vinkel: 90 grader Vinkel: 104 grader Vinkel: 115 grader Vinkel: 125 grader Vinkel: 133 grader
Ser du ikke linjen med midtverdien, lar du Serial Monitor stå åpen og trykker på reset-knappen på Arduino.
Nivå 3: pan-tilt med to servoer
Et pan-tilt-feste har to akser. Den nederste servoen dreier alt fra side til side, og den øverste vipper platen på toppen, vippeplaten, opp og ned. Sammen kan de rette en sensor, en laserpeker eller et lite kamera i alle retninger foran festet.

Sett sammen festet
Delene skrus sammen rundt servoene. Rekkefølgen under er den samme som i Adafruits veiledning for et feste av samme type. Bruk bildene på produktsiden som fasit underveis, og stram skruene bare til de sitter.
- Kjør nivå 2 én gang for hver servo og slipp spaken, så står begge på 90 grader. Trekk så ut kontaktene. Fra nå av dreier du ikke akslene for hånd.
- Klipp til to servoarmer med avbitertang eller hobbykniv: Den korsformede armen skal passe i fordypningen i bunnplaten, og en enkel arm i fordypningen i sidedelen uten tapp. Produktsiden nevner at armene må kortes ned.
- Legg den nederste servoen i den ene sidedelen, med akselen på motsatt side av tappen som vippeplaten skal dreie på. Sett på den andre sidedelen, og skru de to sammen med to skruer.
- Trykk den korsformede armen ned på akselen til den nederste servoen. Velg den stillingen der festet kommer til å peke rett fram, og fest armen med den korte skruen som fulgte med servoen, ikke med de lange festeskruene. Skru så bunnplaten fast i armen med fire av de minste skruene.
- Skru den øverste servoen fast i vippeplaten med to skruer. Akselen skal stå på linje med hullet i den andre enden av platen.
- Skru den enkle armen fast i fordypningen i sidedelen uten tapp med én av de minste skruene.
- Stikk akselen på den øverste servoen inn i armen mens vippeplaten står vannrett, og lirk hullet i den andre enden over tappen. Bruk gjerne en liten skrutrekker som brekkstang. Fest armen til akselen med den korte skruen.
- Kontroller at ledningene kan følge med uten å stramme når festet dreier.
Koble til servo nummer to
| Fra | Til | Farge på tegningen |
|---|---|---|
| Pan-servo, oransje | Pinne 9 | Oransje |
| Tilt-servo, oransje | Pinne 10 | Gul |
| Begge servoer, rød | Plusskinnen | Rød |
| Begge servoer, brun | Minusskinnen | Svart |
| Batteriholder, rød og svart | Plusskinnen og minusskinnen | Rød og svart |
| GND på Arduino | Minusskinnen | Svart |
| GND og VCC på joysticken | GND og 5V på Arduino | Svart og lilla |
| S-X og S-Y på joysticken | A0 og A1 | Blå og grønn |
Kondensatoren settes rett i strømskinnene, med det lange beinet i pluss og siden med den lyse stripen i minus. Den jevner ut de korte strømtoppene når begge servoene starter samtidig. Hva som skjer inni den, står i guiden om kondensatorer. Blir servoledningen for kort når festet dreier, finnes det en forlengelseskabel på 30 cm.
Utslaget bestemmer farten
På nivå 2 bestemte spaken vinkelen direkte. Det passer dårlig her, for festet ville falt tilbake til midten hver gang du slapp. Nå bestemmer utslaget i stedet hvor fort vinkelen endrer seg. Slipper du spaken, blir festet stående der det er.
#include <Servo.h>
const int PAN_PIN = 9; // nederste servo: side til side
const int TILT_PIN = 10; // øverste servo: opp og ned
const int JOY_X = A0; // S-X på joysticken
const int JOY_Y = A1; // S-Y på joysticken
const int DODSONE = 40; // slark rundt midten, av 1023
const float MAKS_FART = 120; // grader per sekund ved fullt utslag
const float PAN_MIN = 10, PAN_MAKS = 170;
const float TILT_MIN = 30, TILT_MAKS = 150;
Servo pan;
Servo tilt;
int midtX = 512, midtY = 512; // måles i setup()
float panVinkel = 90, tiltVinkel = 90;
unsigned long forrige = 0;
unsigned long sistSkrevet = 0;
void setup() {
Serial.begin(9600);
delay(200);
midtX = constrain(analogRead(JOY_X), 300, 700); // la spaken stå i ro
midtY = constrain(analogRead(JOY_Y), 300, 700);
pan.attach(PAN_PIN); // begge servoene går til midten
tilt.attach(TILT_PIN);
forrige = millis();
}
void loop() {
unsigned long tid = millis();
if (tid - forrige < 20) return; // 50 oppdateringer i sekundet
float dt = (tid - forrige) / 1000.0; // sekunder siden sist
forrige = tid;
// utslaget bestemmer farten, ikke vinkelen
panVinkel += utslag(analogRead(JOY_X), midtX) * MAKS_FART * dt;
tiltVinkel += utslag(analogRead(JOY_Y), midtY) * MAKS_FART * dt;
panVinkel = constrain(panVinkel, PAN_MIN, PAN_MAKS);
tiltVinkel = constrain(tiltVinkel, TILT_MIN, TILT_MAKS);
pan.writeMicroseconds(pulsbredde(panVinkel));
tilt.writeMicroseconds(pulsbredde(tiltVinkel));
if (tid - sistSkrevet >= 500) { // to linjer i sekundet
sistSkrevet = tid;
Serial.print("Pan ");
Serial.print(lround(panVinkel));
Serial.print(" Tilt ");
Serial.println(lround(tiltVinkel));
}
}
// Samme omregning som Servo-biblioteket: 0 grader = 544 µs, 180 grader = 2400 µs
int pulsbredde(float vinkel) {
return round(544 + vinkel * (2400 - 544) / 180.0);
}
// Gjør en avlesning om til et tall fra -1 til 1, med dødsone rundt midten
float utslag(int lest, int midtverdi) {
int avvik = lest - midtverdi;
if (abs(avvik) < DODSONE) return 0;
float u;
if (avvik > 0) {
u = float(avvik - DODSONE) / (1023 - midtverdi - DODSONE);
} else {
u = float(avvik + DODSONE) / (midtverdi - DODSONE);
}
return constrain(u, -1.0, 1.0);
}
Løkken kjører 50 ganger i sekundet uten delay(). Hver runde måler den tiden siden sist, dt, og legger til farten ganget med tiden. Slik blir farten den samme selv om en runde skulle ta litt lengre tid. Koden bruker writeMicroseconds() i stedet for write() fordi den tar imot finere steg enn hele grader, og det gir jevnere bevegelse når festet går sakte.
Grensene PAN_MIN, PAN_MAKS, TILT_MIN og TILT_MAKS hindrer at festet presser mot plasten. Start med tallene i koden og utvid forsiktig til du ser hvor festet ditt stopper.
I Serial Monitor skriver programmet ut de to vinklene to ganger i sekundet:
Pan 90 Tilt 90 Pan 112 Tilt 90 Pan 148 Tilt 76 Pan 170 Tilt 61
Prøv selv
Utfordringene bygger på programmet fra nivå 3 og bruker det du allerede har på bordet.
- Tilbake til midten. Koble S-K på joysticken til pinne 2 og sett
pinMode(2, INPUT_PULLUP). Skriv først utdigitalRead(2)og se hvilket tall du får når du trykker spaken ned. La et trykk sette begge vinklene til 90. - Roligere eller raskere. Endre
MAKS_FARTtil 60 og til 240. Hvor går grensen før bevegelsen blir vanskelig å styre? - Husk en stilling. Lagre de to vinklene i to variabler når du trykker, og la et nytt trykk kjøre festet rolig tilbake dit.
- Automatisk søk. La pan sveipe sakte fram og tilbake av seg selv når spaken har stått i ro i ti sekunder.
Hvis det ikke virker
Servoen rører seg ikke
Sjekk at bryteren på batteriholderen står på, og at kontakten ikke er snudd: Oransje skal til signalpinnen. Kontroller deretter ledningen mellom GND på kortet og minusskinnen. Uten felles GND kommer ikke signalet fram.
Servoen dirrer eller rykker når den skal stå stille
Den vanligste årsaken er svak strøm: nesten tomme batterier eller en løs ledning i koblingsbrettet. Sett kondensatoren på 100 µF mellom pluss og minus, og hold signalledningen kort. På nivå 2 og 3 kan du også øke DODSONE til 60.
Arduino starter på nytt, eller USB-forbindelsen faller ut når servoen går
Da får servoen trolig strøm fra kortet i stedet for fra batteriet. Flytt den røde servoledningen til plusskinnen, som bare er koblet til batteriholderen.
Servoen brummer og blir varm i ytterstillingen
Den presser mot den mekaniske stopperen og trekker da mye strøm. Snevre inn området, for eksempel fra 10 til 170 grader, eller juster grensene på nivå 3. Sjekk også at ingenting i festet står i spenn.
Festet går av seg selv rett etter oppstart
Spaken ble holdt eller rørt mens programmet målte midtverdien. Slipp joysticken og trykk på reset-knappen på Arduino.
micro:biten virker, men servoen står stille
Se etter at den svarte klemmen holder både GND-ringen og minusledningen fra batteriet, og at den røde klemmen sitter på pluss fra batteriet. Med fire helt nye alkaliske batterier kan signalet på 3 V bli for svakt. Bruk holderen for tre AA med alkaliske batterier.
Flere servoer, griper og servotester
Servo-biblioteket styrer opptil tolv servoer på en UNO R4, på hvilke som helst digitale pinner. Det er strømmen som setter grensen: Regn med opptil 0,8 A per mikroservo i verste fall, og velg strømforsyning etter det.
En 16-kanals PWM-servokontroller lager pulsene selv og styres over I²C. Den har egen inngang for 4,8 til 6 V til servoene, og hver kanal har pinnene GND, V+ og PWM.
Et gripersett for mikroservo gjør dreiebevegelsen om til en klo som åpner og lukker seg. Koden fra nivå 2 passer, men snevre inn vinkelområdet så kloen ikke presser mot stopperen.
En servotester styrer servoen direkte med en dreieknapp. Den er nyttig når du vil finne midtstillingen før montering eller sjekke en servo du er usikker på.
Skal noe rulle i stedet for å peke, trenger du en 360-graders servo med hjul. Den tar imot samme signal, men tallet bestemmer fart og retning i stedet for vinkel, og omtrent 90 betyr stopp. Den skal ha 3 til 5,5 V, så bruk fire oppladbare AA eller tre alkaliske, ikke fire alkaliske. Flere typer og størrelser ligger under servomotorer.
Vanlige spørsmål
Kan jeg koble en servomotor rett til 5V-pinnen på Arduino?
Arduino fraråder det i databladet for UNO R4 WiFi. En mikroservo kan trekke opptil 0,8 A når den møter motstand, og spenningen på kortet faller når det skjer. Bruk egen strømforsyning og felles GND.
Hvor mange servoer kan en Arduino UNO R4 styre?
Servo-biblioteket kan styre tolv. Trenger du flere, eller vil du spare pinner, bruker du en servokontroller med 16 kanaler på I²C-bussen.
Må servosignalet kobles til en PWM-pinne?
Nei. Servo-biblioteket lager pulsene med en tidtaker og kan bruke alle digitale pinner på UNO R4. Signalet er heller ikke vanlig PWM med analogWrite(): Perioden er fast på 20 ms, og pulsen fyller bare en liten del av den.
Hva er forskjellen på en 180-graders og en 360-graders servo?
En vanlig servo går til en vinkel og holder den. En 360-graders servo mangler vinkelmålingen og dreier rundt uten stopp. Der styrer signalet fart og retning.
Kan micro:bit gi strøm til en servo uten ekstra batteri?
En micro:bit V2 kan gi opptil 190 mA til tilbehør, og det er mindre enn en servo trekker når den møter motstand. Servoen med krokodilleklemmer skal ifølge produsenten alltid ha egen strøm. Bruk batteriholder, så er både servoen og micro:biten trygge.
Hvor sterk er en MG90S?
Produsenten oppgir 1,8 kg·cm ved 4,8 V, omtrent 0,18 Nm. Det betyr at den kan holde 1,8 kg én centimeter fra akselen, eller 180 gram ti centimeter fra akselen. Regn med god margin, for dette er grensen der servoen stopper.
Slik bygger du videre
Nå kan du få noe til å peke dit du vil, og du vet hvorfor motorer skal ha sin egen strøm. Skal noe gå flere runder med nøyaktig posisjon, er neste skritt trinnmotor med Arduino. Skal det rulle, viser guiden om DC-motor med L298N og PWM hvordan du styrer fart og retning, og guiden om robotbyggesett hjelper deg med å velge et ferdig understell. Er selve kodingen ny for deg, begynner du med Arduino-programmering for nybegynnere.
Kilder: datablad for UNO R4 WiFi, Servo-biblioteket til Arduino, Arduinos artikkel om servomotorer, Tower Pro om MG90S, Adafruits veiledning for pan-tilt-feste, datablad for FS90MG-CL, micro:bit-stiftelsen om servoer, MakeCode om servo write pin og MicroPython-dokumentasjonen for pinner.




