Está en la página 1de 24

Universidad Nacional de San Agustn Escuela Profesional de Ingeniera de Sistemas

SEGUNDA PRACTICA DE LABORATIO


COMUNICACIN SERIE/PARALELO

Alumno:
Yucra Condori Carlos Alberto

Docente:
Lucy Delgado Barra

Arequipa Per

2016
INTRODUCCION

Este trabajo esta enfocado en conocer la Comunicacion en Parelelo y Serie, la cual nos permite
conectar varios ETD (Equipos Terminales de Datos) en una red. Los dos terminos de paralelo y
serie se refiere a la forma como se transporta los Datos (bits) en ETDs en una red. La comunicacin
en paralelo usa varios hilos (Thread) para enviar informacion mientras que la comunicacin en serie
utiliza solo un hilo de transporte por lo que es mas lenta.

Se construyo un cable para comunicar los ETD, esta compuesto de un conector DB-9 jack y un
cable UTP, y se conecto a cada PC.

Se uso software como HyperTerminal y ComDebug para probar la conexin y el envio de datos
entre las PC.

Las limitaciones encontradas fueron que algunas PC no escuchaban bien en algunos puertos COM y
huvo inconvenientes para instalar los programas anteriormente dichos en algunas PCs.
OBJETIVOS

Conocer las conexiones serie y paralelo.


Conocer el funciomanieto del hardware y software para lograr la conexin de serie y
paralelo.
Armar un cable conector para la conexin de dos PC que consta de un cable UTP y un
conector DB-9.
Conocer algunos protocolos de comunicacin.
Conocer algunos estandares de comunicacin.
Entender el funcionamiento de cada PIN del conector DB-9
Conocer el funcionamiento de una RED, como el envio de datos, recepcion de datos, canales
de comunicacin entre otras.
CUESTIONARIO

1. Explique el proceso de comunicacin serial con control de flujo de hardware (PC a


Modem)
Este proceso se realiza mediante el control con Pines.
Para entender la comunicacin es necesario saber lo que hace cada PIN mediante el grafico
siguiente:

En el caso de control de flujo por hardware por temas de compatibilidad con linux [1]
usaremos la conexin RTS/CTS, el pin RTS elevara su linea y provocara una interrupcin en
el receptor en otras palabras preguntara si se puede enviar datos, por lo que si el receptor
puede recibir datos habilitara la linea CTS [2], un problema en esta comunicacin es cuando
un dispositivo envie muchos datos Overunnig el otro equipo no pueda procesarlos todos
en otras palabras un equipo escribe muy rapido y el receptor no puede procesar todos los
caracteres recibidos [1].

2. Busque en Internet el cdigo de un programa confeccionado en cualquier lenguaje de


programacin para la comunicacin serial de dos computadoras donde se utilice
control de flujo por software. Destaque la parte del cdigo donde se programe ello.

El programa hecho en c lo que hace es conectar dos pc por medio de una comunicacin
serial [3].
Lo que esta subrayado de rojo se da en control de flujo por software mediante las constantes
(IXON | IXOFF | IXANY);

opciones.c_iflag |= (IXON | IXOFF | IXANY);

#include seriallib.h
/*
Attempt to open the serial port
Return the file descriptor
*/
int OpenSerial(char *port)
{
int fdes;

if ((fdes = open(port,O_RDWR | O_NOCTTY | O_NONBLOCK)) < 0) {


perror("OpenSerial");
} else {
fcntl(fdes,F_SETFL,FNDELAY);
}

return(fdes);
}

/*
Setup the communication options
Hopefully POSIX compliant
*/
int SetupSerial(int fdes,int baud,int databits,int stopbits,int parity)
{
int n;
struct termios options; //,options2;

/* Get the current options */


if (tcgetattr(fdes,&options) < 0) {
perror("SetupSerial 1");
return(FALSE);
}
/*
fprintf(stderr,"iflag - 0%o; oflag - 0%o; cflag - 0%o; lflag - 0%o\n",
(unsigned int)options.c_iflag,
(unsigned int)options.c_oflag,
(unsigned int)options.c_cflag,
(unsigned int)options.c_lflag);
*/

/* Set the baud rate */


switch (baud) {
case 1200:
n = cfsetispeed(&options,B1200);
n += cfsetospeed(&options,B1200);
break;
case 2400:
n = cfsetispeed(&options,B2400);
n += cfsetospeed(&options,B2400);
break;
case 4800:
n = cfsetispeed(&options,B4800);
n += cfsetospeed(&options,B4800);
break;
case 9600:
n = cfsetispeed(&options,B9600);
n += cfsetospeed(&options,B9600);
break;
case 19200:
n = cfsetispeed(&options,B19200);
n += cfsetospeed(&options,B19200);
break;
case 38400:
n = cfsetispeed(&options,B38400);
n += cfsetospeed(&options,B38400);
break;
case 57600: // witilt
n = cfsetispeed(&options,B57600);
n += cfsetospeed(&options,B57600);
break;
default:
fprintf(stderr,"Unsupported baud rate\n");
return(FALSE);
}
if (n != 0) {
perror("SetupSerial 2");
return(FALSE);
}

// Set the data size


options.c_cflag &= ~CSIZE; // Character size mask
switch (databits) {
case 7:
options.c_cflag |= CS7;
break;
case 8:
options.c_cflag |= CS8;
break;
default:
fprintf(stderr,"Unsupported data size\n");
return(FALSE);
}

// Set parity
switch (parity) {
case 'n':
case 'N':
options.c_cflag &= ~PARENB; // Clear parity enable
break;
case 'o':
case 'O':
options.c_cflag |= PARENB; // Parity enable
options.c_cflag |= PARODD; // Enable odd parity
break;
case 'e':
case 'E':
options.c_cflag |= PARENB; // Parity enable
options.c_cflag &= ~PARODD; // Turn off odd parity = even
break;
default:
fprintf(stderr,"Unsupported parity\n");
return(FALSE);
}

// Set stop bits


switch (stopbits) {
case 1:
options.c_cflag &= ~CSTOPB; // Not 2 stop bits = One stop bit
break;
case 2:
options.c_cflag |= CSTOPB; // Two stop bits
break;
default:
fprintf(stderr,"Unsupported stop bits\n");
return(FALSE);
}

// Non blocking return immediately with data


options.c_cc[VMIN] = 0;
options.c_cc[VTIME] = 0;

// Local flags
options.c_lflag = 0; // No local flags
options.c_lflag &= ~ICANON; // Don't canonicalise
options.c_lflag &= ~ECHO; // Don't echo
options.c_lflag &= ~ECHOK; // Don't echo

// Control flags
options.c_cflag &= ~CRTSCTS; // Disable RTS/CTS
options.c_cflag |= CLOCAL; // Ignore status lines
options.c_cflag |= CREAD; // Enable receiver
options.c_cflag |= HUPCL; // Drop DTR on close

// oflag - output processing


options.c_oflag &= ~OPOST; // No output processing
options.c_oflag &= ~ONLCR; // Don't convert linefeeds

// iflag - input processing


options.c_iflag |= IGNPAR; // Ignore parity
options.c_iflag &= ~ISTRIP; // Don't strip high order bit
options.c_iflag |= IGNBRK; // Ignore break conditions
options.c_iflag &= ~INLCR; // Don't Map NL to CR
options.c_iflag &= ~ICRNL; // Don't Map CR to NL
options.c_iflag |= (IXON | IXOFF | IXANY); // xon/xoff flow control
/*
fprintf(stderr,"iflag - 0%o; oflag - 0%o; cflag - 0%o; lflag - 0%o\n",
(unsigned int)options.c_iflag,
(unsigned int)options.c_oflag,
(unsigned int)options.c_cflag,
(unsigned int)options.c_lflag);
*/

// Update the options and do it NOW


if (tcsetattr(fdes,TCSANOW,&options) < 0) {
perror("SetupSerial 3");
return(FALSE);
}

/* Read the options and check they have "taken"


if (tcgetattr(fdes,&options2) < 0) {
perror("SetupSerial 4");
return(FALSE);
}
fprintf(stderr,"iflag - 0%o; oflag - 0%o; cflag - 0%o; lflag - 0%o\n",
(unsigned int)options.c_iflag,
(unsigned int)options.c_oflag,
(unsigned int)options.c_cflag,
(unsigned int)options.c_lflag);
if (memcmp((void *)&options,(void *)&options2,sizeof(options)) != 0) {
perror("SetupSerial 5");
return(FALSE);
} */

// Clear the line


tcflush(fdes,TCIFLUSH);

return(TRUE);
}

void CheckSerialPort(int fdes)


{
int input_speed,output_speed;
struct termios options;

/* Get the current options */


if (tcgetattr(fdes,&options) != 0) {
perror("CheckSpeed");
}

fprintf(stderr,"iflag - 0%o; oflag - 0%o; cflag - 0%o; lflag - 0%o\n",


(unsigned int)options.c_iflag,
(unsigned int)options.c_oflag,
(unsigned int)options.c_cflag,
(unsigned int)options.c_lflag);
fprintf(stderr,"c_ispeed - 0%o; c_ospeed - 0%o\n",
(unsigned int)options.c_ispeed,
(unsigned int)options.c_ospeed);

input_speed = cfgetispeed(&options);
output_speed = cfgetospeed(&options);
fprintf(stderr,"Input speed: %d\n",input_speed);
fprintf(stderr,"Output speed: %d\n",output_speed);
}

/*
Write a string to the serial port device
*/
int SendSerialString(int fdes,char *buffer)
{
int len;

len = strlen(buffer);
if (write(fdes,buffer,len) != len)
return(FALSE);
return(TRUE);
}

/*
Write raw bytes to the serial port device
*/
int SendSerialRaw(int fdes,unsigned char *buffer,int len)
{
if (write(fdes,buffer,len) != len)
return(FALSE);
return(TRUE);
}

/*
Read any characters on the port
Note that the maximum number of bytes to read has to
inclue the trailing '\0' which is added to make a legal
C string.
*/
int ReadSerialString(int fdes,char *buffer,int maxread)
{
int len;

len = read(fdes,buffer,maxread-1);
if (len < 0 && errno != EAGAIN)
return(FALSE);
buffer[len] = '\0';
return(len);
}

/*
Read a single character from the port
*/
int ReadSerialChar(int fdes,unsigned int *n)
{
char c[8];
int len;

len = read(fdes,c,1);
if (len < 1 && errno != EAGAIN)
return(FALSE);
*n = c[0];
return(TRUE);
}

/*
Read raw bytes from the serial port
Return the number read
*/
int ReadSerialRaw(int fdes,unsigned char *buffer,int maxread,int timeout)
{
int len,iptr=0;
unsigned char buf;
struct timeval tp;
double startsecs,secs;

gettimeofday(&tp,NULL);
startsecs = tp.tv_sec + tp.tv_usec / 1000000.0;

for (;;) {
len = read(fdes,&buf,1);
if (len > 0) {
buffer[iptr] = buf;
iptr++;
if (iptr >= maxread)
break;
}
gettimeofday(&tp,NULL);
secs = tp.tv_sec + tp.tv_usec / 1000000.0;
if (secs-startsecs > timeout)
break;
}
return(iptr);
}

/*
Clear serial, read until nothing is left
*/
void ClearSerial(int fdes)
{
char buf;

while (read(fdes,&buf,1) > 0)


;
}

/*
Wait for a particular character
The timeout is in seconds
*/
int SkipSerialUntil(int fdes,char c,double timeout)
{
char buf;
int len;
struct timeval tp;
double startsecs,secs;

gettimeofday(&tp,NULL);
startsecs = tp.tv_sec + tp.tv_usec / 1000000.0;

for (;;) {
len = read(fdes,&buf,1);
if (len > 0 && buf == c)
break;
gettimeofday(&tp,NULL);
secs = tp.tv_sec + tp.tv_usec / 1000000.0;
if (secs-startsecs > timeout)
return(FALSE);
}
return(TRUE);
}
/*
Read until a particular character is received
Return a C string
*/
int ReadSerialUntil(int fdes,char *buffer,char c,int maxread,double timeout)
{
int len,iptr=0;
char buf;
struct timeval tp;
double startsecs,secs;

gettimeofday(&tp,NULL);
startsecs = tp.tv_sec + tp.tv_usec / 1000000.0;
buffer[iptr] = '\0';

for (;;) {
len = read(fdes,&buf,1);
if (len > 0 && buf == c)
break;
if (len > 0 && iptr < maxread-1) {
buffer[iptr] = buf;
iptr++;
buffer[iptr] = '\0';
}
gettimeofday(&tp,NULL);
secs = tp.tv_sec + tp.tv_usec / 1000000.0;
if (secs-startsecs > timeout)
return(FALSE);
}
return(TRUE);
}

/*
Display a possibly binary string
*/
void Raw2stderr(unsigned char *buf,int len)
{
int i;

for (i=0;i<len;i++) {
if (buf[i] < ' ' || buf[i] > 126)
fprintf(stderr,"<%03d>",buf[i]);
else
fprintf(stderr,"%c",buf[i]);
}
}

/*
Display a string potentially with non printable characters
*/
void Str2stderr(char *buf)
{
unsigned int i;

for (i=0;i<strlen(buf);i++) {
if (buf[i] < ' ' || buf[i] > 126)
fprintf(stderr,"<%03d>",buf[i]);
else
fprintf(stderr,"%c",buf[i]);
}
}

/*
Given a 3 byte string from the mouse in "s"
Return the button and position.
*/
void DecodeSerialMouse(unsigned char *s,int *button,int *x,int *y)
{
*button = 'n';
if ((s[0] & 0x20) != 0)
*button = 'l';
else if ((s[0] & 0x10) != 0)
*button = 'r';
*x = (s[0] & 0x03) * 64 + (s[1] & 0x3F);
if (*x > 127)
*x = *x - 256;
*y = (s[0] & 0x0C) * 16 + (s[2] & 0x3F);
if (*y > 127)
*y = *y - 256;
}
/*
Set up for the serialversion of the Magellan Spacemosue
*/
int SerialSpacemouse(char *s)
{
int fd;
struct termios options,options2;

if ((fd = open(s,O_RDWR | O_NOCTTY | O_NONBLOCK)) < 0) {


fprintf(stderr,"Failed to open serial port\n");
} else {
fcntl(fd,F_SETFL,FNDELAY);
}

// Get the current options


if (tcgetattr(fd,&options) < 0) {
fprintf(stderr,"First get failed\n");
exit(-1);
}

// Change things
cfsetispeed(&options,B9600);
cfsetospeed(&options,B9600);
options.c_cflag &= ~CSIZE;
options.c_cflag |= CS8;
options.c_cflag &= ~PARENB;
options.c_cflag |= CSTOPB;
options.c_cc[VMIN] = 0;
options.c_cc[VTIME] = 0;

options.c_lflag = 0; // No local flags


options.c_lflag &= ~ICANON; // Don't canonicalise
options.c_lflag &= ~ECHO; // Don't echo
options.c_lflag &= ~ECHOK; // Don't echo

options.c_cflag &= ~CRTSCTS; // Disable RTS/CTS


options.c_cflag |= CLOCAL; // Ignore status lines
options.c_cflag |= CREAD; // Enable receiver
options.c_cflag |= HUPCL; // Drop DTR on close

options.c_oflag &= ~OPOST; // No output processing


options.c_oflag &= ~ONLCR; // Don't convert linefeeds

options.c_iflag |= IGNPAR; // Ignore parity


options.c_iflag &= ~ISTRIP; // Don't strip high order bit
options.c_iflag |= IGNBRK; // Ignore break conditions
options.c_iflag &= ~INLCR; // Don't Map NL to CR
options.c_iflag &= ~ICRNL; // Don't Map CR to NL
options.c_iflag |= (IXON | IXOFF | IXANY); // xon/xoff flow control
// Update the options and do it NOW
if (tcsetattr(fd,TCSANOW,&options) < 0) {
fprintf(stderr,"Failed to set\n");
exit(-1);
}

// Read the options again and check they have "taken"


if (tcgetattr(fd,&options2) < 0) {
fprintf(stderr,"Second get failed\n");
exit(-1);
}

// Compare
if (memcmp((void *)&options,(void *)&options2,sizeof(options)) != 0) {
fprintf(stderr,"Did not compare favourably!\n");
exit(-1);
}

return(fd);
}
3. Explique qu significan los puertos paralelo SPP, ECP y EPP y como se distribuyen los
pines.

Todos lo puertos puertos paralelos nombrados acontinuacion permiten que la informacion


sea transmitida por varios hilos haciendo que la comunicacin sera mas rpida.

SPP (Puerto Paralelo Estndar): Es el puerto paralelo estandar, antiguamente este puerto
solo soportaba el envio de datos en una sola direccin simple duplex pero con la
incorporacion de PS/2 de IBM [4] este puerto soporta el envio bidireccional full duplex, la
velocidad normal que soporta es de 150 Kb/s hasta 500 Kb/s [8].
La distribucion de pines en un conector DB-25 se d de la siguiente manera:

Nombre de la seal Bit Pin del DB25 Direccin


-Strobe *C0 1 Output
+Data Bit 0 D0 2 Output
+Data Bit 1 D1 3 Output
+Data Bit 2 D2 4 Output
+Data Bit 3 D3 5 Output
+Data Bit 4 D4 6 Output
+Data Bit 5 D5 7 Output
+Data Bit 6 D6 8 Output
+Data Bit 7 D7 9 Output
-Acknowledge S6 10 Input
+Busy *S7 11 Input
+Paper End S5 12 Input
+Select In S4 13 Input
-Auto Feed *C1 14 Output
-Error S3 15 Input
-Initialize C2 16 Output
-Select *C3 17 Output
Ground - 18-25 -
ECP (Puerto de Capacidad Mejorada): Posee la capacidad de DMA Direct Memory
Access tiene acceso a la memoria principal por lo cual su tiempo de respuesta es mas corto
[8], es compatible con EPP y SPP adems supera velocidad de mas de 1 Mb/s.
Tiene mayor funcionalidad y velocidad que EPP [4].
La distribucin de seales es de la siguiente manera:

Seal modo SPP Nombre en I/O Descripcion --Uso de la seal al


Modo ECP usar el puerto en modo ECP
*STROBE HostClk Out Usando junto a PeriphAck en
transferencia de informacin de
direcciones o datos desde el host al
perifrico.
*AUTOFEED HostAck Out Proporciona Status de
Command/Data en transferencias
host a perifrico. Se la usa junto a
PeriphClk durante las
transferencias de perifrico a host.
nSELECTIN 1284Active Out Est en High cuando el host est en
modo de transferencia IEEE 1248
*INIT nReverseRequ Out Se pone en Low para que el canal
est transfiera de perifrico a host
*ACK PeriphClk In Usado junto a HostAck en
transferencias de datos de perifrico
a host
BUSY PeriphAck In Usado junto a HostClk en
transferencias de datos o
direcciones en sentido directo.
Proporciona Status de
Command/Data en transferencias
inversas.
PE nAckReverse In Puesto en Los para reconocer la
seal nReverseRequest.
SELECT Xflag In Flag de Extensibilidad
*ERROR nPeriphReque In Puesto en Low por el perifrico
st para indicar que tiene un dato
disponible para una transferencia en
sentido inverso
Data[8:1] Data[8:1] Bi-Di Canal bidireccional por donde se
transfieren direcciones y datos
EPP (Puerto Paralelo Mejorado): Es de mayor velocidad y ademas compatible con SPP
[6], la velocidad que soporta es de 500 Kb/s hasta 2 Mb/s [8] , este protocolo realiza cuatro
tipos de ciclos [7,6]:
1. Ciclo de escritura de datos
2. Ciclo de lectura de datos
3. Ciclo de escritura de direccin
4. Ciclo de lectura de direccin
La distribucion de seales es de la siguiente manera;

Seal Nombre I/O Descripcin


*STROBE nWRITE Out Est en low durante una operacin
Write y en high durante una read
*AUTOFEED nDATASTB Out Va a low para indicar que un cilo de
lectura o escritura de datos esta en
proceso
*SELECTIN nADDRSTB Out Va a low para indicar que se ejecuta un
cilo de lectura o escritura de
direcciones
*INIT nRESET Out Reset del perifrico (activo low)
*ACK nINTR In Peripheral interrupt. Usado para generar
una interrupcin para la PC
BUSY nWAIT In Seal de Handshake. Estando low
indica quetodo est listo para iniciar un
ciclo y cuando est en high indica que
todo est listo para finalizar un ciclo.
D[8:1] AD[8:1] Bi-Di Lineas de datos (bus bidireccional).
PE user defined In Cada perifrico elige cmo usarlo
(antes Paper End)
SELECT user defined In Cada perifrico elige cmo usarlo
*ERROR user defined In Cada perifrico elige cmo usarlo
4. Defina el protocolo Kermit: Es un protocolo de transferencia de archivos que comunica
dos computadoras mediante el envio de datos por lineas telefonicas en paquetes
agrupandolos en bytes [9].

5. Qu entiende por cdigo ASCII y cdigo ANSI?


ASCII: Es un codigo establecido en USA para la comunicacin de datos que consta de
simbolos imprimibles y no imprimibles.
ANSI: Es una organizacin que establece estandares una modificacion de ASCII.

El cdigo ASCII utiliza 7 bits para representar a cada caracter, mientras que el formato
ANSI utiliza 8 bits para cada uno.

6. Muestre la conexin de un cable Full Null Modem con DB-9 en un extremo y DB-25 en
el otro

CONCLUSIONES:

BIBLIOGRAFIA:

[1] http://www.tldp.org/HOWTO/Text-Terminal-HOWTO-11.html
[2] http://www.brainboxes.com/faq/items/what-is-rts--cts-hardware-flow-control-
[3] http://paulbourke.net/libraries/seriallib.c
[4] http://telematicasalvador.blogspot.pe/2010/10/puertos-paralelos.html
[5] http://eidanyoson.8k.com/proypp1.htm
[6] http://www.pchardware.org/puertos/modoepp.php
[7] http://redeya.bytemaniacos.com/electronica/tutoriales/pc/hardw3.htm
[8] http://www.informaticamoderna.com/El_puerto_paralelo.htm
[9] https://es.wikipedia.org/wiki/Kermit_(protocolo)
ANEXO 1
PRCTICA HECHA EN LABORATORIO
1. OBJETIVOS:
Conocer los enlaces fsicos serie y paralelo
Construccin
de los cables
Emplear el software para lograr el envo de datos.

2. MATERIALES Y EQUIPOS
MATERIALES
- 2 m. cable UTP 8 hilos
- 3 conectores jacks (hembras) DB-9 (serie) con capuchas.
EQUIPO
- Juego de herramientas: alicates, destornilladores, cutters, etc
- Multmetro
- Cautn o pistola de soldar, pasta de soldar y soldadura.
SOFTWARE
- Hyperterminal
- ComDebug

3. ACTIVIDADES Construccin del


cable
Para la construccin del cable se necesita seguir nos guiamos de la siguiente imagen:

Como se puede observar, sern tres los cables que soldaremos entre los conectores.
En uno de los conectores el pin 2 (transmisor) se conectar con el pin 3 (Receptor) del otro conector
y de manera inversa con el segundo cable, el tercer cable ira al pin 5 que es de conexin a tierra de
ambos conectores.
Antes de conectar al cable a la computadora, se debe verificar que las conexiones estn correctas,
con un multmetro se evaluara la continuidad.
Preparacin del cable serial

Comunicacin con Hyperterminal


Hyperterminal es un software de tipo propietario (se apropia del puerto) que nos
permitir realizar la conexin entre dos computadoras por medio del cable construido en
una conexin punto a punto por medio del puerto serial.
Configuracin:
A continuacin, se muestra como se har la configuracin para lograr la
comunicacin. Esta configuracin debe ser la misma en ambas computadoras
1. Dar un nombre y elegir el primer icono en la primera venta, luego presionamos OK.
2. Configurar el puerto, en este caso usaremos el puerto COM1

3. Luego seguimos con la configuracin del puerto como se muestra en la


siguiente imagen.

Los bits por segundo es la velocidad de transmisin entre los dos


equipos remotos ETD.
Cada dato estar compuesto de 8 bits.
En este caso no evaluaremos por paridad.
La cantidad de bits de parada para la conexin ser de 1.
No se har ningn control de flujo.
4. Configuraremos la emulacin para que sea de tipo ANSI. Esto se hace en Archivo-
Configuracin-Configuracin y adems colocamos el Telnet terminal ID como ANSII.

5. Luego realizamos las pruebas, lo que se escriba en una computadora, podr


ser observado desde el terminal de la otra.
6. Al realizar las pruebas se puede notar que el ENTER no funciona y al presionarlo regresa
el cursor al principio, para poder lograr su funcionamiento se debe realizar la siguiente
configuracin. Esto se hace en Archivo-Configuracin-Configuracin-ASCII setup y
seleccionamos Append line feeds to incoming line ends.

7. Con se observa en la siguiente imagen, el ENTER (salto de lnea) ya funciona.


Comunicacin con ComDebug

1. Al momento de abrir el ComDebug se observara la pantalla principal en este


caso usaremos el terminal por lo tanto seleccionaremos Use the program as a
Terminl utility.

2. Luego Configuraremos el puerto en COM1, el trfico de bits ser de 9600, los


datos de bits ser de 8, sin paridad, el bit de parada ser 1 y no tendr ningn flujo
de control. Por ultimo presionamos OK.
3. Luego que ya se haya configurado el ComDebug se podr enviar mensajes entre
los equipos.
La ventaja de esta herramienta es que transforma cada carcter en char como
en hexadecimal.

Para enviar un mensaje se escribir en un recuadro el texto y se


presionara SEND, el equipo remoto recibir este mensaje.
Los dos equipos se pueden comunicar de esta manera.
Comunicacin entre el Hyperterminal y ComDebug
1. Hyperterminal
Se configura de la misma manera como vimos anteriormente, las dos mquinas
deben de tener la misma configuracin.

2. Luego tambin se configura las propiedades como la emulacin en ANSI y el


terminal ID de telnet como ANSI, luego se presiona ACEPTAR.
3. ComDebug
En el ComDebug se debe de tener la misma configuracin del HyperTerminal, como en
el mismo puerto, mismo trfico de bits, bits por dato, sin paridad, el bit de parada
es 1 y sin ningn flujo de control.
Por ltimo se presiona OK.
4. Pruebas de la comunicacin

Hyperterminal

ComDebug

- Como se puede observar en las dos imgenes de arriba, el equipo que ejecuta el
HyperTerminal enva un mensaje por consola hacia el otro equipo, el equipo
receptor recibe el mensaje y lo muestra por caracteres.
- El equipo que ejecuta el ComDebug enva un mensaje hacia el otro equipo y
este lo recibe en su terminal.