MODO GRAFICO EN C++

Para producir la imagen de video, la mayora de los miembros de la familia PC requiere un adaptador de video. Los adaptadores de video fueron diseados para el PCjr, pero inmediatamente se generaliz su uso al resto de las PCs, a tal punto que se llega a un nivel como el de VGA (Video Graphics Array) quien claramente ha demostrado ser el adaptador de video ms popular de los ltimos tiempos. Las aplicaciones de software han evolucionado gigantescamente. Si nos remontamos una o dos dcadas en el tiempo veremos que el entorno en el que giraban los programas era muy limitado y, de poseer capacidades grficas, estas eran apenas unos garabatos cuadriculados (monocromo, por supuesto). Hoy en da no nos imaginamos una aplicacin de software sin su adecuado entorno grfico (La prueba ms concisa: El dominio en el mercado de los Software for Windows). Es por este motivo que todo programador debe tener al menos una nocin de programacin grfica. Adaptadores de Video y Controladores de Grficos: El adaptador de video conecta el ordenador al monitor a travs de un chip llamado controlador de CRT. El adaptador tambin tiene un conjunto de puertos de E/S programables, una ROM generadora de caracteres y memoria RAM para almacenar informacin del visualizador. Los generadores de video operan fundamentalmente segn dos modos diferentes, llamados por IBM, modo texto y modo grfico. El modo texto solo permite visualizar caracteres (El cdigo ASCII completo), aunque hay quienes programan en este modo de una forma pseudogrfica. El modo grfico se utiliza principalmente para producir dibujos complejos, pero puede reproducir caracteres de texto con gran variedad de formas y tamaos. Ninguna funcin grfica de C puede funcionar sin un controlador de grficos en memoria. Los controladores de grficos estn contenidos en los archivos .BGI (Borland Graphics Interface), los cuales deben estar disponibles en el sistema. Los diversos drivers que Borland provee para esta versin de Turbo C se listan a continuacin: 1. CGA 2. MCGA 3. EGA 4. EGA64 (EGA de 64K) 5. EGAMONO (EGA Monocromtica) 6. IBM8514 7. HERCMONO (Hercules) 8. ATT400 (Adaptador de AT&T 6300 PC) 9. VGA 10.PC3270 (IBM 3270)

Es importante destacar que todas las declaraciones de funciones grficas, el Turbo C las realiza en un archivo llamado graphics.h que ser necesario incluir en el programa, de la siguiente manera: #include <graphics.h> Inicializacin del sistema de grficos: Antes de que se pueda usar cualquiera de las funciones grficas es preciso colocar el adaptador de video en uno de las modos grficos usando la funcin initgraph(), que tiene la siguiente sintaxis: void far initgraph (int far *controlador, int far *modo, const char far *camino); La funcin initgraph() carga en memoria un controlador de grficos que corresponda al nmero indicado por controlador. Este nmero est estrechamente ligado con los 10 enumerados en el tema anterior, pudiendo ser 0 para la opcin de autodeteccin (cuya macro es: DETECT ). El parmetro modo indica un nmero entero que especifica el modo de video usado por las funciones grficas. Por ltimo se deber especificar un camino al controlador si este es distinto al directorio de trabajo. Los distintos modos, de acuerdo a cada controlador, son los que se muestran en la siguiente tabla: Controlador CGA Modo CGAC0 CGAC1 CGAC2 CGAC3 CGAHI MCGAC0 MCGAC1 MCGAC2 MCGAC3 MCGAMED MCGAHI EGALO EGAHI EGA64LO EGA64HI EGAMONOHI HERCMONOHI ATT400C0 ATT400C1 ATT400C2 ATT400C3 ATT400CMED ATT400CHI Valor 0 1 2 3 4 0 1 2 3 4 5 0 1 0 1 3 0 0 1 2 3 4 5 Resolucin 320 x 200 320 x 200 320 x 200 320 x 200 640 x 200 320 x 200 320 x 200 320 x 200 320 x 200 640 x 200 640 x 480 640 x 200 640 x 350 640 x 200 640 x 350 640 x 350 720 x 348 320 x 200 320 x 200 320 x 200 320 x 200 640 x 200 640 x 200

MCGA

EGA EGA64 EGAMONO HERC ATT400

VGA PC3270 IBM8514

VGALO VGAMED VGAHI PC3270HI IBM8514LO IBM8514HI

0 1 2 0 0 1

640 x 200 640 x 350 640 x 480 720 x 350 640 x 480 1024 x 768

Para dejar de usar un modo de video grfico y volver a modo texto, se usa o bien closegraph() o restorecrtmode(). Sus prototipos son: void far closegraph (void); void far restorecrtmode (void); La diferencia entre ambas estriba principalmente en que la primera descarga toda la memoria asignada a especificaciones grficas, mientras que la segunda la deja intacta para permitir el regreso al modo indicado cuando se encuentre la siguiente funcin: void far setgraphmode (int modo); Ejemplo: /* Inicializacin del modo grfico. */ #include <graphics.h> main() /* Inicializa y finaliza el modo grfico. */ { int tarjeta, modo, error; detectgraph(&tarjeta,&modo); initgraph(&tarjeta,&modo,"C:\\TC\\BGI"); error=graphresult( ); if (error) { printf("%s",grapherrormsg(error)); } else { getch( ); closegraph( ); } } Cuando se deja al sistema de grficos de Turbo C que establezca el modo de video, el programa necesita alguna manera de conocer el entorno. La funcin getviewsettings() devuelve las dimensiones de la ventana y getmaxcolor() devuelve el nmero de colores permitido en el modo de video aplicable. La sintaxis es la siguiente:

void far getviewsettings (struct viewporttype far *info ); int far getmaxcolor (void); Se ve claramente que la funcin getviewsettings() devuelve el entorno de trabajo a travs de una estructura pasada por referencia. La estructura viewporttype se define en graphics.h como se muestra a continuacin: struct viewporttype { int left, top, right, bottom; int clip; }; Los campos left, top, right y bottom contienen las coordenadas de los extremos de la ventana. Cuando clip == 0 no existe salida que sobrepase los lmites de la ventana. Si este es distinto de cero, se realizar corte manual para no sobrepasar los lmites. Las funciones bsicas: Las funciones elementales en cualquier lenguaje para el trazado de grficos en general, son las que dibujan: puntos, lneas y crculos. En Turbo C estas funciones son llamadas putpixel(), line() y circle() respectivamente. Sus prototipos son: void far putpixel (int x, int y, int c); void far line (int x_ini, int y_ini, int x_fin, int y_fin); void far circle (int x, int y, int r); La funcin putpixel() coloca un pixel de color c en la posicin dada por x e y. La funcin line() dibuja una lnea desde la posicin ( x_ini , y_ini ) hasta la posicin especificada por ( x_fin , y_fin ) en el color preestablecido. La funcin circle() dibuja un circulo de radio r centrado en ( x , y ). Tambin existe otro par de funciones para facilitar el trazado de lneas: void far linerel (int dx, int dy); Este comando es til cuando trabajamos en forma relativa. Su misin es trazar una lnea tomando como referencia la posicin actual y, por medio de los parmetros dx y dy, introducimos un incremento positivo o negativo en la coordenada final. Sino tenemos: void far lineto (int x, int y); Que tambin es utilizada para generar lneas, solo que ahora introducimos la coordenada final en forma absoluta mediante los parmetros x e y. Lgicamente se intuye que es necesario contar con una funcin que me establezca el color de dibujo aplicable al usar line() o circle() (o muchas ms). Por ello surge: void far setcolor (int color);

El valor de color tiene que estar comprendido en el rango vlido para el modo de grficos actual. Esto es entre 0 y getmaxcolor(). Funciones para el tratamiento de figuras geomtricas: La siguiente es una sntesis de las funciones ms usadas para todo tipo de figuras geomtricas. Como se puede apreciar, son de funcionamiento bastante intuitivo. void far rectangle (int left, int top, int right, int bottom); Realiza un rectngulo con los lmites establecidos. void far arc (int x, int y, int StartAngle, int EndAngle, int Radio); Realiza un arco, donde ( x , y ) son las coordenadas del centro, StartAngle y EndAngle nos da el ngulo (en radianes) donde comienza o termina respectivamente de trazar el arco, y Radio fija el valor del radio. void far bar (int left, int top, int right, int bottom); void far bar3d (int left, int top, int right, int bottom, int depth, int topflag); Usados para la creacin de grficos estadsticos. void far ellipse (int x, int y, int StartAngle, int EndAngle, int RadioX, int RadioY); Ellipse con centro en ( x , y ); valores de radio mximo y mnimo ( RadioX e RadioY alternativamente). StartAngle y EndAngle nos da la posibilidad de no generar la ellipse completa. void far sector (int x, int y, int StartAngle, int EndAngle, int RadioX, int RadioY); Dibuja y rellena una porcin elptica. Funciones para el tratamiento de reas: Se puede rellenar cualquier figura cerrada usando la funcin floodfill() cuya sintaxis es: void far floodfill (int x, int y, int ColorBorde); Al usar esta funcin para el relleno de figuras cerradas, llmese por las coordenadas de un punto dentro de la figura y el color de las lneas que constituyen la figura (su contorno). Est dems aclarar que deber tratarse de una figura cerrada. Usando setfillstyle() se puede determinar la forma usada para el relleno. void far setfillstyle (int modelo, int color); Los valores para modelo y sus macros equivalentes se listan a continuacin: Macros EMPTY_FILL SOLID_FILL Valor Significado 0 Relleno con color de fondo 1 Relleno con textura uniforme

LINE_FILL 2 LTSLASH_FILL 3 SLASH_FILL gruesas BKSLASH_FILL 5 LTBKSLASH_FILL 6 HATCH_FILL 7 XHATCH_FILL 8 INTERLEAVE_FILL9 WIDE_DOT_FILL 10 CLOSE_DOT_FILL 11 USER_FILL 12

Relleno -------------------Relleno //////////////////////// 4 Relleno //////////////////////// Relleno Relleno Relleno Relleno Relleno Relleno Relleno Relleno

con

lneas

\\\\\\\\\\\\\\\\\\\\\\\\ con lneas gruesas \\\\\\\\\\\\\\\\\\\\\\\\ con espaciado ligero con espaciado denso con lneas entrecortadas punteado con gran espaciado punteado con poco espaciado definido por el usuario

Salida de texto en modo grfico: Aunque las funciones estndares de texto de Turbo C, tales como la printf(), pueden usarse en la mayora de los modos grficos, no son la alternativa ms flexible. Para aprovechar al mximo el entorno grfico de Turbo C ser necesario usar las funciones de salida de texto en modo grfico, descritas a continuacin: void far outtext (char *cadena); void far outtextxy (int x, int y, char *cadena); Estas funciones sacan la cadena (apuntada por el puntero) a la ventana grfica predefinida. Las principales ventajas de usar outtext() sobre la de usar printf() son sus posibilidades en el manejo de strings en diferentes tipos de caracteres, tamaos, direcciones o resolucin en las posiciones. Tambin es una ventaja la posibilidad de cortar la salida que desbordara la ventana. Por el contrario, printf() no puede cortar la salida. void far settextstyle (int tipo, int direccion, int tamao); El parmetro tipo determina el juego de caracteres a ser usados. Por omisin, es un tipo mapa de 8x8 bits. Se puede dar a tipo uno de los siguientes valores: Tipo DEFAULT_FONT TRIPLEX_FONT SMALL_FONT SANS_SERIF_FONT GOTHIC_FONT Valor 0 1 2 3 4 Significado Tipo mapa de 8x8 bits Letras Grandes Letras pequeas Tipo Sans Serif Letra Gtica

La direccin en la que se visualiza el texto, izquierda a derecha o de abajo a arriba, se determina por el valor de direccin que puede ser HORIZ_DIR o bien VERT_DIR, correspondiendo cada uno de estos a 0 o 1 respectivamente. El parmetro tamao es un multiplicador que aumenta el tamao del caracter. Su rango vlido es de 0 a 10. Al igual que lo hacamos con las ventanas grficas, para obtener informacin respecto a las

especificaciones de texto en modo grfico, puede usarse una funcin cuyo argumento es una estructura pasada por referencia. void far gettextsettings (struct textsettingstype *TextInfo); Esta estructura ha sido definida en graphics.h de la siguiente manera: struct textsettingstype { int font; int direction; int charsize; int horiz; int vert; }; Cambio de estilo de lnea: Turbo C permite cambiar la forma en la que se dibuja una lnea. Todas las lneas son slidas por omisin, pero mediante la especificacin correcta esta puede ser de puntos, de trazos, de puntos y trazos contiguos o personalizado. Para efectuar estos cambios usaremos la funcin: void far setlinestyle (int estilo, unsigned modelo, int ancho); A continuacin se detallan los posibles valores del parmetro estilo: Valor SOLID_LINE DOTTED_LINE CENTER_LINE DASHED_LINE USERBIT_LINE Significado Lnea continua Lnea de puntos Eje de simetra Lnea de trazos Lnea definida por el usuario

Si se desea un estilo personalizado mediante este ltimo valor, la forma de la lnea se introduce por el parmetro modelo como si se tratase de un mapa de bits. Por ejemplo si (estilo==4)&&(modelo==0x1234), cada vez que tracemos una lnea tendr una forma que se corresponder a 0001001000110100 donde los ceros son pixels apagados y los unos son pixels prendidos. El valor del ancho podr ser NORM_WIDTH o bien THICK_WIDTH siendo el primero una forma de especificar un espesor de 1 pixel, y el segundo un espesor de 3 pixels. Funciones que trabajan con porciones de pantalla: Aqu aparece una filosofa distinta de trabajo. Ya no se trata de dibujar con las nociones bsicas de geometra (como se vena haciendo), sino de aprovechar el manejo de la memoria de video como un complemento til a las funciones antes vistas para evitar la redundancia en el dibujo. La funcin getimage() se usa para copiar una regin de la ventana de grficos en una memoria intermedia. La funcin putimage() pone el contenido de una porcin de memoria en la pantalla. La sintaxis es la siguiente:

void far getimage (int left, int top, int right, int bottom, void far *buffer); void far putimage (int left, int top, void far *buffer, int op); La funcin getimage() copia el contenido de una porcin rectangular de la pantalla definida por sus coordenadas en la memoria apuntada por el puntero buffer. Se usa putimage() para visualizar una porcin de pantalla contenida en memoria y apuntada por buffer. Mediante el parmetro op se determina la forma en la que se escribir en pantalla pudiendo este tomar alguno de los siguientes valores: Nombre COPY_PUT XOR_PUT OR_PUT AND_PUT NOT_PUT Valor 0 1 2 3 4 Significado Sobrescribir el destino OR-Exclusivo con destino OR con destino AND con destino Invertir la imagen fuente

El tamao de la memoria intermedia, en bytes, para una regin determinada se proporciona por la funcin imagesize(). Se debe usar esta funcin en lugar de intentar calcular manualmente el espacio necesario, ya que imagesize() proporciona el valor correcto con independencia del modo de video que est en uso. La sintaxis es la siguiente: unsigned far imagesize (int left, int top, int right, int bottom); Cabe aclarar que estas funciones que manejan porciones de pantalla directamente de la RAM de video, lo hacen de una forma similar al funcionamiento de la memcpy() definida en mem.h, solo que ahora uno de los punteros lo prefijamos de acuerdo al valor establecido por el hardware en uso. Esto le da cierta potencialidad a estas funciones aunque para ello tenemos que acercarnos un poco ms al nivel de mquina.

UTILIDADES DEL MOUSE

La clase 'MOUSE' define la utilizacin del mouse mediante interrupciones, adems su manejo se simplifica a unas pocas instrucciones dentro de su aplicacin, y esto gracias a la utilizacin de programacin orientada a objetos. Se ha diseado especficamente esta clase para trabajar con el driver. Se trabaja de manera similar al mouse tradicional, la diferencia radica en que se crea un buffer de memoria donde se guarda temporalmente el grafico que se encuentra debajo del cursor. #if !defined(__MOUSE_H) #define __MOUSE_H

#include "graphics.h" #include "alloc.h" void mhide(); void mshow(); //********************* objeto MOUSE *************************** class MOUSE{ union REGS ireg; struct REGPACK res; int x,y,der,izq,ax,ay,visible,tipo_cursor,reserva; void far *bajo; void dibuja_flecha(); void dibuja_mano(); void quita(){if((reserva!=0)&&(visible==1)){ putimage(ax,ay,bajo,COPY_PUT);visible=0;}} void pone(); public: MOUSE(){bajo=NULL;reserva=visible=0;} ~MOUSE(){if(bajo!=NULL)farfree(bajo);} friend void mhide(); friend void mshow(); void cursor(int); void actualiza(); void inicia(int,int); void datos(int *,int *,int *,int *); void limites(int,int,int,int); int click(){return (izq);} int dclick(){return (der);} int vx(){return(x);} int vy(){return(y);} }; //************** pone el cursor en pantalla **************** void MOUSE::pone(){ if((reserva!=0)&&(visible==0)){ getimage(ax,ay,ax+30,ay+25,bajo); switch(tipo_cursor){ case 1:dibuja_flecha();break; case 2:dibuja_mano();break; } visible=1; } } //****************** dibuja cursor ************************* void MOUSE::dibuja_flecha(){ setcolor(255); line(x+3,y+6,x+3,y+14);line(x+4,y+8,x+4,y+13); line(x+5,y+10,x+5,y+14);line(x+6,y+12,x+6,y+16); line(x+7,y+16,x+7,y+20);line(x+8,y+20,x+8,y+22); setcolor(251); line(x+1,y+1,x+1,y+17);line(x+1,y+1,x+12,y+12); line(x+13,y+13,x+8,y+13);line(x+1,y+17,x+4,y+14);

line(x+8,y+14,x+10,y+21);line(x+5,y+15,x+7,y+22); line(x+1,y+2,x+11,y+12); setcolor(253); line(x+2,y+4,x+2,y+15);line(x+2,y+4,x+9,y+11); line(x+4,y+7,x+8,y+11);line(x+5,y+9,x+7,y+11); putpixel(x+6,y+11,253);line(x+10,y+12,x+7,y+12); line(x+7,y+13,x+7,y+15);line(x+8,y+16,x+8,y+19); putpixel(x+9,y+20,253); setcolor(249); line(x,y,x,y+19);line(x+1,y,x+14,y+13); line(x,y+19,x+4,y+15);line(x+14,y+14,x+9,y+14); line(x+4,y+15,x+6,y+22);line(x+9,y+14,x+11,y+21); line(x+6,y+22,x+11,y+21); } //********************** dibuja mano ******************************** void MOUSE::dibuja_mano(){ setcolor(254); for(int i=x+3;i<x+24;i++)line(i,y+14,i,y+22); setcolor(252);line(x+5,y+24,x+20,y+24);setcolor(253); line(x+3,y+23,x+23,y+23);line(x+8,y+14,x+9,y+14); line(x+13,y+14,x+14,y+14);line(x+18,y+14,x+19,y+14); for(i=1;i<5;i++){ setcolor(256-i); line(x+i,y+14,x+i,y+22-i);line(x+4+i,y+1,x+4+i,y+17-i); line(x+9+i,y+8,x+9+i,y+17i);line(x+14+i,y+8,x+14+i,y+17-i);} for(i=1;i<3;i++){ setcolor(256-i);line(x+19+i,y+8,x+19+i,y+17-i); setcolor(254-i);line(x+21+i,y+8,x+21+i,y+23);} putpixel(x+21,y+22,253);putpixel(x+22,y+23,252); putpixel(x+3,y+22,253);setcolor(249); line(x+1,y+21,x+2,y+23);line(x+2,y+23,x+6,y+25); line(x+7,y+25,x+19,y+25);line(x+23,y+23,x+20,y+25); line(x,y+14,x,y+20);line(x+1,y+13,x+3,y+13); line(x+4,y+2,x+4,y+17);line(x+5,y+1,x+6,y); line(x+7,y,x+8,y+1);line(x+9,y+2,x+9,y+13); line(x+10,y+8,x+11,y+7);line(x+12,y+7,x+13,y+8); line(x+14,y+9,x+14,y+13);line(x+15,y+8,x+16,y+7); line(x+17,y+7,x+18,y+8);line(x+19,y+9,x+19,y+13); line(x+20,y+8,x+21,y+7);line(x+22,y+7,x+23,y+8); line(x+24,y+9,x+24,y+22); } //****** funcion que cambia los limites de accion del mouse ***** void MOUSE::limites(int limx1,int limy1,int limx2, int limy2){ quita(); ireg.x.ax=7; ireg.x.cx=limx1; ireg.x.dx=limx2; int86(0x33, &ireg, &ireg); ireg.x.ax=8;

ireg.x.cx=limy1; ireg.x.dx=limy2; int86(0x33, &ireg, &ireg); pone(); } //************** devuelve datos en punteros ******************** void MOUSE::datos(int *x1,int *y1,int *izq1,int *der1){ *x1=x;*y1=y;*izq1=izq;*der1=der; } //************** cambia puntero del mouse ********************** void MOUSE::cursor(int mask){ if(mask!=tipo_cursor&&mask>0&&mask<3){ quita();tipo_cursor=mask;pone(); } } //***** actualiza la posicion actual del raton y botones ******* void MOUSE::actualiza(){ res.r_ax=3;intr(0x33,&res);izq=res.r_bx&0x01; der = res.r_bx & 0x02;der = der >> 1;x = res.r_cx ;y = res.r_dx; if((x!=ax)||(y!=ay)){ quita();ax=x;ay=y;pone(); } } //************* funcion para inicializar el raton **************** void MOUSE::inicia(int lx,int ly) { ireg.x.ax=0; int86(0x33, &ireg, &ireg); ireg.x.ax = 4; ireg.x.cx = lx; ireg.x.dx = ly; int86(0x33, &ireg, &ireg); bajo=farmalloc(imagesize2(100,100,130,125)); if(bajo==NULL){closegraph(); cout<<"No se pudo reservar memoria para mouse";exit(1); } ax=x=lx;ay=y=ly;visible=0;tipo_cursor=1;reserva=1; limites(1,1,grafo.maxx()-31,grafo.maxy()-2); pone(); } //********************************************************************* ****** MOUSE mouse; // define objeto mouse global //********************************************************************* ***** void mhide(){ mouse.quita(); } void mshow(){

mouse.pone(); } #endif

PUERTO RS-232
El puerto serie del PC es compatible con el estndar RS-232C. Este estndar fue diseado en los 60s para comunicar un equipo terminal de datos o DTE (Data Terminal Equipment, el PC en este caso) y un equipo de comunicacin de datos o DCE (Data Communication Equipment, habitualmente un modem). El estndar especifica 25 pins de seal, y que el conector de DTE debe ser macho y el conector de DCE hembra. Los conectores mas usados son el DB-25 macho, pero muchos de los 25 pins no son necesarios. Por esta razn en muchos PC modernos se utilizan los DB9 macho. Luego, encontrareis uno o ms de estos conectores en el panel trasero del PC. Los voltajes para un nivel lgico alto estn entre -3V y -15V. Un nivel lgico bajo tendr un voltaje entre +3V and +15V. Los voltajes ms usados son +12V y -12V. Las seales ms utilizadas se listan a continuacin: /DTR (Data-Terminal-Ready): El PC indica al modem que esta encendido y listo para enviar datos. /DSR (Data-Set-Ready): El modem indica al PC que esta encendido y listo para transmitir o recibir datos. /RTS (Request-To-Send): El PC pone esta seal a 1 cuando tiene un caracter listo para ser enviado. /CD (Carrier-Detect): El modem pone esta seal a 1 cuando ha detectado el ordenador. /CTS (Clear-To-Send): El modem esta preparado para transmitir datos. El ordenador empezara a enviar datos al modem. TxD: El modem recibe datos desde el PC. RxD: El modem transmite datos al PC.
D-Tipo-25 Pin No. Pin 2 Pin 3 Pin 4 Pin 5 Pin 6 Pin 7 Pin 8 Pin 20 Pin 22 D-Tipo-9 Pin No. Pin 3 Pin 2 Pin 7 Pin 8 Pin 6 Pin 5 Pin 1 Pin 4 Pin 9 Abreviacin TD RD RTS CTS DSR SG CD DTR RI Significado Transmit Data Receive Data Request To Send Clear To Send Data Set Ready Signal Ground Carrier Detect Data Terminal Ready Ring Indicator

El circuito integrado que convierte los datos de paralelo a serie y viceversa se llama UART (Universal Asynchronous ReceiverTransmitter). La UART tpica para un PC es el Intel 8251A, este

circuito integrado puede ser programado para realizar comunicaciones serie sncronas o asncronas. Ocho bits de datos (D0-D7) conectan al 8251A al bus de datos del PC. La entrada de chip select (/CS) habilita el circuito integrado cuando es seleccionado por el bus de control del PC. Este circuito integrado tiene dos direcciones internas, una direccin de control y una de datos. La direccin de control queda seleccionada cuando la entrada C-/D esta seleccionada a nivel alto. La direccin de datos queda seleccionada cuando la entrada C-/D esta a nivel bajo. La seal de RESET receta el circuito integrado. Cuando /RD esta a nivel bajo el ordenador lee un byte de control o de datos byte. La seal /WR es habilitada por PC para escribir un byte. Las dos seales estn conectadas a las seales de control del sistema con los mismos nombres. El UART incluye cuatro registros internos: THR: Registro temporal de salida. TSR: Registro de salida. RDR: Registro de entrada. RSR: Registro temporal de entrada. Cada caracter a transmitir es almacenado en el registro THR. La UART aade los bits de start y stop. Luego copia todos los bits (datos, start and stop bits) al registro TSR. Para acabar el proceso los bits son enviados a la lnea a travs de la seal TD. Cada caracter recibido desde la lnea RD es almacenada en el registro RSR. Los bits de start y stop son eliminados y la UART escribe el caracter en el registro RDR. Para acabar el proceso el caracter es ledo por el PC.

ENVIAR Y RECIBIR DATOS PUERTO COM1 COM2

Las comunicaciones serie se utilizan para enviar datos a travs de largas distancias, ya que las comunicaciones en paralelo exigen demasiado cableado para ser operativas. Los datos serie recibidos desde un modem o otros dispositivos son convertidos a paralelo gracias a lo cual pueden ser manejados por el bus del PC. Los equipos de comunicaciones serie se pueden dividir entre simplex, half-duplex y full-duplex. Una comunicacin serie simplex enva informacin en una sola direccin (p.e. una emisora de radio comercial). Half-duplex significa que los datos pueden ser enviados en ambas direcciones entre dos sistemas, pero en una sola direccin al mismo tiempo. En una transmisin full-duplex cada sistema puede enviar y recibir datos al mismo tiempo. Hay dos tipos de comunicaciones: sncronas o asncronas. En una transmisin sincrona los datos son enviados en bloques, el transmisor

y el receptor son sincronizados por un o ms caracteres especiales llamados caracteres sync. El puerto serie del PC es un dispositivo asncrono, luego empezaremos describiendo este tipo de sistemas. En una transmisin asncrona, un bit identifica su bit de comienzo y 1 o 2 bits identifican su final, no es necesario ningn caracter de sincronismo. Los bits de datos son enviados al receptor despus del bit de start. El bit de menos peso es transmitido primero. Un caracter de datos suele consistir en 7 o 8 bits. Dependiendo de la configuracin de la transmisin un bit de paridad es enviado despus de cada bit de datos. Se utiliza para corregir errores en los caracteres de datos. Finalmente 1 o 2 bits de stop son enviados. Hay dos maneras de direccionar el puerto serie, a travs de la interrupcin 14H de la BIOS y a travs de la interrupcin 21H del DOS. La interrupcin 14H de la BIOS utiliza cuatro funciones para programar el puerto serie. Cada funcin es seleccionada asignando un valor al registro AH del microprocesador. Las cuatro funciones son listadas a continuacin: Funcin 00H: Inicializa el puerto serie y selecciona la velocidad, el nmero de bits de datos de start y de stop y los parmetros de paridad. Funcin 01H: enva un caracter al puerto serie especificado. Funcin 02H: Lee un caracter desde el puerto serie especificado. Funcin 003: Devuelve el estado del puerto serie especificado. Hay varias funciones de la interrupcin 21H del DOS relacionadas a la operacin del puerto serie: Funcin 03H: Lee un caracter desde el puerto COM1. Funcin 04H: Escribe un caracter desde el puerto COM1. Funcin 40H: Esta funcin enva un numero de bytes des de un buffer a un dispositivo especificado. Nombre COM 1 COM 2 COM 3 COM 4 Direccin 3F8 2F8 3E8 2E8 IRQ 4 3 4 3

BIBLIOGRAFIA
http://www.ctv.es/pckits/tpseriee.html http://mundovb.net/mundoc/puertos.htm http://usuarios.lycos.es/froufe/parte9/cap9-2.html
http://www.beyondlogic.org/serial/serial.htm

http://www.geocities.com/charlytospage/manuales.htm
http://club.telepolis.com/urotsukidoji/guias2.htm

http://www.programacion.com/foros/29/msg/16451/ Diccionario de computacin FREEDMAN Biblioteca bsica informtica Dentro y fuera del ordenador