Stap 2: Uitvoer van readOptical.py
Zoals ik al zei in een eerdere blog, heb ik alles gedaan van de wiskunde en de logica voor u, alles wat je hoeft te doen is te volgen.
Hier is uw kans om te krijgen gebruiken om te lezen van binaire en hexadecimale getallen. At is eerst kijkt als wartaal, maar je zal gebruiken om het te krijgen. Als u problemen ondervindt,
Lees de tutorials die ik heb gemaakt een verwijzing naar in mijn eerdere blog posts.
Als u niet wilt gaan in deze grote detailniveau dan kijk voor de gedeelten van de uitvoer wanneer uit de resultaten blijkt ofwel "Doorgaan", "linksaf" of "rechts"
Laten we analyseren wat er gebeurt in het programma:
Eerste off laat kijken naar de opmerkingen van de methode van de readOptical() in ons lineFollow.ino-programma:
0x000 optical1 zwart
0xFF optical1 wit
0x100 optical1 wit
0x1ff optical1 zwart
0x2XX niet klaar; geen gebruik maken van deze waarde
Merk op dat drie optische sensor lezingen met 0x1 of 0x2 begint hex.
De rest beginnen met 0x0 of 0xf. Als u deze getallen naar een binair getal converteren ziet u een patroon. Laden Python Idle en typt u het volgende:
>>> formaat (oxff, '#018b')
De parameter format '#018b' geeft aan dat nummer weergegeven in het doorgegeven als een binaire 16-bits getal zodat het formaatbevel het volgende zal terugkeren:'0b0000000011111111′
Merk op dat er 8 nullen gevolgd door 8 1′s.
Deze 16-bits getal heeft de minst significante 8 bits ingesteld op 1.
Als u type ter naar de volgend in Python:
>>> hex(int('11111111′,2))
U krijgt: '0xff'
Laat nu het volgende proberen:
>>> formaat (0 × 0, '#018b')
Python zal terugkeren: ' 0b0000000000000000′
Laten we proberen de andere twee waarden die de functie readOptical() retourneert.
>>> formaat (0x1ff, '#018b')
' 0b0000000111111111′
>>> formaat (0 × 100, '#018b')
' 0b0000000100000000′
Hoeveel 1′s worden weergegeven in de binaire vertegenwoordiging van 0x1ff?
Welk standpunt is de 1 in, gerekend van rechts, voor 0 × 100?
Corrigeren, In beide gevallen 1 wordt weergegeven in de achtste bit positie vanaf de rechterkant.
De methode van de readOptical() in de lineFollow.ino alleen waarden geretourneerd die een verschillend patroon hebben.
Optische 1 sensoren retourneren alleen nummers die zijn ingesteld binnen 8 bits.
Optische 2 sensoren kunnen hebben nummers die zijn ingesteld in de achtste bit positie, of nummers van de 16-bits.
Laten we beginnen met het kijken naar onze resultaten van de readOptical.py Python programma.
We kijken eerst naar de variabelen die ingesteld in het begin van het lineFollow.ino-programma zijn:
sensor _in = 0xff
Actie1 = 0x0
Actie2 = 0x0
sensorValue1 = 0x0
sensorValue2 = 0x0
De eerste sensor waarde die we aan het lezen bent is 0xff, de rest van de variabelen zijn 0x0.
De eerste als verklaring een bitsgewijs en op twee waarden voert:
Als ((sensor_in & 0xf00) == 0)
Kijk naar de uitvoer weer:
0xFF & 0xf00
0xFF = 0b0000000011111111
0xf00 = 0b0000111100000000
Als 0xff & 0xf00 == 0
binnen als sensor_in & 0xf00 == 00
XFF & 0xff
sensorValue1 = 0b0000000011111111
& 0b0000000011111111
——————
0b0000000011111111
sensorValue1 = 0xff
Kijk goed naar de bitsgewijze AND-bewerking, we controleren om te zien als een van de hogere 8 bits van de 16-bits nummer sensor_in is ingesteld.
In dit geval de vergelijking en retourneren 0 als er geen bits groter is dan de opdat significante 8 bits ingesteld in de variabele sensor_in.
Dus het eerste deel van de als verklaring zal alleen gelden als sensor_in 0x000 of 0xff bevat.
Sinds de eerste als bewering klopt, commando we het van:
sensorValue1 = sensor_in & 0xff;
ANDing een getal met zichzelf geeft ons het zelfde nummer, sensorValue1 = 0xff
0xFF & 0xff
sensorValue1 = 0b0000000011111111
& 0b0000000011111111
--------------------------------
0b0000000011111111
sensorValue1 = 0xff
Laten we overgaan tot de tweede als verklaring:
Als (sensorValue1 == 0x00)
Als we kijken naar de sensorValue1 variabele, het bevat 0xff hiervoor als verklaring vals is en doet niet worden uitgevoerd.
Bewegen op:
Als (sensorValue1 == 0xFF)
sensor_in is gelijk aan 0xff dus voeren we uit de als verklaring:
Actie1 = Actie1 | 0x01;
In dit geval zijn we de variabele van Actie1 gelijk actie en toepassen van de exploitant van het Bitwise of op de waarde van 0 × 01 instellen.
Kijkend naar de resultaten van de OR operatie Actie1 wordt ingesteld op een waarde van 0x01.
binnenkant van sensorValue1 == 0xff
0x0 | 0x01
Actie1 = 0b0000000000000000
| 0b0000000000000001
-------------------------------
0b0000000000000001
Actie1 0x1 =
Op de volgende als verklaring:
Als (sensorValue2 == 0x00)
We controleren of de sensorValue2 gelijk aan 0x00 is, en momenteel sensorValue2 natuurlijk gelijk aan 0x00 is dus voeren we uit de als verklaring:
Actie1 = Actie1 | 0x02;
binnenkant van sensorValue2 == 0x00
0x1 | 0x02
Actie1 = 0b0000000000000001
| 0b0000000000000010
-----------------------------------
0b0000000000000011
Actie1 = 0 × 3
In de laatste als verklaring die we controleren:
Als (sensorValue2 == 0xFF)
sensorValue2 is niet gelijk aan 0xff zodat we gaan. De eindwaarde van Actie1 is 0 × 03, we sluiten de laatste if verklaring en gaat u verder op de de volgende reeks als verklaringen:
Als (Actie1! = Actie2)
{
Als (Actie1 == 3)
line_following.go_forward(50);
Als (Actie1 == 1)
line_following.line_following_turn_left(50);
Als (Actie1 == 2)
line_following.line_following_turn_right(50);
Als (Actie1 == 0)
line_following.go_forward(50);
}
Actie2 = Actie1;
}
Actie1 0x3 =
Actie2 = 0x0
We controleren de eerste als verklaring:
Als (Actie1! = Actie2)
Dit geldt dus we de geneste if invoeren verklaring:
Actie1 0x3 =
zo voeren wij uit de true als verklaring:
line_following.go_forward(50);
Nu in ons programma readOptical.py keren we terug naar de top van de voor lus en we weer met de volgende waarde beginnen: sensor_in = 0x100
Actie1 0x3 =
Actie2 0x3 =
sensorValue1 = 0xff
sensorValue2 = 0x0
In dit geval de sensor_in variabele is gelijk aan 0x100
Laten we eens kijken naar de eerste if verklaring opnieuw:
Als ((sensor_in & 0xf00) == 0)
sensorValue1 = sensor_in & 0xff;
anders als ((sensor_in & 0xf00) >> 8 == 1)
sensorValue2 = sensor_in & 0xff;
Zoals we tijdens de laatste lus, de eerste als verklaring is op zoek naar beide 0xff of 0 × 00 gewezen.
In dit geval de als verklaring is onwaar, zodat we anders indien springen verklaring: In dit geval de als verklaring doet een bitsgewijs en en een recht Shift 8 bits.
Dus zijn we nemen van de 1 op de 9 bits locatie en 8 keer verschuiven naar rechts,
0 × 100 = 0b0000000100000000
0xf00 = 0b0000111100000000
--------------------------------------
& 0b0000000100000000
Rechts
0b0000000000000001
Deze waarde is gelijk aan 1 dus voeren we uit de als verklaring.
sensorValue2 = sensor_in & 0xff;
0 × 100 & 0xff
sensorValue2 = 0b0000000100000000
& 0b0000000011111111
------------------------------------
0b0000000000000000
SensorValue2 = 0x0
Naar beneden de if verklaringen, controleren we de volgende als verklaring:
Als (sensorValue1 == 0x00)
sensorValue1 is gelijk aan 0xff zodat we overslaan dit als verklaring. Volgende als verklaring:
Als (sensorValue1 == 0xFF)
Actie1 = Actie1 | 0x01;
De als bewering klopt dus wij de if voeren statement
binnenkant van sensorValue1 == 0xff
0x3 | 0x01
Actie1 = 0b0000000000000011
| 0b0000000000000001
----------------------------------
0b0000000000000011
Actie1 0x3 =
Volgende als verklaring:
Als (sensorValue2 == 0x00)
Actie1 = Actie1 | 0x02;
De als bewering klopt dus wij de if voeren statement
binnenkant van sensorValue2 == 0 × 00
0x3 | 0x02
Actie1 = 0b0000000000000011
| 0b0000000000000010
---------------------------------------
0b0000000000000011
Actie1 0x3 =
We eindigen de if verklaringen en bewegen op de de volgende reeks als verklaringen:
Als (Actie1! = Actie2)
In dit geval Actie1 is gelijk aan Actie2 zodat we overslaan de if-instructie die motor instructies stuurt.
We lus terug rond om de voor lus opnieuw en selecteer de volgende waarde van de sensor_in.
We hebben op dit punt de motor bestuurder één set als instructies om vooruit te gaan, als de sensoren zowel leest witte gestuurd.
In de volgende Instructable gaan wij over de sensor-waardes lezen als de linker sensor zwart is.
