PROBLEMA DE INGENIERÍA - frsn.utn.edu.ar

UNIVERSIDAD TECNOLOGICA NACIONAL FACULTAD REGIONAL SAN NICOLAS

INGENIERIA EN ELECTRONICA

PROBLEMA DE INGENIERÍA TECNICAS DIGITALES III

BRAZO ROBÓTICO - COMPLEMENTO -

Integrantes:

- Puppo, Marcelo Nicolás

Docentes:

- Profesor: Ing. Felipe Poblete - Auxiliar: Ing. Mariano González

AÑO 2008

Técnicas Digitales III – Problema de ingeniería

2

INDICE

OBJETIVOS DEL TRABAJO 3 MATERIAS INTEGRADAS......................................................................................................... 3 POSIBLES APLICACIONES........................................................................................................ 3 BIBLIOGRAFÍA...........................................................................................................................3

DESARROLLO 5 INTRODUCCIÓN.........................................................................................................................7 TEORÍA DE FUNCIONAMIENTO ..............................................................................................7 DIAGRAMA DE FLUJO: ............................................................................................................ 12 RESULTADOS DE LAS PRUEBAS ...........................................................................................13 CONCLUSIONES........................................................................................................................13

ANEXOS: 14 LISTADOS DE PROGRAMAS ................................................................................................... 14 LIBRERIAS Y FUNCIONES UTILIZADAS ............................................................................... 32 Archivos cabecera (Librerías): ...................................................................................................... 32 Funciones creadas:........................................................................................................................32 FOTOS DE PANTALLA ............................................................................................................. 33


3

OBJETIVOS DEL TRABAJO Este trabajo es complementario del proyecto “Brazo robótico” realizado por otros estudiantes anteriormente. Lo que pretende es:

1. Agregar mayor funcionalidad. 2. Darle un carácter más automatizado. 3. Visualizar el proceso en una pantalla. 4. Llevar un registro del ingreso de piezas y de sus movimientos. 5. Linealizar el movimiento de la pieza al máximo posible.

Inicialmente, el problema de ingeniería consistía en darle al proyecto “Brazo robótico” existente mayor funcionalidad realizando los ajustes necesarios, tanto mecánicos como de software, realizar un seguimiento en pantalla de las piezas mientras éstas efectuaban un movimiento curvilíneo desde la posición de inicio hasta la de destino, y modificar dicho movimiento, para que la trayectoria que trazara fuese en línea recta. Debido al tiempo en desuso y el abandono del aparato, en el momento de realizar las pruebas para comprender su funcionamiento, el mismo no se desempeñaba de manera correcta. Entre los problemas que presentaba se encontraron: engranajes con dientes gastados y/o empastados, uno de los motores paso a paso no completaba el movimiento (no desplazaba el brazo a más de 80 grados), el brazo estaba vencido (por lo que rozaba la base) a causa del peso del electroimán y la maqueta estaba mal posicionada, entre otros. Habiendo consultado a uno de los integrantes que realizó el proyecto y luego a los profesores de la cátedra se replantearon las condiciones y los requisitos a cumplir del problema de ingeniería llegando a la siguiente solución: simular por software el movimiento de los motores y realizar los cálculos necesarios para esto. A partir de la simulación, se centró el objetivo en buscar la solución para el inconveniente del movimiento curvo en lugar de rectilíneo.

MATERIAS INTEGRADAS

• Informática 2. (Programación C++) • Análisis matemático (coordenadas rectangulares/polares, trigonometría) • Física (movimiento rectilíneo/curvilíneo)

POSIBLES APLICACIONES

• Depósito para almacenar distintos tipos de piezas (bultos). • Visualización de un campo de trabajo con distintos elementos en él. • Seguimiento de piezas en un área establecida. • Área donde se necesite reubicar las piezas (bultos) ingresados. • Registro (Historial) de ingreso y movimiento de cada pieza (bulto).

BIBLIOGRAFÍA

• Apuntes de cátedra: • Informática 2. • Física. • Análisis matemático.


4

• Libros.

• Manual Turbo C++. • Fundamentos De Programación En C++

Garrido Carrillo, Antonio (Delta Publicaciones). • Como programar en C/C++ 2/ED H.M. Deitel / P.J. Deitel (Prentice Hall).


5

DESARROLLO Al comenzar el problema de ingeniería desarrollé un soft prototipo utilizando Turbo C++ Versión 3.0 para observar en pantalla la ubicación de las piezas y conseguir un seguimiento de las mismas. La elección de Turbo C++ como herramienta de trabajo se debió a que la interfaz brazo-PC corría bajo este entorno. Debido a los inconvenientes que inutilizaron el “brazo robótico”, la integración del soft prototipo con el brazo no se hizo posible, por lo que opté por descartar éste y realizar un nuevo soft que simulara todo, también usando Turbo C. De esta forma llegué al software final, que no sólo simula la mecánica tomando en cuenta el comportamiento de los motores paso a paso, sino que también presenta una interfaz gráfica más real, dinámica, representativa y amena. Para alcanzar este objetivo, fue necesario utilizar una librería gráfica, que lleva la programación de aplicaciones en Turbo C a un nivel superior. A continuación se presentan ambos software aunque sólo se detalla el funcionamiento del software final. Soft prototipo:


6

Soft final:


7

INTRODUCCIÓN

Se recibe una serie de piezas que deben ser ubicadas en un sitio de almacenaje de área semicircular y radio 200m. La playa de almacenamiento contiene un sector de carga (200; 0º) donde llegan los bultos y se encuentra dividida en un sector de almacenaje para piezas tipo A y un sector de almacenaje para piezas tipo B. Se pueden almacenar 2 tipos de piezas o bultos diferentes, cada uno en un área distinta del sitio de almacenaje y correspondiente a los de su tipo, sin poder ubicarse una pieza tipo A en el área de las piezas tipo B y viceversa. Una vez ubicados todos los bultos, se procede a la reubicación, la cual permite cambiar de posición cualquiera de las piezas existentes en la totalidad de la playa de almacenamiento sin restricciones. La reubicación de las piezas se logra a partir del ingreso de nuevas coordenadas ingresadas. En el presente software, no sólo se ve la trayectoria que trazaba la máquina (curvilínea) sino también la mejora introducida gracias a la cual la pieza se mueve de la posición de inicio a la de destino trazando una línea recta.

TEORÍA DE FUNCIONAMIENTO

El proyecto consiste en un programa realizado en lenguaje C++ que consta de 6 etapas: 1. Registro: se crea un archivo .txt que se completará con los ingresos y todos los movimientos de

las piezas. La primera vez que se ejecuta el programa, se crea este archivo y se va completando a medida que se ingresan piezas o se realizan movimientos en detalle con la fecha y hora de cualquier operación realizada. Ejemplo de escritura en el archivo historial: TIPO: a - COORDENADAS POLARES: ( 60 ; 60 ) - FECHA: Tue Dec 16 17:57:33 2008 LA PIEZA a SE MOVIO DE: ( 60 ; 60 ) A: ( 100 ; 40 ) - FECHA: Tue Dec 16 17:57:59 2008 TIPO: b - COORDENADAS POLARES: ( 120 ; 120 ) - FECHA: Thu Aug 20 20:54:50 2009 LA PIEZA b SE MOVIO DE: ( 120 ; 120 ) A: ( 200 ; 45 ) - FECHA: Thu Aug 20 20:55:24 2009 LA PIEZA b SE MOVIO DE: ( 200 ; 45 ) A: ( 100 ; 60 ) - FECHA: Thu Aug 20 20:55:24 2009


8

Las próximas veces que se ejecuta el programa, se abre el archivo existente y se completa a continuación de la última línea. El archivo de texto creado puede leerse en cualquier momento con cualquier procesador de texto para llevar un control o verificar el historial de movimientos e ingresos, fechas y ubicaciones.

2. Carga de datos: se recibe por teclado la cantidad de piezas, el tipo de pieza (A o B) y la ubicación en coordenadas polares que tendrán éstas dentro de un área de almacenaje. A partir de estos datos, el brazo robótico ubica las piezas en sus lugares correspondientes. El tiempo que demora el brazo en buscar una pieza desde el sector de ingreso y colocarla en la posición que se desea está simulado y corresponde a una función que genera un delay de unos 8 segundos. Se muestran en pantalla los datos referentes a cada pieza y se representan los diferentes tipos mediante dos círculos de color rojo (pieza tipo A) y azul (pieza tipo B). Una vez finalizado el almacenaje, las mismas pueden observarse distribuidas dentro del área de trabajo. Se permite al usuario volver a cargar nuevas piezas a almacenar, si así lo desea. En caso contrario se procede a la próxima etapa.

3. Movimiento de los elementos existentes: pueden reubicarse las piezas de a una por vez, en cualquier ubicación, seleccionándolas por orden de ingreso y dándoles las nuevas coordenadas. En esta instancia cualquier pieza puede ubicarse en cualquier lugar sin importar que el tipo de pieza concuerde con el área preestablecida para las de su tipo. Así, por ejemplo, una pieza tipo A ingresada con coordenadas (150; 50º) en el sector para las de su clase, puede moverse a cualquier ubicación (80; 120º), incluso si ésta pertenece al sector para las piezas tipo B.

4. Cálculos y datos para los movimientos: en esta etapa se realizan los cálculos necesarios para

que el movimiento de la pieza desde su posición original a la posición de destino sea en línea recta, o lo más linealmente posible. Además de los cálculos representativos de la situación real, en la cual la trayectoria de movimiento describía un arco, se realizan los cálculos para solucionar esto de manera que el movimiento sea recto. Ambas trazas se calculan y se visualizan en pantalla al mover una pieza para poder compararlas. Trayectoria curvilínea (REAL):

A partir de las coordenadas en que se haya la pieza y las coordenadas de destino ingresadas, se realizan las diferencias de módulo y ángulo:

Dif Long: (Long origen – Long destino) Dif Ang: (Ang origen – Ang destino)

Estas diferencias son un indicador de cuánto debe moverse la pieza para llegar al destino. Debido a que el programa fue diseñado para funcionar en conjunto con el proyecto brazo robótico, hay que adaptar los cálculos a los condicionamientos del mismo. El brazo posee dos motores paso a paso, uno que gobierna el movimiento a lo largo del mismo (LONGITUD) y otro el movimiento angular (ÁNGULO).

motor 1: encargado del movimiento angular (0º_180º): Desplazamiento angular: 200 pasos ---------- 360º (1 giro) 1.8º x paso


9

180º 100 pasos. motor 2: encargado del movimiento radial (0_200): Desplazamiento angular: 48 pasos ---------- 360º (1 giro) 7.5º x paso 48 pasos ---------------- (long 1mm) 1 paso 0.02083 mm.

A partir de estos datos se conoce la cantidad de pasos necesarios que tendrá que realizar cada motor para llevar la pieza en cuestión al destino propuesto. Para lograrlo, las diferencias de módulo y ángulo obtenidas anteriormente se traducen a pasos de motor 1 y motor 2. Si la cantidad de pasos que debe realizar uno de los motores es positiva el motor girará en un sentido y si ésta es negativa lo hará en sentido opuesto. En el caso de que alguna de las diferencias sea 0, sólo trabajará uno de los motores debido a que la distancia o el ángulo de destino coincidirá con el de origen. Por ejemplo, mover una pieza desde (50; 30º) a (120; 30º) o mover otra desde (70; 160º) a (70; 40º). Para que el movimiento de la pieza sea lo más lineal posible se alterna el funcionamiento entre los motores. Para esto, se busca una relación entre la cantidad de pasos que deben realizar el motor 1 y el 2. La relación se obtiene de dividir la mayor de las cantidades de pasos de uno de los motores sobre la menor:

Rel: Cant mayor de pasos_

Cant menor de pasos

El número obtenido indica que por cada paso que deba realizar el motor cuya cantidad de pasos sea menor, el otro motor debe realizar una cantidad x de pasos, donde x es igual a la relación que se obtuvo. De esta manera, se alternan los pasos entre los motores para lograr una aproximación más directa y más lineal de la pieza desde la posición original hacia la de destino. En caso de que la menor cantidad de pasos sea 0, la relación se supone 1 (porque no se puede dividir por cero) y sólo uno de los motores realizará movimiento. Esta etapa es la más importante ya que en ella se obtienen los datos que necesitará el PIC que comanda los movimientos de ambos motores. Trayectoria rectilínea (IDEAL):

Para lograr que el desplazamiento de la pieza sea sobre una recta hay que tener en cuenta el ángulo que forma la posición de origen (donde se halla la pieza) con la de destino, el problema es que este ángulo no está referenciado al sistema sobre el que se mueve el brazo, por lo que es desconocido y hay que calcularlo. Como los datos con los que se cuenta son las coordenadas polares correspondientes a la posición de origen y la de destino, hay que transformar éstas a coordenadas rectangulares:


10

Como ejemplo, se realizan los cálculos a partir del gráfico anterior. A partir de las posiciones de origen y destino de una pieza, cuyas coordenadas polares son conocidas (α; ℓ1) y (β; ℓ2), éstas se convierten a coordenadas rectangulares utilizando las siguientes relaciones trigonométricas:

Cos α = x1

ℓ1 Cos β = x2

ℓ2 Sen α = y1

ℓ1 Sen β = y2

ℓ2

Una vez obtenidos los pares de coordenadas rectangulares (x1; y1) y (x2; y2), se procede al cálculo del ángulo φ. Éste es de extrema importancia y debe ser respetado a medida que la pieza avanza si se desea que la trayectoria sea en línea recta. Para su cálculo:

Tang φ = (y2 – y1) (x2 – x1)

Para lograr que la ficha describa una trayectoria recta, el soft realiza incrementos sobre el eje de las abscisas a partir de la posición de inicio y calcula la altura correspondiente a este incremento respetando el ángulo φ calculado anteriormente:


11

Así, para los incrementos (p1, p2, p3….) y sus correspondientes alturas (o1, o2, o3….) la sucesión de puntos calculados formarán una recta que sirve de guía para el trayecto de la ficha. Cuando se usan las funciones trigonométricas en Turbo C++, hay que tener la precaución de hacer una conversión del ángulo de sexagesimal a π radianes.

5. Gráficos de trayectoria lineal y curvilínea: en esta etapa se muestra en pantalla cómo la pieza

seleccionada llega a destino. A partir de los cálculos efectuados con anterioridad, se plasman puntos que representan la posición de la ficha a medida que se va moviendo. Para poder observar y controlar la velocidad con que la pieza se desplaza, las funciones a cargo de los movimientos exigen que se presione una tecla, antes de completar el movimiento. De esta forma, la persona puede corroborar que la ficha se está moviendo correctamente. Las trayectorias (rectilínea y curvilínea) se grafican con distinto color. Una vez que ambas trayectorias (real e ideal) llegan al destino, se coloca la ficha en ese punto eliminando la que se encontraba en la posición de inicio.

6. Guardado en archivo historial y fin de ejecución: los movimientos efectuados con anterioridad se registran en el archivo de texto creado/abierto al inicio de la ejecución del soft. En él se guardan la pieza seleccionada, su ubicación original y la nueva, junto con la fecha y hora correspondientes al movimiento de la pieza. Por último, el soft da la posibilidad de realizar otros movimientos cerrando la aplicación en caso de que no se desee efectuar más cambios.


12

DIAGRAMA DE FLUJO:

CREA/ABRE ARCHIVO .TXT

HABILITA DRIVERS VIDEO

GRAFICA FONDO DE PANTALLA

CANT. DE ELEMENTOS

ESC. EN ARCHIVO LOS DATOS

CLASE Y COORDENADAS

GRAFICA LAS PIEZAS

NO

SI

FIN DE PROGRAMA

CIERRA ARCHIVO .TXT Y LIBRERÍA GRAFICA

ESC. EN ARCHIVO EL MOVIMIENTO

CALCULO Y GRAFICA TRAYECTORIA CURVA

CALCULO Y GRAFICA TRAYECTORIA RECTA

CALCULO PASOS DE MOTOR

DESTINO

LISTA ELEM. CARGADOS

ELECCION PIEZA A MOVER

SI

NO CANT. ELEM = 0?

INGRESAR MAS?

MOVER OTRA?

SI

SI

NO


13

RESULTADOS DE LAS PRUEBAS

El programa no se pudo implementar en su totalidad junto con el brazo robótico debido a que el mismo perdió funcionalidad por el paso del tiempo y por no haber recibido mantenimiento. Sin embargo, el programa corre simulando los tiempos del brazo y respetando las relaciones pasos-giro para cada motor.

CONCLUSIONES

I. El hecho de que para determinados movimientos la trayectoria de la pieza no sea una línea recta se debe a que la relación entre las cantidades de pasos se redondea matemáticamente, por lo que al no ser exacta genera no linealidad.

II. Otra razón es que los motores tienen entre sí diferente cantidad de engranes, diferente cantidad de pasos y relaciones distintas. Para un óptimo movimiento en línea recta desde un origen a un destino, se deberían usar motores con igual cantidad de pasos y con una relación de uno.

III. Otra forma de realizar una trayectoria en línea recta, que es la presentada como solución al problema de ingeniería, consiste en calcular la sucesión de puntos que conforman la recta que une los puntos de inicio y destino. La ubicación de estos puntos se puede obtener fácilmente calculando trigonométricamente el ángulo que forma la línea de trayectoria con la horizontal y manteniéndolo a medida que se recorre la recta hasta llegar al destino. La ubicación de cada uno de estos puntos, que consiste en coordenadas rectangulares, se transformará a coordenadas polares y luego a sus equivalentes pasos de motor para que la PC transmita y que la pieza se desplace en línea recta.

La implementación del software final se logró luego de varias pruebas y una amplia investigación acerca de la librería y herramientas graficas que posee Borland C++ versión 3.0. Sin la utilización de las mismas, el desarrollo de un soft que trate de representar gráficamente movimientos en tiempo real no resultaría simbólico y carecería de sentido.


14

ANEXOS:

LISTADOS DE PROGRAMAS

Programa prototipo: #include<stdio.h> #include<stdlib.h> #include<conio.h> #include<dos.h> #include<string.h> #include <time.h> zona(); int ubicacion(int r,int t,char c,int x, int y); datos(); main() { int cant,i; int dato1[20],dato2[20]; char tipo[20]; char datos[40]; int coord[40]; int xo,yo; int f,g,p; int k=0,l=0; int n=0,m=8,x,y,w,h; char c,q; char nom[20]; FILE *fp; time_t timer; struct tm *tblock; clrscr(); fp=fopen("archivo.txt","r"); if (fp==NULL) { printf("NO SE ENCONUENTRA ARCHIVO.TXT - SERA CREADO .\n"); fp=fopen("archivo.txt","w"); } else { fp=fopen("archivo.txt","a"); } getch(); flushall(); clrscr(); //printf("cant elementos :\n"); //scanf("%d",&cant); zona(); do { // zona();


15

gotoxy(1,25); printf("CANTIDAD DE ELEMENTOS:\n"); scanf("%d",&cant); for(i=0;i<=cant-1;i++) { do { // normvideo(); //textbackground(0);textcolor(7); gotoxy(1,26); printf("SELECCIONE LA CLASE: (A) O (B) "); c=getchar(); } while((c!='a')&&(c!='b')); flushall(); tipo[i]=c; datos[k]=c; k++; printf("COORDENADAS:\n"); if(c=='a') { do { for(h=28;h<40;h++) { gotoxy(1,h);clreol(); } gotoxy(1,28); printf("A: 0 < x < 21 Y 0 < y < 20 \n"); scanf("%d",&f); scanf("%d",&g); // dato2[i]=g; flushall(); } while( (f<=0)||(f>=21)||(g<=0)||(g>=21) ); dato1[i]=f; dato2[i]=g; coord[l]=f; l++; coord[l]=g; l++; } if(c=='b') { do { for(h=28;h<40;h++) { gotoxy(1,h);clreol(); } gotoxy(1,28); printf("B: 20 < x < 41 Y 0 < y < 20 \n"); flushall(); scanf("%d",&f); scanf("%d",&g); // dato2[i]=g; flushall(); } while( (f<=21)||(f>=41)||(g<=0)||(g>=21) );


16

dato1[i]=f; dato2[i]=g; coord[l]=f; l++; coord[l]=g; l++; } } // psppspsps clrscr(); //zona(); //cprintf("\n\nINGRESE LAS COORDENADAS CORRESPONDIENTES:"); //printf("\n"); //scanf("%d%d",&x,&y); for(i=0;i<=cant-1;i++) { c=tipo[i]; x=dato1[i]; y=dato2[i]; fprintf(fp,"TIPO: %c - COORDENADAS: ( %d ; %d )",c,x,y); /* toma la hora */ timer = time(NULL); /* convierte fecha/hora a una estructura */ tblock = localtime(&timer); // printf("Fecha y Hora actual: %s", asctime(tblock)); fprintf(fp," - FECHA: %s\n",asctime(tblock)); ubicacion(n,m,c,x,y); n+2; m++; } do{ gotoxy(1,35); cprintf("DESEA REALIZAR OTRO INGRESO ? S/N: "); q=getchar(); }while((q!='n')&&(q!='s')); if(q=='n') w=0; if(q=='s') w=1; for(h=24;h<40;h++) { gotoxy(1,h);clreol(); } }while(w==1); gotoxy(1,23); printf("\n ELEMENTOS CARGADOS:\n"); for(i=0;i<=k-1;i++) { printf("%d: %c - %d - %d\n",i+1,datos[i],coord[i*2],coord[i*2+1]); } do { do{ printf("INDIQUE EL NUMERO DE LA PIEZA A MOVER:");


17

scanf("%d",&p); }while( ( p<=0) || ( p > k ) ); printf("INDIQUE LA POSICION DE DESTINO:"); scanf("%d",&x); scanf("%d",&y); i=p-1; c=datos[i]; xo=coord[i*2]; yo=coord[i*2+1]; /* nuevas coordenadas */ coord[i*2]=x; coord[i*2+1]=y; gotoxy(50-xo,22-yo); textbackground(0); textcolor(1+128); if(c=='a') { cprintf("-"); } if(c=='b') { textcolor(4+128); cprintf(""); } delay(5000); //aca espero q llegue la pieza al destino gotoxy(50-xo,22-yo); textbackground(0); textcolor(7); cprintf("°"); gotoxy(50-x,22-y); //posicion final textcolor(1); if(c=='a') { cprintf("-"); } if(c=='b') { textcolor(4); cprintf(""); } textbackground(0); textcolor(7); do{ gotoxy(1,35); cprintf("\nDESEA MOVER OTRA PIEZA ? S/N: "); q=getchar(); }while((q!='n')&&(q!='s')); if(q=='n') w=0; if(q=='s') w=1; }while(w==1);


18

fclose(fp); getch(); return(0); } //--------------------FIN DE PROGRAMA-------------------------------// zona() { int i,j; textbackground(0); textcolor(7); for(j=0;j<20;j++) { for(i=0;i<40;i++) { gotoxy(10+i,2+j); cprintf("°"); } } textbackground(0); textcolor(9); gotoxy(8,2);printf("20"); gotoxy(8,12);printf("10"); gotoxy(9,22);printf("40"); gotoxy(41,22);printf("9"); gotoxy(55,4);printf("CLASE A: "); textcolor(1);cprintf("-"); gotoxy(55,5);printf("CLASE B: "); textcolor(4);cprintf(""); textbackground(0); textcolor(7); return 0; } int ubicacion(int r,int t,char c,int xo,int yo) { int vec[20],k; int tiempo=30000; vec[r]=xo; vec[r+1]=yo; textbackground(15); textcolor(9); gotoxy(55,7);cprintf("CLASE / UBICACION"); gotoxy(55,t);cprintf(" "); gotoxy(57,t);cprintf(" %c : %d %d",c,vec[r],vec[r+1]); gotoxy(50-xo,22-yo); textbackground(0); textcolor(1+128); if(c=='a') { cprintf("-"); } if(c=='b') { textcolor(4+128); cprintf(""); }


19

//for(k=0;k<tiempo;k++) //{} delay(5000); //aca espero q llegue la pieza gotoxy(50-xo,22-yo); textcolor(1); if(c=='a') { cprintf("-"); } if(c=='b') { textcolor(4); cprintf(""); } textbackground(0); textcolor(7); return 0; } Programa final: #include<stdio.h> #include<stdlib.h> #include<conio.h> #include<dos.h> #include<string.h> #include<time.h> #include<graphics.h> #include<math.h> #include<alloc.h> int graficar(void); int zona(void); int ubicacion(int r,int t,char c,double x, double y,void far *buf[100],int pos); void salvar_pantalla(void far *buf[100],double xo,double yo,int pos); void reestablecer_pantalla(void far *buf[100],double xo,double yo,int pos); main() { int cant,i; double dato1[20],dato2[20]; char tipo[20]; char datos[40]; double coord[40]; double xo,yo; double lon,ang,ang2; int p; double f,g; double hypaux,g2,f2,yaux,ff,gf,angf,ginter,ginter2; int k=0,l=0; int n=0,m=3; int w,h; double x,y; int v; void far *ptr[100]; int pp=0; char c,q; char nom[20]; FILE *fp; double alfa,alfa2,x1,y1,x2,y2,p1=0,o1=0; time_t timer; struct tm *tblock;


20

double pasos_long,pasos_ang,relacion,pasos,fraccion,integer; int pa=0,pl=0; clrscr(); fp=fopen("archivo4.txt","r"); if (fp==NULL) { printf("NO SE ENCONUENTRA ARCHIVO4.TXT - SERA CREADO .\n"); fp=fopen("archivo4.txt","w"); } else { fp=fopen("archivo4.txt","a"); } getch(); flushall(); clrscr(); graficar(); /* funcion q habilita el modo grafico */ zona(); /* funcion q contine el fondo de pantalla */ do { setfillstyle(EMPTY_FILL, getmaxcolor()); /* como clreol() */ bar3d(0,250, getmaxx(), getmaxy(), 0, 1); /* para la mitad inferiror de la pantalla */ outtextxy(10,260, "CANTIDAD DE ELEMENTOS: "); gotoxy(30,17); scanf("%d",&cant); for(i=0;i<=cant-1;i++) { do { highvideo(); textbackground(0);textcolor(7); setfillstyle(EMPTY_FILL, getmaxcolor()); /* como clreol() */ bar3d(0,250, getmaxx(), getmaxy(), 0, 1); /* para la mitad de la pantalla */ outtextxy(10,275,"SELECCIONE LA CLASE: (A) O (B) "); gotoxy(40,18);c=getchar(); } while((c!='a')&&(c!='b')); flushall(); tipo[i]=c; datos[k]=c; k++; if(c=='a') { do { setfillstyle(EMPTY_FILL, getmaxcolor()); // como clreol() bar3d(0,250, getmaxx(), getmaxy(), 0, 1); // para la mitad inferiror de la pantalla


21

outtextxy(10,290, "COORDENADAS:"); outtextxy(10,300,"A: 0 < long < 200 Y 0 < ang < 90¦ "); gotoxy(40,20);scanf("%lf",&lon); gotoxy(40,21);scanf("%lf",&ang); flushall(); } while( (lon<=0)||(lon>=201)||(ang<=0)||(ang>=91) ); dato1[i]=lon; dato2[i]=ang; coord[l]=lon; l++; coord[l]=ang; l++; } if(c=='b') { do { setfillstyle(EMPTY_FILL, getmaxcolor()); // como clreol() bar3d(0,250, getmaxx(), getmaxy(), 0, 1); // para la mitad de la pantalla outtextxy(10,290, "COORDENADAS:"); outtextxy(10,300,"B: 0 < long < 200 Y 90¦ < ang < 180¦ "); flushall(); gotoxy(40,20); scanf("%lf",&lon); gotoxy(40,21); scanf("%lf",&ang); flushall(); } while( (lon<=0)||(lon>=201)||(ang<=90)||(ang>=191) ); dato1[i]=lon; dato2[i]=ang; coord[l]=lon; l++; coord[l]=ang; l++; } } /* cierre del lazo for de cantidad */ for(i=0;i<=cant-1;i++) { c=tipo[i]; x=dato1[i]; y=dato2[i]; /* escribe en el archivo de texto el tipo y coordenadas de la pieza */ fprintf(fp,"TIPO: %c - COORDENADAS POLARES: ( %0.0lf ; %0.0lf )",c,x,y); /* toma la hora y la guarda en un puntero *timer */ timer = time(NULL); /* convierte fecha/hora a una estructura */ tblock = localtime(&timer);


22

/* escribe en el archivo de texto la fecha */ fprintf(fp," - FECHA: %s\n",asctime(tblock)); /* asctime convierte el tiempo almacenado como una estructura en *tblock a un string de 26 caracteres. La cadena de 26 caracteres termina en un caracter nueva linea (\n) y un caracter nulo (\0). es de la forma: DDD MMM dd hh:mm:ss YYYY\n\0 donde: DDD = Day (Mon, Tue, Wed, etc.) MMM = Month (Jan, Feb, Mar, etc.) dd = Date (1, 2, ..., 31) hh = Hour (1, 2, ..., 24) mm = Minutes (1, ..., 59) ss = Seconds (1, ..., 59) YYYY = Year Mon Oct 20 11:31:54 1952\n\0 */ ubicacion(n,m,c,x,y,ptr,pp); /* funcion que grafica las piezas */ n+2; m++; pp++; } do{ outtextxy(10,435, "DESEA REALIZAR OTRO INGRESO ? S/N: "); gotoxy(40,28); q=getchar(); }while((q!='n')&&(q!='s')); if(q=='n') w=0; if(q=='s') w=1; setfillstyle(EMPTY_FILL, getmaxcolor()); /* como clreol() */ bar3d(0,250, getmaxx(), getmaxy(),0, 1); /* para la mitad de la pantalla */ }while(w==1); outtextxy(10,260, " ELEMENTOS CARGADOS: PRESIONE UNA TECLA PARA CONTINUIAR... "); for(i=0;i<=k-1;i++) { gotoxy(23,18+i); printf("%d: %c - %0.0lf - %0.0lf\n",i+1,datos[i],coord[i*2],coord[i*2+1]); outtextxy(450,20, "N¦"); gotoxy(58,3+i);printf("%d",i+1); } getch(); do{ do{ setfillstyle(EMPTY_FILL, getmaxcolor()); /* como clreol() */


23

bar3d(0,250, getmaxx(), getmaxy(),0, 1); /* para la mitad de la pantalla */ outtextxy(10,275, " INDIQUE EL NUMERO DE LA PIEZA A MOVER:"); gotoxy(45,18);scanf("%d",&p); }while( ( p <=0 )||( p>k ) ) ; outtextxy(10,290," INDIQUE EL DESTINO (long y ang):"); gotoxy(45,19); scanf("%lf",&x); gotoxy(45,20); scanf("%lf",&y); i=p-1; c=datos[i]; xo=coord[i*2]; yo=coord[i*2+1]; /* nuevas coordenadas */ coord[i*2]=x; coord[i*2+1]=y; /*calculos de pasos que cada motor debe realizar*/ setfillstyle(EMPTY_FILL, getmaxcolor()); bar3d(450,250,getmaxx(), getmaxy(), 0, 1); outtextxy(460,260,"PASOS DE CADA MOTOR:"); outtextxy(460,275,"LONG: 1mm ------ 48p"); //1 vuelta del motor es 1 milim outtextxy(460,285,"ANG: 180 ------ 100p");//1 vuelta del motor son 200 pasos outtextxy(460,308,"DIF LONG: "); gotoxy(70,20);printf("%0.0lf ",xo-x); outtextxy(460,325," 200 ------ 48px200"); gotoxy(60,22);printf("%0.0lf ------ %0.0lf",xo-x,(xo-x)*48*200/200); pasos_long= (xo-x)*48*200/200; outtextxy(460,357,"DIF ANG: "); gotoxy(70,23);printf("%0.0lf ",yo-y); outtextxy(460,374," 180 ------ 100p"); gotoxy(60,25);printf("%0.0lf ------ %0.0lf",yo-y,(yo-y)*100/180); pasos_ang= (yo-y)*100/180; /*Calculo ideal para trayectoria recta*/ alfa= (yo*M_PI)/180; //sexag a rads x1= xo * cos (alfa); y1= xo * sin (alfa); alfa= (y*M_PI)/180; x2= x * cos(alfa); y2= x * sin(alfa); p1=0; if((x2>=x1)&&(y2>=y1)) {


24

alfa = atan ((y2 - y1)/(x2 - x1)) ; // radianes do{ p1=p1+1; o1 = p1*tan(alfa); putpixel(230+x1+p1, 220-y1-o1, 2); getch(); }while (x2>x1+p1) ; } if((x2>=x1)&&(y2<=y1)) { alfa = atan ((y1 - y2)/(x2 - x1)) ; // radianes do{ p1=p1+1; o1 = p1*tan(alfa); putpixel(230+x1+p1, 220-y1+o1, 2); getch(); }while (x2>x1+p1) ; } if((x2<=x1)&&(y2>=y1)) { alfa = atan ((y2 - y1)/(x1 - x2)) ; // radianes do{ p1=p1+1; o1 = p1*tan(alfa); putpixel(230+x1-p1, 220-y1-o1, 2); getch(); }while (x2<x1-p1) ; } if((x2<=x1)&&(y2<=y1)) { alfa = atan ((y1 - y2)/(x1 - x2)) ; // radianes do{ p1=p1+1; o1 = p1*tan(alfa); putpixel(230+x1-p1, 220-y1+o1, 2); getch(); }while (x2<x1-p1) ; } /*Relacion entre pasos de los motores de Long y Angulo*/ if(fabs(pasos_long) > fabs(pasos_ang) ) { pasos=1; if(pasos_ang ==0) { relacion=1; } else { relacion= pasos_long / pasos_ang ; } } if( fabs(pasos_long) < fabs(pasos_ang) ) { pasos=0;


25

pa=0; if(pasos_long ==0) { relacion=1; } else { relacion= pasos_ang / pasos_long ; } } /*redondeo de la relacion*/ fraccion = modf(relacion, &integer); fraccion = fraccion*10; if( (( fraccion > 5)&&(fraccion >0)) || (( fraccion >= -5)&&(fraccion <0)) ) { relacion = ceil(relacion); } if( (( fraccion <= 5)&&(fraccion >0)) || (( fraccion < -5)&&(fraccion <0)) ) { relacion = floor(relacion); } if(pasos==0) { if((pasos_long == 0)&&(pasos_ang > 0)) { pl=0; do { ang2= ((yo-pa*1.8)*M_PI)/180; f= (xo-pl*0.021) * cos(ang2) ; g= (xo-pl*0.021) * sin(ang2) ; putpixel(230+f, 220-g, 13); getch(); outtextxy(460,420,"Datos al pic: "); gotoxy(60,28); printf("Lon:%dp Ang:%dp",pl,pa); gotoxy(60,29); printf("Rel:%5.1lf",relacion); pa=pa+relacion; // pl=pl+1; }while(pa<=pasos_ang); } if((pasos_long == 0) && (pasos_ang < 0)) { pl=0; do { ang2= ((yo-pa*1.8)*M_PI)/180; f= (xo-pl*0.021) * cos(ang2) ; g= (xo-pl*0.021) * sin(ang2) ; putpixel(230+f, 220-g, 13); getch(); outtextxy(460,420,"Datos al pic: "); gotoxy(60,28); printf("Lon:%dp Ang:%dp",pl,pa); gotoxy(60,29); printf("Rel:%5.1lf",relacion); pa=pa-relacion; // pl=pl-1;


26

}while(pa>=pasos_ang); } if((pasos_long > 0) && (pasos_ang > 0)) /*100;70 a 50;30*/ { pl=1; do { ang2= ((yo-pa*1.8)*M_PI)/180; f= (xo-pl*0.021) * cos(ang2) ; g= (xo-pl*0.021) * sin(ang2) ; putpixel(230+f, 220-g, 13); getch(); outtextxy(460,420,"Datos al pic: "); gotoxy(60,28); printf("Lon:%dp Ang:%dp",pl,pa); gotoxy(60,29); printf("Rel:%5.1lf",relacion); pa=pa+relacion; pl=pl+1; }while(pl<=pasos_long); } if((pasos_long < 0) && (pasos_ang < 0)) /*50,30 a 100.70*/ { pl=-1; do { ang2= ((yo-pa*1.8)*M_PI)/180; f= (xo-pl*0.021) * cos(ang2) ; g= (xo-pl*0.021) * sin(ang2) ; putpixel(230+f, 220-g, 13); getch(); outtextxy(460,420,"Datos al pic: "); gotoxy(60,28); printf("Lon:%dp Ang:%dp",pl,pa); gotoxy(60,29); printf("Rel:%5.1lf",relacion); pa=pa-relacion; pl=pl-1; }while(pl>=pasos_long); } if((pasos_long < 0) && (pasos_ang > 0)) /*50.70 a 100.30*/ { pl=-1; do { ang2= ((yo-pa*1.8)*M_PI)/180; f= (xo-pl*0.021) * cos(ang2) ; g= (xo-pl*0.021) * sin(ang2) ; putpixel(230+f, 220-g, 13); getch(); outtextxy(460,420,"Datos al pic: "); gotoxy(60,28); printf("Lon:%dp Ang:%dp",pl,pa); gotoxy(60,29); printf("Rel:%5.1lf",relacion); pa=pa-relacion; pl=pl-1; }while(pl>=pasos_long); } if((pasos_long > 0) && (pasos_ang < 0)) /*100.30 a 50.70*/ { pl=1; do { ang2= ((yo-pa*1.8)*M_PI)/180; f= (xo-pl*0.021) * cos(ang2) ;


27

g= (xo-pl*0.021) * sin(ang2) ; putpixel(230+f, 220-g, 13); getch(); outtextxy(460,420,"Datos al pic: "); gotoxy(60,28); printf("Lon:%dp Ang:%dp",pl,pa); gotoxy(60,29); printf("Rel:%5.1lf",relacion); pa=pa+relacion; pl=pl+1; }while(pl<=pasos_long); } } if(pasos==1) { pa=0; pl=0; if((pasos_long > 0)&&(pasos_ang == 0)) { do { ang2= ((yo-pa*1.8)*M_PI)/180; f= (xo-pl*0.021) * cos(ang2) ; g= (xo-pl*0.021) * sin(ang2) ; putpixel(230+f, 220-g, 13); getch(); outtextxy(460,420,"Datos al pic: "); gotoxy(60,28); printf("Lon:%dp Ang:%dp",pl,pa); gotoxy(60,29); printf("Rel:%5.1lf",relacion); pl=pl+relacion; // pa=pa+1; }while(pl<=pasos_long); } if((pasos_long < 0) && (pasos_ang == 0)) /*50,30 a 100.70*/ { pl=0; do { ang2= ((yo-pa*1.8)*M_PI)/180; f= (xo-pl*0.021) * cos(ang2) ; g= (xo-pl*0.021) * sin(ang2) ; putpixel(230+f, 220-g, 13); getch(); outtextxy(460,420,"Datos al pic: "); gotoxy(60,28); printf("Lon:%dp Ang:%dp",pl,pa); gotoxy(60,29); printf("Rel:%5.1lf",relacion); pl=pl-relacion; // pa=pa-1; }while(pl>=pasos_long); } if((pasos_long > 0) && (pasos_ang > 0)) /*100.80 a 50.70*/ { do { pl=pl+relacion; pa=pa+1; ang2= ((yo-pa*1.8)*M_PI)/180; f= (xo-pl*0.021) * cos(ang2) ; g= (xo-pl*0.021) * sin(ang2) ; putpixel(230+f, 220-g, 13); getch(); outtextxy(460,420,"Datos al pic: "); gotoxy(60,28); printf("Lon:%dp Ang:%dp",pl,pa);


28

gotoxy(60,29); printf("Rel:%5.1lf",relacion); }while(pa<=pasos_ang); } if((pasos_long < 0) && (pasos_ang < 0)) /*100.70 a 150.80*/ { do { pl=pl-relacion; pa=pa-1; ang2= ((yo-pa*1.8)*M_PI)/180; f= (xo-pl*0.021) * cos(ang2) ; g= (xo-pl*0.021) * sin(ang2) ; putpixel(230+f, 220-g, 13); getch(); outtextxy(460,420,"Datos al pic: "); gotoxy(60,28); printf("Lon:%dp Ang:%dp",pl,pa); gotoxy(60,29); printf("Rel:%5.1lf",relacion); }while(pa>=pasos_ang); } if((pasos_long < 0) && (pasos_ang > 0)) /*50.80 a 100.70 */ { do { pl=pl+relacion; pa=pa+1; ang2= ((yo-pa*1.8)*M_PI)/180; f= (xo-pl*0.021) * cos(ang2) ; g= (xo-pl*0.021) * sin(ang2) ; putpixel(230+f, 220-g, 13); getch(); outtextxy(460,420,"Datos al pic: "); gotoxy(60,28); printf("Lon:%dp Ang:%dp",pl,pa); gotoxy(60,29); printf("Rel:%5.1lf",relacion); }while(pa<=pasos_ang); } if((pasos_long > 0) && (pasos_ang < 0)) /*100.70 a 50.80*/ { do { pl=pl-relacion; pa=pa-1; ang2= ((yo-pa*1.8)*M_PI)/180; f= (xo-pl*0.021) * cos(ang2) ; g= (xo-pl*0.021) * sin(ang2) ; putpixel(230+f, 220-g, 13); getch(); outtextxy(460,420,"Datos al pic: "); gotoxy(60,28); printf("Lon:%dp Ang:%dp",pl,pa); gotoxy(60,29); printf("Rel:%5.1lf",relacion); }while(pa>=pasos_ang); } } /* escribe en el archivo de texto el movimiento de la pieza */ fprintf(fp,"LA PIEZA %c SE MOVIO DE: ( %0.0lf ; %0.0lf ) A: ( %0.0lf ; %0.0lf ) ",c,xo,yo,x,y); /* toma la hora y la guarda en un puntero *timer */ timer = time(NULL);


29

/* convierte fecha/hora a una estructura */ tblock = localtime(&timer); /* escribe en el archivo de texto la fecha */ fprintf(fp," - FECHA: %s\n",asctime(tblock)); ang2= (yo*M_PI)/180; f= xo * cos(ang2) ; g= xo * sin(ang2) ; xo=f; yo=g; reestablecer_pantalla(ptr,xo,yo,i); /* reestablece la pntalla */ getch(); reestablecer_pantalla(ptr,xo,yo,i); /* reestablece la pantalla */ //delay(8000); /* aca espero q llegue la pieza al destino */ ang2= (y*M_PI)/180; f= x * cos(ang2) ; g= x * sin(ang2) ; x=f; y=g; line(230+xo,220-yo,230+x,220-y); /* dibuja una linea de trayectoria */ if(c=='a') { salvar_pantalla(ptr,x,y,i); /* guarda la actual pantalla */ setfillstyle(SOLID_FILL, 4); circle(230+x,220-y,5); floodfill(230+x,220-y, getmaxcolor()); } if(c=='b') { salvar_pantalla(ptr,x,y,i); /* guarda la actual pantalla */ setfillstyle(SOLID_FILL, 1); circle(230+x,220-y,5); floodfill(230+x,220-y, getmaxcolor()); } do{ outtextxy(10,385," DESEA MOVER OTRA PIEZA ? S/N:"); gotoxy(45,25); q=getchar(); }while((q!='n')&&(q!='s')); if(q=='n') w=0; if(q=='s') w=1; }while(w==1); fclose(fp); /* cierra el archivo texto */


30

closegraph(); /* cierra el sistema grafico */ return(0); /* cierra el programa devolviendo el valor cero */ } /*---------------------- FIN DE PROGRAMA-------------------------*/ int graficar(void) { /* pedido auto deteccion */ int gdriver = DETECT, gmode, errorcode; /* inicializa modo grafico, variables locales */ initgraph(&gdriver, &gmode, "d:\\marce\\tc\\bgi"); /* lee resultado de inicializacion */ errorcode = graphresult(); if (errorcode != grOk) /* ocurrio un error */ { printf("Graphics error: %s\n", grapherrormsg(errorcode)); printf("Press any key to halt:"); getch(); exit(1); /* termina con codigo de error */ } return(0); } int zona(void) { int i; setfillstyle(EMPTY_FILL, getmaxcolor()); bar3d(0,0, getmaxx(), getmaxy(), 10, 1); bar3d(0,250,getmaxx(), getmaxy(), 0, 1); setfillstyle(SOLID_FILL, 8); bar(420,210,430,220); setfillstyle(SOLID_FILL, 2); pieslice(230, 220, 0, 180, 10); setfillstyle(EMPTY_FILL, 2); for(i=2;i<=20;i++) { pieslice(230, 220, 0, 180, 10*i); } line(230,220,230,20); outtextxy(400,230, "(200;0§)"); outtextxy(210,230, "(0;0§)"); outtextxy(10,230, "(200;180§)"); outtextxy(210,10, "(200;90§)"); outtextxy(10,20, "CLASE A:"); outtextxy(10,40, "CLASE B:"); setfillstyle(SOLID_FILL, 4); circle(90,23,5); circle(90,43,5); floodfill(90, 23, getmaxcolor()); setfillstyle(SOLID_FILL, 1); floodfill(90, 43, getmaxcolor());


31

setfillstyle(EMPTY_FILL, 2); line(10,250,200,250); return 0; } int ubicacion(int r,int t,char c,double xo,double yo,void far *ptr[100],int pos) { double vec[20]; double f,g,ang2; vec[r]=xo; vec[r+1]=yo; outtextxy(460,20, " CLASE / UBICACION"); gotoxy(62,t);printf(" %c : %0.0lf %0.0lf",c,vec[r],vec[r+1]); ang2= (yo*M_PI)/180; // porq el ang f= xo * cos(ang2) ; // debe ser en g= xo * sin(ang2) ; // radianes xo=f; yo=g; salvar_pantalla(ptr,xo,yo,pos); /* guardo la pantalla actual */ circle(230+xo,220-yo,5); // delay(8000); /* aca espero q llegue la pieza, // es el tiempo q tarda el brazo */ if(c=='a') { setfillstyle(SOLID_FILL, 4); circle(230+xo,220-yo,5); floodfill(230+xo,220-yo, getmaxcolor()); } if(c=='b') { setfillstyle(SOLID_FILL, 1); circle(230+xo,220-yo,5); floodfill(230+xo,220-yo, getmaxcolor()); } return 0; } void salvar_pantalla(void far *buf[100],double xo,double yo,int pos) { unsigned int size; /* calcula el tama¤o de la imagen */ size = imagesize(100,110 ,110,120); /* toma el tama¤o de la imagen en bytes */ if ((buf[pos] = farmalloc(size)) == NULL) { closegraph(); printf("Error: no hay espacio suficiente en memoria.\n"); exit(1); } /* toma la imagen de la pantalla a la memoria */


32

getimage(230+xo-5,220-yo-5 ,230+xo+5,220-yo+5, buf[pos]); //estos van a ser variables /* borra la imagen antigua */ putimage(230+xo-5,220-yo-5 , buf[pos], XOR_PUT); } void reestablecer_pantalla(void far *buf[100],double xo,double yo,int pos) { putimage(230+xo-5,220-yo-5 , buf[pos], COPY_PUT); farfree(buf[pos]); }

LIBRERIAS Y FUNCIONES UTILIZADAS

Archivos cabecera (Librerías):

#include<stdio.h> #include<stdlib.h> #include<conio.h> #include<dos.h> #include<string.h> #include<time.h> #include<graphics.h> #include<math.h> #include<alloc.h>

Funciones creadas:

int graficar(void); Inicializa el modo gráfico cargando el driver que corresponde a la placa de video de la PC. int zona(void); Crea los gráficos en la pantalla sobre los cuales se va a trabajar. int ubicacion(int r,int t,char c,double x, double y,void far *buf[100],int pos); A partir de los parámetros que recibe, esta función grafica en las coordenadas supuestas un circulo azul o rojo. Previamente guarda la imagen de fondo en esa posición. void salvar_pantalla(void far *buf[100],double xo,double yo,int pos); Calcula el tamaño de la imagen a guardar, toma una copia de la misma en las coordenadas deseadas y la guarda en memoria. A continuación, borra de pantalla el área correspondiente que se almacenó en memoria. void reestablecer_pantalla(void far *buf[100],double xo,double yo,int pos); Pone la imagen previamente salvada en memoria de nuevo en la pantalla y libera el bloque de memoria que la almacenaba.


33

FOTOS DE PANTALLA Para obtener fotos de pantalla utilicé Microsoft virtual PC debido a que el uso de la librería gráfica en Turbo C y las funciones correspondientes a la detección de los drivers de video e inicialización del modo gráfico se apoderan del control de la pantalla imposibilitando el uso de las aplicaciones (print screen) del sistema operativo (Windows 98/XP) sobre el cual corre el programa escrito en código C++. Programa prototipo:

Pantalla principal: se observa el área para ubicar las piezas, la referencia para identificar las piezas (A o B) y la cantidad a ingresar.


34

Elementos displayados en el área de almacenamiento y sus res pectivas coordenadas. Coordenadas de destino para la pieza que se va a reubicar.

Pieza reubicada. Posibilidad de efectuar otro movimiento.


35

Programa final:

Corresponde al inicio del programa por primera vez (creación del archivo historial).


36

Pantalla principal: muestra el área semicircular de almacenaje dividida en 2 partes, el sector de ingreso en color gris, las coordenadas y la cantidad de elementos a ingresar por teclado.

Representación de elementos cargados según clase y coordenadas ingresadas.


37

Finalización de carga de elementos.


38

Movimiento de pieza seleccionada. Los datos que se ven corresponden a los pasos que cada motor debería realizar alternadamente para mover la pieza y depositarla en su nueva ubicación. A continuación se ven las trayectorias recta (verde) y la curva (magenta):


39

Pasos necesarios para mover la pieza.


40

El destino de la ficha es el mismo tanto para la trayectoria curva como para la rectilínea.


41

Trayectoria ideal: línea recta. Trayectoria real: Arco en puntos. La pieza clase B llegó a destino.


42

Otros movimientos realizados.

Archivo de texto creado (archivo4.txt) en el cual se observa un registro de los elementos que ingresaron a la playa, junto a sus coordenadas y la fecha de ingreso, así como el movimiento de los mismos.

Documents

PROBLEMA DE INGENIERÍA - frsn.utn.edu.ar