Ensamblado de Robot Evasor de obstáculos

UNIVERSIDAD AUTÓNOMA DE NUEVO LEÓN
FACULTAD DE CIENCIAS FÍSICO-MATEMÁTICAS
ROBOT EVASOR DE OBSTÁCULOS
Maestro: M.C. Aurelio Ramirez Granados
Judith Anakaren Torres Moreno 1625208
Ana Gabriela Parra Antúnez 1583697
David Rodríguez Villarreal 1630983
13 de Noviembre de 2018

❑ Dentro de los últimos años los microcontroladores
han estado al alcance de nuestras manos. Estos
circuitos integrados graban instrucciones las cuales
se introducen mediante un lenguaje de
programación, esto permite al usuario interactuar
con circuitos electrónicos de manera más directa a
diferencia de una computadora.
INTRODUCCIÓN

❑ Desarrollaremos un robot con la capacidad de evadir
todo objeto que se encuentre en su camino. Los
objetos serán detectados por medio de sensores,
éstos envían señales eléctricas cuando se accionan.
❑ La finalidad es que al detectar el objeto frente a él se
dirija hacia el lado opuesto de donde se encuentra el
objeto.
ROBOT EVASOR DE OBSTÁCULOS

❑ 1 kit Chasis Móvil
❑ 1 Tarjeta Arduino
❑ 1 Protoboard Chico
❑ 1 CI Puente H L293D /SN754410NE
❑ Cables
❑ Alambre
❑ 4 tornillos con tuerca 2.56 7/16”
❑ 2 tortillos con tuercas 1/8” x 1
❑ 1 Portapilas de 4 pilas AA
❑ 4 baterías AA
❑ Sensor ultrasónico
❑ 2 motores de corriente continua
MATERIALES

❑ Sensor ultrasónico
Envía una señal ultrasónica inaudible y envía el
tiempo que demoro ésta en la ida y el regreso hasta
el obstáculo más cercano detectado. Se conforma
de dos cilindros, uno de ellos es quien emite la señal
ultrasónica, mientras que el otro la recibe.
CARACTERÍSTICAS Y FUNCIONES
Ilustración 1. Ultrasonico

❑ Puente H L293D
Es un circuito electrónico que permite controlar un
motor eléctrico de Corriente continua con un micro
controlador.
Un motor de corriente continua determina su
dirección de giro en función de la tensión entre sus
terminales

❑ Servomotor SG90
Es tipo de motor especial que permite controlar la posición
del eje en un determinado momento. Está diseñado para
moverse una cierta cantidad de grados y enseguida
mantenerse fijo en esa posición. De manera interna,
frecuentemente, es un mecanismo reductor. Por tanto nos
proporcionan un alto par y un alto grado de precisión.
Ilustración 2. Servomotor

ENSAMBLADO
❑ Primeramente se tienen que realizar las
instalaciones básicas y físicas. Armar el chasis,
colocándole los motores con las ruedas, el switch
interruptor de alimentación de voltaje, el
portapilas y la rueda loca bajo el chasis.
❑ Aquí mismo fijamos el protoboard, ya con el
Circuito Integrado, el Puente H L293D, para
comenzar con la interconexión de los dispositivos
electrónicos con el Arduino.

❑ Chasis Móvil 2WD
Ilustración 3. Armado de Chasis
ENSAMBLADO

❑ Chasis Móvil 2WD Materiales:
○ 1 Chasis de acrilico.
○ 4 Soportes de Motorreductor.
○ 2 Motorreductores B01 1:48.
○ 2 Llantas y 2 ruedas ranuradas
○ 1 Inteructor
○ 4 tornillos 1 ¼ M3 con sus cuatro tuercas M3
○ 1 Porta pilas con 2 tornillo ¾ y 2 tuercas M3
○ 1 Rueda loca con 4 Separadores y 8 tornillos ¼
M3
ENSAMBLADO

❑ Chasis Móvil 2WD Primer Paso: Soldar motores con
sus cables correspondientes y soldar interruptor con
cable de corriente del portapilas y un cable rojo
proporcionado en el kit
Ilustración 4. Motores Soldados
ENSAMBLADO

Segundo Paso: Colocar
los soportes en el chasis.
ingresar los 1 soporte en
cada orificio adecuado al
soporte(Guíate con las
fotos)
Ilustración 5. Soportes de motor
ENSAMBLADO

❑ Chasis Móvil 2WD Tercer
Paso: Colocar los motores
ya soldados a los cables al
chasis usando los
soportes, los tornillos 1 ¼
M3 y las tuercas M3.
Ensambla de igual forma
que la ilustración
siguiente.
Ilustración 6. Ensamblado de motores
ENSAMBLADO

❑ Chasis Móvil 2WD Cuarto
Paso: Colocar la rueda loca
con los 4 separados, 8
tornillos ¼ M3. Ensambla
primero los separadores
con cuatro tornillos sobre
el chasis y despues pon
sobre los separadores la
reda loca y ajstalos con los
4 tornillos sobrantes. Ilustración 7. Ensamblado de Rueda loca
ENSAMBLADO

❑ Chasis Móvil 2WD Quinto
Paso: Colocar el portapilas
con los 2 tornillos ¾ M3
sobrantes y las dos tuercas
M3. Pon el portapilas
sobre el lado contrario de
los motores, justo en
donde se se muestra en la
siguiente imagen en
donde ya están
empotrado con los
tornillos .
Ilustración 8. Incrustrar el portapilas
ENSAMBLADO

Quinto Paso: El
portapilas quedaría
de la siguiente
forma.
Ilustración 9. Ensamblado de portapilas
ENSAMBLADO

❑ Chasis Móvil 2WD Sexto
Paso: Colocar el proto con
puerto H. Usaremos la
parte adhesiva del proto
para pegarlo al chasis de la
siguiente forma .
Ilustración 10. Ensamblado de Proto
ENSAMBLADO

❑ Chasis Móvil 2WD Séptimo
Paso: Colocar el interruptor en
el chasis. Primero hay que
colocar el interruptor como se
señala la siguiente imagen.
Después conectamos en el pin
del medio del interruptor el
cable de corriente del
portapilas y en el pin sobrante
un cable lo suficiente grande
para que alcance le proto.
Ilustración 11. Ensamblado del switch
ENSAMBLADO
Soldar

❑ Chasis Móvil 2WD Octavo
Paso: Colocar las llantas a los
motores. Inserta la llanta en
el eje sobresaliente del motor
de la siguiente manera.
Ilustración 11. Ensamblado de llantas
ENSAMBLADO

❑ Realizamos las conexiones de Alimentación de
Puente H, es decir alimentamos los pines de
voltaje y aterrizamos los pines de GND (Tierra).
❑ Conectamos los motores, M1 en los pines 8 y 10,
mientras que M2 en 11 y 13.
❑ Colocamos de una vez las baterías, con el objetivo
de colocar encima el Arduino.
ENSAMBLADO

❑ Ensamblar arduino en el
chasis: Con dos tornillos
largos facilitados en el kit y
dos turcas ajustaremos
una tabla facilitada en el
kit. En esta tabla pegamos
con silicón el arduino.
Cuidar de no lastimar el
arduino.
Ilustración 12. Ensamblado de llantas
ENSAMBLADO

❑ En el kit que nos prestaron el arduino que viene no es
un arduino original es un genérico entonces tiene un
chip diferente que no tiene los drive en las carpetas
de IDE de arduino entonces viendo el nombre del chip
generico del arduino podremos instalar el driver
correspondiente para que podamos instalar nuestro
programa sin ningún problema.
INSTALACIÓN DE ARDUINO
Ilustración 13. Instalación de arduino
CH340

❑ Para seguir los siguientes pasos de instalación descargar
el driver para mi caso yo use uno para windows 7 y el link
para descargarolo es el siguiente :
https://www.arduined.eu/files/CH341SER.zip
Instalación del driver CH340 en Windows
CH340

❑ Descomprimir el archivo ZIP en una carpeta,
encontraremos 2 carpetas. Abrir la carpeta CH341SER que
es la que contiene el instalador del driver CH340
CH340

❑ Ejecutar el programa de instalación o “setup.exe”. El
sistema operativo puede preguntarnos si confiamos en
el proveedor del software, en este caso debemos
aceptar.
Ilustración 16. Instalación de
arduino CH340

❑ Después de copiar los drivers, el programa de instalación nos
notificará que se ha completado la instalación.
arduino CH340

❑ Conectamos el arduino a la PC y esperamos a que Windows
detecte e instale los drivers para el dispositivo conectado.
❑ Abrimos el administrador de dispositivos (click derecho en
equipo > Propiedades > Administrador de Dispositivos)
para comprobar que el driver haya sido correctamente
instalado, también podemos ver el número de puerto serie
que ha sido asignado (en este caso COM14).
arduino CH340

❑ Sensor Ultrasonico
Ilustración 19. Conexiones del sensor
ultrasónico a Arduino
ENSAMBLADO

❑ Control del Sensor ultrasónico: Declaración de
funciones.
class Sensor_ultrasonico_HCSR04
{
private:
int Echo;
int Trig;
long lduration;
long ldistance;
public: Sensor_ultrasonico_HCSR04(int echo,int trig):
Echo(echo),Trig(trig){lduration=0;ldistance=0;};
//Contructor
void Inicializar_ultrasonico();
float Obtener_Distancia();
};
PROGRAMA

❑ Control del Sensor ultrasónico: Creación de funciones
funciones.
#include <Arduino.h> //Permite utilizar los comandos de Arduino
#include "Sensor_ultrasonico_HCSR04.h"
void Sensor_ultrasonico_HCSR04::Inicializar_ultrasonico()
{
pinMode(Trig, OUTPUT); //Declaración de los pines del ultrasonico
pinMode(Echo, INPUT);
}
float Sensor_ultrasonico_HCSR04::Obtener_Distancia()
{
/* Mide la distancia a la que se encuentra el obstaculo */
digitalWrite(Trig, LOW); //para generar un pulso limpio ponemos a LOW 4us
delayMicroseconds(2);
digitalWrite(Trig, HIGH); //generamos Trigger (disparo) de 10us
delayMicroseconds(10);
digitalWrite(Trig, LOW);
lduration = pulseIn(Echo, HIGH); //medimos el tiempo entre pulsos, en microsegundos
ldistance = (lduration/2) / 29.1; //convertimos a distancia, en cm
return ldistance;
}
PROGRAMA

❑ Puente H L293D
Ilustración 20. Diagrama lógico de
conexiones
CONEXIONES LÓGICAS

❑ Control de Motor reductor: Declaración de
funciones.
class Motor_DC
{
private:
int A;
int B;
int Pwm;
public:
Motor_DC(int a,int b,int pwm): A(a), B(b),Pwm(pwm){}//Constructor
void Inicializar_Motor();
void Adelante(int Velocidad);
void Atras(int Velocidad);
void Stop();
};
PROGRAMA

❑ Control de Motor reductor: Creación de funciones
funciones.
#include "Motor_DC.h"
void Motor_DC::Inicializar_Motor()
{
pinMode(A, OUTPUT); // Declaracion de los pine A
pinMode(B, OUTPUT); // Declaracion de los pine B
pinMode(Pwm, OUTPUT); // Declaracion de los pine Pwn
}
void Motor_DC::Atras(int Velocidad)
{
analogWrite(Pwm,Velocidad );
digitalWrite(A, HIGH);
digitalWrite(B, LOW);
}
PROGRAMA
void Motor_DC::Adelante(int
Velocidad)
{
analogWrite(Pwm,Velocidad );
digitalWrite(A, LOW);
digitalWrite(B, HIGH);
}
void Motor_DC::Stop()
{
analogWrite(0, Pwm);
digitalWrite(A, LOW);
digitalWrite(B, LOW);
}

❑ Control de los dos motores. Declaración de funciones
#include "Motor_DC.h"
class Base_Robot
{
private:
public:
Motor_DC Motor_1;
Motor_DC Motor_2;
Base_Robot(int Pin_Motor_1A,int Pin_Motor_1B,int PWM_1, int Pin_Motor_1C, int
Pin_Motor_1D,int PWM_2): Motor_1(Pin_Motor_1A,Pin_Motor_1B,PWM_1),
Motor_2(Pin_Motor_1C,Pin_Motor_1D,PWM_2){}
void Inicializar_Robot();
void Adelante(int Velocidad_1,int Velocidad_2);
void Atras(int Velocidad_1,int Velocidad_2);
void Stop();
};
Programa

❑ Control de los dos motores. Creación de funciones
#include "Base_Robot.h"
void Base_Robot::Inicializar_Robot()
{
Motor_1.Inicializar_Motor(); // inicializamos los dos motores
Motor_2.Inicializar_Motor();
}
void Base_Robot::Atras(int Velocidad_1,int Velocidad_2)
{
Motor_1.Atras(Velocidad_1);// Función para que los dos motores avance hacia atras
Motor_2.Atras(Velocidad_2);
}
void Base_Robot::Adelante(int Velocidad_1,int Velocidad_2)
{
Motor_1.Adelante(Velocidad_1);// Función para que los dos motores avance hacia
adelante
Motor_2.Adelante(Velocidad_2);
}
void Base_Robot::Stop()
{
Motor_1.Stop();// Función para que los dos motores paren
Motor_2.Stop(); }
Programa

❑ Servomotor
Ilustración 21. Conexiones del servomotor
al Arduino
CONEXIONES LÓGICAS

❑ Evasor: Declaración de funciones y variables.
#include "Sensor_ultrasonico_HCSR04.h"
#include "Base_Robot.h"
#include <Servo.h>
class Evasor
{
private:
Base_Robot Robot;
Sensor_ultrasonico_HCSR04 S1;
Servo Servo_1;
int Pin_Servo;
public:
//Constructor
Evasor(
int Pin_Motor_1A,
int Pin_Motor_1B,
int PWM_1,
int Pin_Motor_1C,
int Pin_Motor_1D,
int PWM_2,
int echo_1,
int trig_1,
int pin_servo):
Programa

❑ Evasor: Declaración de funciones y variables.
Robot(Pin_Motor_1A, Pin_Motor_1B, PWM_1, Pin_Motor_1C, Pin_Motor_1D,
PWM_2),
S1(echo_1,trig_1){Pin_Servo=pin_servo;}
void Inicializar();
void Modo_Evasor(int Velocidad,int Distancia);
void Izquierda(int Velocidad_1,int Velocidad_2);
void Derecha(int Velocidad_1,int Velocidad_2);
void Adelante(int Velocidad_1,int Velocidad_2);
void Stop();
Programa

❑ Evasor: Creación de funciones.
#include "Evasor.h"
void Evasor::Inicializar()
{
Robot.Inicializar_Robot();
S1.Inicializar_ultrasonico();
Servo_1.attach(Pin_Servo); // attaches the servo on pin 9 to the servo object}
}
void Evasor::Izquierda(int Velocidad_1,int Velocidad_2)
{
Robot.Motor_1.Adelante(Velocidad_1);
Robot.Motor_2.Atras(Velocidad_2);
}
void Evasor::Derecha(int Velocidad_1,int Velocidad_2)
{
Robot.Motor_2.Adelante(Velocidad_1);
Robot.Motor_1.Atras(Velocidad_2);
}
void Evasor::Adelante(int Velocidad_1,int Velocidad_2)
{
Robot.Atras(Velocidad_1,Velocidad_2);
}
void Evasor::Stop()
{
Robot.Stop(); }
Programa

❑ Evasor: Creación de funciones (Algoritmo Evasor).
void Evasor::Modo_Evasor(int Velocidad,int Distancia)
{
float Distancia_1;
float Distancia_2;
float Distancia_3;
float Distancia_4;
Servo_1.write(90);
Distancia_1=S1.Obtener_Distancia();
if(Distancia_1 < Distancia)
{
Stop();
Servo_1.write(20);
delay(500);
Servo_1.write(90);
delay(500);
Servo_1.write(150);
delay(500);
Servo_1.write(90);
Programa

❑ Evasor: Creación de funciones (Algoritmo Evasor).
if(Distancia_2>Distancia_4)
{
Izquierda(Velocidad,Velocidad);
delay(400);
Stop();
}
if(Distancia_2<Distancia_4)
{
Derecha(Velocidad,Velocidad);
delay(400);
Stop();
}
}
Adelante(Velocidad,Velocidad);
}
Programa

❑ Programa Arduino usando la funciones del
Evasor.h.
#include "Evasor.h"
Evasor Robot_Evasor(13,12,11,10,9,8,7,6,5);
void setup()
{
Robot_Evasor.Inicializar();
}
void loop()
{
Robot_Evasor.Modo_Evasor(255,9);
}
Programa

❑ Servomotor
Ilustración 22. Armado del kit de
servomotor
ENSAMBLADO

❑ Servomotor Primer paso: las dos piezas
parecidas unirlas usando el servo en el medio de
las dos piezas iguales
servomotor
ENSAMBLADO

❑ Servomotor Segundo paso: Cortar las aspas del servo
para que pueda entrar en la base del servo.
servomotor
ENSAMBLADO

❑ Servomotor Tercer paso: Atornillar el servo en la base
.
servomotor
ENSAMBLADO

❑ Servomotor
servomotor
ENSAMBLADO

❑ Robot
PRODUCTO FINAL
Ilustración 27. Robot evasor de obstáculos.

VIDEO
Ensamblado Robot Evasor de obstaculos
ttps://www.youtube.com/watch?v=lUYlgGynaSs&feature=youtu.be&fbclid=IwAR3UPLXOT
dx2QocG0Y1b5uG3VQr9qQJNzQAmElMtk19JMbgKsg4_9MLfkJM
Robot Evasor de Obstaculos
https://www.youtube.com/watch?v=PDRzEOwAbKw&fbclid=IwAR3xhwYpKhBmFWS51U5
QsznGrB6yf7-Xuj-O5dWk_DN4jhD3rF1W38jPcqQ

Ensamblado de Robot Evasor de obstáculos

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Ensamblado de Robot Evasor de obstáculos

Similar a Ensamblado de Robot Evasor de obstáculos (20)

Último

Último (20)

Ensamblado de Robot Evasor de obstáculos