1. No category

KUNGLIGA TEKNISKA HÖGSKOLAN
Programmering av LEGO
NXT robot
Laborationsrapport för programering av robot
för att följa svartmarkerad linje på maken
Hannes Rabo
2015-08-30
hrabo@kth.se
Introduktionskurs i datateknik (II0310)
Programmering av LEGO NXT robot
Hannes Rabo
2015-08-30
Sammanfattning
Denna laborationsrapport är på en programmeringslaboration av en LEGO NXT robot där roboten
programmerades för att följa en svart linje på golvet. Laborationen ger en kort introduktion till
programmeringen av denna typ av robot samt olika koncept inom programmering i allmänhet. Koden
skrevs i Brick Command Center vilket också hanterade kommunikationen mellan datorn och roboten.
Resultatet blev en robot som kunde utföra tidigare nämnda uppgift utan problem trots vissa problem
med upplägget av hur problemet skulle lösas. Detta gav dock en insikt i ingenjörsarbetet och hur små
förändringar kan ge stora förändringar samt hur många sätt som kan finnas för att lösa ett problem.
Båda dessa faktorer visade tydligt vikten av att förstå tankegången hos andra programmerare då en
uppgift löses kollaborativt.
Innehållsförteckning
1. Inledning .............................................................................................................................................. 3
1.1 Bakgrund ....................................................................................................................................... 3
1.2 Syfte och målsättning .................................................................................................................... 3
2. Genomförande .................................................................................................................................... 3
3. Resultat................................................................................................................................................ 5
4. Analys .................................................................................................................................................. 5
5. Diskussion ............................................................................................................................................ 6
Referenser ............................................................................................................................................... 7
Bilagor...................................................................................................................................................... 7
Institution
Högskola eller universitet
Sida 2 av 7
Programmering av LEGO NXT robot
Hannes Rabo
2015-08-30
1. Inledning
I denna laboration programmerar vi en LEGO NXT robot för att följa en svart linje på marken och
känna av stötar mot hinder. Roboten använder sig av en ljussensor för att känna av det
svartmarkerade området på marken och två trycksensorer för att känna av när roboten slår i ett
hinder. Då ett hinder påträffas ska robotens motorer stängas av, namnen på medlemmar i gruppen
skrivas ut på skärmen och högtalaren ska spela en kort melodi.
1.1 Bakgrund
Programmering kan vara en stor del av en ingenjörs arbete och ett enkelt sätt att lösa problem med
hjälp av en dator. Det är därför en viktig del av utbildningen på KTH och en nödvändig kunskap som
ingenjör. Denna laboration visar på ett simpelt sätt proceduren med att skapa ett program
kollaborativt och programmering i allmänhet men introducerar även denna specifika robots
funktioner och hur de kan användas för att få en robot att utföra en specifik uppgift. I detta fall
handlade det om att få roboten att följa en markerad svart linje på golvet med hjälp av en ljussensor.
1.2 Syfte och målsättning
Syftet är att på ett roligt och relativt enkelt sätt introducera programmering i form av
parprogrammering. Den introducerar även de tillvägagångsätt som används i ingenjörsrollen samt de
arbetssätt och system som används vid KTH. Uppgiften visar även tydligt hur små förändringar och fel
i koden kan ha mycket stora utslag på hur en robot fungerar om den ska utföra sina uppgifter som
förväntat. Detta ger då en insikt i hur stor noggrannhet som krävs och den planering som behövs för
att skriva ett pålitligt och fungerande program.
2. Genomförande
Nedan följer det tillvägagångssätt som vi använde vid lösandet av uppgiften
1. Nedladdning av programvara, drivrutiner och kod.
Första steget i denna laboration är att ladda ner drivrutiner, utvecklingsmiljö och kod för den
roboten. Dessa hämtades från kth hemsidan bilda under kursmaterial.
(https://www.bilda.kth.se/courseId/12708)
2. Installation
Efter att alla filer packats upp från det komprimerade formatet var drivrutinerna tvungna att
installeras på datorn för att kunna kommunicera med roboten medan utvecklingsmiljön
kunde startas direkt utan installation. Utvecklingsmiljön som användes var Brick Command
Center.
3. Anslutning
Roboten ansluts till datorn via en USB-sladd och efter detta kunde utvecklingsmiljön startas.
Vid start skall kommunikationsporten USB väljas för att den ska hitta roboten som är
ansluten till datorn enligt tidigare instruktion.
4. Inladdande av kod i utvecklingsmiljön.
Efter att utvecklingsmiljön har startats kan den delvis färdiga koden laddas in i programmet
antingen genom att den dras in i fönstret från ett annat filhanteringsprogram (ex. vis
explorer.exe) eller genom att välja file --> open och sedan navigera till filen.
Institution
Högskola eller universitet
Sida 3 av 7
Programmering av LEGO NXT robot
Hannes Rabo
2015-08-30
5. Kodgranskning
Fösta steget i redigeringen av koden för en funktionell robot var att noggrant läsa igenom all
kod och leta efter uppenbara misstag eller stavfel samt logiska fel. Dessa kan då direkt
korrigeras innan ytterligare steg i metoden genomförs. Den programmeringsmetod som
användes vid all programmering i uppgiften var parprogrammering vilket innebär att en
person sitter och skriver kod medan en andra person samtidigt övervakar och snabbt kan
hitta eventuella stavfel samt felaktiga tankegångar. Eventuella problem som uppkommer kan
även effektivt diskuteras inom gruppen.
6. Kompilering
När koden har redigerats och uppenbara felstavningar plockats bort kan koden föst
kompileras genom att klicka på f5 (eller välja Compile --> Compile). Eventuella fel i koden
kommer nu att generera felmeddelanden om de inte redan har åtgärdats (ej logiska fel).
7. Korrigering av eventuella fel angivna i felmeddelandet
Efter att man försökt kompilera programmet och det genererat felmeddelanden så kan
radnumren uppsökas och efter felmeddelandet korrigeras. Eftersom fel på rader innan
angivet radnummer inte alltid genererar ett fel på den rad de befinner sig på är det även
viktigt att kolla på dessa rader ifall felet inte upptäcks direkt. Detta gäller speciellt fel med
antalet parenteser eller utsättandet av semikolon som avslutar alla satser i programspråket
som används (NXC).
8. Kompilering och överladdning av program till robot
Steg sex och sju genomförs ända tills det inte längre generas några felmeddelanden och
kompileringen blir lyckad. Programmet kan då överföras till roboten genom att klicka f6 (eller
välja Compile --> Download).
9. Kontroll av beteende och allmän funktion
Kör programmet genom att navigera till filen på roboten och använda den orangea
mittenknappen för att starta den. Kontrollera att roboten fungerar och rör sig och notera
även hur eftersom det kan användas i den vidare analysen av hur koden fungerar.
10. Förändring av kod till ett fungerade upplägg
Förändra koden för att den ska fungera för den specifika uppgiften (se resultat för
förändringar som gjordes i denna labb). Kompilera och överför koden till roboten.
11. Testkörning
Placera roboten med ljussensorn på det svarta sträcket, navigera till filen och klicka på den
orangea mittenknappen för att exekvera koden. Roboten bör följa linjen utan att sensorn
hamnar utanför mer än mycket korta perioder åt gången. Roboten skall även kunna följa
svängar på sträcket åt både höger och vänster.
Institution
Högskola eller universitet
Sida 4 av 7
Programmering av LEGO NXT robot
Hannes Rabo
2015-08-30
3. Resultat
Denna tabell visar förändring av koden där Rad nr. anger radnummer som förändrats i originalkoden,
andra kolumnen i tabellen anger den nya koden för den specificerade raden och kommentarsfältet
ger en inblick i varför koden behövde ändras
Rad
nr.
2
Kod ersatt med:
Kommentar
#define SpeedSlow 50
34
string groupMembers[] = {
35
36
45
”Hannes”,
”Max”
TextOut( 0, (LCD_LINE1 – 8 * i), names[i]);
76
lightIntensity = SensorRaw(IN_3);
94
OnFwd(OUT_A, SpeedFast);
98
OnFwd(OUT_B, SpeedSlow);
115
//dance();
Roboten kunde inte svänga tillräckligt
snabbt med den högre hastigheten (80)
Fel datatyp (int) för att lagra namn då
dessa lagras som textsträngar (string)
Nummer ersatt av namn 1
Nummer ersatt av namn 2
Subtraktionen av 16 placerade texten två
raden ovanför vad som var meningen.
Detta togs därför bort.
Fel port. Porten för den ena trycksensorn
hade angivits istället för den korrekta som
hörde till ljussensorn.
Roboten ska svänga till höger i detta fall
(på linjen). Hjul A ska därför snurra snabbt.
Roboten ska svänga till höger i detta fall
(på linjen). Hjul B ska därför snurra
långsamt.
Funktionen som utförde dansen var onödig
då den inte utförde någon uppgift som var
aktuell för denna labb utan endast
försvårade framfarten.
Efter dessa förändringar fungerade roboten enligt de specificerade kriterierna (se inledning för
labbeskrivning). Uppgiften kunde då utföras utan onödiga rörelser och enligt ett mönster som var
effektivt.
4. Analys
Laborationsresultatet blev lyckat då roboten utan problem kunde utföra uppgiften med gott resultat.
Koden hade följande funktioner och uppbyggnad:


Definition av variabler och makron/konstanter
Överst definierades alla variabler och konstanter som krävdes och användes senare i koden.
Detta innefattade konstanter för hastigheter och radnummer på skärmen samt variabler för
ljudsignalen, gruppmedlemmar, ljusintensitet samt en variabel för enkel avbrytning
huvudloopen i programmet.
void printNamesToScreen(string names[])
Denna funktion innehåller ett förenklat sätt att skriva ut namn/textsträngar till skärmen på
rätt rader. Varje textsträng som skickas som parameter till funktionen i vektorn kommer att
få en unik rad (såvida det inte finns fler textsträngar än rader)
Institution
Högskola eller universitet
Sida 5 av 7
Programmering av LEGO NXT robot





Hannes Rabo
2015-08-30
void dance()
Denna funktion har inte någon aktiv uppgift i detta program och skulle helt kunna uteslutas.
Den får roboten att rotera åt höger i tre sekunder.
task readTouchSensors()
Denna funktion körs i en separat tråd och kontrollerar ifall någon av trycksensorerna har
aktiverats. Om så är fallet så avbryter den huvudloopen och avslutar programmet.
void readLightSensor()
Hämtar värdet från ljussensorn och sparar det i en variabel som alla funktioner kommer åt
task followLine()
Funktion som kör i separat tråd som innehåller huvudloopen och både hittar samt följer
sträcket. Ett högt värde från ljussensorn innebär att den befinner sig över sträcket och i detta
fall kommer loopen att styra roboten åt höger. Är värdet där emot under konstanten
BotThreshold så befinner den sig utanför sträcket och kommer styra åt vänster. Detta får
följden att den alltid kommer försöka befinna sig på den högra kanten av strecket. Om
variabeln bool finnished skulle ändras till true så kommer denna funktion och tillhörande
tråd att avslutas.
task main()
Startfunktionen för programmet där sensorer ställs in och andra trådar för följning av linjen
startas.
5. Diskussion
Under laborationen var det från början svårt att inse på vilket sätt som roboten var tänkt att lösa
uppgiften. Eftersom vår utgångspunkt var att roboten skulle följa det svarta strecket som om det
vore ett det korrekta området och alltså inte behövde svänga så började vi med att försöka lösa
uppgiften på fel sätt. Senare löste vi istället uppgiften genom att se på problemet som att roboten
skulle följa kanten på strecket vilken överensstämde med upplägget på koden och därför gjorde
lösningen mycket enkel att genomföra. Jag fick därför en insikt i ett alternativt sätt att tänka på
problemet och på så sätt komma fram till en enklare lösning. Alternativa och lättare lösningar är
viktiga att ha med sig i bakhuvudet som ingenjör då det alltid krävs effektivisering av system för att
de ska kunna fungera enligt alla önskemål och krav. För att hitta funktionen som var tänkt i just det
här programmet så hade vi som metod att skriva ut variabelvärden från koden till skärmen under
exekveringen. Vi konverterade bland annat heltalsvärdet från ljussensorn till en textsträng och skrev
ut den för att kunna analysera vilka värden som den funktionen genererade och när. För att göra
upptäckandet av nya fel samt ge tillfälle till diskussion användes även metoden parprogrammering
vilken innebar att programmeringen gjordes två och två. En person kunde i detta fall sitta och läsa
koden som den andra skrev för att sedan kommentera på eventuella fel. Detta gjorde att felsökning
kunde bli mycket effektivare då fel oftast omedelbart upptäcktes av den andra personen.
Det programspråk som användes vid laborationen (NXC) har stora likheter med C även om det finns
vissa skillnader. Det gör att det även ger en introduktion till språket C vilket har många andra
användningsområden i industrin och större applikationer och program. Detta gjorde det fungerade
som ett bra alternativ till just C för nybörjare eftersom det även innehöll förenklingar av vissa
koncept som separata trådar.
Institution
Högskola eller universitet
Sida 6 av 7
Programmering av LEGO NXT robot
Hannes Rabo
2015-08-30
Referenser
Lab-PM
https://bilda.kth.se/courseId/12708/content.do?id=23767349
Bilagor
Figur 1 Dagboksinlägg om robotlaborationen
Institution
Högskola eller universitet
Sida 7 av 7