_______________________________________________________________________
_______________________________________________________________________
• Univ .: Tania Alanoca Larico
• RU.: 200000039
• duquesa 571@gmail.com
• Cuarto semestre paralelo 4to A - Electrónica Básica
• Docente: Ing. Guillermo Martín Uria Ovando
• Universidad Publica de El Alto
En este proyecto se realizó el robot se detalla cada uno de los elementos usados y su funcionamiento para la construcción del robot de línea, el diseño, la programación con la finalidad de buscar el proceso completo en la construcción de un robot, sobre que también lo aprendió en clase y también lo motivó a los estudiantes como personas involucradas en cualquier tema, mejorar diseños, impulsar la creatividad y lograr resultados en el campo competitivo sano.
En la materia de la electrónica los robots seguidores de la línea son robots capaces de seguir una línea marcada en el suelo. Ahora esta línea es de color negro sobre un fondo blanco. Son unos robots muy sencillos pero vistosos y todo amante de la robótica han tenido que experimentar con ellos en sus inicios.
En esta ocasión veremos cómo implementar una plataforma robótica para montar nuestro robot y toda la electrónica necesaria.
Realización de pruebas de detección de fallas en el robot y también en la evaluación de las técnicas de construcción de nuestro robot en la que se utilizan materiales de bajo costo y que no están limitadas o bien que se pueden reemplazar siempre y cuando esta se comba con una requisito en la que se integrara.
Para el desarrollo del proyecto, esta ha sido una metodología experimental evolutiva, que encaja como proyecto final, esta parte es muy amplia porque incluye la construcción mecánica del robot, la sonorización del mismo y su control por un micro controlador que a continuación vemos su desarrollo .
Componen los siguientes elementos:
Construyéndolo:
1. Hacer el chasis ligero. El motivo es que pueden usar motores muy rápidos pero que tienen muy poca fuerza, por lo que no se puede mover de un chasis pesado.
2. Alejar los sensores del eje de tracción del robot. Esto permitirá al robot "ver" con antelación cómo es el circuito, detectar las curvas antes de llegar a ellas, anticiparse a las curvas.
3. Conseguir el centro de gravedad del robot en el eje de motores. De esta forma tenderá la máxima tracción y la velocidad en las curvas, lo que nos permitirá aumentar la velocidad del robot.
4. Soldar y colocar motores. El próximo paso es soldar y cada una de las conexiones del motor a un cable corto de 5 cm, los otros extremos del cable son para la placa teniendo en cuenta la imagen anterior.
Siguiente a esto, con los soportes para motores, ajustar los motores uno en cada lado, seguir los agujeros de referencia en la placa.
Una vez que conocemos los principales criterios, veremos qué forma le damos al chasis, y qué material utilizamos para fabricarlo.
Forma de Chasis
Si has visto antes otros robots seguidores y velocistas, vimos que la mayoría de ellos tienen más o menos la misma forma:
- Material para fabricar el chasis:
Para hacer el amarado y realizado de chasis lo más ligero posible tenemos que elegir el material con el que lo fabricaremos con el material Acrílico. Tiene un material resistente pero ligero, que puede ser fácil de mecanizar. Como suele ocurrir, no existe una única opción, sino una serie de posibilidades, cada una con sus ventajas e inconvenientes.

Placa, PCB Robot
En este caso, el chasis del robot es la misma placa PCB, se ha realizado así para minimizar el peso del robot y hacer que la potencia de los motores se aprovechó de la mejor manera.
Sensores y cables

ARDUINO NANO.

El Arduino Nano es un tablero pequeño, completo y compatible con el tablero basado en el ATmega328 (Arduino Nano 3.x). Tiene más o menos la misma funcionalidad del Arduino Duemilanove, pero en un paquete diferente. Le falta un conector de alimentación de CC, y funciona con un cable USB Mini-B en lugar de uno estándar.
En Caso del Pino Analógico A6 y A7 del tablero nano o minipro, sin embargo, es posible que el arte óptico de Estós hijo en solitario Omite el analítico, lo que es posible en el pasado USAR según lecturas analógicas.
Motorreductor de metal pequeño ( motores con reductora Pololu)

Aquí el dilema, ¿qué tipo de motor utiliza? Pues si tienes un robot que te va a salir un poco pesado, es decir que este por 200 a 400 gramos, que es mucho para un robot, velocista de competencia, como puedes usar los motores 30: 1. Pero en cambio si tienes un robot liviano de unos 100 gramos, como puedes usar uno de la reducción 10: 1.
Los HP tienen consumos de corriente de 120mA libre a 1600 mA en paro obteniendo mayores revoluciones por minuto 10: 1 -> 3000 rpm, 30: 1 -> 1000 rpm.
Los MP tienen consumos de 40mA libre a 700mA en paro obteniendo revoluciones fuera de lo normal 10: 1 -> 2200 rpm, 30: 1 -> 730 rpm
Los LP tienen consumos de 40mA libre a 360mA en paro obteniendo revoluciones bajas pero a menor consumo 10: 1 -> 1300 rpm, 30: 1 -> 440 rpm
En el caso del robot realizado, utilizo motores 10: 1 MP 2200 rpm, elegí estos tienen revoluciones altas y el consumo del motor no es tan alto por lo que no tengo problemas con el agotamiento de baterías.
Driver de motor
TB6612FNG. Este controlador posee 2 canales (para dos motores) es capaz de entregar 1 amperio continuo de corriente y 3 Un pico por canal. soporta hasta los 13 Voltios y va bien con los motores HP.

Llantitas.
Estas son las mejores opciones para la vida, no es lo ideal pero hay otras opciones, esto depende de cada uno, así que para empezar, no hijo lo ideal.
Estas llantitas se acoplan bien a los micro motores de pololo asi que no hay mucho problema hasta aqui.

BRAKETS (Pololu)
Sirven para unir los motores con el chasis del robot, estos soportes son estandarizados para los motores pololu.

Dato:

DRV8833. Este controlador es de 2 canales y entrega una corriente de 1.2 Un continuo y 2 Un pico por cada canal soporta hasta 10.8 Voltios y es el utilizo: 3, este controlador es simple de usar, cuenta con los pines necesarios para el control de cada motor , un pin lo puedes usar para dar para el sentido de giro al motor y otro para el pwm, cumple su propuesta muy bien, lo utilizo para motores MP.
CAPACITORES
Los materiales que compramos como resistencias, baterías, capacitares, estaño para soldar, rpm del motor, leds, etc., tienen valores aproximados. o mejor dicho, nos venden valores con porcentajes de error. En el caso de una resistencia, si pedimos que nos den una resistencia de 1000 ohm, puede que nos den una de valor de 996 ohm o 1007 ohm.
QTR 8RC Básicamente estos sensores se utilizan en pines digitales, también se pueden usar en pines analógicos pero previamente configurados como digitales.
Previamente se tiene que configurar los pines para que el micro controlador se cierre y se coloque en un momento determinado, y luego después de que el botón esté configurado como entrada para una lectura digital.
Disposición de los pines a
utilizar:
GND: tierra "-"
Vcc: Alimentación de 5 voltios "+"
Led on: es un "Switch" que enciende y apaga los leds infrarrojos de cada uno de los sensores, de manera predeterminada esta encendido "High", para apagar se necesita dar un estado digital "Low"
Pines 1-8: Son los respectivos pies de la lectura de cada sensor.
3.3v Bypass: utilizar si se requiere alimentar con 3.3v. Los sensores, por defecto se alimentan con 5 v. Es mejor no usarlo.
Previamente es necesario soldar los espadines para una correcta manipulación de los sensores.
Las conexiones físicas son estas:

A continuación, el código completo para empezar a usar los sensores:
#include <QTRSensors.h>
#define NUM_SENSORS 8
#define TIMEOUT 2500
#define EMITTER_PIN 6
QTRSensorsRC qtrrc ((unsigned char []) {19, 18, 17, 16, 15, 14, 11, 12},
NUM_SENSORS, TIMEOUT, EMITTER_PIN);
unsigned int sensorValues [NUM_SENSORS];
Configuración de vacío ()
{
retraso (500);
pinMode (13, SALIDA);
digitalWrite (13, ALTO);
para (int i = 0; i <200; i ++)
{
qtrrc.calibrate ();
}
digitalWrite (13, BAJO);
Serial.begin (9600);
para (int i = 0; i <NUM_SENSORS; i ++)
{
Serial.print (qtrrc.calibratedMinimumOn [i]);
Serial.print ('');
}
Serial.println ();
para (int i = 0; i <NUM_SENSORS; i ++)
{
Serial.print (qtrrc.calibratedMaximumOn [i]);
Serial.print ('');
}
Serial.println ();
Serial.println ();
retraso (1000);
}
void loop ()
{
{
Serial.print (sensorValues [i]);
Serial.print ('\ t');
}
retraso (50);
}
Valores obtenidos con los sensores.
Hecho la conexión respectiva, cargar el programa al arduino. Luego, en una superficie blanca con una línea negra, se puede usar una cinta aislante negra, recorrer los sensores por la parte negra, y por la parte blanca, de esta manera está calibrando los sensores.
.png?timestamp=1512264094776)
PID.
El PID (control proporcional, integral y derivativo) es un mecanismo de control para la realimentación que calcula la desviación o error entre el valor medido y el valor que se quiere obtener, punto de referencia, punto objetivo o punto de consigna acción correctora que ajuste el proceso.
En el caso del robot velocista, el controlador PID, los datos del sensor, y el uso para controlar la velocidad del motor, para esta formación en el curso.
.png?timestamp=1512340682780)


Error:

Se llama a la diferencia entre la posición objetivo y la posición medida del error.

-Proporcional: Es la respuesta al error que tiene que entregar de manera inmediata, es decir, si nos encontramos en el centro de la línea, los motores, tenemos una respuesta de igual valor, si nos alejamos del centro, uno de los motores reducen su velocidad y el otro aumentarra.
-Integral: la integral es la sumatoria de los errores acumulados, tiene como objetivo el disminuir y eliminar el error en el estado estacionario provocado por el modo proporcional, en otras palabras, si el robot velocista se encuentra en mucho tiempo alejado del centro veces cuando se encuentra en curvas), la acción integral se ira acumulando e ira disminuyendo el error hasta llegar al punto de consigna,
- Derivativo: Es la derivada del error, su función es mantener el error al mínimo, corregirse proporcionalmente con la misma velocidad que produce, de esta manera evita que el error se incremente, en otra palabra, anticipando la acción evitando así las oscilaciones excesivas.
Factor (Kp) - Es un valor constante utilizado para aumentar o reducir el impacto de Proporcional. Si el valor es excesivo, el robot responde a tendera inestablemente, oscilando excesivamente. Si el valor es muy pequeño, el robot responderá muy lentamente, tendiendo una ventaja de las curvas Factor (Ki) - Es un valor constante para aumentar o reducir el impacto de la Integral, El valor excesivo de este provocador oscilaciones excesivas, Un valor demasiado bajo no causara impacto alguno. Factor (Kd) - Es un valor constante utilizado para aumentar o reducir el impacto de la Derivada. Un valor excesivo provocara una sobre amortiguación. Provocando inestabilidad.
Salida_pwm = (proporcional * Kp) + (derivativo * Kd) + (integral * Ki);
Aquí viene el reto, la sintonización pid, es aquí donde se tendrá que buscar las constantes que correspondan a las características físicas del robot, la forma más fácil de hacerlo por ensayo y error, hasta obtener el valor deseado.
Esta es la etapa final de tu seguidor, no queremos que esta sea una etapa compleja y para esto te daremos todo para que tu seguidor funcione y lo puedas adaptar a tus necesidades.
#include <QTRSensors.h>
#define NUM_SENSORS 8
#define TIMEOUT 2000
#define EMITTER_PIN 6
#define led1 13
#define led2 4
#define mot_i 7
#define mot_d 8
#define sensores 6
#define boton_1 2
#define pin_pwm_i 9
#define pin_pwm_d 10
QTRSensorsRC qtrrc((unsigned char[]) {19, 18, 17, 16,15,14,11,12}
,NUM_SENSORS, TIMEOUT, EMITTER_PIN);
unsigned int sensorValues[NUM_SENSORS];
unsigned int position=0;
int derivativo=0, proporcional=0, integral=0;
int salida_pwm=0, proporcional_pasado=0;
int velocidad=120;
float Kp=0.18, Kd=4, Ki=0.001;
int linea=0;
void setup()
{
delay(800);
pinMode(mot_i, OUTPUT);
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(boton_1, INPUT);
for (int i = 0; i <40; i++)
{
digitalWrite(led1, HIGH);
delay(20);
qtrrc.calibrate();
digitalWrite(led1, LOW);
delay(20);
}
digitalWrite(led1, LOW);
delay(400);
digitalWrite(led2,HIGH);
while(true)
{
int x=digitalRead(boton_1);
delay(100);
if(x==0)
{
digitalWrite(led2,LOW);
digitalWrite(led1,HIGH);
delay(100);
break; //saltamos hacia el bucle principal
}
}
}
void loop()
{
//pid(0, 120, 0.18, 0.001, 4 );
pid(linea,velocidad,Kp,Ki,Kd);
//frenos_contorno(0,700);
frenos_contorno(linea,700);
}
void pid(int linea, int velocidad, float Kp, float Ki, float Kd)
{
position = qtrrc.readLine(sensorValues, QTR_EMITTERS_ON, linea);
proporcional = (position) - 3500;
Integral=integral + proporcional_pasado;
derivativo = (proporcional - proporcional_pasado);
if (integral>1000) integral = 1000;
if (integral<-1000) integral=-1000;
salida_pwm =( proporcional * Kp ) + ( derivativo * Kd )+(integral*Ki);
if ( salida_pwm > velocidad ) salida_pwm = velocidad;
if ( salida_pwm < -velocidad ) salida_pwm = -velocidad;
if (salida_pwm < 0)
{
motores(velocidad+salida_pwm, velocidad);
}
if (salida_pwm >0)
{
motores(velocidad, velocidad-salida_pwm);
}
proporcional_pasado = proporcional;
}
void motores(int motor_izq, int motor_der)
{
if ( motor_izq >= 0 )
{
digitalWrite(mot_i,HIGH);
analogWrite(pin_pwm_i,255-motor_izq);
}
else
{
digitalWrite(mot_i,LOW);
motor_izq = motor_izq*(-1);
analogWrite(pin_pwm_i,motor_izq);
}
if ( motor_der >= 0 )
{
digitalWrite(mot_d,HIGH);
analogWrite(pin_pwm_d,255-motor_der);
}
else
{
digitalWrite(mot_d,LOW);
motor_der= motor_der*(-1);
analogWrite(pin_pwm_d,motor_der);
}
}
void frenos_contorno(int tipo,int flanco_comparacion)
{
if(tipo==0)
{
if(position<=50)
{
motores(-80,90);
while(true)
{
qtrrc.read(sensorValues);
if( sensorValues[0]>flanco_comparacion || sensorValues[1]>flanco_comparacion )
{
break;
}
}
}
if (position>=6550)
{
motores(90,-80);
while(true)
{
qtrrc.read(sensorValues);
if(sensorValues[7]>flanco_comparacion || sensorValues[6]>flanco_comparacion )
{
break;
}
}
}
}
if(tipo==1)
{
if(position<=50)
motores(-80,90);
while(true)
{
qtrrc.read(sensorValues);
if(sensorValues[0]<flanco_comparacion || sensorValues[1]<flanco_comparacion )
{
break;
}
}
}
if(position>=6550)
{
motores(90,-80);
while(true)
{
qtrrc.read(sensorValues);
if(sensorValues[7]<flanco_comparacion || sensorValues[6]<flanco_comparacion)
{
break;
}
}
}
}
}
El proyecto robot seguidor de linea fue concluida de manera exitosa, el robot funciona perfectamente las únicas dificultades que tuve fue con la conexión sobre todo sobre el sistema del modulo.


Se diseñó e implementó, un robot seguidor de línea, el funcionamiento del robot fue adecuado a la meta propuesta. Se demostró que a pesar de que se usaron componentes básicos de electrónica son suficientes para realizar un proyecto interesante y vistoso. El robot cumple las expectativas esperadas además este sirve como base para adentrarse en el campo de la electrónica y robótica.
Se logro el objetivo principal el cual fue la realización del proyecto en este caso un robot seguidor de línea, gracias a los conocimientos adquiridos en la asignatura.
Se noto que la ubicación de los sensores encargados de mantener el carro sobre la línea es prácticamente fundamental ya que si no, no se encuentran donde deberían estar el robot no hace lo deseado así la parte electrónica y de programación estén en perfecto estado.
Apuntes Electrónica Básica
Concejos y enseñanzas del nuestro Ing. Guillermo Martín Uria Ovando
http://aerobotclubderobticadeaeronuticos.blogspot.com
store.arduino.cc/usa/arduino-nano
https://www.mathworks.com
Make a free website with Yola