Gör: it Robotics startkit - analysera LineFollowing.ino Del1 (2 / 2 steg)

Steg 2: Utdata från readOptical.py

Som jag sa i en tidigare blogg, har jag gjort alla matematik och logik för dig, allt du behöver göra är att följa med.

Här är din chans att få använda för att läsa binära och hexadecimala siffror. At är först ser ut som rappakalja, men du kommer att få använda den. Om du har problem,

Läs tutorials som jag har gjort en hänvisning till i min tidigare blogg inlägg.

Om du inte vill gå in här stor detaljrikedom sedan titta bara för delar av produktionen där resultaten visar antingen "gå fram", "sväng vänster" eller "sväng höger"

Låt oss analysera vad som händer inne i programmet:

Utanför låter först titta på kommentarerna från metoden readOptical() i vårt lineFollow.ino program:

0x000 optical1 svart

0xFF optical1 vit

0x100 optical1 vit

0x1ff optical1 svart

0x2XX inte redo; Använd inte detta värde

Observera att tre optisk sensor behandlingar börjar med antingen 0x1 eller 0x2 hex.

Övriga startar med 0x0 eller 0xf. Om du konverterar dessa tal till ett binärt kommer du se ett mönster. Ladda Python Idle och skriv följande:

>>> format (oxff, "#018b")

Anger parametern format "#018b" för att visa numret passerade som en binär 16 bitars nummer vilket kommandot format kommer att returnera följande:'0b0000000011111111′

Märke att det finns 8 nollor följt av 8 1: s.

Denna 16-bitars nummer har de minst signifikanta 8 bitar inställd på 1.

Om du skriver följande i Python:

>>> hex(int('11111111′,2))

Du kommer att få: "0xff"

Nu kan du prova följande:

>>> format (0 × 0, "#018b")

Python kommer tillbaka: ' 0b0000000000000000′

Kan prova de andra två värden som funktionen readOptical() returnerar.

>>> format (0x1ff, "#018b")

"0b0000000111111111′

>>> format (0 × 100, "#018b")

"0b0000000100000000′

Hur många 1: s visas i den binär representationen av 0x1ff?

Vilken ställning är 1 i, räknat från höger, för 0 × 100?

Korrekt, i båda fallen 1 visar upp i den nionde bitposition från höger.

Metoden readOptical() i lineFollow.ino returnerar endast värden som har ett distinkt mönster.

Optisk 1 sensorer endast returnera nummer som anges i 8 bitar.

Optisk 2 sensorer kan ha tal som ställs i den nionde positionen bit eller 16-bitars nummer.

Låt oss börja titta på våra resultat från readOptical.py Python program.

Först titta vi på de variabler som är inställda i början av programmet lineFollow.ino:

sensor _in = 0xff

insats 1 = 0x0

åtgärd2 = 0x0

sensorValue1 = 0x0

sensorValue2 = 0x0

Det första sensor värdet vi läser är 0xff, resten av variablerna är 0x0.

Först om uttalande utför en bitvis och på två värden:

om ((sensor_in & 0xf00) == 0)

Titta på produktionen igen:

0xFF & 0xf00

0xFF = 0b0000000011111111

0xf00 = 0b0000111100000000

om 0xff & 0xf00 == 0

inne om sensor_in & 0xf00 == 00

xff & 0xff

sensorValue1 = 0b0000000011111111

& 0b0000000011111111

——————

0b0000000011111111

sensorValue1 = 0xff

Titta noga på bitvis AND-operationen, vi kontrollerar för att se om någon av de övre 8 bitarna av 16-bitars nummer sensor_in är inställd.

I detta fall och jämförelsen avkastning 0 som det finns inga bitar större än den så att betydande 8 bitar som i den rörliga sensor_in.

Så den första delen av if uttalande kommer bara vara sant om sensor_in innehåller 0x000 eller 0xff.

Sedan först om uttrycket är sant, köra vi kommandot för:

sensorValue1 = sensor_in & 0xff;

ANDing ett tal med sig själv ger oss samma nummer, sensorValue1 = 0xff

0xFF & 0xff

sensorValue1 = 0b0000000011111111

& 0b0000000011111111

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

0b0000000011111111

sensorValue1 = 0xff

Låt oss gå vidare till den andra om uttalande:

om (sensorValue1 == 0x00)

Om vi tittar på variabeln sensorValue1, den innehåller 0xff så här om uttalande är falska och inte får köras.

Flytta på:

om (sensorValue1 == 0xFF)

sensor_in är lika med 0xff så kör vi om uttalande:

insats 1 = insats 1 | 0x01;

I detta fall ställer vi in variabeln av Åtgärd1 lika åtgärder och använda operatorn bitvis eller till ett värde av 0 × 01.

Titta på resultaten av OR drift Åtgärd1 får ange ett värde för 0x01.

inne i sensorValue1 == 0xff

0x0 | 0x01

insats 1 = 0b0000000000000000

| 0b0000000000000001

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

0b0000000000000001

insats 1 = 0x1

På Nästa om uttalande:

om (sensorValue2 == 0x00)

Vi kontrollerar om sensorValue2 är lika med 0x00, och naturligtvis för närvarande sensorValue2 är lika med 0x00 så kör vi om uttalande:

insats 1 = insats 1 | 0x02;

inne i sensorValue2 == 0x00

0x1 | 0x02

insats 1 = 0b0000000000000001

| 0b0000000000000010

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

0b0000000000000011

insats 1 = 0 × 3

I sist om uttalande vi kontrollerar:

om (sensorValue2 == 0xFF)

sensorValue2 är inte lika med 0xff så vi går vidare. Slutliga Åtgärd1 värdet 0 × 03, vi avslutar den sista om uttalande och gå vidare på den nästa uppsättning 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 = 0x3

åtgärd2 = 0x0

Vi kontrollerar den första om uttalande:

om (insats 1! = åtgärd2)

Detta är sant så vi in den kapslade om uttalande:

insats 1 = 0x3

så kör vi den sant om uttalande:

line_following.go_forward(50);

Nu i vår readOptical.py program återvänder vi till toppen av den för loop och vi börja igen med nästa värde: sensor_in = 0x100

insats 1 = 0x3

åtgärd2 = 0x3

sensorValue1 = 0xff

sensorValue2 = 0x0

I detta fall är sensor_in variabel lika med 0x100

Låt oss titta på den första om uttalande igen:

om ((sensor_in & 0xf00) == 0)

sensorValue1 = sensor_in & 0xff;

annars om ((sensor_in & 0xf00) >> 8 == 1)

sensorValue2 = sensor_in & 0xff;

Som vi påpekade under den sista slingan, först om uttalande söker antingen 0xff eller 0 × 00.

I detta fall om uttalande är falsk, så vi hoppa till den annars om uttalande: I detta fall om uttalande gör en bitvis och och en höger Skift 8 bitar.

Så vi tar 1 9 bitars läge och flytta det 8 gånger till höger,

0 × 100 = 0b0000000100000000

0xf00 = 0b0000111100000000

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

& 0b0000000100000000

Högerskift

0b0000000000000001

Detta värde är lika med 1 så att vi utföra if uttalande.

sensorValue2 = sensor_in & 0xff;

0 × 100 & 0xff

sensorValue2 = 0b0000000100000000

& 0b0000000011111111

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

0b0000000000000000

SensorValue2 = 0x0

Flytta ner om uttalanden, vi kolla nästa om uttalande:

om (sensorValue1 == 0x00)

sensorValue1 är lika med 0xff så vi hoppa över detta om uttalande. Nästa om uttalande:

om (sensorValue1 == 0xFF)

insats 1 = insats 1 | 0x01;

Den om uttrycket är sant så kör vi om uttalande

inne i sensorValue1 == 0xff

0x3 | 0x01

insats 1 = 0b0000000000000011

| 0b0000000000000001

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

0b0000000000000011

insats 1 = 0x3

Nästa om uttalande:

om (sensorValue2 == 0x00)

insats 1 = insats 1 | 0x02;

Den om uttrycket är sant så kör vi om uttalande

inne i sensorValue2 == 0 × 00

0x3 | 0x02

insats 1 = 0b0000000000000011

| 0b0000000000000010

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

0b0000000000000011

insats 1 = 0x3

Vi avsluta om uttalanden och gå vidare till nästa uppsättning om uttalanden:

om (insats 1! = åtgärd2)

I detta fall insats 1 är lika med åtgärd2 så vi hoppa if uttalande som skickar motor instruktioner.

Vi loop tillbaka runt till den för loopen igen och välj nästa sensor_in värde.

På denna punkt har vi skickat den motor driver en inställd om instruktioner att gå framåt, som sensorerna läser båda vita.

I nästa Instructable kommer vi gå vidare läsa sensor värdena när vänstra sensorn är svart.