Proyecto final de Ingeniería Electrónica148.206.53.84/tesiuami/UAMI16753.pdf · con un microcontrolador y un entorno de desarrollo, ... Y debido a que cada dato es del tamaño de

Proyecto final de Ingeniería Electrónica

1


ContenidoIntroducción:............................................................................................................................................3Marco Teórico:.........................................................................................................................................3Planteamiento:..........................................................................................................................................4Propuesta:.................................................................................................................................................4Implementación (1º parte):......................................................................................................................4

Mecánica :.............................................................................................................................................5Electrónica:............................................................................................................................................7Software:...............................................................................................................................................8

Implementación (2º parte):....................................................................................................................13Diseño:.................................................................................................................................................13Electrónica:..........................................................................................................................................14

Producto Terminado:.............................................................................................................................16Problemas:..............................................................................................................................................21Soluciones:..............................................................................................................................................21Conclusiones:..........................................................................................................................................22Referencias:............................................................................................................................................22

2


Introducción:

Muchas son las aplicaciones de la robótica, diversión, exploración, destrucción, fabricación, etc, y en este proyecto se desea una emulación de un brazo real. Un brazo humano posee muchas articulaciones que permiten interactuar con objetos de diferente forma y tamaño, la solución de problemas constantemente se inspira en la naturaleza y trata de emularla.Se plantea usar un servomotor por cada articulación, y aluminio como hueso, el resto es ingeniería.

Marco Teórico:

Entre las tecnologías que se usaron, encontramos las siguientes:• Arduino• Servomotores• Java• Processing• C#• ChipKit

De acuerdo con wikipedia, Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares.Es decir, es un circuito armado disponible y listo para trabajar en proyectos de control, reduciendo el tiempo de diseño e implementación.

Los servomotores son un tipo de motor que poseen un control interno que permite aumentar la torca de un motor simple sacrificando su desplazamiento angular, generalmente se limitan a 180° o menos.

Java es un lenguaje de programación multiplataforma propiedad de Oracle, en el cual se basa la programación de arduino.

Processing es un lenguaje de programación basado en java, para generar aplicaciones multimedia, y esta muy relacionado con arduino para la interface de usuario.

C# es otro lenguaje de programación propiedad de Microsoft que sigue el paradigma orientado a objetos.

3


ChipKit es un circuito similar al arduino con la diferencia de que este utiliza un microcontrolador de Microchip y posee más puertos de control o monitoreo.

Planteamiento:

Se desea implementar el control para un brazo robótico de aluminio con movimiento en base a servo motores. El control debe permitir manipulación en tiempo real, así como programar subrutinas para tareas simples. El hardware se basará en la placa de desarrollo ChipKit Uno 32, mientras que el software se planea en Java y comunicación a través del puerto USB.

Propuesta:

Se plantea utilizar aluminio para la construcción del brazo, y una tarjeta “arduino” para la parte de control por hardware; Mientras que la parte de control por sotfware se delega a “processing” ya que están relacionados a nivel de IDE este permite la comunicación serial.

Implementación (1º parte):

Comenzando por el brazo se cuenta con una pieza de aluminio parecida al marco de una ventana, cuya densidad lineal es de aproximadamente 3.5g/cm. Los servos tienen en sus especificaciones que tienen un peso de 43g y tienen una torca de 5kgcm. Se plantea el modelo mostrado en la ilustración 1.

Mecánica :

Suponiendo que cada segmento tiene la misma longitud y no se considera el peso de estos,

4

Ilustración 1: Modelo ideal del brazo


tenemos la ecuación 1. que nos da como respuesta una longitud de casi 40 cm .

Ecuación 1.Pero este modelo no considera el peso de cada segmento de aluminio ni el peso de algún objeto que cargue. Un segundo modelo se muestra en la ilustración 2.

Volviendo a suponer que la longitud de cada segmento de brazo es igual tenemos la ecuación 2.

Ecuación 2.Donde x2 corresponde a el peso del segmento de aluminio, y posee una densidad de 3.5g/cm. Y x1 corresponde al peso de la mano/pinza más algún objeto que sujeta. Lo que deja a la ecuación con 2 incógnitas. Así que vamos a suponer el valor de l menor al valor obtenido en el modelo ideal. Comenzamos con 30cm.

5

Ilustración 2: Modelo real del brazo.

5kgcm=l(43g)+21(43g )=l (129g)

l=5kgcm0.129kg

=38.759cm

5kgcm=94

l (x1)+21(43g)+32

l (x2)+l (43g)+12( x2)

5kgcm=l(94

x1+129g+2 x2)


Ecuación 3.La ecuación 3 muestra que 30cm es demasiado, se evalúa para 20cm en la ecuación 4.

Ecuación 4.Nuevamente el resultado no es aceptable, se avaluó con 15 cm en la ecuación 5.

Ecuación 5.El resultado de la ecuación 5 es suficiente para al menos sostener otro servo que corresponde a la mano/pinza.

Electrónica:

La ilustración 3 muestra un diagrama de la conexión entre los servo motores y el microcontrolador.

6

x2=l (3.5gcm

)

5kgcm=30cm(94

x1+129g+60(3.5))

5kgcm=1352

x1+10.17kgcm

5kgcm=15cm (9

4x1+129g+30(3.5g))

5kgcm=33.75 x1cm+3.51kgcm33.75x1=5kg−3.51kg

x1=1.49kg33.75

x1=44.14g

5kgcm=20cm(94

x1+129g+30 (3.5g))

5kgcm=45 x1cm+5.38kgcm


Respecto al código del arduino se plantea una técnica polling revisando constantemente la comunicación serial en busca de 2 datos de entrada, el primero, de el número de servo que se quiere controlar, y el segundo del valor que debe asignar. A continuación se muestra la primera versión del código.

/*codigo para arduino que controla la posicionde los servos del brazo deacuerdo a la informacionque recibe por comunicacion serial*/#include <Servo.h>Servo hombro1; //pin 5Servo codo2; //pin 6Servo munieca3; //pin 9Servo pinza4; //pin 10byte angulo;

void setup(){// inicializa comunicacion serialSerial.begin(9600);// asigna puertos a los servoshombro1.attach(5);codo2.attach(6);munieca3.attach(9);pinza4.attach(10);//establece la posicion inicial de los servoshombro1.write(145);codo2.write(00);munieca3.write(00);pinza4.write(170);}

void loop() {byte num_servo;// primero pregunta si hay datos disponibles en la entrada serialif (Serial.available()) {// el primer dato debe ser el numero del servonum_servo = Serial.read();// el segundo dato es el angulo que debe estan entre 0 y 179delay(150);angulo = Serial.read();switch(num_servo){case 1:hombro1.write(angulo);break;case 2:codo2.write(angulo);break;case 3:munieca3.write(angulo);break;case 4:pinza4.write(angulo);case 5:delay(angulo*4);}//Serial.flush();}}

7

Ilustración 3: Diagrama de conexión de los servos.


Como se puede observar en el código, se incluye un valor para los retardos que se usan en las rutinas. Y debido a que cada dato es del tamaño de un byte el valor de tiempo se multiplica por 4 al llegar.

Software:

Para la parte de control desde PC se programo una interfaz con processing, aunque como processing no ofrece un framework para GUI, los elementos visuales se programaron a mano.A continuación se muestra el código de processing usado.

/*Codigo principalinicializa y lleva la logica de control*/import processing.serial.*;Serial puerto;PFont fuente;slider hombro;slider codo;slider munieca;slider pinza;boton b_rutina1;boton b_rutina2;boton b_rutina3;int basex;int basey;int espax;int ancho;int alto;void setup(){size(400,400,P3D);println(Serial.list());puerto = new Serial(this, "COM3", 9600);fuente = loadFont("AngsanaUPC-48.vlw");textFont(fuente,28);//strokeCap(ROUND);basex=40;basey=130;espax=100;ancho=20;alto=10;hombro = new slider(basex,basey,ancho,alto,150,105);codo = new slider(basex+espax,basey,ancho,alto,150,0);munieca = new slider(basex + espax*2,basey,ancho,alto,150,75);

pinza = new slider(basex + espax*3,basey,ancho,alto,150,0);b_rutina1 = new boton(basex,basey+200,70,20,"rutina 1");b_rutina2 = new boton(basex+espax,basey+200,70,20,"rutina 2");b_rutina3 = new boton(basex + espax*2,basey+200,70,20,"rutina 3");}

void draw(){int pivx_h=basex+10;int pivy_h=40;int pivx_c=basex+espax+10;int pivy_c=58;int pivx_m=basex+10+espax*2;int pivy_m=55;int angulo;//---------parte estatica---------background(#3ea5e3);divisiones();dibujaperfil(pivx_h,pivy_h);dibujabrazo(pivx_c,pivy_c);fill(0);text("hombro", basex -5, basey-5);text("codo", basex -5 + espax, basey-5);text("muñeca", basex -5 + 2* espax, basey-5);text("pinza", basex-5 + 3* espax, basey-5);b_rutina1.display();b_rutina2.display();b_rutina3.display();//dibujamunieca(pivx_m,pivy_m);//---------parte dinamica---------hombro.update();codo.update();munieca.update();

8


pinza.update();hombro.display();codo.display();munieca.display();pinza.display();//--------rotaciones-------//----hombropushMatrix();translate(pivx_h,pivy_h);angulo=hombro.mapeo(0,190)-60;rotateZ(radians(angulo));strokeWeight(4);line(0,0,40,0);popMatrix();//----codopushMatrix();translate(pivx_c,pivy_c);angulo=codo.mapeo(0,90);rotateZ(radians(angulo));strokeWeight(4);line(0,0,40,0);popMatrix();//----muniecapushMatrix();translate(pivx_m,pivy_m);angulo=munieca.mapeo(0,179)-90;rotateZ(radians(angulo));dibujamunieca(0,0);popMatrix();//----pinzadibujapinza(basex-15 + espax*3, 50 );}void mouseMoved(){hombro.overS();codo.overS();munieca.overS();pinza.overS();}void mousePressed(){hombro.pressS();codo.pressS();munieca.pressS();pinza.pressS();if(b_rutina1.over()){rutina1();}if(b_rutina2.over()){rutina2();}if(b_rutina3.over()){rutina3();}}

void rutina1(){//paso 1 liberar pinzapuerto.write(4);puerto.write(40);puerto.write(5);puerto.write(150);//paso 2 bajar brazopuerto.write(1);puerto.write(147);puerto.write(5);puerto.write(250);//paso 3 estirar codopuerto.write(2);puerto.write(0);puerto.write(5);puerto.write(250);//paso 4 alinear pinzapuerto.write(3);puerto.write(80);puerto.write(5);puerto.write(150);//paso 5 cerrar pinzapuerto.write(4);puerto.write(179);puerto.write(5);puerto.write(150);//paso 6 subir brasopuerto.write(1);puerto.write(0);puerto.write(5);puerto.write(250);//paso 7 doblar codopuerto.write(2);puerto.write(90);puerto.write(5);puerto.write(250);//paso 8 abrir pinzapuerto.write(4);puerto.write(40);//fin}void rutina2(){// paso 1 abrir pinzapuerto.write(4);puerto.write(40);puerto.write(5);puerto.write(150);//paso 2 girar muniecapuerto.write(3);puerto.write(0);puerto.write(5);puerto.write(150);//paso 3 cerrar pinza

9


puerto.write(4);puerto.write(179);puerto.write(5);puerto.write(150);//paso 4 girar muniecapuerto.write(3);puerto.write(179);puerto.write(5);puerto.write(150);}void rutina3(){//paso 1 liberar pinzapuerto.write(4);puerto.write(40);puerto.write(5);puerto.write(150);//paso 2 bajar brazopuerto.write(1);puerto.write(140);puerto.write(5);puerto.write(250);//paso 3 posicionar codopuerto.write(2);puerto.write(45);puerto.write(5);puerto.write(250);//paso 4 alinear pinzapuerto.write(3);puerto.write(80);puerto.write(5);puerto.write(150);//paso 5 cerrar pinzapuerto.write(4);puerto.write(179);puerto.write(5);puerto.write(150);//paso 6 subir brasopuerto.write(1);puerto.write(30);puerto.write(5);puerto.write(250);//paso 7 estirar codopuerto.write(2);puerto.write(0);puerto.write(5);puerto.write(250);//paso 8 abrir pinzapuerto.write(4);puerto.write(40);//fin}void mouseReleased(){int posicion;

if(hombro.cambio){hombro.press=false;hombro.cambio=false;posicion=hombro.mapeo(0,179);println("hombro " + posicion);puerto.write(1);puerto.write(posicion);}if(codo.cambio){codo.press=false;codo.cambio=false;posicion=codo.mapeo(100,0);println("codo " + posicion);puerto.write(2);puerto.write(posicion);}if(munieca.cambio){munieca.press=false;munieca.cambio=false;posicion=munieca.mapeo(179,0);println("munieca " + posicion);puerto.write(3);puerto.write(posicion);}if(pinza.cambio){pinza.press=false;pinza.cambio=false;posicion=pinza.mapeo(40,179);println("pinza " + posicion);puerto.write(4);puerto.write(posicion);}}/*Clase botondibuja un boton en la pantallae incluye un metodo para revisatr siel raton esta sobre el mismo*/class boton{int x;int y;int w;int h;String label;boton(int px, int py, int ancho, int alto, String etiq){x=px;y=py;w=ancho;h=alto;label=etiq;}

10


void display(){stroke(0);strokeWeight(2);if(this.over()){fill(#3EE34F);}else{fill(255);}rectMode(CORNER);rect(x,y,w,h);fill(0);text(label,x+5,y+15);}boolean over(){if(mouseX > x && mouseX < x+w && mouseY > y && mouseY < y+h)return true;elsereturn false;}}

/*Segmento de codigo que dibujalineas que dividen el area de trabajo en secciones*/void divisiones(){stroke(255);strokeWeight(2);line(0,100,400,100);line(0,300,400,300);line(100,0,100,300);line(200,0,200,300);line(300,0,300,300);}/*Parte del codigo que dibuja unarepresentacion del brazo*/void dibujaperfil(int homx,int homy){stroke(0);strokeWeight(1);fill(255);ellipse(homx,homy-20,22,22);arc(homx,homy,30,15,PI,TWO_PI);arc(homx,homy,30,110,0,PI/2);arc(homx,homy,30,110,PI/2,PI);}void dibujabrazo(int brax,int bray){stroke(0);strokeWeight(1);

//noFill();fill(255);//arc(brax,bray,16,16,0,PI);//arc(brax,bray-20,26,20,PI,TWO_PI);//rect(brax-10,bray-20,20,20);//line(brax-8,bray,brax-13,bray-20);ellipse(brax,bray-20,20,70);}void dibujamunieca(int x, int y){int x1=x;int y1=y+10;int x2=x1+22;//72int y2=y1-32;//48int x3=x1+5;//55int y3=y1-20;//60int x4=x1-10;//40int y4=y1-50;//30fill(255);strokeWeight(2);beginShape();vertex(x1,y1);bezierVertex(x1+15,y1,x2+10,y2+4,x2,y2);bezierVertex(x2-10,y2-4,x3+5,y3+5,x3,y3);bezierVertex(x3-5,y3-5,x4+20,y4,x4,y4);bezierVertex(x4-20,y4,x1-30,y1,x1,y1);endShape();}void dibujapinza(int x,int y){int anchop=10;int manl=20;int manw=5;int altop=70;fill(255);strokeWeight(2);beginShape();vertex(x,y);vertex(x+manl,y);vertex(x+manl,y-altop/2);vertex(x+manl+anchop,y-altop/2);//,.-vertex(x+manl+anchop,y+altop/2+manw);//,.-vertex(x+manl,y+altop/2+manw);vertex(x+manl,y+manw);vertex(x,y+manw);endShape(CLOSE);int dy=pinza.mapeo(0,65)/2;fill(0);beginShape(TRIANGLES);//vertex(x+manl+anchop,y-altop/2+dy);vertex(x+25+manl+anchop,y+5+dy-altop/2);vertex(x+manl+anchop,y+5-altop/2+dy);//vertex(x+manl+anchop,y-dy+altop/2+manw);

11


vertex(x+manl+anchop,y-5-dy+altop/2+manw);vertex(x+25+manl+anchop,y-5-dy+altop/2+manw);endShape();}/*clase que representa un controldeslizable con limites definidos.*/

class slider{int x;int y;int w;int h;int largo;int pos;boolean cambio;boolean press;boolean over;slider(int xx, int yy, int ancho, int alto, int l, int p){x=xx;y=yy;w=ancho;h=alto;largo=l;pos=p;press=false;over=false;}//dibuja el slidervoid display(){

//smooth();stroke(0);//strokeCap(ROUND);strokeWeight(4);line(x+w/2, y, x+w/2, y+largo);fill(255);strokeWeight(1);if(over || press){fill(#3EE34F);}rect(x, y+pos, w, h);}//actualiza la posision de la caja del slider

void update(){if(press){cambio=true;pos = mitady();}}//devuelve un valor que este entre la longitud del sliderint mitady(){if(mouseY < y){return (0 );}else{if(mouseY > y + largo){return ( largo );}else{return (mouseY - y );}}}//pregunta si esta sobre la cajavoid overS(){if(mouseX > x && mouseX < x+w && mouseY > y+pos && mouseY < y + pos + h){over = true;}else{

over = false;}}//pregunta si se presiono sobre la cajavoid pressS(){if(over && mousePressed){press = true;}else{press = false;}}int mapeo(int bajo_, int alto_){//println("largo = " + largo);float m = (alto_ - bajo_);//println(m);m = m / largo;//println("pendiente = " + m);float sal = bajo_ + m * pos;return (int(sal));}}

Hasta este punto se tiene un control simple en tiempo real y tres “rutinas” preestablecidas que solo se ejecutan una vez.

12


Implementación (2º parte):

Para esta segunda parte se desea cambiar la interfaz gráfica con el propósito de que sea mas amigable con el usuario y que en principio pueda ser usada por un niño. Además se debe poder programar rutinas y estas se deben poder ejecutar cuando el brazo este desconectado del PC.

Diseño:

Se plantean 4 casos de uso, y estos fueron implementados casi en su totalidad.1. Conectar brazo2. Mover brazo.3. Crear rutina.4. Cargar rutina.Los casos de uso, diagramas de colaboración y código se pueden encontrar enlos archivos externos.

Electrónica:

Se realizo un cambio de tecnología para explorar otros campos. En este caso se reemplazó el arduino por un nuevo producto competidor de la familia microchip, el chipkit uno32 que es el equivalente en hardware del arduino uno, además ofrece otras características como mayor cantidad de entradas y salidas digitales.El código dentro del chipkit es muy parecido, solo cambia un par de asignaciones de servo y el código para cargar la rutina en la memoria local.

/*Codigo principal*/#include <Servo.h>//const byte inicio = B11111111;//FFconst byte final = B11110000;//F0const byte id_hombro = B00000001;//01const byte id_codo = B00000010;//02const byte id_munieca = B00000011;//03const byte id_pinza = B00000100;//04const byte id_tiempo = B00000101;//05byte aux;byte angulo;boolean seguir;byte rutina[50];Servo s_hombro;//pin 5

Servo s_codo;//pin 6Servo s_munieca;//pin 8Servo s_pinza;//pin 9void setup(){// inicializa la comunicacion serialSerial.begin(9600);// asigna puertos a los servoss_pinza.attach(9);s_munieca.attach(8);s_codo.attach(6);s_hombro.attach(5);//establece posicion inicial de los servoss_pinza.write(170);s_munieca.write(00);s_codo.write(00);s_hombro.write(145);

13


//led bandera de estadopinMode(43,OUTPUT);digitalWrite(43,LOW);seguir=false;}void loop(){//verifica que exista datos en la entrada serialif(Serial.available()>0){//retraso para corregir bugdelay(10);//lee el numero de servo o retardoaux=Serial.read();delay(10);if(aux==inicio){//cargar rutina en memoria localcargar();//levantar bandera de ejecucion localseguir=true;}else{// bajar bandera de ejecucion localseguir=false;//decodificar instruccionangulo=Serial.read();deco(aux,angulo);digitalWrite(43,HIGH);}}//fin serial availableexe_rutina();}/*Codigo para cargar la rutina*/void cargar(){int j=0;byte x;do{delay(10);x=Serial.read();rutina[j]=x;j++;

}while(x!=final && Serial.available()>0);Serial.flush();}/*codigo que "emula una maquina virtual"ejecuta intrucciones de tiempo y cambio de posicion de servo*/void deco(byte instruc, byte valor){switch(instruc){case id_pinza:s_pinza.write(valor);break;case id_munieca:s_munieca.write(valor);break;case id_codo:s_codo.write(valor);break;case id_hombro:s_hombro.write(valor);break;case id_tiempo:delay(valor*250);break;default:digitalWrite(43,LOW);}}/*codigo que ejecuta la rutina de forma local*/void exe_rutina(){byte a;byte b;if(seguir){for(int i=0; i<50 && rutina[i]!=final; i+=2){a=rutina[i];b=rutina[i+1];deco(a,b);}}}

El código correspondiente a la GUI es muy largo para incluirlo en este reporte, así que se puede consultar de forma externa al igual que el resto de los otros códigos fuente. Aunque se debe recordar que el código esta en C# y el proyecto fue construido con visual C# 2010 Express.

14


Producto Terminado:

El producto terminado se puede apreciar en las fotografías 1 a 7.

15

Fotografía 1: Descripción general.


16

Fotografía 2: Vista frontal.


17

Fotografía 3:Vista del perfil interno.

Fotografía 4:Angulo del hombro arriba.


18

Fotografía 5:Dimensión del griper

Fotografía 6:Angulo hombro abajo.


19

Fotografía 7: Conexiones.


Problemas:

1. Un error en la evaluación de la ecuación 4, dio como resultado que 20cm era una medida apropiada.

2. La fabricación de la mano/pinza era demasiado complicada para llevarse a cabo sin las herramientas y recursos adecuados.

3. El abandono de la tecnología “processing” implicó conseguir nuevas bibliotecas para trabajar con USB a bajo nivel.

4. Java no tiene buen acoplamiento con el control de hardware, JNI (Java Native Interfaces) requiere de conocimientos mas avanzados de programación y de la tecnología misma.

Soluciones:

1. Se creo un contrapeso en la sección del hombro, para compensar el error de cálculo, además de algunos agujeros a lo largo de los segmentos para aligerar su peso, sin que estos debilitaran la estructura.

2. Se recurrió a un dispositivo de terceros, un “griper” que incluye 2 servos, 1 de la muñeca, y otro de la pinza.

3. Se buscó de forma exhaustiva una biblioteca adecuada, pero ninguna permitió llevar a cabo la comunicación de forma simple. Por último se recurrió a la página del fabricante para buscar información, lo que llevó a usar los drivers que proporciona el fabricante FTDI para sus productos que realizan conversión de USB a UART.

4. Se intentó trabajar con C++ pero diversos problemas empujaron el proyecto a otras alternativas, y al final se trabajó con C#.

20


Conclusiones:

El aluminio es un buen candidato para la fabricación de piezas robóticas como aprendizaje, pero este no proporcionaba las características óptimas, se debería intentar con otros materiales más adecuados como la fibra de carbono.

Al mismo tiempo, los servos utilizados poseen una torca muy baja para aplicaciones industriales, en esta implementación solo se logró levantar objetos de peso ligero como, lapices, gomas, memorias flash, canicas, etc.

Aunque se utilizó otra tarjeta de desarrollo para el control de los servos, esta no fue explotada en capacidades, y para el objetivo del proyecto, podría considerarse demasiado “poderosa”.

Java puede ser una opción muy atractiva para hacer aplicaciones de escritorio, pero posee sus limitaciones cuando tiene que trabajar con el hardware que lo hospeda.

Y personalmente mi más importante conclusión es que el primer lugar donde se debe buscar información es con el fabricante, ya que este es el primero que puede proporcionar soluciones a los problemas encontrados.

Referencias:

• http://www.ftdichip.com • http://www.arduino.cc/es • http://www.chipkit.org/forum/index.php?&er=t • http://msdn.microsoft.com/en-us/vstudio/hh341490.aspx • http://es.wikipedia.org • http://www.csharpya.com.ar/

21

http://www.ftdichip.com/

http://www.csharpya.com.ar/

http://es.wikipedia.org/

http://msdn.microsoft.com/en-us/vstudio/hh341490.aspx

http://www.chipkit.org/forum/index.php?&er=t

http://www.arduino.cc/es

Documents

Proyecto final de Ingeniería Electrónica148.206.53.84/tesiuami/UAMI16753.pdf · con un microcontrolador y un entorno de desarrollo, ... Y debido a que cada dato es del tamaño de