En el último Instructable, comenzamos a analizar las operaciones bitwise en el boceto de lineFollow.ino. Observamos cómo se interpretan las lecturas del sensor para hacer que el robot avance.

En este tutorial vamos a continuar nuestro análisis para ver cómo se interpreta el programa lineFollow.ino cuando el negro está debajo del sensor izquierdo. Al referirse nuevamente a la salida de nuestro programa readOptical.py de Python cuando las lecturas del tercer y cuarto sensor son 0x00 y 0x100.

(Consulte el programa readOptical.py si necesita un recordatorio. Volveremos a comenzar desde el principio del bucle for:

optValues ​​= 0xff, 0x100, 0x00, 0x100, 0xff, 0x100

para elem en optValues:

sensor _in = 0x0

action1 = 0x3

action2 = 0x3

sensorValue1 = 0xff

sensorValue2 = 0x0

0x0 y 0xf00

0x0 = 0b00000000000000000

xf00 = 0b0000111100000000

si 0 × 0 y 0xf00 == 0

dentro si sensor_in y 0xf00 == 0

0x0 y 0xff

sensorValue1 = 0b0000000000000000

& 0b0000000011111111

----------------------------------------------

0b0000000000000000

sensorValue1 = 0 × 0

El valor sensor_in es 0 × 00 y nuevamente realizamos una operación AND & con el valor de 0xf0. Como dijimos anteriormente, estamos comprobando si los datos de sensor_in son un valor de 8 bits o 16 bits. Por supuesto, 0x00 es un valor de 8 bits como se muestra arriba, (todos ceros). Así que la operación & AND devuelve un 0x00. Entonces sensorValue1 es igual a 0x00.

Dado que sensorValue1 es igual a 0x00

ejecutamos la sentencia if

si (sensorValue1 == 0x00)

dentro de sensorValue1 == 0x00

0x3 y 0xf

eaction1 = 0b0000000000000011

& 0b0000000011111110

------------------------------------------

0b0000000000000010

action1 = 0x2

Ahora aquí hay un bit interesante, observe que desde el bucle pasado action1 era 0x3, así que ahora Y & action1 con 0xfe, notamos que la máscara de bits, 0xfe tiene los ocho bits establecidos en 1 con la excepción de la posición del bit 0. Entonces cuando nosotros Y y los dos valores obtenemos action1 = 0x2. Como dijimos, los valores de los sensores tienen significados especiales, en este caso estamos configurando nuestra acción para un giro a la derecha.

Como sensorValue1 no es igual a 0xff, omitimos la siguiente instrucción if. sensorValue2 es igual a 0x00 por lo que permite saltar dentro de la instrucción if.

si (sensorValue2 == 0x00)

dentro de sensorValue2 == 0x00

0x2 | 0x02

action1 = 0b0000000000000010

| 0b0000000000000010

-------------------------------------------

0b0000000000000010

action1 = 0x2

Como action1 ahora es igual a 0x2, cuando OR y con 0x02, por supuesto, obtenemos un valor de 0x02.

La última instrucción if, por supuesto, devuelve false, así que la omitimos. Ahora podemos pasar al segundo conjunto de sentencias if:

if (action1! = action2)

{

si (acción1 == 3)

line_following.go_forward (50);

si (acción1 == 1)

line_following.line_following_turn_left (50);

si (acción1 == 2)

line_following.line_following_turn_right (50)

; si (acción1 == 0)

line_following.go_forward (50);

}

acción2 = acción1;

Como action1 es igual a 0 × 02, se da el comando "girar a la derecha".

Saltemos de nuevo la parte superior de la sentencia if y veamos como el siguiente valor de sensor_in si 0x100.

sensor _in = 0x100

action1 = 0x2

action2 = 0x2

sensorValue1 = 0x0

sensorValue2 = 0x0

0x100 y 0xf00

0x100 = 0b00000001000000000

xf00 = 0b0000111100000000

si 0x100 & 0xf00 == 0

dentro de elif

0x100 y 0xff

sensorValue2 = 0b0000000100000000

& 0b0000000011111111

---------------------------------------------------

0b0000000000000000

SensorValue2 = 0x0

Tome nota de los valores de action1, action2, sensorValue1 y sensorValue2. Como antes, influirán en los valores cuando repasemos las instrucciones if nuevamente.

sensor_in ahora es igual a un valor de 0x100, como señalamos antes, este es un número de 16 bits, por lo que cuando evaluamos la primera sentencia if, la instrucción else if será verdadera.

Después de procesar la operación AND &, sensorValue2 ahora contiene el valor de 0x00. De nuevo, cuando procesamos el recordatorio de las sentencias if, establecemos los valores de sensorValue1 y sensorValue2.

Como resultado, sensorValue1 y sensorValue2 tienen los valores de 0x00, por lo que el resultado final de action1 es 0x02.

Ahora, como en la última vez que procesamos el segundo valor del sensor, action1 y action2 contienen los mismos valores, por lo que el control del motor si se omite la instrucción y no se dan los comandos del motor.

En este punto, el robot se está moviendo hacia la línea negra. Así que el último conjunto de valores en el programa readOptical.py simula esta situación. Ambos sensores leen valores como si sensor1 y sensor2 devuelven valores blancos.

Puede consultar la primera vez que analizamos las afirmaciones if cuando los valores del sensor eran 0xff y 0x100 para ver los resultados.

De nuevo, vigile los valores anteriores de sensorValue1, sensorValue2, action1 y action2, ya que estos valores determinan si el motor de las instrucciones se ejecutan o no.

Ahora veamos los resultados del segundo readOptical.py donde tenemos los siguientes valores de sensores configurados en la matriz optValues:

optValues ​​= 0xff, 0x100, 0xff, 0x1ff, 0xff, 0x100

Comenzamos de nuevo asumiendo que el robot se encuentra a horcajadas en la línea negra, luego, como la línea negra se curva en un círculo, asumimos que el sensor correcto se vuelve negro.

El programa readOptical.py luego procesa las sentencias if y termina con el tercer conjunto de valores simulando nuevamente que el robot se encuentra a horcajadas en la línea central.

Abra su archivo de salida readOptical.py que guardamos anteriormente y deje que vuelva a revisar la lógica if. Como ya hemos discutido la lógica de que tanto sensor1 como sensor2 son blancos, simulando el robot que se encuentra a horcajadas en la línea central, puede revisar este código usted mismo mirando el análisis anterior.

Veamos ahora el segundo conjunto de valores cuando el sensor correcto es negro. De nuevo, vigile los valores anteriores de sensorValue1, sensorValue2, action1 y action2.

sensor _in = 0xff

action1 = 0x3

action2 = 0x3

sensorValue1 = 0xff

sensorValue2 = 0x0

0xff y 0xf00

0xff = 0b0000000011111111

0xf00 = 0b0000111100000000

si 0xff & 0xf00 == 0

dentro si sensor_in y 0xf00 == 0

0xff y 0xff

sensorValue1 = 0b0000000011111111

& 0b0000000011111111

----------------------------------------------------

0b0000000011111111

sensorValue1 = 0xff

El tercer paso a través del bucle utiliza un valor sensor_in de 0xff.Note hemos analizado nuestra lógica antes de que sensor_in se establezca en 0xff, el resultado de action1 sigue siendo 0x03, pero como los valores de action1 y action2 se configuran con los mismos valores, el motor Si la sentencia no se ejecuta esta vez.

Así que no se envía ningún control del motor al robot.

Ahora pasamos por el bucle por cuarta vez, donde el valor sensor_in es 0x1ff.

sensor _in = 0x1ff

action1 = 0x3

action2 = 0x3

sensorValue1 = 0xff

sensorValue2 = 0x0

0x1ff y 0xf00

0x1ff = 0b0000000111111111

0xf00 = 0b0000111100000000

si 0x1ff & 0xf00 == 0

dentro de elif

0x1ff y 0xff

sensorValue2 = 0b0000000111111111

& 0b0000000011111111

-------------------------------------------------

0b0000000011111111

SensorValue2 = 0xff

Como antes, sensor_in se configura en un número de 16 bits, por lo que ejecutamos else en la lógica.

El valor de sensorValue2 ahora se establece en 0xff. Así que ahora sensorValue1 y sensorValue2 están configurados en 0xff.

si (sensorValue1 == 0xFF)

por lo que la sentencia if anterior se ejecuta.

dentro de sensorValue1 == 0xff

0x3 | 0x01

action1 = 0b0000000000000011

| 0b0000000000000001

--------------------------------------------

0b0000000000000011

action1 = 0x3

action1 ahora se establece en 0x03.

La siguiente sentencia if se ejecuta:

si (sensorValue2 == 0xFF)

0x3 y 0xfd

action1 = 0b0000000000000011

& 0b0000000011111101

-----------------------------------------

0b0000000000000001

action1 = 0x1

Como resultado de la operación AND &, action1 ahora se establece en un valor de 0x1.

Dado que action1 y action2 son diferentes, la lógica del motor if se ejecuta y como puede ver, se ejecuta la instrucción del motor de "ir a la izquierda".

El tercer conjunto de valores es el mismo que antes y da instrucciones para que el robot "Avance". Si lo deseas, puedes revisar la lógica por tu cuenta.

Así que ahora hemos evaluado toda la lógica que controla el robot en el programa lineFollow.ino.

¿Cómo procedemos desde aquí?

¿Deberíamos preocuparnos mucho por qué el ingeniero diseñó el conductor / senor de la manera en que lo hizo? Realmente no.

Ahora que entendemos lo que está haciendo la lógica, en futuros proyectos que usan los sensores ahora sabemos cómo usar esta lógica para leer e interpretar los datos sensor1 y sensor2.

Si en el futuro queremos diseñar nuestro propio tablero de conductores, entonces podemos ver por qué el ingeniero diseñó el tablero de la forma en que lo hizo.

Pero ahora tiene el conocimiento suficiente para escribir nuevos programas para usar los datos del sensor con su robot. En los futuros Instructables, seguiremos estudiando el trabajo con el kit de inicio Make: it Robotics.

Disfrutar.

Echa un vistazo a mi blog para más información.

joepitz.wordpress.com/

Suministros: