Make: it Robotics starterskit - analyseren van de LineFollowing.ino deel 2


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/

Gerelateerde Artikelen

Make: it Robotics starterskit - analyseren van de LineFollowing.ino deel 1

Make: it Robotics starterskit - analyseren van de LineFollowing.ino deel 1

In onze laatste blogpost we bepaalde sensorgegevens uit de drie verschillende posities die onze robot tegenkomen kunt wanneer na de zwarte lijn, (links sensor zwart, links sensor/sensor wit, juiste sensor zwart) gevangen.In deze blogpost wij gaan nem
Make: it Robotics starterskit - Sensor Data draadloos verzenden

Make: it Robotics starterskit - Sensor Data draadloos verzenden

In dit Instructable we willen nemen wat we geleerd hebben in "Make: it Robotics Starter Kit – draadloze connectiviteit" en "Make: it Robotics Starter Kit – vastleggen van Sensor Data" en combineert deze gegevens vastleggen van de senso
Make: it Robotics starterskit - begrip Bitwise Math

Make: it Robotics starterskit - begrip Bitwise Math

Deze blogpost is een voortzetting op mijn knutselen met de Make: it Robotics Kit. Hopelijk kan ik doorgeven op sommige van de informatie die ik heb geleerd zodat het gemakkelijker voor anderen om aan de slag over het werken met de Robotics Kit.Na het
Make: it Robotics starterskit-draadloze connectiviteit

Make: it Robotics starterskit-draadloze connectiviteit

In dit blog bericht wij gaan nemen van de informatie die we geleerd hebben in de eerdere blogpost getiteld "Make: it Robotics starterskit-Software deel 2″ Real-time sensorgegevens vastleggen en verzenden van deze gegevens draadloos naar onze computer
Make: it Robotics starterskit-Driver board vertrouwd

Make: it Robotics starterskit-Driver board vertrouwd

In deze blogpost zullen we een kijkje op de kaart die bij de zorg: it Robotics Starter Kit wordt geleverd. Er is geen documentatie die wordt geleverd met de Start kit betreffende het bestuur van de bestuurder dan het schema.Tenzij u al enige ervaring
Make: it Robotics Starter Kit vastleggen van Sensor Data

Make: it Robotics Starter Kit vastleggen van Sensor Data

Laatste Instructable bespraken we een beetje over wat er in het linefollow.ino-programma doet. Ik heb gepresenteerd een Python-script dat ons toelaten zal om het analyseren van de bit-gewijze if verklaringen om te zien hoe de waarde die de methode re
Automatisch kwantificeren en analyseren van gebeurtenissen met Wolfram gegevens neerzetten en próta OS

Automatisch kwantificeren en analyseren van gebeurtenissen met Wolfram gegevens neerzetten en próta OS

Het Wolfram gegevens Drop is een open dienst die maakt het makkelijk om te accumuleren gegevens van welke aard ook, vanaf elke locatie - het instellen voor onmiddellijke berekening, visualisatie, analyse, opvragen of andere activiteiten.Dit instructa
Analyseren van elk willekeurig IR-protocol met alleen je Arduino board

Analyseren van elk willekeurig IR-protocol met alleen je Arduino board

onlangs was ik in diepe onderzoek over hoe te maken van onze eigen "zelf leren universele Remote". Dus toen ik voor de procedure zocht voor het maken van deze, eerste stap die ik vond is het analyseren van IR-protocol, pulse de frequentie (perio
How To Make Quilled omzoomd met behulp van papier Art filigraan bloemen | DIY

How To Make Quilled omzoomd met behulp van papier Art filigraan bloemen | DIY

How To Make Quilled omzoomd met behulp van papier Art filigraan bloemen | DIYIn deze tutorial u hoe leert te quilled omzoomd bloemen in op steenworp afstand. Laten we beginnen.Nou ik hoop dat je genoten hebt van dit ambacht en zo ja, vergeet dan niet
Hoe om te analyseren van een voertuig CAN-BUS met behulp van een Arduino verbonden aan een CAN-BUS schild en vrije software.

Hoe om te analyseren van een voertuig CAN-BUS met behulp van een Arduino verbonden aan een CAN-BUS schild en vrije software.

De Hardware die is ingebouwd in een vorige InstructableIn een vorige instructable Ive getoond hoe kun je samen hardware als u wilt scannen uw kan bus, de instructable kan hier worden gevonden.Ik heb gemaakt een forumdraad uitleggen een beetje meer in
Hoe maak je een korte Film van Professional voor $80 (deel I - pre-productie).

Hoe maak je een korte Film van Professional voor $80 (deel I - pre-productie).

Deel II kan hier worden gevonden: How to make van een korte Film van Professional voor $80 (deel II - productie)Ik heb het maken van films sinds de vijfde klas. In deze tijd, heb ik talloze korte broek die voortdurend beter krijgen gemaakt. Als een s
Versterking van een 3D afgedrukt deel

Versterking van een 3D afgedrukt deel

Zoals we weten allemaal, 3D gedrukte onderdelen geproduceerd door onze gewone huis type printers zijn niet zo sterk en wanneer gebruikt in plaats van de werkelijke delen, zij duren niet lang. Ik dacht dat het zou geweldig zijn als het is mogelijk om
Overspuiten van wielen - polijsten van bouten en moeren (deel 1 van 3)

Overspuiten van wielen - polijsten van bouten en moeren (deel 1 van 3)

dit instructable doorloopt de stappen die ik nam te refinish een set oude 3-delige wielen die ik had rond leggend.  De wielen zijn oude Racing Hart Type-C wielen uit de vroege jaren 90, zodat ze ongeveer 20 jaar oud op dit punt, en waren vrij beat up
De doos van de Gift van de decoratieve Origami: Deel II, Bling toevoegen

De doos van de Gift van de decoratieve Origami: Deel II, Bling toevoegen

Deze tutorial zal gaan over de opties die ik heb gekozen om mijn dozen versieren. Terwijl ik kon heel goed gewoon zeggen "doen wat je wilt", hoop ik dat mijn eenvoudige decoraties, evenals sommige nuttige adviezen uit mijn ervaring zal helpen st