Info

  • Principiantes
  • Edades: 11+

Temas STEAM

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

Introducción

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

Materiales

Desarrollo de la actividad

BLOCKS

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.

Paso 1

Abrir el programa BLOCKS.

Paso 2

Configurar la velocidad de los motor reductores, para esto se utiliza el bloque  Velocidad del motor que se encuentra en la parte derecha de la pantalla en la casilla Motores.

 

Paso 3

Lleva el bloque hasta la casilla de color naranja Configuraciones en la parte izquierda de la pantalla .  Repetir el paso para los dos motores, verificar que se encuentren en M1 (Motorreductor derecho) y M2 (Motorreductor izquierdo), finalmente se pondrá 60% de velocidad.

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

Paso 4

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.

Paso 5

Llevar el bloque hasta la casilla de color naranja Configuraciones en la parte izquierda de la pantalla.  Repetir el paso para los dos Sensores, verificar que se encuentren en J1 (Sensor de línea derecho) y J2 (Sensor de linea izquierdo) respectivamente,  finalmente poner un rango de 800.

Paso 6

Dar las órdenes de control, todo lo que se programa  desde este momento irá en la casilla de Ciclo infinito ubicada en  la parte izquierda de la pantalla. Lo siguiente  será realizar la lógica para leer las líneas y moverse según esto.

  • Ir a la casilla Control/Lógica ubicada en la parte derecha de la pantalla.

Paso 7

De la casilla control lógica sacar el bloque Si Hacer.

Paso 8

Arrastrar el bloque  Si hacer hasta el bloque ciclo infinito ubicado al lado derecho de la pantalla.

Paso 9

Ahora se debe comparar ambos sensores y según los datos que nos entreguen (Blanco o negro) realizar diferentes acciones, para esto se debe ir a la casilla  Control/Lógica  y sacar el bloque Y.

Paso 10

Arrastrar el bloque  Y hasta el  primer espacio del bloque Si hacer ubicado al lado derecho de la pantalla.

 

Paso 11

Volver a Control/Lógica y sacar el bloque Igual a.

Paso 12

Arrastrar el bloque Igual a  hasta el  primer espacio del bloque Y ubicado al lado izquierdo de la pantalla.

Paso 13

Se hace lo mismo del PASO 11 y PASO 12  para el segundo espacio de Y. Hasta ahora la programación debe ir así

Paso 14

Lo siguiente será colocar los bloques de los sensores que se van a leer, para ello se debe ir a la casilla Sensores y sacar el bloque Leer línea.

Paso 15

Llevar el bloque Leer la línea hasta el primer espacio de cada bloque Igual a  y cambiar el segundo Leer la línea a J2 desde la pestaña desplegable.

Paso 16

Para finalizar la primer condición se debe decirle que compare BLANCO para ello se va a la casilla Sensores y se saca el bloque BLANCO.

 

Paso 17

Llevar el bloque Blanco hasta la segunda espacio del bloque igual a, hacer esto para ambos bloques Igual a.

Paso 18

Ya se ha terminado la parte de la condición ahora se programará qué hacer cuando esta condición se cumpla, ir a la casilla motores y sacar el bloque Encender motor.

 

Paso 19

Si se cumple  la condición y ambos sensores están leyendo color BLANCO, el robot debe avanzar, para esto, se pondrá motor M1 y motor M2 hacia adelante, desplazando el bloque Encender motor hasta el  hacer del condicional.

Paso 20

Hacer lo mismo para las demás condiciones:

1° Condición: J1=Blanco y J2=Blanco (Se realizó en el paso 19)

2° Condición: J1=Blanco y J2=Negro

3° Condición: J1=Negro y J2=Blanco

4° Condición: J1=Negro y J2=Negro

  • ir al bloque Si Hacer que se encuentra en el ciclo infinito, clic derecho sobre este, aparecerá una lista y se da clic en duplicar.

Paso 21

Al duplicarlo  aparecerá un conjunto de bloques igual al que ya se realizó dentro del ciclo infinito, colocar debajo del primer Sí hacer y cambiar los valores según la  2° condición :J1=BLanco y J2=Negro, entonces M1=ADELANTE M2=ATRÁS (Para que gire a la izquierda).

Paso 22

Repetir el PASO 20 y PASO 21 pero se realiza la 3° Condición: J1=Negro y J2=Blanco, entonces M1=ATRÁS M2=ADELANTE (Para que gire a la derecha).

Paso 23

Repetir el PASO 20 y PASO 21 pero realizar la 4° Condición: J1=Negro y J2=Negro , entonces M1=ATRÁS M2=ADELANTE (Para que gire a la derecha). en este paso no importa hacia donde gire, lo importante es que de un giro de 180° (Media vuelta) para que regrese por la línea, por lo tanto indicar que gire durante un tiempo, en promedio es 3150 milisegundos, pero puede variar.

Tener presente: Si gira más de 180° se debe disminuir el tiempo y si gira menos de 180° se debe aumentar. El tiempo se da con el bloque Esperar ____ Milisegundos  que se encuentra en la casilla Control/lógica.

En la siguiente imagen se puede ver la programación ya lista con una velocidad de 45% para ambos motores y un tiempo de 3150 milisegundos.

CODE

Paso 1

Abrir el programa CODE.

Paso 2

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 se utiliza el código motorSpeed(M1, 45); Donde M1 es el motor que se va a configurar y 45 el porcentaje de la velocidad que se utilizará.

void setup() 
{
  motorSpeed(M1, 45);
  motorSpeed(M2, 45);
}

Paso 3

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

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

Paso 4

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 1° Condición: J1=Blanco y J2=Blanco, ahora se utilizará el if que es donde se dará la condición, su estructura es:

if(CONDICIÓN)

{

código de la acción que se ejecutará si se da la condición

}

La condición tendrá la siguiente estructura if(lineRead(J1) == WHITE && lineRead(J2) == BLACK) 

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

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 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);
   }

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

Se continúa con la 3° Condición: J1=Negro y J2=Negro donde debe realizar el medio giro para devolverse por la pista, en este caso se debe colocar un tiempo promedio de 3000 milisegundos el código es delay (3000) dónde 3000 es el tiempo en milisegundos que se utilizará en esta ocasión.

  • Esta es la programación completa.
/********************************************************/
/* Company:       Pygmalion                             */ 
/* Create Date:   2018-06-11                            */
/* File Name:     Linea_sin_interseccionesCODE          */
/* Module Name:   LineSensors                           */
/* Revision:      v1.0                                  */
/********************************************************/

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);  
   }
    if(lineRead(J1) == BLACK && lineRead(J2) == BLACK)
   {
    motorOn(M1, REVERSE);
    motorOn(M2, FORWARD);
    delay(3000);  
   }

}

Conceptos claves

Campo: Es el área en la cual el Innobot se va a desplazar para realizar la actividad.

Motorreductor: es construido por un motor eléctrico y una serie de engranajes que van acoplados a la flecha de un motor eléctrico y sirve para reducir el número de rpm del motor.