Programmering og koding

Servomotor med Arduino og micro:bit: fra sveip til pan-tilt

Fotorealistisk illustrasjon av et pan-tilt-feste med to MG90S-servoer, en joystickmodul og Arduino UNO R4 WiFi på en arbeidsbenk

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.

Tegning av målet: En joystick styrer via Arduino to servomotorer i et pan-tilt-feste, side til side og opp og ned.
Slik virker det ferdige prosjektet. Dette er en tegning. Jo lenger du skyver spaken, jo raskere dreier festet, og det blir stående når du slipper.
Kort forklart En servo har tre ledninger: brun til GND, rød til pluss og oransje til en signalpinne. Gi servoen egen strøm på 4,8 til 6 V fra en batteriholder, og koble minus fra batteriet sammen med GND på kortet. På Arduino holder det med 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 røykfarget hus og servoarm
    Mikroservo MG90S med metallgir1 stk til nivå 1 og 2, 2 stk til nivå 3
    kr 149,00
    På lager
  • Arduino UNO R4 WiFi sett på skrå
    Arduino UNO R4 WiFi1 stk, sender styresignalet
    kr 599,00
    På lager
  • Svart batteriholder for fire AA-batterier med deksel og bryter
    Batteriholder for 4 AA med bryter1 stk, strøm til servoene
    kr 49,00
    På lager
  • Hvitt loddefritt koblingsbrett med 400 hull
    Koblingsbrett med 400 hull1 stk, fordeler pluss og minus
    kr 75,00
    På lager
  • Sett med koblingsledninger i flere farger
    Koblingsledninger, hann og hunn1 sett, hann-hann til servoen og hunn-hann til joysticken
    kr 99,00
    På lager
  • Svart joystickmodul med grå tommelspak
    Joystickmodul med trykknapp1 stk, fra nivå 2
    kr 89,00
    På lager
  • Svart pan-tilt-feste for to mikroservoer
    kr 99,00
    På lager
  • Blå mikroservo med gul, rød og svart krokodilleklemme
    Servo med krokodilleklemmer1 stk, bare til micro:bit-delen
    kr 229,00
    På lager

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.

Blokkskjema over innsiden av en servomotor: styrekrets, motor, gir og et potensiometer som melder vinkelen tilbake.
Forenklet tegning. Styrekretsen får styresignalet utenfra og den målte vinkelen innenfra. Motoren går helt til forskjellen er borte.

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 styrepulser med ulik pulsbredde og servoarmen i 0, 90 og 180 grader: Bredere puls gir større vinkel på servomotoren.
Tallene er standardverdiene i Servo-biblioteket til Arduino. På micro:bit er det samme området 0,5 til 2,5 ms, så samme vinkeltall kan gi litt ulik stilling på de to kortene.

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.

Servokontakten med tre ledninger: Brun er GND, rød er pluss på 4,8 til 6 V og oransje er styresignalet.
Brun er minus, rød er pluss og oransje er signal. Andre merker bruker svart, rød og gul eller hvit i samme rekkefølge.

Servo, trinnmotor eller DC-motor?

Motortypene løser hver sin oppgave. Velg etter hva som skal bevege seg, ikke etter hva du har liggende.

MotorDu bestemmerPasser tilDu trenger i tillegg
ServomotorVinkel innenfor omtrent 180 graderArmer, luker, ror, pan-tilt, gripereBare en signalpinne og egen strøm
TrinnmotorAntall trinn, så mange omdreininger du vilVisere, skinner, nøyaktig posisjon over flere runderDriverkort, se guiden om trinnmotor med Arduino
DC-motorFart og retningHjul, vifter, pumperMotordriver, se guiden om L298N, MOSFET og PWM
360-graders servoFart og retning, ikke vinkelSmå hjul på lette roboterBare 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.

Koblingsprinsipp for servo med egen strømforsyning: Batteriet gir strøm, Arduino gir signal, og minus er felles GND.
Prinsippet bak alle koblingene i guiden. Pluss fra batteriet går bare til servoen, aldri til 5V på Arduino eller 3V på micro:bit.
StrømkildeSpenningPasser tilMerk
4 oppladbare AA (NiMH)ca. 4,8 VÉn eller to mikroservoer, flyttbartTåler korte strømtopper godt
4 alkaliske AAca. 6 VMest mulig kraft og fartØvre grense for MG90S ifølge produktsiden
3 alkaliske AAca. 4,5 VServo sammen med micro:bitServoen oppfatter signalet på 3 V sikrere når den selv får lav spenning
5 V-adapter med DC-kontakt5 VFast oppsett, flere servoerVelg en som gir minst 1 A per servo
5V-pinnen på Arduino5 VJoystick og sensorerIkke til servoer
Bryt strømmen før du flytter ledninger. Slå av bryteren på batteriholderen og trekk ut USB-kabelen når du kobler om. Sjekk rød og svart to ganger før du slår på igjen. Bytter du om pluss og minus, kan servoen bli ødelagt.

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

Nivå 1: nybegynner. Tid: 30 minutter. Du trenger UNO R4 WiFi, én MG90S, batteriholder for 4 AA, koblingsbrett og fire koblingsledninger med hannkontakt i begge ender.

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.

Koblingstegning med én servomotor: Batteriholderen gir strøm via koblingsbrettet, og oransje ledning går til pinne 9 på Arduino.
Forenklet tegning sett ovenfra. De lange skinnene langs kanten av koblingsbrettet er koblet sammen på langs, og her bruker du dem som pluss og minus.
  1. 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.
  2. Stikk tre hann-hann-ledninger inn i servokontakten. Ledningen fra rød går til plusskinnen og ledningen fra brun til minusskinnen.
  3. Ledningen fra oransje går til pinne 9 på Arduino.
  4. Koble en ledning fra GND på Arduino til minusskinnen. Dette er den felles forbindelsen.
  5. 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

Nivå 1: nybegynner. Tid: 30 minutter. Du trenger micro:bit, servo med krokodilleklemmer og en batteriholder for 3 AA med tre alkaliske batterier.

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.

Koblingstegning for micro:bit og servo med krokodilleklemmer: gul klemme på P0, svart på GND og rød på pluss fra batteriholderen.
Forenklet tegning. Ringen merket 3V brukes ikke. Selve micro:biten får strøm fra USB eller batteripakken sin, som vanlig.
  1. Fest den gule klemmen på ringen merket 0.
  2. Legg den avisolerte enden av den svarte ledningen fra batteriholderen mot GND-ringen, og fest den svarte klemmen over begge.
  3. 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.
  4. 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.

MakeCode-blokker for servo på micro:bit: Ved start og knapp A+B gir 90 grader, knapp A gir 0 og knapp B gir 180 grader.
Blokkene med norsk tekst i MakeCode. Tegningen er forenklet, og fargene kan avvike litt fra editoren.

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

Nivå 2: viderekommen. Tid: 45 minutter. Du trenger oppsettet fra nivå 1, en joystickmodul og tre koblingsledninger med hunnkontakt i den ene enden.

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.

Koblingstegning for servo og joystick: Joysticken får 5V og GND fra Arduino, S-X går til A0, og servoen har egen strøm.
Forenklet tegning. Joysticken bruker lite strøm og kan trygt få 5 V fra Arduino. Servoen får fortsatt strøm fra batteriet.

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

Nivå 3: avansert. Tid: 1 til 1,5 timer. Du trenger oppsettet fra nivå 2, én MG90S til, et pan-tilt-feste, en liten stjernetrekker, en avbitertang eller hobbykniv og gjerne en elektrolyttkondensator på 100 µF.

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.

Fotorealistisk illustrasjon av delene til pan-tilt-festet lagt utover en arbeidsbenk sammen med to MG90S-servoer, servoarmer og skruer.
Illustrasjon. Festet består av fire plastdeler med skruer og muttere. De to servoene og servoarmene kjøpes for seg.

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. Skru den øverste servoen fast i vippeplaten med to skruer. Akselen skal stå på linje med hullet i den andre enden av platen.
  6. Skru den enkle armen fast i fordypningen i sidedelen uten tapp med én av de minste skruene.
  7. 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.
  8. Kontroller at ledningene kan følge med uten å stramme når festet dreier.

Koble til servo nummer to

Koblingstegning for pan-tilt med to servoer: signal fra pinne 9 og 10, strøm fra batteriholder og joystick på A0 og A1.
Forenklet tegning. Nytt siden nivå 2 er servoen på pinne 10, ledningen fra S-Y til A1 og kondensatoren mellom pluss og minus.
FraTilFarge på tegningen
Pan-servo, oransjePinne 9Oransje
Tilt-servo, oransjePinne 10Gul
Begge servoer, rødPlusskinnenRød
Begge servoer, brunMinusskinnenSvart
Batteriholder, rød og svartPlusskinnen og minusskinnenRød og svart
GND på ArduinoMinusskinnenSvart
GND og VCC på joystickenGND og 5V på ArduinoSvart og lilla
S-X og S-Y på joystickenA0 og A1Blå 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.

Graf over dødsone og fart for joystickstyring av servo: ingen fart rundt midten, deretter jevnt økende til full fart.
Prinsippskisse, ikke i målestokk. Full fart er satt til 120 grader per sekund i koden, og dødsonen er 40 av 1023 til hver side.
#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.

  1. Tilbake til midten. Koble S-K på joysticken til pinne 2 og sett pinMode(2, INPUT_PULLUP). Skriv først ut digitalRead(2) og se hvilket tall du får når du trykker spaken ned. La et trykk sette begge vinklene til 90.
  2. Roligere eller raskere. Endre MAKS_FART til 60 og til 240. Hvor går grensen før bevegelsen blir vanskelig å styre?
  3. 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.
  4. 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.

Mange servoer på to pinner

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.

kr 729,00
På lager
Griper

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.

kr 229,00
På lager
Test uten kode

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

kr 129,00
På lager

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.

Alle guider

Produkter omtalt i denne guiden

Produktene som brukes og sammenlignes i guiden, med pris og lagerstatus.