En el Instructable pasado empezamos analizando las operaciones bit a bit en el bosquejo de lineFollow.ino. Vimos cómo se interpretan las lecturas del sensor para hacer que el robot vaya hacia adelante.
En este tutorial vamos a continuar nuestro análisis al considerar cómo el programa de lineFollow.ino interpreta cuando el negro bajo el sensor izquierdo. Haciendo referencia otra vez a la salida de nuestro readOptical.py Python programa cuando las lecturas del sensor tercero y cuarto son 0 x 00 y 0 x 100.
(consulte el programa de readOptical.py si necesita un recordatorio. Vamos otra vez a empezar en la parte superior del nuevo bucle for:
optValues = [0xff, 0 x 100, 0 x 00, 0 x 100, 0xff, 0 x 100]
para elem en optValues:
sensor _En = 0 x 0
acción1 = 0x3
action2 = 0x3
sensorValue1 = 0xff
sensorValue2 = 0 x 0
0 x 0 y 0xf00
0 x 0 = 0b00000000000000000
xf00 = 0b0000111100000000
Si 0 × 0 y 0xf00 == 0
dentro de if sensor_in & 0xf00 == 0
0 x 0 & 0xff
sensorValue1 = 0b0000000000000000
& 0b0000000011111111
----------------------------------------------
0b0000000000000000
sensorValue1 = 0 × 0
El valor de sensor_in es 0 × 00 y realizar una y otra vez y operación con el valor de 0xf0. Como hemos dicho antes estamos comprobando si sensor_in datos están un valor de 8 bits o 16 bits. Por supuesto, 0 x 00 es un valor de 8 bits como se muestra arriba (todos ceros). Así que el & operación devuelve un 0 x 00. Por lo que sensorValue1 es igual a 0 x 00.
Puesto que sensorValue1 es igual a 0 x 00
ejecutamos el if instrucción
Si (sensorValue1 == 0 x 00)
dentro de sensorValue1 == 0 x 00
0X3 & 0xf
eaction1 = 0b0000000000000011
& 0b0000000011111110
------------------------------------------
0b0000000000000010
acción1 = 0 x 2
Ahora aquí es un poco interesante, cuenta que desde el ciclo pasado action1 era 0x3, ahora y & action1 con 0xfe, cuenta la máscara de bits, 0xfe cuenta con todos los ocho bits a 1 con la excepción de la posición del bit 0. Así que cuando nos y y los dos valores obtenemos action1 = 0 x 2. Como hemos dicho, los valores de los sensores tienen significados especiales, en este caso estamos configurando nuestra acción para vuelta a la derecha.
Puesto que sensorValue1 no es igual a 0xff nos saltamos el if de la siguiente declaración. sensorValue2 es igual a 0 x 00 permite así salta dentro de la fi comunicado.
Si (sensorValue2 == 0 x 00)
dentro de sensorValue2 == 0 x 00
0 x 2 | 0 x 02
acción1 = 0b0000000000000010
| 0b0000000000000010
-------------------------------------------
0b0000000000000010
acción1 = 0 x 2
Desde action1 ahora es igual a 0 x 2, cuando se o & con 0 x 02 por supuesto obtenemos un valor de 0 x 02.
El último si declaración por supuesto devuelve false para que nos la saltamos. Ahora podemos pasar el el segundo 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 es igual a 0 × 02 el comando "girar a la derecha" es dado.
Vamos a saltar hacia atrás el la parte superior de la fi comunicado y aspecto como el siguiente sensor_in valoran si 0 x 100.
sensor _En = 0 x 100
acción1 = 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
dentro de elif
0 x 100 & 0xff
sensorValue2 = 0b0000000100000000
& 0b0000000011111111
---------------------------------------------------
0b0000000000000000
SensorValue2 = 0 x 0
Tome nota de los valores de acción1, action2, sensorValue1 y sensorValue2. Como antes de que se influyen los valores cuando ejecuta a través del if declaraciones otra vez.
sensor_in ahora es igual a un valor de 0 x 100, como mencionamos antes este es un número de 16 bits, así que cuando evaluamos la primera si declaración else si declaración sea verdadera.
Después de procesar la y & operación, sensorValue2 ahora contiene el valor de 0 x 00. Otra vez como procesamos el recordatorio del if instrucciones, establecen los valores de sensorValue1 y sensorValue2.
Como resultado sensorValue1 y sensorValue2 tienen los valores de 0 x 00 action1 resultado final es 0 x 02.
Ahora como la última vez que procesamos el segundo valor de sensor, acción1 y action2 ambos contienen los mismos valores, por lo que se dan el control del motor si se omite la declaración y no comandos de motor.
En este momento el robot está moviendo hacia la línea negra. Por lo que están pasado de valores en el programa de readOptical.py simular esta situación. Ambos sensores leer valores que sensor1 y sensor2 devolución valores blanco.
Usted puede referir a la primera vez que corría por el if declaraciones cuando los valores de los sensores fueron 0xff y 0 x 100 para ver los resultados.
Otra vez, mantener un ojo en los valores anteriores de sensorValue1, sensorValue2, acción1 y action2, estos valores determinan si el motor si las instrucciones se ejecutan o no.
Ahora vamos a echar un vistazo a los resultados del segundo readOptical.py donde tenemos los siguientes valores del sensor en la matriz de optValues:
optValues = [0xff, 0 x 100, 0xff, 0x1ff, 0xff, 0 x 100]
Comenzamos asumiendo otra vez que el robot está entre la línea negra, a continuación, como las curvas de la línea negra en un círculo asumimos entonces que el sensor derecho se pone negro.
El programa de readOptical.py luego procesa if declaraciones y termina con el tercer grupo de valores otra vez simulando el robot a caballo entre el centro de la línea otra vez.
Abra su archivo de salida de readOptical.py que nos salvó antes y deje revisar if lógica otra vez. Puesto que ya hemos discutido la lógica de imagen1 y sensor2 siendo blanco, simulando el robot a caballo entre la línea central, puede revisar este código por su cuenta observando el análisis anterior.
Ahora veamos el segundo conjunto de valores cuando el sensor de la derecha es de color negro. Fíjate otra vez de los valores anteriores de sensorValue1, sensorValue2, acción1 y action2.
sensor _En = 0xff
acción1 = 0x3
action2 = 0x3
sensorValue1 = 0xff
sensorValue2 = 0 x 0
0xFF & 0xf00
0xFF = 0b0000000011111111
0xf00 = 0b0000111100000000
Si 0xff & 0xf00 == 0
dentro de if sensor_in & 0xf00 == 0
0xFF y 0xff
sensorValue1 = 0b0000000011111111
& 0b0000000011111111
----------------------------------------------------
0b0000000011111111
sensorValue1 = 0xff
Tercer pase a través del lazo con un valor de sensor_in de 0xff. Tenga en cuenta que hemos recorren nuestra lógica antes con sensor_in se establece en 0xff, el resultado de acción1 sigue siendo 0 x 03, pero porque acción1 y action2 valores se establecen en los mismos valores, el motor si la instrucción no se ejecuta esta vez.
Tan control del motor no se envía al robot.
Ahora corremos a través del lazo para la cuarta vez que sensor_in valor es 0x1ff.
sensor _En = 0x1ff
acción1 = 0x3
action2 = 0x3
sensorValue1 = 0xff
sensorValue2 = 0 x 0
0x1ff & 0xf00
0x1ff = 0b0000000111111111
0xf00 = 0b0000111100000000
Si 0x1ff & 0xf00 == 0
dentro de elif
0x1ff & 0xff
sensorValue2 = 0b0000000111111111
& 0b0000000011111111
-------------------------------------------------
0b0000000011111111
SensorValue2 = 0xff
Como antes, sensor_in se establece en un número de 16 bits así que ejecutamos el if más lógica.
valor de sensorValue2 se establece ahora en 0xff. Ahora sensorValue1 y sensorValue2 se establecen en 0xff.
Si (sensorValue1 == 0xFF)
así que el anterior si se ejecuta la instrucción.
dentro de sensorValue1 == 0xff
0X3 | 0 x 01
acción1 = 0b0000000000000011
| 0b0000000000000001
--------------------------------------------
0b0000000000000011
acción1 = 0x3
acción1 ahora se establece en 0 x 03.
La próxima si entonces se ejecuta la instrucción:
Si (sensorValue2 == 0xFF)
0X3 & 0xfd
acción1 = 0b0000000000000011
& 0b0000000011111101
-----------------------------------------
0b0000000000000001
acción1 = 0 x 1
Como resultado de la y & operación, acción1 ahora se establece en un valor de 0 x 1.
Se ejecuta la acción1 y action2 son diferentes, la lógica del motor si se ejecuta la instrucción y como se puede ver la instrucción motor de "ir a la izquierda".
El tercer conjunto de valores son los mismos que antes y dar instrucciones para el robot para "Ir adelante" Si desea usted puede revisar la lógica de su propio.
Hasta ahora hemos evaluado todos los de la lógica que controla el robot en el programa de lineFollow.ino.
¿Cómo a proceder desde aquí?
Debemos preocuparnos mucho por el ingeniero diseñó el motor controlador/Señor la manera él o ella lo hizo. No realmente.
Ahora que entendemos lo que la lógica hace, en el futuro los proyectos que utilizan los sensores ahora sabemos cómo usar esta lógica para leer e interpretar los datos imagen1 y sensor2.
Si en el futuro queremos diseñar nuestro propio controlador entonces podemos mirar en por qué el ingeniero diseñó el tablero de la manera o hizo.
Pero ahora tienes suficientes conocimientos como para redactar nuevos programas para utilizar los datos del sensor con su robot. En el futuro Instructables seguiremos ver en el trabajo con el hacer: es robótica Starter Kit.
Disfrutar.
Pásate por mi blog para más información
http://joepitz.wordpress.com/
