You are on page 1of 17

INSTITUTO POLITECNICO NACIONAL ³Unidad Profesional Interdisciplinaria En Ingeniería Y Tecnologías Avanzadas´

SIMULACION DE MOVIMIENTO DE UN ROBOT CARTESIANO DE DOS EJES EN C, CON AMBIENTE GRAFICO

Grupo: 2MM3 Carrera Alva E. Jesus Osmar De la Torre Castro Mario Alejandro

INDICE - Introducción Objetivos Desarrollo del sistema Resultados Conclusiones .

Que de forma gráfica y/o aplicada podemos ver a un brazo el cual alcanza el punto deseado. de manera inversa este valor de ³Y´ se vuelve negativo por debajo del origen e igualmente se va incrementando negativamente conforme se aleja del origen. y se decrementa hacia la izquierda. Existe también el eje ³X´ el cual en sentido convencional se incrementa hacia la derecha. Coordenadas polares: Este tipo de coordenadas posen como sus dos ejes una distancia absoluta con respecto al origen a la denominamos radio y un Angulo al que denominaremos (Theta) que convencionalmente mide la rotación con respecto de lo que en coordenadas cartesianas es el eje ³+X´ al que denominaremos eje polar.0) y generalmente se caracterizan por el eje ³Y´ el cual en el sentido convencional es positivo hacia arriba del origen y se va incrementando conforme se incrementa la distancia hacia arriba del origen. . en el punto donde se intersectan se le define como el origen o la coordenada (0. en nuestra carrera aplicado a la mecatrónica podemos ver que Para comenzar a hablar del programa iniciamos a hablar sobre estos dos tipos de coordenadas Coordenadas cartesianas de 2 dimensiones: Este tipo de coordenadas son representadas por dos ejes que son perpendiculares entres ellos.Introducción: Debido a nuestro personal por iniciar a aprender acerca de la programación aplicada en la cinemática de robots se eligió este proyecto que convierte una coordenada cartesiana en dos dimensiones a una coordenada polar igualmente en dos dimensiones. cuando se mueve en sentido anti horario se incrementa positivamente hasta 3600 o lo que es lo mismo medido en radianes 2 de igual manera se podría decir que moviendo en sentido retro giro llega hasta y moviéndose en el sentido horario hasta ± .

)/ Cateto adyacente (C.Conversión de coordenadas: Para pasar de una coordenada cartesiana a una polar lo primero que debemos hacer es obtener la distancia del punto con respecto al origen. la cual podemos obtener a base de la ecuación de Pitágoras: H= (a2+b2)1/2 O lo que es lo mismo la distancia al origen o radio será igual a la raíz de la suma de los cuadrados de las coordenadas ³X´.´Y´ quedando de la siguiente manera: Radio= (X2+Y2)1/2 Ahora para calcular el ángulo tenemos que: Tangente ( )= Cateto Opuesto (C.O. y=-yi+341.A.A. .O.d1<d2. con x Tenemos que =Arc tan (Y/X).). y=(-sin(ang1)*d1)+341.d1=d1+4){ x=(cos(ang1)*d1)+380. x=xi+380. for(d1. con Y y al C. Pero si sacamos la función inversa y sustituimos al C.

Además de aplicar la mayoría de los conocimientos obtenidos a través del curso de programación avanzada. el cual previamente introdujimos valores de posición.OBJETIVOS Uno de los objetivos principales del programa es simular un brazo el cual alcanza un punto. . y tomando en cuenta nuestros conocimientos previos en el curso de mecánica del cuerpo rígido y así poder realizar el ingreso de las fórmulas de cálculo para el programa aquí mencionado.

también debemos de poner las coordenadas de y en sentidos contrarios para todos los cálculos. por lo cual ahora hacemos un traslado del punto de origen. y de cero a ± . Para poder seleccionar un punto inicial debemos tomar en cuenta que la ubicación de las coordenadas de los pixeles no es igual que el sentido convencional. inicialmente de acuerdo a si la coordenada inicial de Y era positiva o negativa nos mandaba a otra secuencia de if.h> #include <winbgim. Ahora ya teniendo resuelto el problema de los ángulos nos dedicamos a investigar como graficar para lo cual encontramos que en dev existe una librería para descargarse conocida como winbgim. el punto inicial de los gráficos comienzan en la esquina superior derecha mirando de frente el monitor. por lo cual más tarde tendremos que convertir esto a un valor exacto de 0 a 2 . esto lo logramos sumando las coordenadas del punto de origen a todos las operaciones que hagamos en la computador. #include <windows.ELABORACION DEL PROGRAMA: El primer problema para la elaboración del programa fue el cómo poder calcular los ángulos. Después lanzamos una línea del punto de origen a la coordenada inicial y debido a que es muy pequeña la línea y aparentemente en la librería no hay comandos para cambiar el grosor de línea lo que hacemos en graficar líneas que se muevan desde los pixeles que se en . Sin embargo la función que ya da el Angulo de acuerdo al cuadrante lo da de cero a + . En otras palabras calculaba la tangente y posteriormente de acuerdo al cuadrante sumaba o restaba el Angulo de uno de los ejes para tener el Angulo exacto. Sin embargo al investigar cómo utilizar la función arco tangente en el programa descubrimos que existen dos arcos tangentes una que da el valor exacto dependiendo del cuadrante y otra que lo da únicamente como Angulo. x aumenta hacia la derecha. y aumente hacia abajo en vez de disminuir. en la cual dependiendo de si x era positiva o negativa sumaba o restaba ángulos de los ejes. Teniendo esta información en cuenta y habiendo graficado círculos centrados en el nuevo origen y de un radio definido hasta que cubran toda la pantalla logramos crear un margen.h> También calculamos los radios Ahora que ya calculamos los ángulos tanto de las coordenadas iniciales como las de las coordenadas a moverse iniciamos los gráficos y graficamos un margen que sea del radio máximo que deseamos pueda alcanzar el brazo.

pero si dicho ángulo es mayor a es decir es mayor a la mitad del circulo conviene más rotar en sentido contrario. para lo cual de nuevo usamos una sentencia para decidir en qué dirección es el giro más corto: Restamos el ángulo 1 del ángulo 2 si el ángulo resultante es positivo quiere decir que dicho ángulo es lo que debe de sumarse al ángulo 1. e ir poniendo círculos en las nuevas coordenadas. habiendo calculado previamente los dos ángulos y los radios existen dos opciones que el radio de la coordenada inicial sea más o menos grande que el radio de la segunda coordenada: Si es más grande tendremos que borrar el círculos que pusimos anteriormente e ir dibujando pixeles que se incrementen lentamente para dar el efecto de que la línea se incrementa.encuentran al lado del origen hasta los pixeles que se encuentran al lado de la primer coordenada. ir incrementando o decrementando el Angulo inicial hasta que se convierta en el ángulo de la segunda coordenada Para lo cual ahora convertimos los radios de 0 a 2 con un simple if. pero con el Angulo de la primer coordenada. Ahora empezaremos a calcular lo que son los movimientos. Ambas secuencias las logramos con un for. poniendo la longitud del segundo arco como final de las repeticiones y el incremento o decremento del radio 1 hasta que se convierta en el mismo largo que el radio 2. . haremos algo similar. Para la siguiente secuencia grafica de movimientos. si los angulos son negativos el angulo es igual a y le adicionamos dicho Angulo negativo. de esta manera parece que la línea se extiende al tiempo que los círculos parpadean. Pero si el ángulo que resulto de la resta es negativo quiere decir que debe ir retrocediendo el ángulo hasta llegar al otro ángulo. e igualmente si lo que tiene que girar es mayor a es mejor que gire en el otro sentido. Después de cualquier secuencia debe de terminar un punto del origen al radio 2. Para que se denote mas donde está la coordenada inicial graficamos círculos alrededor de dicha coordenada. Ahora hacemos de nuevo una sentencia for mientras un ángulo sea diferente del otro se deberá ir incrementando o decrementando. En caso de ser más chico se irían borrando los círculos y se irían colocando otros hasta llegar al radio deseado. detenerlos y borrarlos.

optando por esta segunda opción. pero hay otro problema al hacer esto puede que el valor gire eternamente y nunca coincida. por lo cual haremos una sentencia dentro del for si el ángulo entre los dos ángulos es = o menor al de un centésima el ángulo se convertirá en el ángulo 2 restando esa centésima de esta manera al terminar esta iteración del ciclo for se convertirá en el ángulo exacto y saldrá de la secuencia. sin embargo al probar si la línea se dibujaba bien y se borraba bien quedaron residuos de pixeles dibujados en las partes más lejanas y esto es porque cerca del centro los radios son pequeños y alejado son grandes por lo cual en las esquinas no alcazaba a borrar todos los pixeles que había trazado de trayectorias anteriores. si el radio es mayor al máximo alcance. por lo cual o el cambio en el movimiento de los ángulos se hacía más pequeños atrasando la memoria de la computadora o se trazaban mas líneas negras paralelas a la que borran las líneas. Bien ahora que ya definimos el cómo realizar el giro colocaremos dentro del dos secuencias una para dibujar la línea y el circulo.Y. los pide de nuevo. Y ahora que las funciones por separadas se encontraban sueltas es momento de integrarlas en una sola utilizando la misma clase y la herencia de variables entre las funciones. . por lo cual en el for de giro pondremos como aumentos o decrementos en valores de centésimas. al terminar cambia la bandera y pregunta si desea trazar otra coordenada de ser así regresa la función y la bandera impide que se habrá otra función de gráficos. haciendo que el nuevo movimiento se realice sobre la misma ventana. la pausamos y después la borramos.Como los ángulos llevan varias diezmilésimas de entero sería demasiado tardado para la computadora que la pongamos a girar de diezmilésima en diezmilésima por lo cual haremos que los ángulos cambien solo de centésima en centésima. para terminar y seguir optimizando el código al principio del programa se piden la coordenada X. Ahora para que el sistema pueda encender y apagar la función grafica se crea una bandera si el programa corre por primera vez los lanza. en los círculos alrededor del centro al momento de borrarse si son del radio máximo permitido irán borrando parte del margen por lo cual al trazar los cambios de ángulos si son de un intervalo del radio máximo ira redibujando el margen eliminado al tiempo que continua rotando.

RESULTADOS .

Además nos resultó muy útil y de mucha practica el elaborar este programa. porque además de que pusimos a prueba nuestros conocimiento aprendidos en el curso. pudimos aplicar de manera práctica la programación en C++ directamente a nuestra área de ingeniería.CONCLUSIONES Nuestra conclusión tras la realización del programa fue que el realizar un programa en este lenguaje bajo de programación resulta ser más largo de lo que podría ser el realizarlo en otro programa especializado. .

void moveline(). }. int mar.h> #include<math.h> #include<stdio. float ang2. yf=0. int yf.h> class robot{ int xi. int yi. void getratio().h> #include<string. float d2. int xf. void ig(). float var.h> #include<conio. void cangle().#include <winbgim. public: robot().h> #include<stdlib. //________________________________________________________________________ ______ robot::robot(){ xi=0. float d1.h> #include<iostream. yi=0. } .h> #include <winbgim.h> #include <windows. xf=0. void margen(). float ang1. void mgrade(). float d.

cin>>xf. d2=pow(var. } //************************************************************************ **** void robot::margen(){ cout<<"\ndiametros: "<<d1<<" "<<d2. cout<<"Proporciona el nuevo valor de Y: ".a).5).0. var=((xf*xf)+(yf*yf)).341).} }while(d2>339). b=yf.//________________________________________________________________________ ______ void robot::getratio(){ do{ cout<<"Proporciona el nuevo valor de X: ". system("pause"). system("cls"). } //________________________________________________________________________ ______ void robot::cangle(){ int a. if(d2>339){cout<<"El punto se encuentra fuera del rango de movimiento.5). system ("pause").xi).0.k++){ . int b. ang1=atan2(yi. d1=pow(var.k<=10. cin>>yf. ang2=atan2(b. a=xf. moveto(381.\nPor favor ingreselos nuevamente". for(float k=0. cout<<"\nX es: "<<a<<"\nY es: "<<b<<"\n". var=((xi*xi)+(yi*yi)).

341). } sleep(50). y=(-sin(ang1)*d1)+341.for(float j=0.} } } //________________________________________________________________________ ______ void robot::moveline(){ int x. lineto(xi+379.j).341. setcolor(14).-yi+341).-yi+341).y-1).d1=d1+4){ x=(cos(ang1)*d1)+380. lineto(xi+381.342).-yi+341).j<=3.y). int y. for(float k=0. moveto(381. for(float i=340. lineto(xi+381.j++){circle(x.} setcolor(BLACK). for(d1.d1<d2. moveto(381. moveto(381.341). } setcolor(14).-yi+341.j<=3.-yi+340). lineto(x-1.sleep(2).i<=560.i).j++){circle(x. for(float j=0. lineto(xi+379.moveto(379.340). lineto(x. if (d1<d2){ x=xi+380.moveto(380.j++){circle(xi+380.j). moveto(379.moveto(380.i=i+1){ circle(380.341).342).k<=14. y=-yi+341.moveto(380.y.j<=3.340). lineto(x.} .moveto(380.j).y.setcolor(k).k++){ setcolor(k).y+1).y). for(float j=0.y).341). lineto(x.341).-yi+342).341). moveto(380. lineto(x+1. lineto(xi+380.

int y.j).d1--){ x=(cos(ang1)*d1)+380.j). for(float j=0. float a. for(float j=0. setcolor(14). setcolor(14).} if(ang2<0){ang2=6.y. y=(-sin(ang1)*d2)+341.j<=5.d1>=d2. y=(-sin(ang1)*d1)+341.j++){circle(x. int dir1.j).} if(ang1>=6.28318){ang2=ang1-6.j++){circle(x.28318+ang2.28318.j++){circle(x.} . y=(-sin(ang1)*d1)+341. for(float j=0.} } } //________________________________________________________________________ _____ void robot::mgrade(){ int x. for(float j=0.y.j<=3.j).j<=3.} x=(cos(ang1)*d2)+380. setcolor(14).28318. setcolor(BLACK).y.j<=3.} if(ang2>=6.28318+ang1.} sleep (10). setcolor(BLACK).} } // Ahora va para un diametro menor que el final else{ for(d1.28318){ang1=ang1-6.} } x=(cos(ang1)*d1)+380.sleep (20). if(ang1<0){ang1=6.y.j++){circle(x.

for(float j=0.j++) { circle(x.28318){ang2=ang1-6. moveto(380.} if(ang2>=6.01.28318+ang1. y=(-sin(ang1)*d2)+340.341).342).} if((fabs(ang2-ang1))<=0.y). moveto(380. dir1=ang2-ang1.340). lineto(x-1.28318+ang1.28318){ang1=ang1-6.341).} x=(cos(ang1)*d2)+380.ang1!=ang2.}else{a=-0.} if(ang1>=6.01.28318.14159){ a=0.} else{ a=0.} if(ang2<0){ang2=6.y+1).14159){ a=-0. if(ang2>=ang1){if((fabs(dir1))<=3.cout<<"\nEl antiguo angulo en radianes es: "<<ang1<<"\nEl angulo nuevo en radianes es: "<<ang2.01. . sleep(5). } } cout<<"\nDireccion"<<a.}} else{ if((fabs(dir1))<=3.j). lineto(x.28318. lineto(x.y).01){ang1=ang2-a. moveto(379.ang1=ang1+a){ if(ang1<0){ang1=6.341). moveto(380.01.j<=4.y.y). lineto(x.y-1). for(ang1. lineto(x+1. moveto(381. setcolor(14).

setcolor(14).} setcolor(BLACK).} setcolor(10). .j<=7. moveto(381.y).y). moveto(380.341). } for(float j=0. y=(-sin(ang2)*d2)+340. moveto(380+i.y-1). moveto(380.i<=5. } } } x=(cos(ang2)*d2)+380.341). lineto(x-i.y).y. lineto(x.341).342).y). moveto(380. moveto(380-i.j++){circle(x. lineto(x. lineto(x+1.341).y-i).i<=350.//se definen de nuevo las coordenadas para k el calculo sea mas exacto. lineto(x+i.341+1).j).y). lineto(x. moveto(379.i). for(int i=1. moveto(380.341-i). lineto(x-1. if(d2>=330){ for(float i=340.341.341).341).i++) { moveto(380. moveto(380.i=i+1){ circle(380.y). lineto(x.340). lineto(x.y+i).

//open graphics window } //************************************************************************ ****** //************************************************************************ ****** //**************************************d********************************* ******* int main(){ int f.mgrade().y+1). } . } while(f==0).j<=3.j).700). cnmtks. return(0). f=1.moveline().margen(). char q1[67]. yi=yf. if(f!=0){ cnmtks.ig()."¿Desea realizar otro recorrido? Pulse 0 para volver a realizarlo: "). strcpy(q1.lineto(x.j++){circle(x.y.getratio(). robot cnmtks. } //================================================================ ============= void robot::ig(){ initwindow(750. cin>>f. cnmtks.} cnmtks.} xi=xf.cangle(). closegraph(). for(float j=0. cnmtks. cout<<"¿Desea realizar otro recorrido?\nPulse 0 para volver a realizarlo: ". do { cnmtks.