Étape 2: Sortie de readOptical.py
Comme je le disais dans un précédent blog, j’ai fait toutes les mathématiques et la logique pour vous, tout ce que vous avez à faire est de suivre.
Voici votre chance d’obtenir permet de lire des nombres binaires et hexadécimaux. At est tout d’abord on dirait comme charabia, mais vous obtiendrez utiles. Si vous rencontrez des problèmes,
Lire les tutoriels que j’ai fait référencent à dans mon blog précédent messages.
Si vous ne voulez pas aller dans ce grand détail, puis il suffit de regarder pour les sections de sortie lorsque les résultats indiquent soit « aller de l’avant », « tourner à gauche » ou « tournez à droite »
Permet d’analyser ce qui se passe à l’intérieur du programme :
Premier arrêt permet d’observer les observations de la méthode readOptical() dans notre programme de lineFollow.ino :
0x000 optical1 noir
0xFF optical1 blanc
optical1 0 x 100 blanc
0x1ff optical1 noir
0x2XX n’est pas prêt ; n’utilisez pas cette valeur
Notez que trois lectures du capteur optique commencent par 0 x 1 ou 0 x 2 hex.
Les autres commencent par 0 x 0 ou 0xf. Si vous convertissez ces nombres binaires, vous verrez un motif. Chargez le Python ralenti et tapez la commande suivante :
>>> format (oxff, « # 018 b »)
Le paramètre de format « # 018 b » indique pour afficher le nombre passé comme un nombre binaire de 16 bits, la commande format retournera ce qui suit:'0b0000000011111111′
Remarquez qu’il y a 8 zéros suivis de 8 1.
Ce nombre de 16 bits a les 8 bits les moins significatifs la valeur 1.
Si vous tapez ce qui suit en Python :
>>> hex(int('11111111′,2))
Vous obtiendrez: « 0xff »
Maintenant passons essaient ce qui suit :
>>> format (0 × 0, 018 « # b »)
Python retourne: ' 0b0000000000000000′
Permet d’essayer les deux autres valeurs que la fonction readOptical() retourne.
>>> format (0x1ff, « # 018 b »)
' 0b0000000111111111′
>>> format (0 × 100, « # 018 b »)
' 0b0000000100000000′
1 combien sont affichés dans la représentation binaire de 0x1ff ?
Quelle position est la 1, en comptant à partir de la droite, pour 0 × 100 ?
Corriger, dans les deux cas 1 s’affiche dans la neuvième position de bit de la droite.
La méthode readOptical() dans le lineFollow.ino retourne uniquement les valeurs qui ont une nette tendance.
Capteurs optiques de 1 retournent uniquement des nombres qui sont définies au sein de 8 bits.
Optiques 2 capteurs peuvent avoir des numéros qui sont définies dans la neuvième position de bit, ou 16 bits.
Nous allons commencer à regarder nos résultats du programme Python readOptical.py.
Tout d’abord, nous examinons les variables qui sont configurés dans le début du programme lineFollow.ino :
capteur _in = 0xff
Action1 = 0 x 0
Action2 = 0 x 0
sensorValue1 = 0 x 0
sensorValue2 = 0 x 0
La première valeur de capteur que nous lisons est 0xff, le reste des variables sont 0 x 0.
Le premier si instruction effectue une opération AND sur deux valeurs :
Si ((sensor_in & 0xf00) == 0)
Regardez à nouveau la sortie :
0xFF & 0xf00
0xFF = 0b0000000011111111
0xf00 = 0b0000111100000000
Si 0xff & 0xf00 == 0
à l’intérieur d’if sensor_in & 0xf00 == 00
xff & 0xff
sensorValue1 = 0b0000000011111111
& 0b0000000011111111
——————
0b0000000011111111
sensorValue1 = 0xff
Regardez attentivement l’opération de bits AND, nous vérifions pour voir si un des supérieures 8 bits de la sensor_in numéro 16 bit est défini.
Dans ce cas, la comparaison et retourner 0 qu’il n’y a aucun bit supérieur à la peur des 8 bits définis dans la variable sensor_in.
Si la première partie de la fi déclaration sera true si sensor_in contient 0x000 ou 0xff.
Depuis le premier si l’affirmation est vraie, nous exécutons la commande de :
sensorValue1 = sensor_in & 0xff ;
ANDing, un certain nombre avec lui-même nous donne la sensorValue1 numéro, même = 0xff
0xFF & 0xff
sensorValue1 = 0b0000000011111111
& 0b0000000011111111
--------------------------------
0b0000000011111111
sensorValue1 = 0xff
Passons à la deuxième si déclaration :
Si (sensorValue1 == 0 x 00)
Si nous regardons la variable sensorValue1, il contient 0xff si ce si la déclaration est fausse et ne pas exécutée.
Aller :
Si (sensorValue1 == 0xFF)
sensor_in est égal à 0xff, alors nous exécutons l’if déclaration :
Action1 = action1 | 0 x 01 ;
Dans ce cas, nous définissons la variable d’action1 égale action et appliquer l’opérateur au niveau du bit ou à la valeur de 0 x 01.
En regardant les résultats de l’OR opération action1 obtient a une valeur de 0 x 01.
à l’intérieur de sensorValue1 == 0xff
0 x 0 | 0 x 01
Action1 = 0b0000000000000000
| 0b0000000000000001
-------------------------------
0b0000000000000001
Action1 = 0 x 1
Sur la fi prochaine déclaration :
Si (sensorValue2 == 0 x 00)
Nous vérifions si sensorValue2 est égal à 0 x 00, et bien sûr actuellement sensorValue2 est égale à 0 x 00 alors nous exécutons l’if déclaration :
Action1 = action1 | 0 x 02 ;
à l’intérieur de sensorValue2 == 0 x 00
0 x 1 | 0 x 02
Action1 = 0b0000000000000001
| 0b0000000000000010
-----------------------------------
0b0000000000000011
Action1 = 0 × 3
Dans le dernier si déclaration nous vérifions :
Si (sensorValue2 == 0xFF)
sensorValue2 n’est pas égal à 0xff, alors nous passer. La valeur finale d’action1 est 0 × 03, nous sortir la fi dernière déclaration et continuez sur la la prochaine série d’if 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 ;
}
Action1 = 0 x 3
Action2 = 0 x 0
Nous vérifions le premier si déclaration :
Si (action1! = action2)
C’est vrai alors nous entrons dans l’if imbriqué instruction :
Action1 = 0 x 3
Si nous exécutons le true si déclaration :
line_following.go_forward(50) ;
Maintenant dans notre programme de readOptical.py nous revenons à la partie supérieure de la boucle et nous commence à nouveau avec la valeur suivante : sensor_in = 0 x 100
Action1 = 0 x 3
Action2 = 0 x 3
sensorValue1 = 0xff
sensorValue2 = 0 x 0
Dans ce cas la variable sensor_in est égale à 0 x 100
Regardons le premier si la déclaration de nouveau :
Si ((sensor_in & 0xf00) == 0)
sensorValue1 = sensor_in & 0xff ;
sinon si ((sensor_in & 0xf00) >> 8 == 1)
sensorValue2 = sensor_in & 0xff ;
Comme nous l’a souligné au cours de la dernière boucle, le premier si déclaration cherche soit 0xff ou 0 x 00.
Dans ce cas, l’if déclaration est fausse, alors nous sautons à la combinaison else-if instruction : dans ce cas, l’if déclaration fait une opération AND et une droite Maj 8 bits.
Donc nous prenant le 1 à l’emplacement de 9 bit et déplaçant vers la droite, 8 fois
0 × 100 = 0b0000000100000000
0xf00 = 0b0000111100000000
--------------------------------------
& 0b0000000100000000
Décalage vers la droite
0b0000000000000001
Cette valeur est égale à 1 si nous exécutons le cas énoncé.
sensorValue2 = sensor_in & 0xff ;
0 × 100 & 0xff
sensorValue2 = 0b0000000100000000
& 0b0000000011111111
------------------------------------
0b0000000000000000
SensorValue2 = 0 x 0
En descendant la fi des déclarations, nous vérifions la prochaine fi déclaration :
Si (sensorValue1 == 0 x 00)
sensorValue1 est égal à 0xff donc nous sauter cela si déclaration. If prochaine déclaration :
Si (sensorValue1 == 0xFF)
Action1 = action1 | 0 x 01 ;
Le si l’affirmation est vraie, alors nous exécutons l’if instruction
à l’intérieur de sensorValue1 == 0xff
0 x 3 | 0 x 01
Action1 = 0b0000000000000011
| 0b0000000000000001
----------------------------------
0b0000000000000011
Action1 = 0 x 3
If prochaine déclaration :
Si (sensorValue2 == 0 x 00)
Action1 = action1 | 0 x 02 ;
Le si l’affirmation est vraie, alors nous exécutons l’if instruction
à l’intérieur de sensorValue2 == 0 × 00
0 x 3 | 0 x 02
Action1 = 0b0000000000000011
| 0b0000000000000010
---------------------------------------
0b0000000000000011
Action1 = 0 x 3
Nous finir la fi des déclarations et se déplacer sur la la prochaine série de fi des déclarations :
Si (action1! = action2)
Dans ce cas action1 est égal à action2 donc nous sauter l’if instruction qui envoie des instructions du moteur.
Nous boucle retour autour de la boucle à nouveau et sélectionnez la valeur suivante de sensor_in.
À ce stade, nous avons envoyé le moteur et pilote un ensemble si les instructions pour aller de l’avant, comme les capteurs lisent tous les deux blanc.
Dans la prochaine Instructable, nous allons passer à la lecture des valeurs de la sonde lorsque le capteur de gauche est noir.
