Paso 2: Salida de readOptical.py
Como dije en un anterior blog, he hecho todas las matemáticas y la lógica para ti, todo lo que tienes que hacer es seguir.
Aquí está tu oportunidad de conseguir utilizar a la lectura de números binarios y hexadecimales. En primero es se ve como un galimatías, pero usted tendrá uso a él. Si tienes problemas,
Leer los tutoriales que he hecho referencia en mi anterior blog.
Si no quieres entrar en este gran detalle a continuación, busque las secciones de salida cuando los resultados indiquen ya sea "seguir adelante", "gire a la izquierda" o "derecha"
Vamos a analizar lo que está sucediendo dentro del programa:
Primero apagado veamos los comentarios del método de readOptical() en nuestro programa de lineFollow.ino:
0x000 optical1 negro
0xFF optical1 blanco
optical1 0 x 100 blanco
0x1ff optical1 negro
0x2XX no está listo; no utilizar este valor
Observe que tres lecturas de sensor óptico comienzan con 0 x 1 o 0 x 2 hexagonal.
El resto comienza con 0 x 0 o 0xf. Si convierte a estos números a binario, verá un patrón. Python marcha lenta de la carga y escriba lo siguiente:
>>> formato (oxff, '#018b')
Indica que el parámetro de formato '#018b' para mostrar el número pasado como un número binario de 16 bits por lo que el comando de formato devolverá lo siguiente:'0b0000000011111111′
Observe que hay 8 ceros seguidos de 8 1′s.
Este número de 16 bits tiene los 8 bits menos significativos en 1.
Si escribe en el siguiente en Python:
>>> hex(int('11111111′,2))
Usted conseguirá: '0xff'
Ahora haga lo siguiente:
>>> formato (0 × 0, '#018b')
Python devolverá: ' 0b0000000000000000′
Permite probar los otros dos valores que devuelve la función readOptical().
>>> formato (0x1ff '#018b')
' 0b0000000111111111′
>>> formato (0 × 100, '#018b')
' 0b0000000100000000′
¿Cuántos 1′s se muestran en la representación binaria de 0x1ff?
¿Qué posición es la 1, contando desde la derecha, 0 × 100?
Correcto, en ambos casos se muestra 1 en la novena posición de bit de la derecha.
El método readOptical() en el lineFollow.ino sólo devuelve valores que tienen un patrón distinto.
Sensores ópticos 1 devolución sólo los números que están situados a 8 bits.
2 sensores ópticos pueden tener números que se encuentran en la novena posición de la broca, o 16 bits.
Vamos a empezar mirando en nuestros resultados desde el programa de Python readOptical.py.
Primero nos fijamos en las variables que son configurados en el inicio del programa lineFollow.ino:
sensor _En = 0xff
acción1 = 0 x 0
action2 = 0 x 0
sensorValue1 = 0 x 0
sensorValue2 = 0 x 0
El primer valor de sensor que estamos leyendo es 0xff, 0 x 0 el resto de las variables.
La primera si la declaración realiza un BitWise y una en dos valores:
Si ((sensor_in & 0xf00) == 0)
Vistazo a la salida otra vez:
0xFF & 0xf00
0xFF = 0b0000000011111111
0xf00 = 0b0000111100000000
Si 0xff & 0xf00 == 0
dentro de if sensor_in & 0xf00 == 00
XFF & 0xff
sensorValue1 = 0b0000000011111111
& 0b0000000011111111
——————
0b0000000011111111
sensorValue1 = 0xff
Mira de cerca la operación AND bit a bit, estamos comprobando a ver si alguno de los 8 bits superiores de la sensor_in número de 16 bit está establecido.
En este caso la comparación y devolver 0 como ningún bit más de la que 8 bits significativos situado en la variable sensor_in.
Así que la primera parte de la fi comunicado sólo será cierto si sensor_in contiene 0x000 o 0xff.
Desde la primera si la declaración es verdad, ejecutamos el comando de:
sensorValue1 = sensor_in & 0xff;
ANDing un número con sí mismo nos da el mismo número, sensorValue1 = 0xff
0xFF y 0xff
sensorValue1 = 0b0000000011111111
& 0b0000000011111111
--------------------------------
0b0000000011111111
sensorValue1 = 0xff
Pasemos a segundo si declaración:
Si (sensorValue1 == 0 x 00)
Si nos fijamos en la variable sensorValue1, que contiene 0xff así esta declaración es falsa y no se ejecutan.
Móvil:
Si (sensorValue1 == 0xFF)
sensor_in es igual a 0xff así que ejecutamos el if declaración:
acción1 = action1 | 0 x 01;
En este caso estamos creando la variable de acción1 igual acción y aplicar el operador Bitwise o el valor de 0 × 01.
Mirando los resultados de la acción1 de operación OR se establece en un valor de 0 x 01.
dentro de sensorValue1 == 0xff
0 x 0 | 0 x 01
acción1 = 0b0000000000000000
| 0b0000000000000001
-------------------------------
0b0000000000000001
acción1 = 0 x 1
En el if de la siguiente declaración:
Si (sensorValue2 == 0 x 00)
Comprobamos si sensorValue2 es igual a 0 x 00, y por supuesto actualmente sensorValue2 es igual a 0 x 00 para que ejecutar el if declaración:
acción1 = action1 | 0 x 02;
dentro de sensorValue2 == 0 x 00
0 x 1 | 0 x 02
acción1 = 0b0000000000000001
| 0b0000000000000010
-----------------------------------
0b0000000000000011
acción1 = 0 × 3
En el último si declaración comprobamos:
Si (sensorValue2 == 0xFF)
sensorValue2 no es igual a 0xff para que pasemos. El valor final de acción1 es 0 × 03, nos salga el último if declaración y proceder en el el siguiente conjunto de if declaraciones:
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 = acción1;
}
acción1 = 0x3
action2 = 0 x 0
Comprobamos la primera si declaración:
Si (action1! = action2)
Esto es válido para entrar en el if anidado declaración:
acción1 = 0x3
así que ejecutamos el true si declaración:
line_following.go_forward(50);
Ahora en nuestro programa de readOptical.py volvemos a la parte superior de la para bucle y comience de nuevo con el siguiente valor: sensor_in = 0 x 100
acción1 = 0x3
action2 = 0x3
sensorValue1 = 0xff
sensorValue2 = 0 x 0
En este caso la variable sensor_in es igual a 0 x 100
Echemos un vistazo a la primera si declaración otra vez:
Si ((sensor_in & 0xf00) == 0)
sensorValue1 = sensor_in & 0xff;
else if ((sensor_in & 0xf00) >> 8 == 1)
sensorValue2 = sensor_in & 0xff;
Como señaló en el último bucle, el primero si la declaración está buscando o 0xff o 0 × 00.
En este caso el if declaración es falsa, por lo que saltamos al if else declaración: en este caso el if instrucción hace un Bitwise y una derecha Shift 8 bits.
Así que estamos tomando el 1 en la ubicación de 9 bits y cambio 8 veces a la derecha,
0 × 100 = 0b0000000100000000
0xf00 = 0b0000111100000000
--------------------------------------
& 0b0000000100000000
Cambio derecha
0b0000000000000001
Este valor es igual a 1 por lo que ejecutar el if instrucción.
sensorValue2 = sensor_in & 0xff;
0 × 100 & 0xff
sensorValue2 = 0b0000000100000000
& 0b0000000011111111
------------------------------------
0b0000000000000000
SensorValue2 = 0 x 0
Bajando el if declaraciones, comprobamos el if de la siguiente declaración:
Si (sensorValue1 == 0 x 00)
sensorValue1 es igual a 0xff así que nos saltamos este si declaración. If siguiente declaración:
Si (sensorValue1 == 0xFF)
acción1 = action1 | 0 x 01;
El si la afirmación es cierta, así que ejecutamos el if instrucción
dentro de sensorValue1 == 0xff
0X3 | 0 x 01
acción1 = 0b0000000000000011
| 0b0000000000000001
----------------------------------
0b0000000000000011
acción1 = 0x3
If siguiente declaración:
Si (sensorValue2 == 0 x 00)
acción1 = action1 | 0 x 02;
El si la afirmación es cierta, así que ejecutamos el if instrucción
dentro de sensorValue2 == 0 × 00
0X3 | 0 x 02
acción1 = 0b0000000000000011
| 0b0000000000000010
---------------------------------------
0b0000000000000011
acción1 = 0x3
Terminamos para arriba el si las declaraciones y se mueven en el el siguiente conjunto de if declaraciones:
Si (action1! = action2)
En este caso action1 equivale a action2 así que nos saltamos el if instrucción que envía instrucciones del motor.
Lazo alrededor para el lazo otra vez y seleccionar el siguiente valor de sensor_in.
En este punto hemos enviado el conductor del motor de un sistema si tanto instrucciones para seguir adelante, como los sensores leen blanco.
En el Instructable siguiente nos trasladaremos al leer los valores de los sensores cuando el sensor izquierdo es de color negro.
