Dans le dernier Instructable nous avons commencé à analyser les opérations au niveau du bit dans l’esquisse de la lineFollow.ino. Nous avons examiné comment les lectures du capteur sont interprétées pour rendre le robot à aller de l’avant.
Dans ce tutoriel, nous allons continuer notre analyse à la recherche comment le programme lineFollow.ino interprète quand le noir dans sous le capteur de gauche. Toujours en se référant à la sortie de notre readOptical.py Python programme lorsque les lectures du capteur de troisième et quatrième sont 0 x 00 et 0 x 100.
(voir le programme de readOptical.py si vous avez besoin d’un rappel. Nous allons commencer à nouveau en haut de la boucle à nouveau :
optValues = [0xff, 0 x 100, 0 x 00, 0 x 100, 0xff, 0 x 100]
pour elem dans optValues :
capteur _in = 0 x 0
Action1 = 0 x 3
Action2 = 0 x 3
sensorValue1 = 0xff
sensorValue2 = 0 x 0
0 x 0 & 0xf00
0 x 0 = 0b00000000000000000
xf00 = 0b0000111100000000
Si 0 × 0 & 0xf00 == 0
à l’intérieur d’if sensor_in & 0xf00 == 0
0 x 0 & 0xff
sensorValue1 = 0b0000000000000000
& 0b0000000011111111
----------------------------------------------
0b0000000000000000
sensorValue1 = 0 × 0
La valeur de sensor_in est 0 × 00 et nous avons effectuez à nouveau un AND & opération avec la valeur de 0xf0. Comme nous avons dit précédemment, nous vérifions si les données de sensor_in sont une valeur 8 bits ou 16 bits. Bien sûr, 0 x 00 est une valeur 8 bits comme indiqué ci-dessus, (des zéros). Donc le & opération renvoie un 0 x 00. SensorValue1 est donc égale à 0 x 00.
Étant donné que sensorValue1 est égal à 0 x 00
nous exécutons l’if instruction
Si (sensorValue1 == 0 x 00)
à l’intérieur de sensorValue1 == 0 x 00
0 x 3 & 0xf
eaction1 = 0b0000000000000011
& 0b0000000011111110
------------------------------------------
0b0000000000000010
Action1 = 0 x 2
Voici maintenant un peu intéressant, vous remarquerez que de la dernière boucle action1 est 0 x 3, donc nous avons maintenant et & action1 avec 0xfe, remarquez le masque de bits, 0xfe a tous les huit bits, la valeur 1 à l’exception de la position de bit 0. Ainsi, lorsque nous AND & les deux valeurs nous obtenons action1 = 0 x 2. Comme nous l’avons dit, les valeurs de la sonde ont des significations spéciales, dans ce cas nous mettons en place notre action pour un virage à droite.
Puisque sensorValue1 n’est pas égal à 0xff on saute la fi prochaine déclaration. sensorValue2 est égal à 0 x 00 permet donc saute à l’intérieur de l’if instruction.
Si (sensorValue2 == 0 x 00)
à l’intérieur de sensorValue2 == 0 x 00
0 x 2 | 0 x 02
Action1 = 0b0000000000000010
| 0b0000000000000010
-------------------------------------------
0b0000000000000010
Action1 = 0 x 2
Puisque action1 est désormais égale à 0 x 2, lorsque nous ou & avec 0 x 02 nous obtenons bien sûr une valeur de 0 x 02.
Le dernier si instruction bien sûr retourne false afin de nous ignorer. Nous pouvons maintenant aller le le deuxième ensemble de fi des déclarations :
Si (action1! = action2)
{
Si (action1 == 3)
line_following.go_forward(50) ;
Si (action1 == 1)
line_following.line_following_turn_left(50) ;
Si (action1 == 2)
line_following.line_following_turn_right(50)
; Si (action1 == 0)
line_following.go_forward(50) ;
}
Action2 = action1 ;
Puisque action1 est égale à 0 × 02 la commande « tourner à droite » est donnée.
Nous allons passer vers le haut le haut de l’if instruction et à l’air comme la prochaine sensor_in valeur si 0 x 100.
capteur _in = 0 x 100
Action1 = 0 x 2
Action2 = 0 x 2
sensorValue1 = 0 x 0
sensorValue2 = 0 x 0
0 x 100 & 0xf00
0 x 100 = 0b00000001000000000
xf00 = 0b0000111100000000
Si 0 x 100 & 0xf00 == 0
à l’intérieur d’elif
0 x 100 & 0xff
sensorValue2 = 0b0000000100000000
& 0b0000000011111111
---------------------------------------------------
0b0000000000000000
SensorValue2 = 0 x 0
Prenez note des valeurs de l’action1, action2, sensorValue1 et sensorValue2. Comme avant ils influenceront les valeurs lorsque nous traversent la fi des déclarations à nouveau.
sensor_in est maintenant égale à une valeur de 0 x 100, comme nous le mentionnions avant il s’agit d’un nombre de 16 bits, alors quand nous évaluons le premier si déclaration l’autre si la déclaration sera vraie.
Après avoir traité l’et & opération, sensorValue2 maintenant contient la valeur de 0 x 00. Encore une fois que nous traitons le rappel de la fi des déclarations, nous avons mis les valeurs de sensorValue1 et sensorValue2.
Ainsi sensorValue1 et sensorValue2 ont les valeurs de 0 x 00 alors action1 résultat final est 0 x 02.
Maintenant comme la dernière fois, nous avons traité la seconde valeur de la sonde, action1 et action2 tous deux contiennent les mêmes valeurs, donc la commande du moteur si la déclaration est ignorée et aucune commande moteur est donnés.
À ce stade, le robot se déplace en direction de la ligne noire. Ce sont dernièrement défini des valeurs dans le programme readOptical.py simuler cette situation. Les deux capteurs lire des valeurs comme si Capteur1 et sensor2 renvoient des valeurs blancs.
Vous pouvez faire référence à la première fois, nous avons couru à travers la fi des déclarations lorsque les valeurs de la sonde étaient 0xff et 0 x 100 pour voir les résultats.
Encore une fois Gardez un oeil sur les valeurs précédentes de sensorValue1, sensorValue2, action1 et action2 que ces valeurs déterminent si le moteur si les instructions sont exécutées ou non.
Maintenant permet de jeter un regard sur les résultats de readOptical.py deuxième où nous avons les valeurs suivantes de capteur situés dans la baie d’optValues :
optValues = [0xff, 0 x 100, 0xff, 0x1ff, 0xff, 0 x 100]
Nous commençons à nouveau en supposant que le robot est chevauchant la ligne noire, alors que les courbes de la ligne noire dans un cercle, nous supposons ensuite que le capteur de droit devient noir.
Le programme readOptical.py traite ensuite la fi des déclarations et finit avec le troisième ensemble de valeurs encore simulant le robot enjambant le centre ligne à nouveau.
Ouvrez votre fichier de sortie readOptical.py que nous avons enregistré précédemment et laisser examiner la fi logique à nouveau. Puisque nous avons déjà discuté la logique des Capteur1 tant sensor2 étant blanc, simulant le robot cheval sur la ligne médiane, vous pouvez consulter ce code vous-même en regardant l’analyse antérieure.
Maintenant regardons le deuxième ensemble de valeurs lorsque le capteur droit est noir. Encore une fois Gardez un œil des valeurs précédentes de sensorValue1, sensorValue2, action1 et action2.
capteur _in = 0xff
Action1 = 0 x 3
Action2 = 0 x 3
sensorValue1 = 0xff
sensorValue2 = 0 x 0
0xFF & 0xf00
0xFF = 0b0000000011111111
0xf00 = 0b0000111100000000
Si 0xff & 0xf00 == 0
à l’intérieur d’if sensor_in & 0xf00 == 0
0xFF & 0xff
sensorValue1 = 0b0000000011111111
& 0b0000000011111111
----------------------------------------------------
0b0000000011111111
sensorValue1 = 0xff
Troisièmement, traverser la boucle à l’aide d’une valeur de sensor_in de 0xff. Notez que nous avons parcouru notre logique avant avec sensor_in étant mis à 0xff, le résultat de l’action1 est toujours 0 x 03, mais parce que les valeurs action1 et action2 sont sur les mêmes valeurs, le moteur si la déclaration n’exécute pas cette fois.
Donc aucun contrôle moteur n’est envoyé au robot.
Maintenant, nous courons dans la boucle pour la quatrième fois où la valeur de sensor_in est 0x1ff.
capteur _in = 0x1ff
Action1 = 0 x 3
Action2 = 0 x 3
sensorValue1 = 0xff
sensorValue2 = 0 x 0
0x1ff & 0xf00
0x1ff = 0b0000000111111111
0xf00 = 0b0000111100000000
Si 0x1ff & 0xf00 == 0
à l’intérieur d’elif
0x1ff & 0xff
sensorValue2 = 0b0000000111111111
& 0b0000000011111111
-------------------------------------------------
0b0000000011111111
SensorValue2 = 0xff
Comme avant, sensor_in est défini sur un nombre de 16 bits, alors nous exécutons l’ElseIf logique.
sensorValue2 valeur est maintenant définie à 0xff. Alors maintenant, sensorValue1 et sensorValue2 sont mis à 0xff.
Si (sensorValue1 == 0xFF)
Si les précédentes si l’instruction est exécutée.
à l’intérieur de sensorValue1 == 0xff
0 x 3 | 0 x 01
Action1 = 0b0000000000000011
| 0b0000000000000001
--------------------------------------------
0b0000000000000011
Action1 = 0 x 3
Action1 est maintenant définie à 0 x 03.
La prochaine si l’instruction est ensuite exécutée :
Si (sensorValue2 == 0xFF)
0 x 3 & 0xfd
Action1 = 0b0000000000000011
& 0b0000000011111101
-----------------------------------------
0b0000000000000001
Action1 = 0 x 1
À la suite de l’et & opération, action1 s’apprête à une valeur de 0 x 1.
Action1 et action2 étant différentes, la logique moteur si l’instruction est exécutée, et comme vous pouvez voir l’instruction moteur de « aller à gauche » est exécutée.
Le troisième ensemble de valeurs sont les mêmes qu’avant et donner des instructions pour le robot à « Aller Foward » si vous voulez vous pouvez passer en revue la logique de votre propre chef.
Donc, nous avons évalué maintenant toute la logique qui contrôle le robot dans le programme lineFollow.ino.
Comment à procéder d’ici ?
Nous en préoccuper beaucoup pourquoi l’ingénieur conçu le moteur pilote/senor la façon dont il ou elle a fait. Pas vraiment.
Maintenant que nous comprenons que la logique fait, à l’avenir les projets qui utilisent les capteurs nous savons maintenant comment utiliser cette logique pour lire et interpréter les données Capteur1 et sensor2.
Si à l’avenir, nous voulons concevoir notre propre carte pilote puis nous pouvons regarder dans pourquoi l’ingénieur a conçu le jury de la façon dont il ou elle a fait.
Mais maintenant, vous avez suffisamment de connaissances pour écrire de nouveaux programmes d’utiliser les données du capteur avec votre robot. À l’avenir les Instructables que nous continuerons à chercher à travailler avec la marque : on Robotics Starter Kit.
Profitez.
Consulter mon blog pour plus d’informations
http://joepitz.wordpress.com/
