Guía Innobot Reto Seguidor de Línea – Recorrido con intersecciones

 

Info

  • Principiantes
  • Edades: 11+

Temas STEAM

  • Tecnología
  • Ingeniería
  • Ciencia
  • Matemáticas
  • Artes

Logros y habilidades

  • Comprende la lógica de programación en los entornos BLOCKS y CODE.
  • Diseña y programa un seguidor de linea con el innobot.
  • Afianza las habilidades de programación.
  • Desarrolla habilidades de trabajo en equipo, programación y solución de problemas.
  • Realiza programaciones utilizando los periféricos del innobot.

Recomendaciones

  • Inventar sus propias pistas con intersecciones y variar la programación según la pista.
  • Los tiempos de giro y las velocidades pueden variar de robot en robot por diferentes motivos tales como: Carga de batería, desfase de los motores, la forma en cómo se arma el chasis, entre otras. Se debe realizar ajustes de estas dos variables en cada programación cuando se utiliza un robot diferente.
  • Haber realizado el Tutorial Guía Innobot 07 – Robot seguidor de linea.

Introducción

Utiliza los sensores de línea del Innobot, para detectar una Linea, seguir su recorrido, sortear intersecciones y retornar por el mismo camino.

Desarrollo de la actividad

1. Robot  Seguidor de Línea con retorno.
A continuación, encontrarás el código en BLOCKS, para que el Innobot pueda seguir una línea y tomar intersecciones.

Paso 1

Abrir el programa BLOCKS.

Paso 2

Configurar la velocidad de los motorreductores, se utiliza el bloque “Velocidad del motor” que se encuentra en la parte derecha de la pantalla en la casilla “Motores”. Se le asigna una velocidad del  45%  a ambos motores

Nota: La velocidad se puede variar,  desde 0% (el motorreductor no se mueve) hasta el 100% (Velocidad máxima del motorreductor).

Paso 3

Ahora se le dará el umbral al sensor de línea para que identifique el color negro o blanco, para esto se debe ir a la pestaña “Sensores” y sacar el bloque “Comparar la línea”, se debe verificar que se encuentren en J1 (Sensor de línea derecho) y J2 (Sensor de linea izquierdo) respectivamente y finalmente poner un rango de 800.

Paso 4

La pista o campo en el cual se va a realizar la actividad en esta ocasión es la siguiente:

Paso 5

Programarlas condiciones principales como se hizo en el seguidor de línea básico, para este paso será J1=Blanco y J2=Blanco, colocar el bloque “Si, hacer” que se encuentra en la casilla “Control/Lógica” en el ciclo infinito.

Paso 6

Ahora se saca el bloque “Y” de la casilla “Control/Lógica” y se conecta en la entrada del SI en el bloque “Si, hacer” que se había colocado en el paso anterior.

Paso 7

Se va a la casilla “control/lógica” y se saca el bloque “Igual a”, se debe  sacar dos para colocarlos en los dos espacios del bloque “Y” que se colocó anteriormente.

Paso 8

Ahora se debe ir a la casilla sensores y sacar el bloque “Leer la línea” , se toman dos para colocarlos en la primer casilla de cada bloque “Igual a”, uno es J1 y el otro se cambia a J2.

Paso 9

Ahora se debe ir a la casilla sensores y sacar el bloque “BLANCO” , se toman dos para colocarlos en la Segunda casilla de cada bloque “Igual a”.

Paso 10

Ya con la condición lista se debe programar la acción que se realiza cuando se cumple esta condición, se va a la casilla motores y se toma el bloque  “Encender motor”, deben ser dos para encender ambos motores. Uno de ellos es M1 y el otro se debe cambiar a M2, ambos van hacia adelante.

Paso 11

Para continuar con la siguientes condiciones sin necesidad de hacer todo de nuevo, se da clic derecho sobre el bloque “Si, hacer” que se encuentra ya en la programación y luego clic en duplicar, aparecerá un conjunto de bloques exactamente igual al que duplicamos y lo colocamos debajo del primer bloque “Si, hacer”.

Paso 12

Ahora se deben cambiar los parámetros para que esté acorde a esta condición, J1 ira en BLANCO, J2 ahora irá NEGRO, el motor M1 hacia adelante y el motor M2 hacia atrás.

Paso 13

Volvemos a duplicar el conjunto de bloques (Paso 11) y cambiamos los parámetros de acuerdo a la 3° condición; J1=Negro, J2=Blanco y M1=Atrás, M2=Adelante.  en la imagen 13 se muestra como debe ir la programación hasta ahora.

Paso 14

En la siguiente condición se lee negro en ambos sensores, quiere decir que,  se ha encontrado la primer intersección, pero según la pista hay dos ocasiones en que los sensores leen negro en los sensores (Primer intersección y cuando llega a la torre), por ello se creará una variable para saber en cual intersección se encuentra. para ello es va a la casilla variables y se saca el bloque “Tipo ___, nombre = Numero 0”.

 

Paso 15

Se lleva el bloque hasta el bloque de programación “Declaraciones” que se encuentra al lado derecho y donde dice Nombre se cambia por “intersección” , todo en minúsculas y sin tildes, vale aclarar que puede llevar cualquier nombre pero es mejor colocarle un nombre de acuerdo para lo que se utilizara y finalmente el número quedará en 0

Paso 16

Ahora se debe ir a “control/Lógica” y sacar un bloque “si, hacer”, se colocarán debajo del último “Sí, hacer” que hay en la programación, luego en “control/Lógica” sacar un bloque “igual a”, que irá en el primer espacio del bloque “Si, hacer” Que se colocó anteriormente.

Paso 17

Se tomará el bloque “Variable intersección” que se encuentra en las casillas variables y se ubica en el primer espacio del bloque “Igual a”, del paso anterior.

Paso 18

De nuevo en la casilla variables sacamos el bloque “Número”  y se coloca en el segundo espacio del bloque “Igual a”.

Paso 19

Así debe ir la programación.

Paso 20

Se duplica de nuevo un conjunto de bloques como en el PASO 11 y se coloca dentro del espacio hacer, dentro del último bloque “Si hacer”. sea cambian los parámetros así: J1=Negro, J2=Negro, M1= Adelante y M2= Reversa (Para que vaya a la izquierda en la primera intersección).

Paso 21

Para girar a la izquierda en la primera intersección se debe poner un tiempo para que gire 90° y quede colineal a la línea negra que debe seguir después de girar, para esto se va a la casilla “Control/Lógica” y se toma el bloque “Esperar ____ milisegundos” y se coloca debajo del último “encender motor” y se coloca un tiempo en este caso es de 550.

Paso 22

La variable “intersección” se creó con el fin de saber en cual intersección se encuentra. cómo funciona: La variable fue iniciada en “0” (Cero) y cada vez que lea una intersección se sumará 1 a la variable (0+1 = 1), así se puede crear una condición para cuando detecte otro intersección y debe realizar una acción diferente.

Ahora se debe colocar el bloque “Incrementar” que se encuentra en la casilla variables

 

Paso 23

Al bloque incrementar donde esta el “0” se cambia por un “1” que es la cantidad que se quiere incrementar.

Paso 24

Duplica el conjunto de bloques que se acaba de realizar desde el primer Si hacer, y se cambian los valores del igual a, donde esta el “0” se cambia por “1”, que es valor que indica la siguiente intersección, además se modifica el valor de el “Esperar” por 2000 y si se observa la variable intersección vuelve a incrementar como su valor actual es 1 al incrementar en 1 se convierte en 2 (1+1=2).

Paso 25

Para la última intersección, se debe configurar el umbral para el tercer sensor que se utilizara, porque en esta última intersección no se lee negro-negro, sino que, se lee de un solo lado, por esto debemos incluir otro sensor de línea al lado derecho, así cuando los dos sensores derechos detecten línea negra se puede identificar, el robot que se utilizó para esto tenía cuatro sensores pero el J4 no fue necesario utilizarlo.

Paso 26

Se duplica de nuevo el conjunto de bloques para las intersecciones y se cambian los valores J2 por J3, el “Esperar” por 550, el bloque “Incrementar” se debe borrar.

Paso 27

En el  lugar del bloque que se borró en el paso anterior se debe colocar el bloque “decrementar” que se encuentra en la casilla variables y finalmente a este bloque cambiar el “0” por un “2”, Recordar que el valor actual de la variable “intersección” es 2 al decrementar en 2 se vuelve la variable a 0 dando a entender que ya termino el recorrido.

Paso 1

Abrir el programa CODE.

Paso 2

Lo primero será declarar las configuraciones que irán dentro de las llaves (“{}”) que hay en el void setup(), que seran velocidad y rango de línea.

Para velocidad utilizaremos el código motorSpeed(M1, 45); Donde M1 es el motor que a configurar y 45 el porcentaje de la velocidad que utilizaremos en esta ocasión.

/********************************************************/
/* Company:       Pygmalion                             */ 
/* Create Date:   2018-06-11                            */
/* File Name:     Programación_intersecciones_1CODE     */
/* Module Name:   LineSensors                           */
/* Revision:      v1.0                                  */
/********************************************************/
int interseccion = 0;
void setup() 
{
  motorSpeed(M1, 40);
  motorSpeed(M2, 40);
}

Paso 3

Debemos configurar el rango en el cual los sensores van detectar el BLANCO y el NEGRO, para esto utilizaremos el código lineCompare(J1, 800); Donde J1 es el sensor a configurar y 800 el rango de detección.

/********************************************************/
/* Company:       Pygmalion                             */ 
/* Create Date:   2018-06-11                            */
/* File Name:     Programación_intersecciones_1CODE     */
/* Module Name:   LineSensors                           */
/* Revision:      v1.0                                  */
/********************************************************/
int interseccion = 0;
void setup() 
{
  motorSpeed(M1, 40);
  motorSpeed(M2, 40);
  lineCompare(J1, 800);
  lineCompare(J2, 800);
  lineCompare(J3, 800);
}

Paso 4

Lo siguiente será continuar con la programación dentro del ciclo infinito que en CODE es void loop(), desde ahora todo irá dentro de las llaves (“{}”).

Se realizarán las condiciones la primera 1° Condición: J1=Blanco y J2=Blanco, ahora se utilizará el if que es donde se dará la condición, su estructura es:

void loop() 
{

    if(lineRead(J1) == WHITE && lineRead(J2) == WHITE)
   {

Paso 5

Programar la acción cuando se de la condición, en este caso será M1=FORWARD para ir adelante, en caso de necesitar ir hacia atrás se coloca M1=REVERSE, el código será:

motorOn(M1, FORWARD) donde M1 es motor que se moverá y FORWARD la dirección.

void loop() 
{

    if(lineRead(J1) == WHITE && lineRead(J2) == WHITE)
   {
    motorOn(M1, FORWARD);
    motorOn(M2, FORWARD);
   }

Paso 6

Continuar con la 2° Condición: J1=Blanco y J2=Negro donde debe girar a la izquierda.

void setup() 
{
  motorSpeed(M1, 45);
  motorSpeed(M2, 45);
  lineCompare(J1, 800);
  lineCompare(J2, 800);
}

void loop() 
{
    if(lineRead(J1) == WHITE && lineRead(J2) == WHITE)
   {
    motorOn(M1, FORWARD);
    motorOn(M2, FORWARD);
   }
  
    if(lineRead(J1) == WHITE && lineRead(J2) == BLACK)
   {
    motorOn(M1, FORWARD);
    motorOn(M2, REVERSE);  
   }

Paso 7

Ahora con la 3° Condición: J1=Negro y J2=Blanco donde debe girar a la derecha.

void setup() 
{
  motorSpeed(M1, 45);
  motorSpeed(M2, 45);
  lineCompare(J1, 800);
  lineCompare(J2, 800);
}

void loop() 
{
    if(lineRead(J1) == WHITE && lineRead(J2) == WHITE)
   {
    motorOn(M1, FORWARD);
    motorOn(M2, FORWARD);
   }
  
    if(lineRead(J1) == WHITE && lineRead(J2) == BLACK)
   {
    motorOn(M1, FORWARD);
    motorOn(M2, REVERSE);  
   }
    if(lineRead(J1) == BLACK && lineRead(J2) == WHITE)
   {
    motorOn(M1, REVERSE);
    motorOn(M2, FORWARD);  
   }

Paso 8

Ahora se programaran las intersecciones  se realiza la condición if(interseccion == 0)

void loop() 
{

    if(lineRead(J1) == WHITE && lineRead(J2) == WHITE)
   {
    motorOn(M1, FORWARD);
    motorOn(M2, FORWARD);
   }
  
    if(lineRead(J1) == WHITE && lineRead(J2) == BLACK)
   {
    motorOn(M1, FORWARD);
    motorOn(M2, REVERSE);  
   }
    if(lineRead(J1) == BLACK && lineRead(J2) == WHITE)
   {
    motorOn(M1, REVERSE);
    motorOn(M2, FORWARD);  
   }
   if(interseccion == 0) 
   {

Paso 9

luego se realiza la condición de J1 y J2 cuando sean iguales a negro.

   if(interseccion == 0) 
   {
    if(lineRead(J1) == BLACK && lineRead(J2) == BLACK) //En la primera interseccion debe girar a la izquierda
    {

Paso 10

Para que el robot gire más rápido cambiamos la velocidad de los motores a 75

   if(interseccion == 0) 
   {
    if(lineRead(J1) == BLACK && lineRead(J2) == BLACK) //En la primera interseccion debe girar a la izquierda
    {
    motorSpeed(M1, 75); //Se aumenta las velocidades para dar el giro mas rapido
    motorSpeed(M2, 75);

Paso 11

El robot al girar puede que quede un poco atrás en este paso le indicamos que debe avanzar un poco más para que cuando gire quede otra vez sobre la siguiente línea. encendemos M1 y M2 hacia adelante durante un tiempo corto.

   if(interseccion == 0) 
   {
    if(lineRead(J1) == BLACK && lineRead(J2) == BLACK) //En la primera interseccion debe girar a la izquierda
    {
    motorSpeed(M1, 75); //Se aumenta las velocidades para dar el giro mas rapido
    motorSpeed(M2, 75);
    motorOn(M1, FORWARD); //Los motores deben avanzar un poco para cuando gire quede colineal con la linea
    motorOn(M2, FORWARD);
    delay(200);

Paso 12

En este paso se programa el giro a la izquierda de la primera intersección, además se le aumenta una unidad a la variable intersección y cerramos las llaves de las condiciones anidadas que acabamos de realizar.

   if(interseccion == 0) 
   {
    if(lineRead(J1) == BLACK && lineRead(J2) == BLACK) //En la primera interseccion debe girar a la izquierda
    {
    motorSpeed(M1, 75); //Se aumenta las velocidades para dar el giro mas rapido
    motorSpeed(M2, 75);
    motorOn(M1, FORWARD); //Los motores deben avanzar un poco para cuando gire quede colineal con la linea
    motorOn(M2, FORWARD);
    delay(200);
    motorOn(M1, FORWARD); //Gira a la izquierda 90 grados
    motorOn(M2, REVERSE); 
    delay(400);
    interseccion +=1; //Se aumenta en 1 la variable interseccion para sabe que ya paso la primer intersección
    }
   }

Paso 13

Ahora se restablece la velocidad a la inicial (40%) de ambos motores.

   if(interseccion == 0) 
   {
    if(lineRead(J1) == BLACK && lineRead(J2) == BLACK) //En la primera interseccion debe girar a la izquierda
    {
    motorSpeed(M1, 75); //Se aumenta las velocidades para dar el giro mas rapido
    motorSpeed(M2, 75);
    motorOn(M1, FORWARD); //Los motores deben avanzar un poco para cuando gire quede colineal con la linea
    motorOn(M2, FORWARD);
    delay(200);
    motorOn(M1, FORWARD); //Gira a la izquierda 90 grados
    motorOn(M2, REVERSE); 
    delay(400);
    interseccion +=1; //Se aumenta en 1 la variable interseccion para sabe que ya paso la primer intersección
    }
   }
   motorSpeed(M1, 40); //Se retorna la velocidad a la principal para que lea la linea bien
   motorSpeed(M2, 40);

Paso 14

Se realiza la condición para la segunda intersección que es cuando llega a la torre y debe girar 180° para devolverse por la pista. en esta ocasión otra vez J1 y J2 leen negro.

   if(interseccion == 1) //La segunda interseccion es cuando llega a la torre, ya que , vuelve a leer con los sensores en negro
   {
    if(lineRead(J1) == BLACK && lineRead(J2) == BLACK)
    {  

		

Paso 15

Se suma una unidad a la variable intersección para saber que ya pasó por la torre, se gira a la derecha durante un tiempo equivalente a los 180° (Medio giro).

   if(interseccion == 1) //La segunda interseccion es cuando llega a la torre, ya que , vuelve a leer con los sensores en negro
   {
    if(lineRead(J1) == BLACK && lineRead(J2) == BLACK)
    {  
    motorOn(M1, FORWARD); 
    motorOn(M2, REVERSE);
    delay(2000);
    interseccion +=1; //Se aumenta la variable interseccion para saber que ya paso la segunda interseccion
    }
   }

Paso 16

Cuando intersección = 2, quiere decir que solo falta una intersección pero en esta los sensores que deben leer negro son J1 y J3

   if(interseccion == 2)//Es para la tercera y ultima interseccion
   {
    if(lineRead(J1) == BLACK && lineRead(J3) == BLACK)//En esta solo leen negro los sensores derechos J1 y J3
    {

Paso 17

Para que el robot gire más rápido cambiamos la velocidad de los motores a 75

   if(interseccion == 2)//Es para la tercera y ultima interseccion
   {
    if(lineRead(J1) == BLACK && lineRead(J3) == BLACK)//En esta solo leen negro los sensores derechos J1 y J3
    {
    motorSpeed(M1, 75);
    motorSpeed(M2, 75);

Paso 18

Se activan los motores M1 y M2 para que gire a la derecha y se le da un tiempo equivalente a 90° y se le restan a la variable intersección 2 unidades para que vuelva a quedar en 0. aquí se terminan las intersecciones.

   if(interseccion == 2)//Es para la tercera y ultima interseccion
   {
    if(lineRead(J1) == BLACK && lineRead(J3) == BLACK)//En esta solo leen negro los sensores derechos J1 y J3
    {
    motorSpeed(M1, 75);
    motorSpeed(M2, 75);
    motorOn(M1, REVERSE);//Se gira a la derecha
    motorOn(M2, FORWARD); 
    delay(400);
    interseccion -=2;//Se devuelve la variable a cero para indicar que ya terminaron las intersecciones
    }
   }

Paso 19

Para finalizar se restablece la velocidad a la inicial (40%) de ambos motores.

   if(interseccion == 2)//Es para la tercera y ultima interseccion
   {
    if(lineRead(J1) == BLACK && lineRead(J3) == BLACK)//En esta solo leen negro los sensores derechos J1 y J3
    {
    motorSpeed(M1, 75);
    motorSpeed(M2, 75);
    motorOn(M1, REVERSE);//Se gira a la derecha
    motorOn(M2, FORWARD); 
    delay(400);
    interseccion -=2;//Se devuelve la variable a cero para indicar que ya terminaron las intersecciones
    }
   }
   motorSpeed(M1, 40);
   motorSpeed(M2, 40);

}

Paso 20

Esta es la programación completa.

/********************************************************/
/* Company:       Pygmalion                             */ 
/* Create Date:   2018-06-11                            */
/* File Name:     Programación_intersecciones_1CODE     */
/* Module Name:   LineSensors                           */
/* Revision:      v1.0                                  */
/********************************************************/
int interseccion = 0;
void setup() 
{
  motorSpeed(M1, 40);
  motorSpeed(M2, 40);
  lineCompare(J1, 800);
  lineCompare(J2, 800);
  lineCompare(J3, 800);
}

void loop() 
{

    if(lineRead(J1) == WHITE && lineRead(J2) == WHITE)
   {
    motorOn(M1, FORWARD);
    motorOn(M2, FORWARD);
   }
  
    if(lineRead(J1) == WHITE && lineRead(J2) == BLACK)
   {
    motorOn(M1, FORWARD);
    motorOn(M2, REVERSE);  
   }
    if(lineRead(J1) == BLACK && lineRead(J2) == WHITE)
   {
    motorOn(M1, REVERSE);
    motorOn(M2, FORWARD);  
   }
   if(interseccion == 0) 
   {
    if(lineRead(J1) == BLACK && lineRead(J2) == BLACK) //En la primera interseccion debe girar a la izquierda
    {
    motorSpeed(M1, 75); //Se aumenta las velocidades para dar el giro mas rapido
    motorSpeed(M2, 75);
    motorOn(M1, FORWARD); //Los motores deben avanzar un poco para cuando gire quede colineal con la linea
    motorOn(M2, FORWARD);
    delay(200);
    motorOn(M1, FORWARD); //Gira a la izquierda 90 grados
    motorOn(M2, REVERSE); 
    delay(400);
    interseccion +=1; //Se aumenta en 1 la variable interseccion para sabe que ya paso la primer intersección
    }
   }
   motorSpeed(M1, 40); //Se retorna la velocidad a la principal para que lea la linea bien
   motorSpeed(M2, 40);

   
   if(interseccion == 1) //La segunda interseccion es cuando llega a la torre, ya que , vuelve a leer con los sensores en negro
   {
    if(lineRead(J1) == BLACK && lineRead(J2) == BLACK)
    {  
    motorOn(M1, FORWARD); 
    motorOn(M2, REVERSE);
    delay(2000);
    interseccion +=1; //Se aumenta la variable interseccion para saber que ya paso la segunda interseccion
    }
   }
   if(interseccion == 2)//Es para la tercera y ultima interseccion
   {
    if(lineRead(J1) == BLACK && lineRead(J3) == BLACK)//En esta solo leen negro los sensores derechos J1 y J3
    {
    motorSpeed(M1, 75);
    motorSpeed(M2, 75);
    motorOn(M1, REVERSE);//Se gira a la derecha
    motorOn(M2, FORWARD); 
    delay(400);
    interseccion -=2;//Se devuelve la variable a cero para indicar que ya terminaron las intersecciones
    }
   }
   motorSpeed(M1, 40);
   motorSpeed(M2, 40);

}

Conceptos clave

Campo: Es el área en la cual el Innobot se va a desplazar para realizar la actividad.
Intersección: es el punto de encuentro de dos o más cosas de forma lineal, especialmente calles o vías.