En nuestra última publicación del blog, capturamos algunos datos de sensores de las tres posiciones diferentes que nuestro robot puede encontrar cuando sigue la línea negra (sensor izquierdo, sensor izquierdo / sensor derecho, negro sensor derecho).

En esta publicación del blog vamos a tomar los datos del sensor y ejecutarlos en nuestro programa readOptical.py Python y evaluar lo que está sucediendo en nuestro programa lineFollow.ino.

Vamos a ver las siguientes secciones de código:

if ((sensor_in & 0xf00) == 0) sensorValue1 = sensor_in & 0xff;

else if ((sensor_in & 0xf00) >> 8 == 1)

sensorValue2 = sensor_in & 0xff;

if (sensorValue1 == 0x00) action1 = action1 & 0xfe;

if (sensorValue1 == 0xFF) action1 = action1 | 0x01;

si (sensorValue2 == 0x00)

action1 = action1 | 0x02;

si (sensorValue2 == 0xFF)

action1 = action1 & 0xfd;

if (action1! = action2)

{

si (acción1 == 3)

line_following.go_forward (50);

if (action1 == 1) line_following.line_following_turn_left (50);

if (action1 == 2) line_following.line_following_turn_right (50);

si (acción1 == 0)

line_following.go_forward (50);

}

acción2 = acción1;

Nuestro programa de Python readOptical.py contiene el código anterior, pero también calcula los operadores de Bitwise y convierte las declaraciones del programa (expresiones) en binarios para que podamos ver fácilmente lo que realmente está haciendo el programa.

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

joepitz.wordpress.com/

Suministros:

Paso 1: Python viene al rescate

Si aún no lo ha hecho, instale Python y cree el programa readOptical.py usando su editor de texto favorito. Si está usando Windows, el bloc de notas está bien. Cree una carpeta en su computadora y coloque este programa readOptical.py en esta carpeta.

Estoy usando Python 2.7, instalo la última versión 2.x de Python desde el sitio web a continuación: http://www.python.org/download/ Aquí hay un video de YouTube, cómo instalar Python e incluir Python en tu ruta. Esto es asumiendo que está ejecutando el sistema operativo Windows.

Para ejecutar nuestro programa, necesitamos iniciar una solicitud de comando, (ubicada en Todos los programas-> Accesorios-Solicitud de comando). Inicie este programa escriba el siguiente comando en la solicitud en la ventana:

Desea cambiar a la ubicación de la carpeta donde colocó su programa readOptical.py.

En mi computadora creé la carpeta C: Code Python readOptical. Así que escribiría el siguiente comando en el símbolo del sistema:

> cd Code Python ReadOptical

Ahora vamos a editar nuestro programa readOptical.py para incluir las lecturas del sensor que anotamos cuando capturamos los datos del sensor. Entonces, usando su editor de texto favorito, edite readOptical.py y edite la línea de abajo para incluir las lecturas de sus sensores.

Vamos a ejecutar nuestro readOptical.py dos veces, Una vez con datos de nuestros sensores para cuando ambos sensores son blancos y el sensor izquierdo negro, y una segunda vez con datos de nuestros sensores cuando ambos sensores son blancos y el sensor derecho es negro.

De esta manera podemos ver todos los resultados del programa readOptical.py sin que se eliminen datos de la ventana del símbolo del sistema.

Edite esta línea en su programa readOptical.py:

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

Hemos incluido las lecturas de los sensores de cuando ambos sensores son blancos, cuando los sensores en el sensor izquierdo son negros y otra vez cuando ambos sensores son blancos. La razón por la que estamos haciendo esto es para darle un ejemplo real de lo que el robot vería cuando sigue una línea.

Primero, el robot vería los dos sensores en blanco (el robot sobre la línea negra), luego, al girar el círculo, el robot vería que el sensor izquierdo se volvía negro, en el que el robot giraba a la derecha hasta que ambos sensores se vieran blancos nuevamente.

(de nuevo, estoy usando los sensores izquierdo y derecho cuando miro la parte frontal del robot.

Después de editar nuestro programa readOptical.py, escribiríamos lo siguiente en el Símbolo del sistema, (debe estar sentado en la ubicación de su carpeta donde coloca su programa readOptical.py)

> Python readOptical.py

En este punto, el programa debería ejecutarse y debería ver la siguiente salida en el Símbolo del sistema. Copie la salida y péguela en otra ventana del Bloc de notas de Windows, para que podamos ver esto en un minuto.

Si recibe algún error, edite su programa readOptical.py. Python es sensible a la sangría, Python usa la sangría de espacio para determinar cómo se debe comportar el programa cuando se ejecuta.

Si recibe algún error de sangría, tendrá que regresar y verificar que pegó el programa readOptical.py en su operador de texto, que no movió ninguna sangría en ninguna línea de código.

El primer resultado de nuestro programa debe ser similar al siguiente: (archivo adjunto)

(solo mira esto por ahora, vamos a profundizar un poco más)

(También refiérase a su salida, se formateará para que las columnas se alineen mejor)

Lecturas del sensor (donde se encuentra la franja negra) Centro izquierda Centro C: Código Python readOptical src> python readoptical.py

Paso 2: Salida desde ReadOptical.py

Como dije en un blog anterior, he hecho todas las matemáticas y la lógica por ti, todo lo que tienes que hacer es seguirlas.

Aquí tiene la oportunidad de acostumbrarse a leer números binarios y hexadecimales. Al principio se ve como un galimatías, pero te acostumbrarás. Si tienes problemas, Lee los tutoriales a los que he hecho referencia en mis publicaciones de blog anteriores.

Si no desea entrar en este gran detalle, simplemente busque las secciones de salida en las que los resultados indiquen "avanzar", "girar a la izquierda" o "girar a la derecha"

Analicemos lo que está pasando dentro del programa:

En primer lugar, veamos los comentarios del método readOptical () en nuestro programa lineFollow.ino:

0x000 optical1 negro

0xff optical1 blanco

0x100 optical1 blanco

0x1ff optical1 negro

0x2XX no está listo; no use este valor

Tenga en cuenta que tres lecturas de sensores ópticos comienzan con 0x1 o 0x2 hex.

El resto comienza con 0x0 o 0xf. Si convierte estos números a binarios, verá un patrón. Cargue Python Idle y escriba lo siguiente:

>>> formato (oxff, ‘# 018b’)

El parámetro de formato ‘# 018b’ indica que se muestra el número pasado como un número binario de 16 bits, por lo que el comando de formato devolverá lo siguiente:’0b00000000111111 ′

Observe que hay 8 ceros seguidos por 8 1s.

Este número de 16 bits tiene los 8 bits menos significativos establecidos en 1.

Si escribes lo siguiente en Python:

>>> hex (int (’11111111 ′, 2))

Obtendrá:’0xff’

Ahora vamos a probar 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 se muestran en la representación binaria de 0x1ff?

¿En qué posición está el 1 en, contando desde la derecha, para 0 × 100?

Correcto, en ambos casos 1 aparece en la posición del noveno bit desde la derecha.

El método readOptical () en el lineFollow.ino solo devuelve valores que tienen un patrón distinto.

Los sensores ópticos 1 solo devuelven números que se establecen dentro de 8 bits.

Los sensores ópticos 2 pueden tener números que se configuran en la posición del noveno bit, o números de 16 bits.

Comencemos a ver nuestros resultados del programa readOptical.py de Python.

Primero observamos las variables que se configuran al principio del programa lineFollow.ino:

sensor _in = 0xff

action1 = 0x0

action2 = 0x0

sensorValue1 = 0x0

sensorValue2 = 0x0

El primer valor del sensor que estamos leyendo es 0xff, el resto de las variables son 0x0.

La primera instrucción If realiza un BitWise AND en dos valores:

if ((sensor_in & 0xf00) == 0)

Mira la salida de nuevo:

0xff y 0xf00

0xff = 0b0000000011111111

0xf00 = 0b0000111100000000

si 0xff & 0xf00 == 0

dentro si sensor_in y 0xf00 == 00

xff y 0xff

sensorValue1 = 0b0000000011111111

& 0b0000000011111111

------

0b0000000011111111

sensorValue1 = 0xff

Observando detenidamente la operación AND bitwise, estamos comprobando si alguno de los 8 bits superiores del número de 16 bits sensor_in está configurado.

En este caso, la comparación AND devuelve 0, ya que no hay bits mayores que los 8 bits más significativos establecidos en la variable sensor_in.

Así que la primera parte de la sentencia if solo será verdadera si sensor_in contiene 0x000 o 0xff.

Dado que la primera sentencia if es verdadera, ejecutamos el comando de:

sensorValue1 = sensor_in & 0xff;

Y al ingresar un número consigo mismo, nos da el mismo número, sensorValue1 = 0xff

0xff y 0xff

sensorValue1 = 0b0000000011111111

& 0b0000000011111111

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

0b0000000011111111

sensorValue1 = 0xff

Vayamos a la segunda sentencia if:

si (sensorValue1 == 0x00)

Si observamos la variable sensorValue1, contiene 0xff, por lo que esta sentencia if es falsa y no se ejecuta.

Moviéndose en

si (sensorValue1 == 0xFF)

sensor_in es igual a 0xff así que ejecutamos la instrucción if:

action1 = action1 | 0x01;

En este caso, estamos configurando la variable de acción1 para una acción igual y aplicamos el operador OR de Bitwise al valor de 0 × 01.

Al observar los resultados de la operación OR, action1 se establece en un valor de 0x01.

dentro de sensorValue1 == 0xff

0x0 | 0x01

action1 = 0b0000000000000000

| 0b0000000000000001

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

0b0000000000000001

action1 = 0x1

En la siguiente sentencia if:

si (sensorValue2 == 0x00)

Verificamos si sensorValue2 es igual a 0x00, y por supuesto actualmente sensorValue2 es igual a 0x00, por lo que ejecutamos la instrucción if:

action1 = action1 | 0x02;

dentro de sensorValue2 == 0x00

0x1 | 0x02

action1 = 0b0000000000000001

| 0b0000000000000010

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

0b0000000000000011

action1 = 0 × 3

En la última sentencia if comprobamos:

si (sensorValue2 == 0xFF)

sensorValue2 no es igual a 0xff, así que seguimos adelante. El valor final de action1 es 0 × 03, salimos de la última sentencia if y procedemos con el siguiente 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;

}

action1 = 0x3

action2 = 0x0

Verificamos la primera sentencia if:

if (action1! = action2)

Esto es cierto, por lo que ingresamos a la instrucción if anidada

action1 = 0x3

por lo que ejecutamos la sentencia true if:

line_following.go_forward (50);

Ahora en nuestro programa readOptical.py volvemos a la parte superior del bucle for y comenzamos nuevamente con el siguiente valor: sensor_in = 0x100

action1 = 0x3

action2 = 0x3

sensorValue1 = 0xff

sensorValue2 = 0x0

En este caso la variable sensor_in es igual a 0x100

Veamos la primera sentencia if de nuevo:

if ((sensor_in & 0xf00) == 0)

sensorValue1 = sensor_in & 0xff;

else if ((sensor_in & 0xf00) >> 8 == 1)

sensorValue2 = sensor_in & 0xff;

Como señalamos durante el último bucle, la primera instrucción if busca 0xff o 0 × 00.

En este caso, la instrucción if es falsa, por lo que saltamos a la instrucción else if: En este caso, la instrucción if está haciendo un bit a Bitwise AND y un Right Shift de 8 bits.

Así que tomamos el 1 en la ubicación de 9 bits y lo cambiamos 8 veces hacia la derecha, 0 × 100 = 0b0000000100000000

0xf00 = 0b0000111100000000

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

& 0b0000000100000000

Giro a la derecha

0b0000000000000001

Este valor es igual a 1 por lo que ejecutamos la instrucción if.

sensorValue2 = sensor_in & 0xff;

0 × 100 y 0xff

sensorValue2 = 0b0000000100000000

& 0b0000000011111111

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

0b0000000000000000

SensorValue2 = 0x0

Bajando las declaraciones if, verificamos la siguiente instrucción if:

si (sensorValue1 == 0x00)

sensorValue1 es igual a 0xff, por lo que saltamos esta instrucción if. Siguiente declaración si:

si (sensorValue1 == 0xFF)

action1 = action1 | 0x01;

La sentencia if es verdadera por lo que ejecutamos la sentencia if

dentro de sensorValue1 == 0xff

0x3 | 0x01

action1 = 0b0000000000000011

| 0b0000000000000001

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

0b0000000000000011

action1 = 0x3

Siguiente declaración si:

si (sensorValue2 == 0x00)

action1 = action1 | 0x02;

La sentencia if es verdadera por lo que ejecutamos la sentencia if

dentro de sensorValue2 == 0 × 00

0x3 | 0x02

action1 = 0b0000000000000011

| 0b0000000000000010

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

0b0000000000000011

action1 = 0x3

Terminamos las sentencias if y pasamos al siguiente conjunto de sentencias if:

if (action1! = action2)

En este caso, action1 es igual a action2, por lo que omitimos la instrucción if que envía instrucciones del motor.

Volvemos al bucle for de nuevo y seleccionamos el siguiente valor sensor_in.

En este punto, hemos enviado un conjunto al controlador del motor si hay instrucciones para seguir adelante, ya que los sensores están en blanco.

En la siguiente instrucción, seguiremos leyendo los valores del sensor cuando el sensor izquierdo esté en negro.