Detección de la
dirección base del puerto paralelo
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.
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
a,
b,
x,
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;
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);
gotoxy(8,24);write('[Copyrigth (c) 1997 por JCGR Soft <pparalelo@hotmail.com>]');
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
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
|
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
|
0
|
0
|
1
|
0
|
0
|
0
|
0
|
0
|
Máscara = 32
|
Resulta
|
0
|
0
|
1
|
0
|
0
|
0
|
0
|
0
|
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
|
0
|
0
|
1
|
0
|
0
|
0
|
0
|
0
|
Máscara = 32
|
Resulta
|
0
|
0
|
0
|
0
|
0
|
0
|
0
|
0
|
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
.
