CENTRO DE CIENCIAS DE LA INGENIERIA

DEPARTAMENTO DE INGENIERIA AUTOMOTRIZ

INGENIERIA ROBOTICA 4B
MECANICA
INFORME FINAL
Maestro: Omar Martnez Parga
INTEGRANTES
2017
DAVID PACHECO BERRONES
SETH VILLALOBOS ROMO
RICARDO HUMBERTO GALLEGOS CHAVEZ
ROBOTICA 4B
 PROTOTIPO ROBOT DELTA

PROTOTIPO ROBOT DELTA

AGRADECIMIENTOS

A la primera persona, que le queremos agradecer es a nuestros Maestros, de

Sistemas Embebidos Jorge Alberto Salinas Martnez, de Mecnica Omar Martnez
Parga y al maestro de CAD Abel Daz Olivares, que sin su ayuda y conocimientos no
hubiese sido posible realizar este proyecto.

A nuestros Padres, por habernos proporcionado la mejor educacin y lecciones de

vida.

En especial a nuestros Papas, por habernos enseado que con esfuerzo, trabajo y
constancia todo se consigue, y que en esta vida nadie regala nada.

En especial a nuestras madres, por cada da hacernos ver la vida de una forma
diferente y confiar en nuestra toma de decisiones.

A nuestros compaeros de clase, con lo que hemos compartido grandes

momentos.

A nuestros amigos, por estar siempre a nuestros lados y motivarnos.

A todos nuestros familiares, por todo su apoyo.

En especial al M.C Rolando Lpez Martnez por formarme como tcnico en

Mecatrnica, enseando sus conocimientos en el rea de la Mecatrnica y
disciplina en la forma de entregar algn proyecto y en la forma de trabajar.

RESUMEN
La Robtica se compone de la combinacin de varias disciplinas, las ms
importantes y bsicas son la Mecnica, Elctrica, Control y Programacin, ya que
en conjunto se llega a un prototipo de algn tipo de robot ya sea, mvil, areo,
acutico, hibrido o paralelo, sean ya para uso industrial, domestico, etc.

El propsito en general es aplicar los conocimientos adquiridos a lo largo del

semestre Enero-Junio, de la Carrera de Ingeniera en Robtica de 4 Semestre de la
Universidad Autnoma de Aguascalientes, en la cual aplicaremos en conjunto los
conocimientos adquiridos en las materias de Mecnica, CAD y Sistemas embebidos
para llegar a disear, construir y programar un prototipo de Robot paralelo tipo
Delta, el cual en cada procedimiento aplicamos conocimiento adquirido en clases,
para llegar as a un prototipo funcional.

Empezando desde el inicio con el diseo del Robot, en el cual usaremos el software
SolidWorks de modelacin de piezas en 3D, para as disear pieza por pieza del
robot siguiendo el uso de mecanismos mecnicos para realizar movimientos en el
robot y as actu en el espacio de trabajo que caracteriza al robot delta. Tambin

2
 PROTOTIPO ROBOT DELTA

para ensamblar y analizar sus movimientos en su espacio de trabajo, as tambin

una simulacin de fuerzas estticas que actan sobre las plataformas del robot.

Siguiendo con construir el robot en fsico, ya teniendo todas las piezas despus de
mandarlas a manufactura. Ensamblando cada una de ellas, para llegar as al
ensamblaje diseado en el software SolidWorks verificando que cumpla con dichos
movimientos ya calculados en el software.

Al final la programacin del robot delta, usando la tarjeta Arduino Mega (AVR2560),
programando en el IDE Atmel Studio, en lenguaje de programacin C.

INTRODUCCIN
El conocimiento en diseo, programacin de Robots de distintos tipos, es
indispensable para los alumnos de Ingeniera Robtica, donde tienen que aplicar
los conocimientos en el rea de la robotica, donde estos tienen un gran margen de
aplicaciones, realizando trabajos de uso rudo, o que sean peligrosos para el ser
humano, o para trabajos donde se requiere una gran precisin, un robot donde
entra en esta rea de aplicacin es el Robot paralelo tipo Delta, el cual se
caracteriza, por ser veloz y tener una gran precisin, usado para levantar cargas
pequeas, en el rea Industrial, etc.

El Robot paralelo tipo Delta (Figura 1), consta principalmente en sus partes
mecnicas de una plataforma o base esttica, la cual llevara los 3 servomotores
que efectuaran el movimiento giratorio en sus 3 articulaciones, tiene 3 grados de
libertad, donde en cada barra lleva un conjunto de acoplamientos como
chumaceras, y para disminuir la friccin se usan valeros.

Las barras llegan hasta la base o plataforma mvil, la cual llevara colocado un
actuador que en este caso ser un electroimn, que dar como resultado el
levantamiento de piezas de metal o algn objeto metlico de no ms de 2kg, la
cual las transportara por su espacio de trabajo.

3
 PROTOTIPO ROBOT DELTA

Figura 1.- Robot Paralelo tipo Delta

Implementando el prototipo en una base transportadora la cual simulara un

sistema de automatizacin, donde tendr un gabinete de control y como todo
sistema de control llevara su botn de paro y arranque, ya que son necesarios para
arrancar el sistema y el paro, para detener la ejecucin ya que si ocurre algn fallo
rpido detener el sistema para arreglar y aplicar el mantenimiento correcto para su
funcionamiento correcto.

Se indicara paso a paso, como se fue realizando cada procedimiento para concluir
con un prototipo de robot delta.

FUNDAMENTOS
En el sector industrial en ocasiones se ocupa el manejo de piezas pequeas o
cargas pequeas, que necesitan una excelente precisin al momento de
empaquetarlas o separar las daadas de las de buen estado, por lo que este tipo
de robot por sus caractersticas es el ms adecuado en este tipo de trabajos
debido a su velocidad y precisin, y con esto mejorando la produccin en tiempo
por lo que es ms ganancia.

Debido a lo anterior, es de gran importancia para los alumnos de la carrera de

Ingeniera Robtica, conocer y poner en prctica los conocimientos de la carrera

4
 PROTOTIPO ROBOT DELTA

para producir proyectos como ste, los cuales complementan su formacin

acadmica.

PROCEDIMIENTOS

1. CAD (DISEO ASISTIDO POR COMPUTADORA) DISEO DE PROTOTIPO

ROBOT DELTA
Utilizando el Software SolidWorks disear las siguientes piezas.

Figura 2.- Base Esttica

Figura 3.- Base Mvil

5
 PROTOTIPO ROBOT DELTA

Figura 4.- Brazo

Figura 5.- Chumacera

Figura 6.- Acoplamiento Hembra

6
 PROTOTIPO ROBOT DELTA

Figura 7.- Acoplamiento Macho

Figura 8.- Acoplamiento

Figura 9.- Eje Superior

7
 PROTOTIPO ROBOT DELTA

Figura 10.- Base balero inferior

Ensamblar todas las piezas en la plantilla Ensamble en SolidWorks

Figura 11.- Ensamble Prototipo Robot Delta

2. CONSTRUIR PROTOTIPO
En este paso se mandaron los archivos de solidworks de cada pieza
para obtener pieza por pieza en material de aluminio para despus
pulirlo y as armarlo fsicamente.

8
 PROTOTIPO ROBOT DELTA

Figura 12.- Base Mvil y Chumaceras.

Figura 13.- Base esttica.

Figura 14.- Ensamble de Acoplamientos

Ensamblando pieza por pieza, llegamos al prototipo similar al diseado

en el software en el paso anterior.

9
 PROTOTIPO ROBOT DELTA

Figura 15.- Prototipo ensamblado de Robot Delta.

Construccin de Gabinete de Control.

Figura 16.- Gabinete

3. PROGRAMACION
Utilizando la Tarjeta Arduino Mega (AVR 2560) se programa en el IDE
Atmel Studio, utilizando lenguaje de programacin C.
Utilizando el siguiente cdigo para la programacin.
#include <avr/io.h> ADCSRA = (1<<ADEN)|(1<<ADPS2)|
#define F_CPU 16000000UL (1<<ADPS1)|(1<<ADPS0);
#include <util/delay.h> }
#include <stdlib.h>
#include "lcd.h" // LEER VALOR ADC
#include "sonar.h" uint16_t adc_read(uint8_t ch)
{
//****************VARIABLES ch &= 0b00000111;
GLOBALES**************// ADMUX = (ADMUX & 0xF8)|ch;
unsigned char banarranque=0; ADCSRA |= (1<<ADSC);
unsigned char banparo=0; while(ADCSRA & (1<<ADSC));
uint16_t adc_result0, return (ADC);
adc_result1,adc_result2; }
char cad[10];
//****************FUNCIONES*********** int servo_1(int SH)
***********// {
//INICIALIZAR ADC PORTL|=_BV(PL0);
void adc_init() for(int i=0;i<=SH;i++)
{ {
ADMUX = (1<<REFS0);
// 16000000/128 = 125000 _delay_us(1);

10
 PROTOTIPO ROBOT DELTA

} lcd_puts("MODO MANUAL
PORTL&=~(_BV(PL0)); ACTIVADO");
for(int k=0;k<=(10000-SH);k++) lcd_gotoxy(0,1);
{ lcd_puts("CONTROLA ROBOT DELTA");
_delay_us(1); lcd_gotoxy(5,2);
} lcd_puts("UTILIZANDO");
return 0; lcd_gotoxy(3,3);
} lcd_puts("LOS 3 JOYSTICKS");
PORTC=0b00000011;
int servo_2(int SH) _delay_ms(500);
{ lcd_clrscr();
PORTL|=_BV(PL1); while(banparo==0)
for(int i=0;i<=SH;i++) {
{ lcd_clrscr();
_delay_ms(100);
_delay_us(1); adc_result0=0;
} adc_result1=0;
PORTL&=~(_BV(PL1)); adc_result2=0;
for(int k=0;k<=(10000-SH);k++) adc_result0 = adc_read(0); //
{ read adc value at PA0
_delay_us(1); adc_result1 = adc_read(1); //
} read adc value at PA1
return 0; adc_result2 = adc_read(2);
} lcd_gotoxy(0,0);
lcd_puts("MODO MANUAL
int servo_3(int SH) ACTIVADO");
{ itoa(adc_result0,cad,10);
PORTL|=_BV(PL2); lcd_gotoxy(0,1);
for(int i=0;i<=SH;i++) lcd_puts("X:");
{ lcd_gotoxy(2,1);
lcd_puts(cad);
itoa(adc_result1,cad,10);
_delay_us(1); lcd_gotoxy(7,1);
} lcd_puts("Y:");
PORTL&=~(_BV(PL2)); lcd_gotoxy(9,1);
for(int k=0;k<=(10000-SH);k++) lcd_puts(cad);
{ itoa(adc_result2,cad,10);
_delay_us(1); lcd_gotoxy(14,1);
} lcd_puts("Z:");
return 0; lcd_gotoxy(16,1);
} lcd_puts(cad);
if(adc_result2>500)
void Arranque() {
{ adc_result0=adc_result2+577;
if(PINA==0x01) adc_result1=adc_result2+577;
{ adc_result2=adc_result2+577;
banarranque=1; lcd_gotoxy(0,2);
banparo=0; lcd_puts("EJE Z NEGATIVO");
} itoa(adc_result0,cad,10);
} lcd_gotoxy(0,3);
void Paro() lcd_puts("X:");
{ lcd_gotoxy(2,3);
if(PINA==0x02) lcd_puts(cad);
{ itoa(adc_result1,cad,10);
banarranque=0; lcd_gotoxy(7,3);
banparo=1; lcd_puts("Y:");
adc_result0=adc_result0+500; lcd_gotoxy(9,3);
adc_result1=adc_result1+500; lcd_puts(cad);
adc_result2=adc_result2+500; itoa(adc_result2,cad,10);
servo_1(adc_result0); lcd_gotoxy(14,3);
servo_2(adc_result1); lcd_puts("Z:");
servo_3(adc_result2); lcd_gotoxy(16,3);
} lcd_puts(cad);
} servo_1(adc_result0);
servo_2(adc_result1);
void Manual() servo_3(adc_result2);
{ }
lcd_gotoxy(0,0); if(adc_result2<500)
{

11
 PROTOTIPO ROBOT DELTA

adc_result0=adc_result2+300; DDRL=0xFF; //PUERTO L SALIDA

adc_result1=adc_result2+300; (SERVOMOTORES)
adc_result2=adc_result2+300; //int distance_in_cm=0;
lcd_gotoxy(4,2); adc_init();
lcd_puts("EJE Z POSITIVO"); lcd_init(LCD_DISP_ON_CURSOR);
itoa(adc_result0,cad,10); lcd_gotoxy(5,0);
lcd_gotoxy(0,3); lcd_puts("ROBOT DELTA");
lcd_puts("X:"); lcd_gotoxy(1,1);
lcd_gotoxy(2,3); lcd_puts("INGENIERIA ROBOTICA");
lcd_puts(cad); lcd_gotoxy(0,2);
itoa(adc_result1,cad,10); lcd_puts("1.- BOTON ARRANQUE");
lcd_gotoxy(7,3); lcd_gotoxy(0,3);
lcd_puts("Y:"); lcd_puts("2.- BOTON PARO");
lcd_gotoxy(9,3); while (1)
lcd_puts(cad); {
itoa(adc_result2,cad,10); PORTC=0x01;
lcd_gotoxy(14,3); Arranque();
lcd_puts("Z:"); while(banarranque==1)
lcd_gotoxy(16,3); {
lcd_puts(cad); lcd_clrscr();
servo_1(adc_result0); lcd_gotoxy(5,0);
servo_2(adc_result1); lcd_puts("ESCOGE MODO");
servo_3(adc_result2); lcd_gotoxy(5,1);
lcd_puts("DE OPERACION");
} lcd_gotoxy(0,2);
/*adc_result0 = adc_read(0)+700; lcd_puts("1.- BOTON MANUAL");
// read adc value at PA0 lcd_gotoxy(0,3);
adc_result1 = lcd_puts("2.- BOTON
adc_read(1)+700; // read adc value AUTOMATICO");
at PA1 _delay_ms(500);
adc_result2 = adc_read(2)+500; Paro();
servo_1(300); if(PINA==0x04)
servo_2(1000); {
servo_3(1600);*/ lcd_clrscr();
if(PINA==0x10) Manual();
{ }
PORTC=0b00000111; }
} Paro();
else if(banparo==1)
{ {
PORTC=0b00000011; lcd_clrscr();
} lcd_gotoxy(1,0);
Paro(); lcd_puts("PARO DE
} EMERGENCIA");
} lcd_gotoxy(7,1);
lcd_puts("ACTIVADO");
lcd_gotoxy(2,2);
lcd_puts("PRESIONA ARRANQUE");
//***************PROGRAMA lcd_gotoxy(4,3);
PRINCIPAL*************// lcd_puts("PARA CONTINUAR");
int main(void) _delay_ms(2000);
{ }
//char cad[10]; /*distance_in_cm=read_sonar();
DDRA=0x00; //Puerto A como if (distance_in_cm == TRIG_ERROR)
entrada {
/* lcd_gotoxy(0,0);
PA0=BOTON ARRANQUE lcd_puts("ERROR!!!");
PA1=BOTON PARO _delay_ms(DELAY_BETWEEN_TEST
PA2=BOTON MODO MANUAL S/2);
PA3=BOTON MODO AUTOMATICO lcd_clrscr();
PA4=BOTON ELECTROIMAN _delay_ms(DELAY_BETWEEN_TEST
*/ S/2);
DDRC=0xFF; //Puerto C como Salida
/*
PC0=VENTILADOR }
PC1=MOTOR BANDA else if (distance_in_cm ==
PC2=ELECTROIMAN ECHO_ERROR)
*/ {
lcd_gotoxy(0,0);

12
 PROTOTIPO ROBOT DELTA

lcd_puts("CLEAR!!!");
_delay_ms(DELAY_BETWEEN_TEST
S);
lcd_clrscr();
}
else
{
lcd_gotoxy(0,2);
lcd_puts("Distance(cm):");
itoa(distance_in_cm, cad, 10);
lcd_gotoxy(14,2);
lcd_puts(cad);
_delay_ms(DELAY_BETWEEN_TEST
S);
lcd_clrscr();
}*/
}
}

Simulando el programa en el software Proteus para verificar el

funcionamiento correcto del programa.

13
 PROTOTIPO ROBOT DELTA

Figura 17.- Simulacin en Proteus.

ANALISIS DE RESULTADOS
Los resultados obtenidos al principio nos encontramos con un error, la cual fue en
los servomotores donde implementamos servomotores de 13kg/cm, los cuales no
levantaron correctamente el robot, por lo que tuvimos que implementar
servomotores de 40kg/cm, para as verificar el funcionamiento correcto, adems
que se implementaron pequeas piezas para sostener dichos servos, ya que sus
medidas eran ms grandes que los anteriores.
Adems de modificar la programacin ya que al implementarlo en la banda
transportadora, en un espacio de su espacio de trabajo chocara con el soporte
donde estaba sostenido, haciendo as una condicin para que el robot no pueda
moverse en esas coordenadas y as prevenir los choques que afectaran las piezas
del robot, ya que son de aluminio y un golpe las dejara marcadas.

CONCLUSIN

14
 PROTOTIPO ROBOT DELTA

En los ltimos aos, los robots han jugado un papel importante en la industria,
milicia, en hospitales, en investigaciones, y ya en estos tiempos para uso
domstico, donde robots autnomos eran de ciencia ficcin hoy da se estn
haciendo realidad, cada vez se estn haciendo ms avanzado y ms autnomos
que antes, aplicando el uso de inteligencia artificial para ser ms precisos en las
aplicaciones que son aplicados, mejorando la produccin.
Aplicando los conocimientos de las materias de Mecnica, CAD y sistemas
embebidos se logr el propsito de cada materia, donde cada uno jugo un papel
importante en la construccin del robot delta, teniendo que ver cada conocimiento
adquirido en la finalizacin del robot, como en CAD, que nos ayud en el diseo y
tener una vista grafica de cmo va quedar construido el robot, as como la
implementacin de mecanismos mecnicos que fueron los conocimientos que
obtuvimos en el rea de mecnica para obtener y realizar los movimientos del
robot, as como saber que material aplicar en el diseo, adems de otras factores
importantes. Ya todo esto en conjunto se termina con la programacin usando un
sistema embebido que es la tarjeta de arduino Mega, en la cual aprendimos como
utilizar los puertos, manejar PWM para controlar el giro del servomotor,
interrupciones, todo esto en lenguaje de programacin C.
El prototipo del robot delta, es una manera de conocer cmo trabajan distintos
tipos de robot, ya que hay desde mviles, areos, acuticos, y este robot es ms
de una manera industrial donde es ms usado para transportar cargas pequeas,
aunque tambin tiene muchas ms aplicaciones dependiendo el uso al que se
quiere aplicar, ya que esto mejora la enseanza de la carrera, donde se
implementan los conocimientos aplicados al rea de la robtica.
ANEXOS

15
 PROTOTIPO ROBOT DELTA

Figura 18.- Servomotor 40kg/cm

Figura 19.- Tarjeta de Relevadores

Figura 20.- Tarjeta Arduino Mega (AVR Atmega 2560)

CONSULTAS REALIZADAS

[1] Pablo G. Bejerano (2016, Mayo 10) blogthinkbig [En linea].

Disponible en: http://blogthinkbig.com/por-primera-vez-un-robot-opera-mejor-que-un-equipo-de-
cirujanos/ .
[2]Gabriela Gonzales (2016, Abril 26) blogthinbig [En linesa].
Disponible en: http://blogthinkbig.com/por-que-es-arduino-ultil-y-que-se-puede-crear-con-el/ .
[3] Abraham Alonso, Como reconocen los robots los Objetos, MUY INTERESANTE, 2015, pp
23-24.
[4] E. Muller. Evolucion de la Robotica, MUY INTERESANTE, 2016, pp 10-11.
[5] Alejandro Beltran Nova, Sistema de control de robot delta basado en visin artificial, (2015,
Junio 23) pp-21-24.

16
PROTOTIPO ROBOT DELTA

17