Gör: it Robotics startkit - analysera LineFollowing.ino del 2

I senaste Instructable började vi analysera de bitvisa operationerna i lineFollow.ino skissen. Vi såg hur sensormätningar tolkas för att göra roboten gå framåt.

I denna tutorial vi kommer att fortsätta vår analys ser hur lineFollow.ino programmet tolkar när svarten i under vänstra sensorn. Genom att återigen hänvisa till utdata från våra readOptical.py Python program när de tredje och fjärde sensormätningar är 0x00 och 0x100.

(se readOptical.py programmet om du behöver en påminnelse. Vi startar igen på toppen av den för loopen igen:

optValues = [0xff, 0x100, 0x00, 0x100, 0xff, 0x100]
för elem i optValues:

sensor _in = 0x0

insats 1 = 0x3

åtgärd2 = 0x3

sensorValue1 = 0xff

sensorValue2 = 0x0

0x0 & 0xf00

0x0 = 0b00000000000000000

xf00 = 0b0000111100000000

om 0 × 0 & 0xf00 == 0

inne om sensor_in & 0xf00 == 0

0x0 & 0xff

sensorValue1 = 0b0000000000000000

& 0b0000000011111111

----------------------------------------------

0b0000000000000000

sensorValue1 = 0 × 0

Sensor_in värdet är 0 × 00 och vi utför igen en och & drift med värdet på 0xf0. Som vi sagt innan kontrollerar vi om sensor_in data är en 8 eller 16 bitars värde. 0x00 är naturligtvis ett 8-bitars värde som visas ovan, (alla nollor). Så den & och returnerar en 0x00. Så sensorValue1 är lika med 0x00.
Eftersom sensorValue1 är lika med 0x00

Vi utför if uttalande

om (sensorValue1 == 0x00)
inuti sensorValue1 == 0x00

0x3 & 0xf

eaction1 = 0b0000000000000011

& 0b0000000011111110

------------------------------------------

0b0000000000000010

insats 1 = 0x2

Nu här är en intressant bit, märker att från senaste slingan Åtgärd1 var 0x3, så vi nu och & Åtgärd1 med 0xfe, märker bitmask, 0xfe har alla åtta bit med värdet 1 med undantag av den bit 0 positionen. Så när vi och & två värden får vi Åtgärd1 = 0x2. Som vi sa, sensor värdena har speciella betydelser, i detta fall sätter vi upp våra åtgärder för en högersväng.
Eftersom sensorValue1 inte är lika med 0xff vi hoppa över nästa om uttalande. sensorValue2 är lika med 0x00 så kan hoppa inne om uttalande.

om (sensorValue2 == 0x00)
inne i sensorValue2 == 0x00

0x2 | 0x02

insats 1 = 0b0000000000000010

| 0b0000000000000010

-------------------------------------------

0b0000000000000010

insats 1 = 0x2

Insats 1 är nu lika med 0x2, när vi eller & med 0x02 vi naturligtvis få ett värde på 0x02.
Sist om uttalande naturligtvis returnerar false så vi hoppa över den. Kan vi nu gå vidare till den andra uppsättningen av om uttalanden:

om (insats 1! = åtgärd2)

{

om (insats 1 == 3)

line_following.go_forward(50);

om (insats 1 == 1)

line_following.line_following_turn_left(50);

om (insats 1 == 2)

line_following.line_following_turn_right(50)

om (insats 1 == 0)

line_following.go_forward(50);

}

åtgärd2 = Åtgärd1;

Insats 1 är lika med 0 × 02 ges kommandot "sväng höger".
Låt oss hoppa tillbaka upp till toppen av if uttalande och utseende som den nästa sensor_in värde om 0x100.

sensor _in = 0x100

insats 1 = 0x2

åtgärd2 = 0x2

sensorValue1 = 0x0

sensorValue2 = 0x0

0x100 & 0xf00

0x100 = 0b00000001000000000

xf00 = 0b0000111100000000

om 0x100 & 0xf00 == 0

inuti elif

0x100 & 0xff

sensorValue2 = 0b0000000100000000

& 0b0000000011111111

---------------------------------------------------

0b0000000000000000

SensorValue2 = 0x0

Ta del av värdena för insats 1, åtgärd2, sensorValue1 och sensorValue2. Som innan de påverkar värdena när vi kör igenom om uttalanden igen.
sensor_in är nu lika med ett värde av 0x100, som vi noterat innan detta är ett 16-bitars nummer, så när vi utvärderar den första om uttalande den annan om uttalande kommer att vara sant.

Efter bearbetning AND & drift, sensorValue2 nu innehåller värdet av 0x00. Igen när vi bearbetar påminnelsen om uttalanden, vi ange värden för sensorValue1 och sensorValue2.

Som ett resultat har sensorValue1 och sensorValue2 värden för 0x00 så Åtgärd1 slutresultatet är 0x02.

Nu som förra gången vi bearbetade det andra värdet är sensor, innehåller Åtgärd1 och åtgärd2 båda samma värden, så ges det motoriska kontrollerar om uttalande hoppas över och inga motoriska kommandon.

På denna punkt är roboten på väg tillbaka mot den svarta linjen. Så är senast inställda värden i readOptical.py programmet simulera denna situation. Båda sensorerna läser värden som om sensor1 och sensor2 vita returvärden.

Du kan referera till första gången vi körde genom om uttalanden när sensorn värdena var 0xff och 0x100 se resultatet.

Igen hålla ett öga på de tidigare värdena för sensorValue1, sensorValue2, insats 1 och åtgärd2 som dessa värden bestämmer om motorn om exekveras deklarationerna eller inte.

Nu kan ta en titt på de andra readOptical.py resultat där vi har de följande värden på sensorn i matrisen optValues:

optValues = [0xff, 0x100, 0xff, 0x1ff, 0xff, 0x100]

Vi börjar igen förutsatt att roboten är gränsöverskridande den svarta linjen, så som svart linje kurvor i en cirkel vi sedan antar rätt sensorn blir svart.

ReadOptical.py programmet bearbetar sedan om uttalanden och slutar med den tredje uppsättningen värden igen simulera roboten gränsöverskridande centrera fodrar igen.

Öppna upp din readOptical.py-utdatafil som vi äldre och låta granska om logik igen. Eftersom vi redan har diskuterat logik både sensor1 och sensor2 att vara vit, simulera roboten gränsöverskridande centrera fodrar, kan du granska denna kod på din egen genom att titta på den tidigare analysen.

Låt oss nu titta på den andra uppsättningen värden när rätt sensorn är svart. Återigen hålla ett öga av tidigare värden för sensorValue1, sensorValue2, insats 1 och åtgärd2.

sensor _in = 0xff

insats 1 = 0x3

åtgärd2 = 0x3

sensorValue1 = 0xff

sensorValue2 = 0x0
0xFF & 0xf00

0xFF = 0b0000000011111111

0xf00 = 0b0000111100000000

om 0xff & 0xf00 == 0

inne om sensor_in & 0xf00 == 0

0xFF & 0xff

sensorValue1 = 0b0000000011111111

& 0b0000000011111111

----------------------------------------------------

0b0000000011111111

sensorValue1 = 0xff

Tredje passera genom öglan med hjälp av ett sensor_in av 0xff. Observera att vi har kört genom vår logik innan med sensor_in sätts till 0xff, Åtgärd1 leder fortfarande 0x03, men eftersom Åtgärd1 och åtgärd2 värden anges till samma värden, motorn om uttalande inte körs denna gång.

Så skickas ingen motorisk kontroll till roboten.
Nu kör vi genom öglan för fram tid där sensor_in värde är 0x1ff.

sensor _in = 0x1ff

insats 1 = 0x3

åtgärd2 = 0x3

sensorValue1 = 0xff

sensorValue2 = 0x0
0x1ff & 0xf00

0x1ff = 0b0000000111111111

0xf00 = 0b0000111100000000

om 0x1ff & 0xf00 == 0

inuti elif

0x1ff & 0xff

sensorValue2 = 0b0000000111111111

& 0b0000000011111111

-------------------------------------------------

0b0000000011111111

SensorValue2 = 0xff

Som tidigare, sensor_in är inställd på en 16 bitars nummer så kör vi den annars om logik.
sensorValue2 är nu värdet till 0xff. Så nu ställs sensorValue1 och sensorValue2 till 0xff.

om (sensorValue1 == 0xFF)
så den ovan om deklarationen exekveras.

inne i sensorValue1 == 0xff

0x3 | 0x01

insats 1 = 0b0000000000000011

| 0b0000000000000001

--------------------------------------------

0b0000000000000011

insats 1 = 0x3

insats 1 anges nu till 0x03.

Nästa om deklarationen exekveras då:

om (sensorValue2 == 0xFF)

0x3 & 0xfd

insats 1 = 0b0000000000000011

& 0b0000000011111101

-----------------------------------------

0b0000000000000001

insats 1 = 0x1

Till följd av AND & drift, Åtgärd1 anges nu till värdet 0x1.
Eftersom Åtgärd1 och åtgärd2 andra, motor logiken om deklarationen exekveras och som ni kan se motor anvisningen av "gå vänster" körs.

Den tredje uppsättningen värden är samma som tidigare och ge instruktioner för roboten att "Gå framåt" om du vill kan du granska logiken på egen hand.

Så har vi nu utvärderat alla den logik som styr roboten i programmet lineFollow.ino.

Hur att vi gå härifrån?

Bör vi bryr oss så mycket varför ingenjören utformad motor driver/senor hur han eller hon gjorde. Inte riktigt.

Nu när vi förstår vad logiken gör, i framtida projekt som använder sensorer vet vi nu hur man använder denna logik att läsa och tolka sensor1 och sensor2 data.

Om i framtiden vill vi utforma vår egen förare ombord då vi kan undersöka varför ingenjör konstruerade styrelsen hur han eller hon gjorde.

Men nu har du tillräcklig kunskap att skriva nya program att använda sensordata med din robot. I framtiden Instructables vi kommer att fortsätta att titta på arbeta med Make: it Robotics Starter Kit.

Njuta av.

Kolla in min blogg för mer information

http://joepitz.wordpress.com/