In de laatste Instructable begonnen we analyseren de bitsgewijze bewerkingen in de schets van de lineFollow.ino. We keken hoe de sensor lezingen worden geïnterpreteerd zodat de robot vooruit gaan.
In deze tutorial zullen we blijven onze analyse bij het bestuderen hoe het programma lineFollow.ino worden geïnterpreteerd wanneer de black in onder de linker sensor. Door opnieuw te verwijzen naar de output van onze readOptical.py Python program als de derde en vierde sensor lezingen 0x00 en 0x100.
(verwijs naar de readOptical.py programma als u een herinnering nodig. Zullen we opnieuw beginnen aan de bovenkant van de for-lus opnieuw:
optValues = [0xff, 0x100, 0x00, 0x100, 0xff, 0x100]
voor elem in optValues:
sensor _in = 0x0
Actie1 0x3 =
Actie2 0x3 =
sensorValue1 = 0xff
sensorValue2 = 0x0
0x0 & 0xf00
0x0 = 0b00000000000000000
xf00 = 0b0000111100000000
als 0 × 0 & 0xf00 == 0
binnen als sensor_in & 0xf00 == 0
0x0 & 0xff
sensorValue1 = 0b0000000000000000
& 0b0000000011111111
----------------------------------------------
0b0000000000000000
sensorValue1 = 0 × 0
De sensor_in waarde is 0 × 00 en wij voeren opnieuw een en & werking met de waarde van 0xf0. Zoals gezegd zijn wij het als sensor_in gegevens een 8 bits of 16-bits waarde is te controleren. Natuurlijk is 0x00 een 8-bit waarde zoals hierboven, (alle nullen). Dus de & AND-bewerking retourneert een 0x00. Dus sensorValue1 gelijk aan 0x00 is.
Aangezien sensorValue1 gelijk aan 0x00 is
Wij voeren de if statement
Als (sensorValue1 == 0x00)
binnen sensorValue1 == 0x00
0x3 & 0xf
eaction1 = 0b0000000000000011
& 0b0000000011111110
------------------------------------------
0b0000000000000010
Actie1 0x2 =
Nu hier is een interessant stukje, merken dat uit de laatste lus Actie1 was 0x3, dus we nu en & Actie1 met 0xfe, opmerken het bitmasker, 0xfe heeft alle 8-bits ingesteld op 1 met uitzondering van de bits 0-positie. Dus wanneer we en & de twee waarden krijgen we Actie1 0x2 =. Zoals we al zeiden, de sensor-waardes een speciale betekenis hebben, In dit geval zijn we het opzetten van ons optreden voor een bocht naar rechts.
Aangezien sensorValue1 niet gelijk aan 0xff is we overslaan de volgende als verklaring. sensorValue2 is gelijk aan 0x00 dus laten we springen binnenkant van de als verklaring.
Als (sensorValue2 == 0x00)
binnenkant van sensorValue2 == 0x00
0x2 | 0x02
Actie1 = 0b0000000000000010
| 0b0000000000000010
-------------------------------------------
0b0000000000000010
Actie1 0x2 =
Aangezien Actie1 nu gelijk aan 0x2 is, wanneer we of & met 0x02 krijgen we natuurlijk een waarde van 0x02.
De laatste als verklaring natuurlijk false retourneert zodat we het overslaan. We kunnen nu op de de tweede reeks van if 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;
Aangezien Actie1 gelijk aan 0 × 02 is wordt de opdracht "turn Right" gegeven.
Laten we springen back-up van de de top van de if-instructie en kijk als de volgende sensor_in waarde als 0x100.
sensor _in = 0x100
Actie1 0x2 =
Actie2 0x2 =
sensorValue1 = 0x0
sensorValue2 = 0x0
0x100 & 0xf00
0x100 = 0b00000001000000000
xf00 = 0b0000111100000000
Als 0x100 & 0xf00 == 0
binnen elif
0x100 & 0xff
sensorValue2 = 0b0000000100000000
& 0b0000000011111111
---------------------------------------------------
0b0000000000000000
SensorValue2 = 0x0
Neem nota van de waarden van Actie1 Actie2, sensorValue1 en sensorValue2. Zoals voordat zij de waarden beïnvloedt wanneer we via de if verklaringen opnieuw.
sensor_in is nu gelijk aan een waarde van 0x100, zoals we opgemerkt voordat dit een 16-bits getal is, dus toen we de eerste if evalueren verklaring het anders als verklaring zal gelden.
Na het verwerken van de en & werking, sensorValue2 nu bevat de waarde van 0x00. Weer zoals wij de herinnering van de if verwerken verklaringen, stellen we de waarden van sensorValue1 en sensorValue2.
Dientengevolge hebben sensorValue1 en sensorValue2 de waarden van 0x00 dus Actie1 eindresultaat 0x02 is.
Nu net als de laatste keer dat we de tweede sensor waarde verwerkt, Actie1 en Actie2 beide dezelfde waarden bevatten, zodat de motorische controle als de verklaring is overgeslagen en geen motor opdrachten worden gegeven.
Op dit punt is de robot terug richting de zwarte lijn. Dus zijn laatste set van waarden in het readOptical.py-programma simuleren deze situatie. Beide sensoren lezen waarden alsof sensor1 en sensor2 witte waarden retourneren.
U kunt verwijzen naar de eerste keer dat we via de if liepen verklaringen toen de sensor-waardes 0xff waren en 0x100 om de resultaten te zien.
Weer een oogje houden op de vorige waarden van sensorValue1, sensorValue2, Actie1 en Actie2 deze waarden vast te stellen of de motor als instructies worden uitgevoerd of niet.
Laat nu een kijkje nemen op de resultaten van de tweede readOptical.py waar sprake is van de volgende sensor-waardes ingesteld in de array optValues:
optValues = [0xff, 0x100, 0xff, 0x1ff, 0xff, 0x100]
We uitgaan wederom ervan uitgaande dat de robot is het breukvlak van de zwarte lijn, dan als de zwarte lijn curven in een cirkel nemen wij vervolgens dat de juiste sensor gaat zwart.
Het readOptical.py programma verwerkt dan de if verklaringen en eindigt met de derde set waarden opnieuw simuleren de robot breukvlak van het center lijn weer.
Open te stellen uw readOptical.py-uitvoerbestand dat wij eerder opgeslagen en laten bekijken als logica opnieuw. Aangezien wij reeds hebben besproken de logica van zowel sensor1 en sensor2 zijn wit, de robot op de middenlijn te simuleren, kunt u deze code op uw eigen controleren door te kijken naar de eerdere analyse.
Laten we nu kijken naar de tweede reeks van waarden wanneer de juiste sensor zwart is. Opnieuw Houd een oogje van de vorige waarden van sensorValue1, sensorValue2, Actie1 en Actie2.
sensor _in = 0xff
Actie1 0x3 =
Actie2 0x3 =
sensorValue1 = 0xff
sensorValue2 = 0x0
0xFF & 0xf00
0xFF = 0b0000000011111111
0xf00 = 0b0000111100000000
Als 0xff & 0xf00 == 0
binnen als sensor_in & 0xf00 == 0
0xFF & 0xff
sensorValue1 = 0b0000000011111111
& 0b0000000011111111
----------------------------------------------------
0b0000000011111111
sensorValue1 = 0xff
Derde passeren de lus de waarde van een sensor_in van 0xff gebruiken. Opmerking dat we hebben uitgevoerd door onze logica voordat met sensor_in wordt ingesteld op 0xff, het resultaat van Actie1 is nog steeds 0x03, maar omdat Actie1 en Actie2 waarden zijn ingesteld op dezelfde waarden, de motor als verklaring voert niet uit deze tijd.
Dus is geen motorische controle verzonden naar de robot.
Nu lopen we door de lus voor de weer tijd waar sensor_in waarde is 0x1ff.
sensor _in = 0x1ff
Actie1 0x3 =
Actie2 0x3 =
sensorValue1 = 0xff
sensorValue2 = 0x0
0x1ff & 0xf00
0x1ff = 0b0000000111111111
0xf00 = 0b0000111100000000
Als 0x1ff & 0xf00 == 0
binnen elif
0x1ff & 0xff
sensorValue2 = 0b0000000111111111
& 0b0000000011111111
-------------------------------------------------
0b0000000011111111
SensorValue2 = 0xff
Zoals voorheen, sensor_in is ingesteld op een 16-bits nummer dus wij het anders als voeren logica.
sensorValue2 waarde is nu ingesteld op 0xff. Dus nu zijn sensorValue1 en sensorValue2 ingesteld op 0xff.
Als (sensorValue1 == 0xFF)
dus de hierboven als statement wordt uitgevoerd.
binnenkant van sensorValue1 == 0xff
0x3 | 0x01
Actie1 = 0b0000000000000011
| 0b0000000000000001
--------------------------------------------
0b0000000000000011
Actie1 0x3 =
Actie1 is nu ingesteld op 0x03.
De volgende als verklaring dan wordt uitgevoerd:
Als (sensorValue2 == 0xFF)
0x3 & 0xfd
Actie1 = 0b0000000000000011
& 0b0000000011111101
-----------------------------------------
0b0000000000000001
Actie1 0x1 =
Als gevolg van de en & bewerking, Actie1 is nu ingesteld op de waarde 0x1.
Aangezien Actie1 en Actie2 verschillend zijn, de motor logica als statement wordt uitgevoerd, en zoals u kunt zien de motor instructie van "go links" wordt uitgevoerd.
De derde set waarden zijn dezelfde als voorheen en hem daartoe instructies geven voor de robot "Gaan doorsturen" als u wilt kunt u het bekijken van de logica op uw eigen.
Zo hebben we nu al de logica waarmee de robot in het lineFollow.ino-programma geëvalueerd.
Hoe om te gaan we vanaf hier?
Moeten we zorg heel veel waarom de ingenieur ontworpen de motor driver/senor de manier waarop hij of zij deed. Niet echt.
Nu we begrijpen wat de logica doet, in de toekomst projecten die daar gebruik de sensoren nu weten wij hoe met deze logica de sensor1 en sensor2 gegevens lezen en interpreteren.
Als in de toekomst willen we ontwerpen onze eigen stuurprogramma board dan wij kunnen onderzoeken waarom de ingenieur ontworpen voor de Raad van bestuur de manier waarop hij of zij deed.
Maar nu heb je genoeg kennis om te schrijven van nieuwe programma's de sensorgegevens gebruiken met uw robot. In de toekomst Instructables we zullen blijven kijken werken met het merk: it Robotics Starter Kit.
Geniet van.
Check out mijn blog voor meer informatie
http://joepitz.WordPress.com/