Labb rapport - NXT Lego Robot programmering

KTH - KISTA
Programmering av NXT
lego robot
Peter Yakob
2015-08-29
Pyakob@kth.se
Introduktionskurs i datateknik (H15) II0310
Sammanfattning
Den här rapporten handlar om hur två personer med grundläggande kunskaper inom programmering
testade att programmera en lego robot med hjälp av program språket NXC (Not eXactly C). Du
kommer få läsa om vilka steg vi följde för att programmera roboten, vilka problem vi stötte och hur vi
löste de som t.ex. hur programmet skulle hantera robotens motorer. Syftet med denna laboration
var att introducera par programmering på ett enkelt med ändå roligt sätt. Målet var att rätta till fel i
en kod som vi hade blivit tilldelade och sedan se till så att roboten kunde följa en svart linje med
hjälp av en ljussensor, den skulle också kunna skriva ut gruppmedlemmarnas namn på sin LCD skärm
samt spela upp en ton när den träffade väggen.
Innehållsförteckning
Sammanfattning ...................................................................................................................................... 2
Innehållsförteckning ................................................................................................................................ 2
1. Inledning .............................................................................................................................................. 3
1.1 Bakgrund ....................................................................................................................................... 3
1.2 Syfte och målsättning .................................................................................................................... 3
2. Genomförande .................................................................................................................................... 3
3. Resultat................................................................................................................................................ 4
4. Analys .................................................................................................................................................. 6
5. Diskussion ............................................................................................................................................ 6
Referenser ............................................................................................................................................... 6
Bilagor...................................................................................................................................................... 7
1. Inledning
Den här rapporten kommer att handla om hur jag och min labbpartner programmerade vår första
robot med hjälp av NXC. Jag kommer gå igenom varför vi utförde denna laboration samt problem
som vi stötte på.
1.1 Bakgrund
I laborationen så fick vi använda oss av grundläggande programmerings kunskaper för att hitta och
lösa problem som fanns i robotens kod. Dessa grundläggande kunskaper är väldigt viktiga och är
något som vi i framtiden kommer använda oss mycket av när vi programmerar mjuk & hårdvara.
1.2 Syfte och målsättning
Syftet med laboration var att introducera grundläggande programmering i par på ett roligt med
samtidigt enkelt sätt. Målet var då att hitta fel i robotens kod och rätta till den så att den kunde följa
en svart linje med hjälp av en ljussensor.
2. Genomförande
Innan laboration så laddade vi ner BricxCC och robotens drivrutiner, BricxCC användes för att
programmera och kompilera koden medan robotens drivrutiner behövdes för att koppla upp den till
våra datorer.
Det första vi gjorde var att starta & koppla roboten till datorn med hjälp av en USB sladd, efter det så
tog vi en titt på koden i BricxCC. Vi skummade igenom koden och sedan testade vi att kompilera den,
då stötte vi på vårt första problem laborationen.
Det första problemet vi hade var en datatyp som inte var kompatibel, problemet var att en integer
användes istället för en string när programmet skulle skriva ut namn ur en lista, detta problem löste
vi ganska snabbt och vi fortsatte därefter med att testa roboten genom att ladda upp vår
modifierade kod så att vi kunde test köra den. Det första jag märkte efter vårt första test var att
roboten spelade upp en ton och skrev ut text på LCD skärmen när sensorerna kom i kontakt med
väggen därefter så stängde den av sig själv en kort stund senare. Texten som skrevs ut var
”PeterGruppmedlemmar:” det som borde ha skrivits ut var ”Gruppmedlemmar: Peter, Simon” d.v.s.
texten som skrevs ut hamnade i fel ordning och bara en gruppmedlems namn skrevs ut på skärmen.
När det här problemet dök upp så blev vi lite förvirrade över varför bara ett namn ur vår lista skrevs
ut på robotens skärm. Vi satt och analyserade koden som hanterade utskrivningen av namn och
försökte hitta problemet, det vi kom fram till var att koden som hanterade vilken rad som namnen
skulle skrivas ut på var fel. Koden skrev ut ”Gruppmedlemmar.” på rad 56 och skrev ut det första
namnet ur listan på rad 64 och det andra namnet i listan skrevs också ut på rad 56. Detta var troligen
varför det andra namnet i listan inte dök upp, så vi gjorde en väldigt liten modifiering i koden som
skrev ut namnen ur listan, detta löste problemet och vi kunde nu börja fokusera oss på robotens
ljussensor och motorer.
3. Resultat
Koden ovan försöker skriva ut namnen från listan ”groupMembers” på robotens skärm.
Men vi stötte på ett fel som sa ”Error: Datatypes are not compatible”
Om vi tar en titt på koden ovanför så ser vi att listan har en integer som datatyp, vi ändrade den till
en string eftersom integer kan inte hantera text och samtidigt så skrev vi in våra namn i listan istället
för siffrorna.
Det andra problemet vi stötte på var att namnen i listan inte skrevs ut korrekt på robotens LCD
skärm.
Vi löste detta genom att ändra värdet 16 på rad 46 till 6, och detta gjorde vi för att minska värdet på
LCD_LINE2 så att texten inte skulle hamna före LCD_LINE1 eller på samma rad som var fallet med det
andra namnet i listan.
Lite enkel matematik visar oss varför vi gjorde denna ändring.
LCD_LINE1 = rad 56
(detta är definierat på rad 10 i koden)
LCD_LINE2 = rad 48
(detta är definierat på rad 11 i koden)
(LCD_Line2 - (8*i-16))
(rad 46)
När i = 0 d.v.s. när det första namnet i vår lista ska skrivas ut så skrivs den ut på:
(LCD_Line2 - (8*i-16)) => 48 – (8 * 0 – 16) => 48 + 16 = 64 (rad 64 på robotens skärm)
Och när i = 1 så skrivs det andra namnet ut på:
(LCD_Line2 - (8*i-16)) => 48 – (8 * 1 – 16) => 48 + 8 = 56 (rad 56 på robotens skärm)
Genom att ändra värdet 16 till 6 så får LCD_LINE2 aldrig samma värde som LCD_LINE1 i det är fallet.
Om vi tar en titt på koden som skriver ut ”Gruppmedlemmar:” på rad 42, så ser vi att den skrivs ut på
LCD_Line1 d.v.s. rad 56 vilket är samma värde som det andra namnet skrivs ut på. Detta var då
problemet som orsakade att texten skrevs inkorrekt.
Nästa problem vi stötte på var att Ljussensorn inte verkade fungera korrekt, vi märkte att koden läste
av fel sensor.
Koden läste av värdet från sensor 1 som inte var en ljussensor (IN_1) så vi ändrade till den korrekta
sensorn IN_3.
Här så hade vi problem med att få roboten att följa den svarta linjen, det tog oss ett bra tag innan vi
löste problemen i kod stycket ovanför. Vi fick testa oss fram genom att ändra vilken motor som skulle
köras i olika situationer. Till slut så kom vi fram till denna lösning.
Nästa gång vi testade roboten så lyckades den följa den svarta linjen och åka in en halv cirkel, när den
träffade väggen så skrevs namnen i listan ut på robotens skärm.
4. Analys
Anledningen till att vi behövde testa oss fram på olika moment var för att vi inte tog oss tiden och
läste igenom hela koden ordentligt, vi skummade bara igenom den lite snabbt och satte igång direkt
med att testa hur roboten fungerade. Detta ledde till lite strul i slutet av laborationen när vi skulle få
roboten att följa den svarta linjen, vi kom fram till en lösning efter ett bra tag. När vi gjorde ändringar
i if-satsen som hanterade motorerna så blev det ganska uppenbart att vi inte riktigt tänkte igenom
hur den biten av koden fungerade. Men för det mesta så var det inte för mycket svårigheter. Vi tog
även och minskade variablerna för SpeedSlow & SpeedFast för att vi trodde att om roboten var för
snabb så skulle den inte hinna med att svänga i linjens kurvor, men det påpekades senare när vi var
klara med uppgiften att vi kunde ha höjt hastigheten eftersom roboten skulle varit snabbare på att
svänga om hastigheten var högre.
5. Diskussion
Syftet med laborationen var att vi skulle få testa på att programmera en robot i par och lösa problem
som vi hittade i koden. Målet var då att lösa alla problem och få roboten att följa den svarta linjen i
en halv cirkel, för att sedan träffa väggen och spela upp en ton samt skriva ut text på LCD skärmen
och sedan stänga av programmet ett kort stund därpå.
Det jag har lärt mig är lite grundläggande om hur man programmerar robotar, detta kommer vara
väldigt bra inom den närmaste framtiden när vi ska bygga och programmera våra egna robotar i
kursen ingenjörsmetodik.
När det gäller lösningsmetoder så skulle jag säga att vi för det mesta testade oss fram speciellt när vi
skulle se till så att roboten följde linjen korrekt, personligen gillade jag denna metod eftersom det var
roligt att se hur de olika ändringarna fick roboten att fungera, men detta är nog inte det optimala
sättet att lösa problem och är något som jag kommer försöka undvika i framtiden om det är möjligt.
Referenser
”Labb-PM” Från II0310 Introduktionskurs i datateknik (H15) - Bilda
Bilagor
Kommentarsblad för laborationsuppgift i
II0310 Introduktionskurs i
datateknik
Radnu
mmer Ny Kod
34-36
46
Kommentar
String
groupMembers[] =
{
”Peter”,
”Simon”
Ändrade datatypen från en integer till en string samt ersatte
};
siffrorna i listan med gruppmedlemmarnas namn.
TextOut(0,
Ändrade värdet 16 till 6 så att det andra namnet I listan inte ska
(LCD_LINE2 –
hamna på rad 56 som LCD_LINE1 skrivs ut på. Har även sett till så
(8*i-6)), names[i]); att det första namnet i listan inte har ett värde som är högre än 56.
92
lightIntensity =
Ändrade så att lightIntensity läser av värdet från rätt sensor (IN_1
sensorRaw(IN_3); är ingen ljussensor)
Har inte mycket att kommentera på dessa, kan bara säga att vi
testade oss fram och denna lösning är den som fungerade för oss.
Man skulle antagligen kunna byta plats på B & A eftersom det inte
OnFwd(OUT_B,
borde spela någon roll, det viktigaste är att man har en Fast & en
SpeedFast);
Slow för både B & A samt att de är i samma if-sats.
93
OnFwd(OUT_B,
SpeedSlow);
98
OnFwd(OUT_A,
SpeedFast);
99
OnFwd(OUT_A,
SpeedSlow);
2
Vi ändrade hastigheterna på SpeedSlow och SpeedFast eftersom vi
#define SpeedSlow trodde att roboten skulle ha det lättare att följa den svarta linjen om
40
den inte gick för snabbt.
3
#define SpeedFast
60
76