Detección de la dirección base del puerto paralelo ~ Lenguajes de interfaz

Detección de la dirección base del puerto paralelo

MS-DOS

Bajo MS-DOS se puede usar el comando externo debug.exe del siguiente modo:

Ejecutar el comando: debug.exe, luego aparece el símbolo -

Escribir después de este signo d 40:0008

Dependiendo del equipo aparece un volcado de la memoria de la siguiente forma: (los datos pueden variar)

0040:0000 ______________________78 03 00 00 00 00 00 00

La dirección del puerto se encuentra en forma invertida (78 03), entonces la dirección es:

0378 en hexadecimal. Cabe hacer notar que esta dirección puede ser diferente en otros PC.

(Se escribe q y luego enter para salir de debug.exe)

En Turbo Pascal con ensamblador

Program buscar_base;

uses crt;

Var base : word;

begin

asm

mov ax, 0040h {Colocar 0040h en el reg. Ax}

mov es, ax {Direccionar el segmento es con el valor de ax}

mov ax, es:[si] {Colocar en ax el contenido de la dirección de memoria [0040:0008]}

mov base, ax; {Actualizar la variable base con el valor de ax}

end;

writeln (' La dirección base en decimal es : ',base);

end.

En Turbo Pascal

Program buscar_base;

uses crt;

Var base:word;

Begin

base:=memW[$0040:$0008];

writeln('La dirección base en decimal es : ',base);

end.

Analizador del puerto paralelo

Este analizador se utiliza para determinar la dirección base del puerto y además permite visualizar el contenido de los registros en forma continua y en formato binario y hexadecimal.

Este programa se compila con Turbo Pascal.

{Archivo analisis.pas}

{Analizador de estado del Puerto Paralelo}

{Autor: Juan Carlos Galarza Roca}

{Diciembre de 1997}

{Versión : 1.0}

Program analisis_PP;

uses crt, dos, cadena, utiles;

var

dir_base,

dir_estado,

dir_control : Word;

puntero_int_1C : Pointer;

tick : Integer;

sw_m_t : Integer;

{$F+,S-,W-}

procedure manejador; interrupt;

{Este manejador se utiliza para temporizar el despliegue del

indicador de exploración, de modo que se haga la lectura de

datos y a la vez se despliegue el indicador}

var

y : Integer;

begin

if sw_m_t=0 then begin;

{sw_m_t es la bandera del manejador de tareas

Esta bandera es actualizada por el programa

principal

}

x:=whereX;

y:=whereY;

{se guarda la posición del cursor en la pantalla}

tick:=tick+1;

{ La variable tick se incrementa cada 18,20677500572 segundos}

a:=6;

b:=3;

textcolor(7);

gotoxy(39+a,b);write('Explorando... ');

textcolor(2);

case tick of

13: begin gotoxy(60+a,b); write('> ');

gotoxy(52+a,b); write(' <');end;

15: begin gotoxy(60+a,b); write('-> ');

gotoxy(52+a,b) ;write(' <-');end;

17: begin gotoxy(60+a,b); write(' -> ');

gotoxy(52+a,b); write(' <- ');end;

19: begin gotoxy(60+a,b); write(' -> ');

gotoxy(52+a,b); write(' <- ');end;

21: begin gotoxy(60+a,b); write(' -> ');

gotoxy(52+a,b); write(' <- ');end;

23: begin gotoxy(60+a,b); write(' -> ');

gotoxy(52+a,b); write(' <- ');end;

25: begin gotoxy(60+a,b); write(' <- ');

gotoxy(52+a,b); write('< ');end;

27: begin gotoxy(60+a,b); write(' <- ');

gotoxy(52+a,b); write(' -> ');end;

29: begin gotoxy(60+a,b); write(' <- ');

gotoxy(52+a,b); write(' -> ');end;

31: begin gotoxy(60+a,b); write(' <- ');

gotoxy(52+a,b); write(' -> ');end;

33: begin gotoxy(60+a,b); write('<- ');

gotoxy(52+a,b); write(' -> ');end;

34: tick:=13;

end;

gotoxy(x,y);

{Devolver la posición original del cursor}

end;

{$F-,S+}

begin

cursor_off;

tick:=0;

{Colocar el manejador de tareas}

GetIntVec($1C,puntero_int_1C);

SetIntVec($1C,Addr(manejador));

clrscr;

dir_base:=memW[$0040:0008];

dir_estado:=dir_base+1;

dir_control:=dir_base+2;

textcolor(2);

gotoxy(23,2);writeln('Analizador del Puerto Paralelo');

textcolor(9);

gotoxy(8,4); writeln('Direcciones: ');

textcolor(9);

gotoxy(10,5); writeln('Datos : ',dec_a_hexa(dir_base),' (h)');

gotoxy(10,6); writeln('Estado : ',dec_a_hexa(dir_estado),' (h)');

gotoxy(10,7); writeln('Control: ',dec_a_hexa(dir_control),' (h)');

{Ciclo repetivo principal}

repeat

sw_m_t:=1;

textcolor(9);

gotoxy(34,4); writeln('Estado: ');

gotoxy(36,5); write('Datos : ',port[dir_base]:3,' (d) ');

dec_bin(port[dir_base]);write(' (b)');

gotoxy(36,6); write('Estado : ',port[dir_estado]:3,' (d) ');

dec_bin(port[dir_estado]);write(' (b)');

gotoxy(36,7); write('Control: ',port[dir_control]:3,' (d) ');

dec_bin(port[dir_control]);write(' (b)');

textcolor(7);

gotoxy(9,9); write('Registro de Datos');

gotoxy(25,10); write('Pines 9 8 7 6 5 4 3 2');

gotoxy(25,11); write('Nombre D7 D6 D5 D4 D3 D2 D1 D0');

textcolor(2);

gotoxy(25,12); write('Valor '); dec_bin2(port[dir_base]);

textcolor(7);

gotoxy(9,14); write('Registro de Estado');

gotoxy(25,15); write('Pines 11 10 12 13 15 ** ** **');

gotoxy(25,16); write('Nombre -S7 S6 S5 S4 S3 ** ** **');

textcolor(2);

gotoxy(25,17);write('Valor '); dec_bin2(port[dir_estado]);

textcolor(7);

gotoxy(9,19); write('Registro de Control');

gotoxy(25,20); write('Pines ** ** ** ** 17 16 14 1');

gotoxy(25,21); write('Nombre ** ** ** ** -C3 C2 -C1 -C0');

textcolor(2);

gotoxy(25,22);write('Valor '); dec_bin2(port[dir_control]);

textcolor(2);

textcolor(7);

sw_m_t:=0;

delay(100);

until keypressed;

cursor_on;

{Restaurar manejador de tareas}

SetIntVec($1C,puntero_int_1C);

end.

Envio y lectura de datos del puerto

Envío de datos al puerto

El puerto paralelo puede ser usado como una comunicación directa con el PC, de este modo es posible desarrollar aplicaciones en tiempo-real que necesiten un rápido tiempo de respuesta.

El acceso se realiza escribiendo un byte (8 bits) en registro determinado. Este byte debe referirse a cada uno de los bits del registro. Esto significa que se debe definir el byte a escribir en sistema binario.

Por ejemplo si queremos escribir en el registro de datos el bit D0 y el bit D2 entonces el byte es:

0	0	0	0	0	1	0	1	= 5 En decimal
D7	D6	D5	D4	D3	D2	D1	D0	Registro de datos

Luego, se debe escribir 5 en el registro de datos (dirección base):

Notas:

dir_base y dir_estado es de tipo word, y dato es de tipo byte.

En Turbo Pascal

Port[dir_base]:=5;

En C

Outportb(dir_base, 5);

En ensamblador

mov dx, dir_base {Direccionar en dx la dirección base}

mov al, 5 {Colocar en ² al ² el número 5}

out dx, al {Enviar al puerto}

Lectura de datos del puerto

La lectura de datos se realiza accesando un byte del registro determinado. Al hacer la lectura se debe convertir el byte a binario para determinar él o los bits que interesen. Note que sólo se debe leer el registro de estado, o sea, la dirección base+1.

En Turbo Pascal

Var dato: byte;

dato:=Port[dir_estado];

En C

unsigned int dato;

dato=inportb(dir_estado);

En ensamblador

mov dx, dir_estado {Direccionar dx con el registro de estado del puerto}

in al, dx {Leer del puerto. En el registro ² al ² está el dato leído}

Por ejemplo, si el dato leído es igual a 96, significa que los bits S5 y S6 están activos(tienen un nivel alto, un 1).

0	1	1	0	0	0	0	0	= 96 En decimal
S7	S6	S5	S4	S3	S2	S1	S0	Registro de estado

Enmascaramiento

Tanto en el envío como recepción de datos binarios, se realizan operaciones a nivel de bits. Estas operaciones permiten aislar uno más bits. Este proceso se denomina enmascaramiento.

Por ejemplo, para saber si determinado bit que se ha leído del registro de estado está en un nivel alto (1 lógico) se puede hacer la operación "Y" lógica (AND) de la lectura con un valor que resulta de elevar 2 a la posición que ocupa ese bit en el byte, y luego realizar la comparación.

Si el bit que se desea conocer es el bit 5, entonces la operación es:

Masc:=2^5=32

(Byte_leido AND masc)

En el caso que el bit 5 esté en un nivel alto:

Byte_leido

0	1	1	0	0	0	0	0	96
S7	S6	S5	S4	S3	S2	S1	S0	Posición

AND

Máscara = 32

Resulta

32= máscara

En el caso que el bit 5 no esté en un nivel alto:

Byte_leido

0	1	0	1	0	0	0	0	80
S7	S6	S5	S4	S3	S2	S1	S0	Posición

AND

Máscara = 32

Resulta

0 <> máscara

Si el bit 5 es 1, entonces el resultado es 16, o igual a masc.

Haciendo la comparación:

Si (Byte_leido AND masc) = masc entonces

Inicio

/* las acciones a realizar cuando el 4to bit es 1 */

Fin

Si el bit 5 es 0, entonces el resultado siempre es 0, lo cual es diferente a masc.

En caso que se desee realizar el enmascaramiento de más de un bit, se realiza la suma los valores.

Ej. Máscara para el bit 5 y el 7

Masc= 2^5+2^7=160

Lenguajes de interfaz

jueves, 14 de mayo de 2015