Robotbyggesett: velg riktig robot for læring og prosjekt

Det beste robotbyggesettet er det der akkurat det du vil øve på er vanskelig, og resten er enkelt. Vil du skrive kode, velger du en liten hjulrobot. Vil du forstå gir og ledd, bygger du en manuell arm. Vil du styre bevegelser presist, tar du en servoarm. En robothund er en ferdig maskin du tester og bruker, ikke noe du bygger.

Nivå

Fra første robot til avansert plattform

Tid

Omtrent 1 time til første Cutebot-program

Lodding

Nei til Cutebot, KSR10 og servoarmen

Du lærer

Velge etter alder og mål, skrive et første program og regne moment

Hva skal roboten din gjøre den første kvelden?

Start med oppgaven, ikke med hvor imponerende roboten ser ut. Hvert av de fire settene under har et første mål du kan nå, og et første hinder du må regne med.

Hvilken robot passer for barn i ulik alder?

Følg aldersmerkingen på produktet, men se også på hva barnet liker. Et barn som elsker å skru, blir lei av en bil som er ferdig på fem minutter. Et barn som vil se noe skje med en gang, blir lei av mange små deler. Kartet under viser hvor du kan begynne. Alle settene ligger under roboter for nybegynnere og roboter.

Robot for barn under 8 år: lek først

Under 8 år bør målet være å leke, ikke å kode. Ingen av byggesettene i denne guiden er merket for denne alderen, og de har små deler.

Hvilken robot passer for barn på 8 til 13 år?

Fra 8 år kan barn begynne med blokkprogrammering, og det er her utvalget er størst. Alle de fire settene under er merket fra 8 eller 9 år.

Robot for 14 år og eldre: mer å bygge, mer å forstå

Fra 14 år åpner resten av byggesettene seg. Her avgjør målet valget mer enn alderen. Vil du kode en gående robot, er Tobbie II en seksbeint robot til micro:bit, der du skriver i JavaScript Blocks Editor eller Python Editor. Tobbie med 107 deler er også merket fra 14 år og går på fire AAA-batterier. Liker du å bygge uten datamaskin, gir KSR19 5-i-1 mekanisk koding, som produktsiden anbefaler fra 14 år, og 12-i-1-settet går på sol. Flere modeller finner du under DIY-byggesett.

Byggesett for robotarm: hvilken velger du?

Velg etter hvordan du vil styre armen. Bare KSR10 styres uten kode og uten styrekort, med brytere.

Hvor mange ledd må du styre samtidig?

Tallet som sier mest om vanskelighetsgraden, er antall frihetsgrader: hvor mange bevegelser som må styres hver for seg. En hjulrobot trenger to. Svinger du, får det ene hjulet bare en annen fart enn det andre.

En arm må tenke annerledes, fordi hvert ledd flytter alt som sitter lenger ut. Beveger du skulderen, flytter griperen seg også. Derfor må du planlegge rekkefølgen. Ett bein på en robothund har tre ledd, og fire bein gir tolv. Der tar produsentens styringssystem seg av balansen, så den kan du ikke lære ved å bygge selv.

Hvorfor løfter en utstrakt arm så mye mindre?

Dette er regnestykket som overrasker flest. Et ledd må motvirke et moment, altså kraft ganger avstand. En masse på 100 g trekkes ned med omtrent 0,98 N. Den kraften er den samme uansett hvor massen er, men momentet vokser med armens lengde.

Så kan du regne på den femaksede armen. Joy-IT oppgir 21,5 kg·cm ved 7,4 V for servoene, som tilsvarer omtrent 2,1 Nm. Anta at den bevegelige delen av armen veier 500 g, med tyngdepunktet 15 cm fra skulderen. Det er et regneeksempel, så vei gjerne din egen.

• Armens egen masse: 0,5 kg × 9,81 m/s² × 0,15 m = 0,74 Nm
• Last på 100 g ytterst, 30 cm ut: 0,29 Nm
• Til sammen 1,03 Nm, altså omtrent halvparten av det oppgitte momentet

Margen er i virkeligheten mindre. Motorino-styrekortet tåler høyst 6 V, så du når ikke 7,4 V, og Joy-IT oppgir ikke momentet ved lavere spenning. I tillegg krever akselerasjon ekstra moment. Det er en av grunnene til at programmet senere i guiden beveger armen sakte.

Robotbyggesett side om side

Cutebot: en leveringsbil som viker for hindringer

Målet er en avgrenset leveringsrute på gulvet: bilen kjører fra Hent til Lever med en lett pappeske, og reagerer hvis noen setter noe i veien. Bygg den i tre trinn, slik at du alltid har noe som virker.

• 
  Cutebot med ultralydsensor1 stk, ferdig montert chassis, sensoren plugges i
• 
  BBC micro:bit 2 GO1 stk, med USB-kabel til PC-en

1. Batterier: Sett tre AAA-batterier i holderen, slik merkingen viser. De følger ikke med.
2. Sensor: Med bilen slått av plugger du ultralydsensoren i raden merket SONAR, med de to runde lydgiverne vendt fremover.
3. micro:bit: Skyv kortet helt ned i sporet, med LED-skjermen og knappene vendt mot sensoren.
4. Program: Åpne MakeCode, klikk New Project, og følg teksten under. Koble micro:bit til PC-en med USB-kabelen og klikk Download.
5. Kjør: Sett bilen på gulvet, slå på hovedbryteren bak og trykk på knapp A. Hold en bok foran den.

Programmet under er første trinn med sensor: bilen rygger og svinger unna i stedet for å stoppe. I MakeCode legger du inn utvidelsen cutebot under Utvidelser (Extensions), bytter til JavaScript og limer inn koden. Knapp A starter bilen og knapp B stopper den.

let kjorer = false
let avstand = 0
let naer = 0
input.onButtonPressed(Button.A, function () {
    kjorer = true
})
input.onButtonPressed(Button.B, function () {
    kjorer = false
})
basic.forever(function () {
    if (kjorer) {
        avstand = cuteBot.ultrasonic(cuteBot.SonarUnit.Centimeters)
        if (avstand > 1 && avstand < 20) {
            naer += 1
        } else {
            naer = 0
        }
        if (naer >= 2) {
            cuteBot.colorLight(cuteBot.RGBLights.ALL, 0xff0000)
            cuteBot.motors(-40, -40)
            basic.pause(400)
            cuteBot.motors(0, -40)
            basic.pause(randint(300, 600))
            naer = 0
        } else {
            cuteBot.colorLight(cuteBot.RGBLights.ALL, 0x00ff00)
            cuteBot.motors(40, 40)
        }
    } else {
        cuteBot.stopcar()
        cuteBot.closeheadlights()
    }
})

Variabelen naer er den lille detaljen som gjør programmet robust. Bilen reagerer først når to målinger på rad er under 20 cm, så én feilmåling ikke får den til å rygge. Verdier på 1 cm eller mindre regnes som ugyldige.

Neste steg er å følge teipen med de to linjesensorene og stoppe ved hvert stoppested. Alt sammen, med tegninger av blokkene og kode for linjefølgeren, står i den komplette Cutebot-guiden. Er micro:bit helt nytt for deg, begynner du med kom i gang med micro:bit.

Prøv selv: Endre 20 til 30 og 40 til 60. Når begynner bilen å treffe boken før den rekker å reagere?

KSR10: lag et program på papir, uten kode

KSR10 kan ikke programmeres i grunnversjonen, men du kan likevel tenke som en programmerer. Hvert trykk på en bryter er en kommando, og hele rekkefølgen er et program. Du og en venn kan bytte på å være datamaskin.

1. Merk bordet. Sett to kryss med teip innenfor rekkevidden, som Velleman tegner med omtrent 32 cm radius, og legg en lett skumkloss på det første.
2. Kjør for hånd og mål. Flytt klossen én gang, og noter bryter, retning og sekunder for hvert trinn.
3. Kjør etter arket. Sett armen tilbake og la en annen person følge arket med stoppeklokke. Treffer klossen krysset?
4. Finn feilen. Rett bare ett tall om gangen og kjør på nytt. Dette er feilsøking, og det virker på samme måte i kode.
5. Bytt batterier. Kjør det samme arket med nesten tomme batterier. Tidene passer ikke lenger, siden armen ikke vet hvor den er.

Femakset servoarm: myk bevegelse og sikker parkering

• 
  Femakset robotarm med griper1 stk, mekanikk og seks servoer
• 
  16-kanals PWM-servokontroller (Joy-IT Motorino)1 stk, sender servosignalene og fordeler strømmen
• Arduino UNO R4 WiFi1 stk med USB-C-kabel, kjører programmet
• Nettadapter 5 V, 4 A, plugg 5,5/2,1 mm1 stk, strøm til servoene ved rolig bevegelse
• Grenuttak med bryter1 stk, innen rekkevidde utenfor armens område

Joy-IT beskriver armen med styrekort fra egen serie: MotoPi for Raspberry Pi og Motorino for Arduino. Motorino står som et skjold (shield) oppå UNO-kortet og lager servosignalene selv, med en PCA9685-brikke og en egen krystall. Arduinoen trenger bare å gi beskjed over I²C.

Kalibrer før du monterer

Dette er trinnet folk angrer på at de hoppet over. Joy-IT ber deg sette hver servo til 1500 µs, og griperens servo til 1600 µs, før du skrur den fast. Da står armen rett opp i midtstillingen og får hele arbeidsområdet. Programmet under gjør det samme når det starter, så du kan bruke det til dette: koble til én servo om gangen og la den finne stillingen før du monterer resten.

Koble opp: to strømkretser, felles GND

1. Trykk Motorino ned på UNO R4 WiFi med strømmen helt av. Sett jumperen på kortet til 5V, som er logikknivået på UNO-kortet.
2. Plugg inn servoene: dreieskive på kanal 0, skulder på 1, albue på 2, håndledd på 3, vri på 4 og griper på 5. Pinnene heter GND, V+ og PWM. Brun leder går til GND, rød til V+ og oransje til PWM.
3. Sett 5 V-adapteren i DC-kontakten merket VIN og i grenuttaket, som står av. Skjoldet tåler 4,8 til 6 V og høyst 5 A i denne kontakten. Ikke bruk 7,4 V her, selv om servoene tåler det.
4. Koble UNO-kortet til PC-en med USB-C. Den gir logikkstrøm og data, ikke servostrøm.
5. Vri armen for hånd omtrent rett opp før du slår på grenuttaket. Servoene vet ikke hvor de står, og går raskt til første posisjon de får beskjed om.

Hele programmet

Installer «Adafruit PWM Servo Driver Library» i Library Manager i Arduino IDE. Joy-IT har også en egen tilpasset utgave. Programmet bruker den offisielle og ber den bruke krystallen på kortet, slik Joy-ITs utgave gjør. Last opp, åpne Serial Monitor på 115200 baud og skriv k eller p.

// Femakset robotarm (Joy-IT Robot02) med Motorino-skjold på Arduino UNO R4 WiFi.
// Skriv k og Enter i Serial Monitor for å kjøre sekvensen, p og Enter for å parkere.
// Skriver du noe mens armen beveger seg, avbrytes sekvensen og armen parkerer sakte.
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm(0x40);  // adressebroene på skjoldet er åpne

const uint8_t PRESKALER = 121;           // 25 MHz / (4096 x 122) gir omtrent 50 Hz
const uint32_t KRYSTALL_HZ = 25000000;   // krystallen på Motorino
const uint8_t ANTALL = 6;
const uint16_t STEG_MS = 20;             // ny posisjon 50 ganger i sekundet
const uint16_t PARK_MS = 3000;           // parkering tar alltid minst så lang tid

const char *NAVN[ANTALL] = {"dreieskive", "skulder", "albue", "håndledd", "vri", "griper"};

// Grenser i mikrosekunder per kanal. Forsiktige verdier rundt midtstillingen, med vilje.
const uint16_t MIN_US[ANTALL] = {1000, 1300, 1200, 1100, 1000, 1200};
const uint16_t MAX_US[ANTALL] = {2000, 1800, 1600, 1900, 2000, 1900};

// Parkering er kalibreringsstillingen fra Joy-IT: armen står rett opp.
const uint16_t PARK[ANTALL] = {1500, 1500, 1500, 1500, 1500, 1600};

const uint16_t APEN = 1400;    // bytt om APEN og LUKKET hvis griperen går motsatt vei
const uint16_t LUKKET = 1750;  // så lukket at en skumkloss holdes uten at servoen summer

struct Stilling {
  const char *navn;
  uint16_t us[ANTALL];
  uint16_t varighetMs;
};

const Stilling SEKVENS[] = {
  {"sving mot hent", {1250, 1500, 1500, 1500, 1500, APEN}, 2500},
  {"len fram", {1250, 1650, 1350, 1400, 1500, APEN}, 3000},
  {"lukk griper", {1250, 1650, 1350, 1400, 1500, LUKKET}, 1500},
  {"løft", {1250, 1500, 1500, 1500, 1500, LUKKET}, 3000},
  {"sving mot lever", {1750, 1500, 1500, 1500, 1500, LUKKET}, 4000},
  {"senk", {1750, 1650, 1350, 1400, 1500, LUKKET}, 3000},
  {"slipp", {1750, 1650, 1350, 1400, 1500, APEN}, 1500},
  {"løft igjen", {1750, 1500, 1500, 1500, 1500, APEN}, 3000},
};
const uint8_t ANTALL_STILLINGER = sizeof(SEKVENS) / sizeof(SEKVENS[0]);

uint16_t naa[ANTALL];  // siste posisjon vi har sendt til hver servo

// Myk start og stopp: t går fra 0 til 1, svaret starter og slutter med fart null.
float myk(float t) {
  return t * t * (3.0f - 2.0f * t);
}

// Tømmer alt som ligger i mottaket, også linjeskiftet fra Serial Monitor.
void tomSerial() {
  delay(20);
  while (Serial.available() > 0) {
    Serial.read();
  }
}

// Flytter alle ledd samtidig. Svarer false hvis noen skrev noe underveis.
bool flytt(const uint16_t mal[ANTALL], uint16_t varighetMs, bool kanAvbrytes) {
  uint16_t fra[ANTALL];
  uint16_t til[ANTALL];
  for (uint8_t k = 0; k < ANTALL; k++) {
    fra[k] = naa[k];
    til[k] = constrain(mal[k], MIN_US[k], MAX_US[k]);
  }
  uint16_t steg = max(varighetMs / STEG_MS, 1);
  for (uint16_t i = 1; i <= steg; i++) {
    if (kanAvbrytes && Serial.available() > 0) {
      return false;
    }
    float s = myk((float)i / steg);
    for (uint8_t k = 0; k < ANTALL; k++) {
      int forskjell = (int)til[k] - (int)fra[k];
      naa[k] = fra[k] + (int)(forskjell * s);
      pwm.writeMicroseconds(k, naa[k]);
    }
    delay(STEG_MS);
  }
  return true;
}

void parker() {
  Serial.println("Parkerer sakte");
  flytt(PARK, PARK_MS, false);
  Serial.println("Parkert");
}

void kjorSekvens() {
  for (uint8_t i = 0; i < ANTALL_STILLINGER; i++) {
    Serial.print("Flytter til: ");
    Serial.println(SEKVENS[i].navn);
    if (!flytt(SEKVENS[i].us, SEKVENS[i].varighetMs, true)) {
      tomSerial();
      Serial.println("Avbrutt");
      break;
    }
    delay(300);
  }
  parker();
}

void setup() {
  Serial.begin(115200);
  while (!Serial && millis() < 3000) {
  }
  if (!pwm.begin(PRESKALER)) {
    Serial.println("Fant ikke skjoldet på 0x40. Sjekk at det står riktig på UNO-kortet.");
    while (true) {
      delay(1000);
    }
  }
  pwm.setOscillatorFrequency(KRYSTALL_HZ);
  Serial.println("Motorino funnet på 0x40");

  // Én servo om gangen, fra griperen og ned. Strømtoppen blir mindre,
  // og du rekker å slå av hvis et ledd går feil vei.
  for (int k = ANTALL - 1; k >= 0; k--) {
    naa[k] = PARK[k];
    pwm.writeMicroseconds(k, naa[k]);
    Serial.print("Vekker kanal ");
    Serial.print(k);
    Serial.print(": ");
    Serial.println(NAVN[k]);
    delay(1000);
  }
  Serial.println("Klar. Skriv k for sekvens, p for parkering.");
}

void loop() {
  if (Serial.available() > 0) {
    char kommando = Serial.read();
    tomSerial();
    if (kommando == 'k') {
      kjorSekvens();
    } else if (kommando == 'p') {
      parker();
    }
  }
}

Slik skal det se ut når du har skrevet k:

Motorino funnet på 0x40
Vekker kanal 5: griper
Vekker kanal 4: vri
Vekker kanal 3: håndledd
Vekker kanal 2: albue
Vekker kanal 1: skulder
Vekker kanal 0: dreieskive
Klar. Skriv k for sekvens, p for parkering.
Flytter til: sving mot hent
Flytter til: len fram
Flytter til: lukk griper
Flytter til: løft
Flytter til: sving mot lever
Flytter til: senk
Flytter til: slipp
Flytter til: løft igjen
Parkerer sakte
Parkert

Linjene som ikke sier seg selv

• pwm.begin(PRESKALER) starter brikken med ekstern klokke, altså krystallen. Tallet 121 gir omtrent 50 Hz ved 25 MHz, som er klokkefrekvensen Joy-ITs bibliotek regner med. Joy-IT oppgir ikke frekvensen til krystallen på kortet, så sjekk at servoene oppfører seg normalt før du monterer armen. Etterpå må setOscillatorFrequency kalles, ellers regner biblioteket om mikrosekundene med feil klokkefrekvens.
• constrain i flytt() gjør at ingen stilling kan komme utenfor MIN_US og MAX_US, selv om du skriver feil tall i tabellen. Grensene i tabellen er forsiktige verdier rundt midtstillingen, ikke tall fra Joy-IT. Utvid dem bare litt om gangen, og aldri lenger enn leddet kan bevege seg uten å støte mot noe.
• parker() er laget slik at den ikke kan avbrytes. Når du stopper en sekvens, går armen rolig opp til midtstilling i stedet for å bli stående utstrakt.

Prøv selv: Legg en skumkloss der armen griper, og juster bare tallene i SEKVENS til den treffer. Legg deretter til en tredje plass. Guiden om trinnmotorer viser et annet motorprinsipp med samme regel for egen motorforsyning.

Denne koden er kompilert for UNO R4 WiFi, men ikke prøvd på en fysisk arm. Kjør derfor sakte første gang, og juster tallene etter din egen montering.

Robothund: en testplan i stedet for en byggeplan

Unitree oppgir omtrent 15 kg, opptil 2,5 m/s, en trinnhøyde på omtrent 15 cm og en helning på 30° for Air, og 1 til 2 timers drift. Gang og balanse er allerede løst. Det som gjenstår å øve på, er hvordan du bruker en slik maskin kontrollert, og hvor godt den faktisk ser rommet.

1. Rydd og merk. Fjern løse kabler og gjenstander og merk testområdet med teip. Ingen personer eller dyr i området.
2. Sjekk stopp først. Få roboten til å stå og stoppe noen ganger før den går noe sted. Bare én person styrer.
3. Gå sakte. Kjør laveste fart langs de fire punktene på plantegningen.
4. Mål. Sammenlign avstander i appens kart med tommestokken. Skriv ned avviket for glass, blanke flater og stolbein.
5. Vurder neste steg. Først når dette er kjedelig, er det tid for trapper eller terreng, og da med en egen risikovurdering.

Hva du lærer, og hva du kjøper etterpå

Skal en gruppe jobbe sammen, er flere små hjulroboter nesten alltid bedre enn én stor plattform. Da får alle prøve, og noe kan gå galt uten at det koster dyrt.

Vanlige spørsmål

Hvilket robotbyggesett er best for en nybegynner?

Cutebot med micro:bit gir raskest vei fra idé til synlig resultat, fordi monteringen tar minutter. Liker du heller å bygge enn å kode, er KSR10 et godt alternativ.

Kan Velleman KSR10 programmeres?

Ikke i grunnsettet. Det styres med en kablet boks med fem brytere og har ingen programmerbar kontroller. Du kan likevel øve på sekvenser med papirprogrammet i denne guiden.

Følger det styrekort med den femaksede armen?

Nei. Pakken har mekanikk og seks servoer. Du trenger et styrekort, for eksempel Motorino til Arduino eller MotoPi til Raspberry Pi, og en egen strømforsyning.

Hvor mye kan en hobbyrobotarm løfte?

Det kommer an på avstand, stilling og fart. Velleman oppgir 100 g for KSR10. For servoarmen må du regne moment for din egen stilling, som vist over, og teste med lett last først.

Kan jeg drive servoene fra 5 V-pinnen på Arduino?

Nei. Hver servo kan trekke opptil 2 A, som kortet ikke er laget for. Bruk en egen forsyning og felles GND.

Hvilken robot for barn er best?

Det kommer an på alder og mål, og vi har ikke testet settene mot hverandre. Under 8 år: en lekerobot eller Cutebot med voksen. Fra 8 år: BitCar eller Maqueen Lite for kode og solcelleroveren for bygging. Se kartet over.

Kan barn programmere en robot uten å kunne kode?

Ja. MakeCode bruker blokker som dras sammen, og det samme programmet kan vises som JavaScript senere. Begynn med kom i gang med micro:bit uten robot, så er det lettere å skjønne hva bilen gjør.

Hva er forskjellen på en robotarm for hobby og en robotarm i industrien?

Hovedsakelig løfteevne, presisjon og sikkerhet. En hobbyarm som KSR10 er oppgitt til 100 g og er laget for å lære, mens en industriarm står i et sikret område og gjentar samme bevegelse hele dagen. Prinsippene med ledd, moment og sekvenser er de samme.

Kan jeg bygge en robothund selv?

Ikke med settene her, for en firebent robot krever styringssystem for balanse. Vil du bygge noe som går, er edderkoppen med åtte bein mekanisk enklere, og Tobbie II har seks bein og kode. Unitree Go2 Air er robothunden du tester og bruker.

Er en robothund egnet for barn?

Nei, ikke uten en voksen som styrer. Go2 Air veier omtrent 15 kg og kan bevege seg raskt, så bruk krever avgrenset område og faste rutiner.

Kilder

Tekniske data er hentet fra Joy-ITs side om Robot02, med håndbok, kalibrering og kodeeksempel, Joy-ITs side om Motorino, Vellemans håndbok for KSR10, ELECFREAKS' dokumentasjon for Cutebot og Unitrees side om Go2.