Tautronix - FASE 5

-


                    


                                                


Introducción a la Ingeniería Electrónica - 710100M

Facultad de Ingeniería

Universidad del Valle


Integrantes

Daniel Eduardo Zuluaga Escobar - 202126017

Gonzalo José Paz González - 202124979


FASE 5 - Robot seguidor de línea Tautronix

En la fase 5 se presenta un resumen de las anteriores fases y los últimos cambios hechos al robot, en este caso se le realizaron unos ajustes al código para optimizarlo y corregir que el robot se quedaba en bucle y le costaba tomar curvas. También se lubricó el balín que se estaba quedando pegado y generaba conflicto al pasar por encima de la cinta aislante de la pista de pruebas.


Robot seguidor de línea (Tautronix): Es un robot seguidor de línea inspirado en la forma que tienen los autos de fórmula 1, su nombre se lo debemos a una mezcla entre la letra griega taf o tau (Τ τ), la palabra electrónica y el icónico animal toro que representa en algunas culturas fuerza y potencia.

Su principal objetivo es seguir un recorrido trazado por una línea en el menor tiempo posible, esto será posible gracias a su diseño y componentes.

Seguidor de línea: Un robot seguidor de línea cumple la misión de seguir un recorrido determinado, el cual es trazado normalmente por una línea de color negro la cual no tiene una forma totalmente definida pero sí ciertas especificaciones especiales dependiendo de las reglas de la pista.

COMPONENTES

Motorreductores

Son los encargados de darle el impulso necesario a nuestro robot seguidor de línea. 

Motor con caja reductora, este es usado más que todo para prácticas de robótica, conjunto una super llanta para la implementación de carritos seguidores de lí­nea o evasores de obstáculos, entre otras aplicaciones. El kit de dos motores con llantas tiene un precio de $15.000.


Figura 1 (Motorreductor)


Especificaciones técnicas

Motor DC

  • -Imán permanente

  • -Escobillas de carbón

  • -Eje biaxial

Voltaje de operación 3V~6V Corriente de operación

  • 100mA (sin carga)

  • 200mA (con carga)

Caja reductora (piñonera plástica)1:48 Velocidad

  • 9800 rpm (sin carga)

  • 220 rpm (con carga)

Torque:0.5KgCm

Tamaño: 6.92cm x 2.25cm x 1.88cm

Peso: 35 gramos


Ruedas


Las ruedas le dan soporte y movimiento al robot con ayuda de los motores para que así nuestro seguidor de línea pueda completar el recorrido.

Figura 2 (Rueda)

Especificaciones técnicas:


Color: negro y amarillo

Ancho: 2,5cm

Altura: 6cm


Rueda loca o balín


Rueda de perdigón de acero reforzado, esta es comúnmente usada en robots de este tipo ya que brinda mayor movilidad y permite cambiar de dirección rápidamente.



 

Figura 3 (Rueda loca o balín)

Chasis 


El chasis sobre el que se montarán los componentes del robot es una lámina de madera que fue cortada pensando cumplir con las condiciones óptimas para el robot, para que sea ligero,  resistente y a la vez darle un poco de personalidad y estilo.


Figura 4 (Plano del chasis)

Arduino nano 

Se utilizó como placa microcontroladora el Arduino nano, que es una placa de desarrollo de tamaño compacto, completa y compatible con protoboards, se basa en el microcontrolador ATmega328P. Posee 14 pines para entrada y salida digital, 6 entradas analógicas, un cristal de 16Mhz, conexión Mini-USB, terminales de conexión ICSP y un botón de reseteo. Cabe aclarar que tiene las mismas capacidades que el Arduino UNO, tanto en potencia como en conectividad, las diferencias están en su compacto tamaño, conector jack de alimentación y que los pines cambian a un formato de pines header.

Figura 5 (Arduino nano)
Driver puente H TB6612FNG 1.2A

Se decidió utilizar el driver para motores TB6612FNG que posee 2 puentes H, puede controlas hasta dos motores DC con corriente constante de 1.2A. Este driver tiene dos señales de entrada (IN1 y IN2) que sirven para controlar los motores en uno de cuatro modos: CW(giro en sentido de las manecillas del reloj), CCW (en contra de las manecillas), short-brake y stop. Las dos salidas de motores (A y B) pueden ser controladas de manera separada, la velocidad de cada motor es controlada mediante una señal PWM con una frecuencia de hasta 100kHz.
Figura 6 (Driver puente H TB6612FNG 1.2A)

Sensores QTR8-A

 Es un sensor de reflectancia pensado como sensor de línea, puede ser usado como sensor de proximidad o como sensor de reflectancia. El módulo es un portador de 8 pares emisores y recibidores de IR. Cuando este detecta la superficie de color blanco su valor se aproxima a 0 y cuando detecta la superficie de color negro su valor se aproxima a 1000.

Figura 7 (Sensor QTR-8A Chino)


Baquelitas

Se utilizó una baquelita como soporte base para soldar el Arduino y demás componentes.

Figura 8 (Baquelitas)
Protoboard

Se utilizó para desarrollar el ejercicio del programa y hacer pruebas.


Baterías

Se utilizaron dos baterías de celular Li-ion de 1500mAh y 3.8V cada una de la marca Samsung y Lenovo.

Figura 9 (Baterías)

Mecanismos de sujeción:

Se utilizó silicona caliente para fijar todas las piezas con el objetivo de que todo quede completamente fijo y que sea fácil de retirar en caso de querer hacer algún cambio.

Figura 10 (Silicona)



PLANOS TAUTRONIX

Figura 11 (Plano - Vista desde arriba)

Figura 12 (Plano - Vista desde el lateral)


Diagrama de conexión del robot:

Figura 13 (Diagrama de conexiones y bloques)




Imágenes del montaje actualizado:



Figura 14 (Montaje - Lateral derecho)

Figura 15 (Montaje - Lateral izquierdo)

Figura 16 (Montaje - Arriba)

Figura 17 (Montaje - atrás)



Video del robot en funcionamiento actualizado:

Figura 18 (Video Tautronix en funcionamiento)

Diagrama de flujo del código previo:

Figura 19 (Diagrama de flujo previo)

Programa previo implementado para el funcionamiento de robot:

#define EMITTER_PIN             12  // Emitter es controlado por el pin digital 2
#define pwm_i 3
#define izq_1 5
#define izq_2 4

#define pwm_d 9
#define der_1 7
#define der_2 8

//Los sensores del 0 al 5 se conectaron a las entradas analógicas del 0 al 5, respectivamente.

void setup()
{  
delay(1000);
pinMode(izq_1,OUTPUT);
pinMode(izq_2,OUTPUT);
pinMode(der_1,OUTPUT);
pinMode(der_2,OUTPUT);
pinMode(6,OUTPUT);
  delay(500);
  int i;
  pinMode(13, OUTPUT);
  digitalWrite(13, HIGH);    // Encender LED para indicar que está en modo calibración.
  for (i = 0; i < 400; i++)  //Realizar la calibración, toma unos 10 segundos.
  {
    qtra.calibrate();       // Lee todos los sensores 10 veces a 2.5ms cada uno.
  }
  digitalWrite(13, LOW);     // Apagar el LED para indicar que pasó la calibración.
}
 
void loop()
{ 
  unsigned int position = qtra.readLine(sensorValues);
    digitalWrite(6,HIGH);
   if (sensorValues[0] < 500 && sensorValues[1] < 500 && sensorValues[2] < 500 && sensorValues[3] < 500 && sensorValues[4] < 500 && sensorValues[5] < 500 && sensorValues[6] < 500 && sensorValues[7] < 500)
  {
    digitalWrite(izq_1,LOW);
    digitalWrite(izq_2,HIGH);
    analogWrite(pwm_i,75);
    digitalWrite(der_1,LOW);
    digitalWrite(der_2,HIGH);
    analogWrite(pwm_d,75);
  }
  if (sensorValues[3] > 500 && sensorValues[4] > 500)
  {
    digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,150);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,150);
  } 
  if(sensorValues[3] > 500 && sensorValues[2] > 500)
    {digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,150);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,125);
    }
  if(sensorValues[2] > 500 && sensorValues[1] > 500)
    {digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,150);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,100);
    }
   if(sensorValues[1] > 500 && sensorValues[0] > 500)
    {digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,150);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,75);
    }
     if (sensorValues[4] > 500 && sensorValues[5] > 500)
  {
    digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,125);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,150);
  } 
  if(sensorValues[5] > 500 && sensorValues[6] > 500)
    {digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,100);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,150);
    }
  if(sensorValues[6] > 500 && sensorValues[7] > 500)
    {digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,75);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,150);
    }
  }

Caracterísitcas:

"pmw_d" corresponde al motor derecho.
"pmw_i" corresponde al motor izquierdo.

Velocidad máxima 150, velocidad mínima 0.
  • La parte derecha del sensor corresponde a los sensores 0, 1 y 2.
  • La parte central del sensor corresponde a los sensores 3 y 4.
  • La parte izquierda del sensor corresponde a los sensores 5, 6 y 7.
  • Si los sensores del lado derecho detectan negro arrojando valores mayores a 500 (Cercanos a 1000) el motor del lado izquierdo baja la velocidad. Asimismo pasa con el lado izquierdo, cuando los sensores detectan negro y arrojan valores mayores a 500 el motor del lado derecho baja la velocidad y el motor del lado izquierdo se pone a su máxima velocidad.
  • Si los sensores de la parte central (3 y 4) arrojan valores mayores a 500 se le asigna a ambos motores la velocidad máxima.

Diagrama de flujo actualizado:

Figura 20 (Diagrama de flujo actualizado)



Código actualizado:

#include <QTRSensors.h>

#define NUM_SENSORS
#define NUM_SAMPLES_PER_SENSOR
#define EMITTER_PIN             12  // Emitter es controlado por el pin digital 2
#define pwm_i 3
#define izq_1 5
#define izq_2 4

#define pwm_d 9
#define der_1 7
#define der_2 8

// Los sensores del 0 al 5 se conectaron a las entradas analógicas del 0 al 5, respectivamente.

QTRSensorsAnalog qtra((unsigned char[]) {0, 1, 2, 3, 4, 5, 6, 7},
  NUM_SENSORS, NUM_SAMPLES_PER_SENSOR, EMITTER_PIN);
unsigned int sensorValues[NUM_SENSORS];


void setup()
{  delay(1000);
pinMode(izq_1,OUTPUT);
pinMode(izq_2,OUTPUT);
pinMode(der_1,OUTPUT);
pinMode(der_2,OUTPUT);
pinMode(6,OUTPUT);
  delay(500);
  int i;
  pinMode(13, OUTPUT);
  digitalWrite(13, HIGH);    // Encender LED para indicar que está en modo calibración.
  for (i = 0; i < 400; i++)  // Realizar la calibración, toma unos 10 segundos
  {
    qtra.calibrate();       // Lee todos los sensores 10 veces a 2.5ms cada uno.
  }
  digitalWrite(13, LOW);     // Apagar el LED para indicar que pasó la calibración.
}
 



void loop()
{ 
  unsigned int position = qtra.readLine(sensorValues);
    digitalWrite(6,HIGH);
   if (sensorValues[0] < 600 && sensorValues[1] < 600 && sensorValues[2] < 600 && sensorValues[3] < 600 && sensorValues[4] < 600 && sensorValues[5] < 600 && sensorValues[6] < 600 && sensorValues[7] < 600)
  {
    digitalWrite(izq_1,LOW);
    digitalWrite(izq_2,HIGH);
    analogWrite(pwm_i,125);
    digitalWrite(der_1,LOW);
    digitalWrite(der_2,HIGH);
    analogWrite(pwm_d,125);
  }
    if (sensorValues[0] > 600 && sensorValues[1] > 600 && sensorValues[2] > 600 && sensorValues[3] > 600 && sensorValues[4] > 600 && sensorValues[5] > 600 && sensorValues[6] > 600 && sensorValues[7] > 600)
  {
    digitalWrite(izq_1,LOW);
    digitalWrite(izq_2,HIGH);
    analogWrite(pwm_i,0);
    digitalWrite(der_1,LOW);
    digitalWrite(der_2,HIGH);
    analogWrite(pwm_d,0);
  }
  else
  {
    if (sensorValues[3] > 600 && sensorValues[4] > 600)
  {
    digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,200);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,200);
  } 
  if(sensorValues[3] > 600 && sensorValues[2] > 600)
    {digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,200);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,150);
    }
  if(sensorValues[2] > 600 && sensorValues[1] > 600)
    {digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,200);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,75);
    }
   if(sensorValues[1] > 600 && sensorValues[0] > 600)
    {digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,200);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,50);
    }
     if (sensorValues[4] > 600 && sensorValues[5] > 600)
  {
    digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,150);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,200);
  } 
  if(sensorValues[5] > 600 && sensorValues[6] > 600)
    {digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,75);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,200);
    }
  if(sensorValues[6] > 600 && sensorValues[7] > 600)
    {digitalWrite(izq_1,HIGH);
    digitalWrite(izq_2,LOW);
    analogWrite(pwm_i,50);
    digitalWrite(der_1,HIGH);
    digitalWrite(der_2,LOW);
    analogWrite(pwm_d,200);
    }
  }
  }

Cambios en el código:

* Se añadieron dos librerías para definir el número de sensores y para la calibración.
* Se cambió el valor del if de 500 a 600 (El que arrojan los sensores) por si al momento de calibrar el blanco da valores superiores a 500.
* Se agregó otro if para que cuando TODOS los sensores estén en el negro se detengan los motores.
* Se cambió la velocidad máxima de los motores a 200 y a partir de ello se cambiaron todos los valores, esto para mejorar el desempeño en las curvas.







Comentarios

Publicar un comentario

Entradas populares de este blog

Robot laberinto Kastelean

-
Imagen
    KASTELAN-   FASE 3 PROYECTO FINAL ROBOT LABERINTO   UNI VERSIDAD DEL VALLE INTRODUCCIÓN A LA INGENIERÍA ELECTRÓNICA     CHRISTIAN HOMERO ERAZO- 2127953 NICOLAS MOLINA SANCHEZ- 202128387 JULIAN COTACIO CASTRO -202126044 Sensor ultrasónico.   para medir las distancias con arduino lo podemos hacer de diferentes maneras nosotros escogimos el ultrasónico arduino que utiliza las propiedades del sonido para medir distancias.   El funcionamiento de los sensores sería el siguiente: el sensor envía una onda ultrasónica que rebota contra el objeto y el receptor detecta la onda y toma las decisiones que se han programado para seguir avanzando.     Para nuestro Robot para laberinto se van utilizar 4 Sensores ultrasónico HC-SR04   Características del sensor ultrasónico HC-SR04 ●       Alimentación de 5 volts. ●       Interfaz de cuatro hilos (vcc, t...
Leer más

Fase 4 Robot seguidor de linea

-
Imagen
FASE 4   Robot seguidor de linea Introducción En la presente fase, describiremos el driver elegido para el respectivo control de los motores que conforman el robot seguidor de línea, diagramas de conexión correspondientes y la programación para que los motores se muevan hacia adelante, hacia atrás y hacia los lados de acuerdo a la información capturada por los sensores CNY70. Para la presente fase se realizó un cambio en las baterías previamente seleccionadas por 2 baterías Li-po de 3.7V y 500mAh cada una, ya que las baterías alcalinas si bien nos proporcionaban el voltaje y corriente que necesitábamos, tendían a descargarse muy rápidamente. Imagen 1. Baterias Li-po Diagrama de bloques El diagrama de bloq...
Leer más

FASE 2 ROBOT SEGUIDOR DE LINEA

-
Imagen
SCARAB FASE 2 ROBOT SEGUIDOR DE LINEA Introducción Para este segundo informe pondremos en funcionamiento un programa que controla dos leds por medio de dos botones, uno en función de pulsador y el otro como interruptor, todo ello sobre la estructura diseñada del robot. Adicionalmente, se detalla el sistema de alimentación del trabajo final y los argumentos sobre los cuales se seleccionaron los elementos. SIMULACIÓN PROGRAMA CONTROLA LEDS Gráfica 1. Circuito dos leds Para la simulación del programa que controla los leds, tuvimos en cuenta la Gráfica 1 y respectivamente los componentes detallados en la tabla 1. Tabla 1. Consumo programa control de leds Para hallar el valor de las resistencias recurrimos a la ley de Ohm, por la cual, se tiene en cuenta que los pines del Arduino tienen una salida de 5V, al estar en paralelo, a cada bloque de series le llega 5V y la corriente se divide, a cada serie le debe llegar 10mA que circulara igualmente entre los componentes que van ...
Leer más