Brazo robótico parte 2 - Facultad Regional San Nicolás

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
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
2
Técnicas Digitales III – Problema de ingeniería
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.
3
Técnicas Digitales III – Problema de ingeniería
• 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).
4
Técnicas Digitales III – Problema de ingeniería
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:
5
Técnicas Digitales III – Problema de ingeniería
Soft final:
6
Técnicas Digitales III – Problema de ingeniería
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
7
Técnicas Digitales III – Problema de ingeniería
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
8
Técnicas Digitales III – Problema de ingeniería
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:
9
Técnicas Digitales III – Problema de ingeniería
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
Sen α = y1
ℓ1
Cos β = x2
ℓ2
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:
10
Técnicas Digitales III – Problema de ingeniería
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.
11
Técnicas Digitales III – Problema de ingeniería
DIAGRAMA DE FLUJO:
CREA/ABRE ARCHIVO .TXT
HABILITA DRIVERS VIDEO
GRAFICA FONDO DE PANTALLA
CANT. DE ELEMENTOS
CLASE Y COORDENADAS
ESC. EN ARCHIVO LOS DATOS
GRAFICA LAS PIEZAS
NO
CANT. ELEM = 0?
SI
SI
SI
INGRESAR MAS?
NO
LISTA ELEM. CARGADOS
ELECCION PIEZA A MOVER
DESTINO
CALCULO PASOS DE MOTOR
CALCULO Y GRAFICA TRAYECTORIA RECTA
CALCULO Y GRAFICA TRAYECTORIA CURVA
ESC. EN ARCHIVO EL MOVIMIENTO
MOVER OTRA?
SI
NO
CIERRA ARCHIVO .TXT Y LIBRERÍA GRAFICA
FIN DE PROGRAMA
12
Técnicas Digitales III – Problema de ingeniería
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.
13
Técnicas Digitales III – Problema de ingeniería
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();
14
Técnicas Digitales III – Problema de ingeniería
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
flushall();
scanf("%d",&f);
scanf("%d",&g);
// dato2[i]=g;
flushall();
}
while( (f<=21)||(f>=41)||(g<=0)||(g>=21) );
0 < y < 20 \n");
15
Técnicas Digitales III – Problema de ingeniería
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:");
16
Técnicas Digitales III – Problema de ingeniería
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);
17
Técnicas Digitales III – Problema de ingeniería
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("");
}
18
Técnicas Digitales III – Problema de ingeniería
//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;
19
Técnicas Digitales III – Problema de ingeniería
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();
zona();
/*
/*
funcion q habilita el modo grafico
*/
funcion q contine el fondo de pantalla */
do
{
setfillstyle(EMPTY_FILL, getmaxcolor());
bar3d(0,250, getmaxx(), getmaxy(), 0, 1);
pantalla */
/* como clreol() */
/* para la mitad inferiror de la
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());
bar3d(0,250, getmaxx(), getmaxy(), 0, 1);
pantalla */
/* como clreol() */
/* para la mitad de la
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
20
Técnicas Digitales III – Problema de ingeniería
outtextxy(10,290, "COORDENADAS:");
outtextxy(10,300,"A: 0 < long < 200
gotoxy(40,20);scanf("%lf",&lon);
gotoxy(40,21);scanf("%lf",&ang);
flushall();
Y
0 < ang < 90¦ ");
}
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());
bar3d(0,250, getmaxx(), getmaxy(), 0, 1);
// como clreol()
// para la mitad de la
pantalla
outtextxy(10,290, "COORDENADAS:");
outtextxy(10,300,"B: 0 < long < 200
flushall();
gotoxy(40,20); scanf("%lf",&lon);
gotoxy(40,21); scanf("%lf",&ang);
Y
90¦ < ang < 180¦ ");
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);
*/
21
Técnicas Digitales III – Problema de ingeniería
/* 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);
n+2;
m++;
pp++;
/*
funcion que grafica las piezas
*/
}
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());
bar3d(0,250, getmaxx(), getmaxy(),0, 1);
pantalla
*/
/* como clreol()
*/
/* para la mitad de la
}while(w==1);
outtextxy(10,260, " ELEMENTOS CARGADOS:
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);
PRESIONE UNA TECLA PARA
} getch();
do{
do{
setfillstyle(EMPTY_FILL, getmaxcolor());
/* como clreol()
*/
22
Técnicas Digitales III – Problema de ingeniería
bar3d(0,250, getmaxx(), getmaxy(),0, 1);
pantalla
*/
/* para la mitad de la
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;
x1= xo * cos (alfa);
y1= xo * sin (alfa);
//sexag a rads
alfa= (y*M_PI)/180;
x2= x * cos(alfa);
y2= x * sin(alfa);
p1=0;
if((x2>=x1)&&(y2>=y1))
{
23
Técnicas Digitales III – Problema de ingeniería
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;
24
Técnicas Digitales III – Problema de ingeniería
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;
<0))
<0))
if(
(( fraccion > 5)&&(fraccion >0)) || (( fraccion >= -5)&&(fraccion
)
{
relacion = ceil(relacion);
}
if(
(( fraccion <= 5)&&(fraccion >0))
|| (( fraccion < -5)&&(fraccion
)
{
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;
25
Técnicas Digitales III – Problema de ingeniería
}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))
{
pl=1;
do
{
ang2= ((yo-pa*1.8)*M_PI)/180;
f= (xo-pl*0.021) * cos(ang2) ;
/*100.30 a 50.70*/
26
Técnicas Digitales III – Problema de ingeniería
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);
27
Técnicas Digitales III – Problema de ingeniería
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);
28
Técnicas Digitales III – Problema de ingeniería
/* 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')
if(q=='s')
w=0;
w=1;
}while(w==1);
fclose(fp);
/*
cierra el archivo texto
*/
29
Técnicas Digitales III – Problema de ingeniería
closegraph();
return(0);
}
/*
/*
cierra el sistema grafico */
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());
30
Técnicas Digitales III – Problema de ingeniería
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, "
gotoxy(62,t);printf("
ang2= (yo*M_PI)/180;
f= xo * cos(ang2) ;
g= xo * sin(ang2) ;
xo=f;
yo=g;
CLASE / UBICACION");
%c :
%0.0lf %0.0lf",c,vec[r],vec[r+1]);
// porq el ang
// debe ser en
// radianes
salvar_pantalla(ptr,xo,yo,pos);
circle(230+xo,220-yo,5);
//
//
/* guardo la pantalla actual */
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 */
31
Técnicas Digitales III – Problema de ingeniería
getimage(230+xo-5,220-yo-5 ,230+xo+5,220-yo+5, buf[pos]);
variables
/* borra la imagen antigua */
putimage(230+xo-5,220-yo-5 , buf[pos], XOR_PUT);
}
//estos van a ser
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.
32
Técnicas Digitales III – Problema de ingeniería
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.
33
Técnicas Digitales III – Problema de ingeniería
Elementos displayados en el ár ea 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.
34
Técnicas Digitales III – Problema de ingeniería
Programa final:
Corresponde
historial).
al
inicio
del
prog rama
por
primera
vez
(creación
del
archivo
35
Técnicas Digitales III – Problema de ingeniería
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.
36
Técnicas Digitales III – Problema de ingeniería
Finalización de carga de elementos.
37
Técnicas Digitales III – Problema de ingeniería
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):
38
Técnicas Digitales III – Problema de ingeniería
Pasos necesarios para mover la pieza.
39
Técnicas Digitales III – Problema de ingeniería
El destino de la ficha es el mismo tanto para la trayectoria curva como para la
rectilínea.
40
Técnicas Digitales III – Problema de ingeniería
Trayectoria ideal: línea recta. Trayectoria real: Arco en puntos. La pieza clase
B llegó a destino.
41
Técnicas Digitales III – Problema de ingeniería
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.
42