Programando e acesso para porta paralela

Porta Paralela

Programando e acesso para portos

Descoberta do endereço funda da porta paralela

Primeiramente algum procedimento deveria ser tido que poder determinar que é o endereço que funda do porto.

Como foi dito previamente, a porta paralela tem seu endereço que funda de cor em dois endereços consecutivos. Então deveria ser lido o conteúdo destes endereços de cor para determinar se um porto existir e o qual seu endereço é.

MS-DOS

Debaixo de MS-DOS você pode usar o comando externo debug.exe do modo seguinte:

Executar o comando: debug.exe, então o símbolo se aparece -

Escrever depois deste sinal d 40:0008

Dependendo do time se aparece um transtornado da memória do modo seguinte: (os dados podem variar)

0040:0000 ______________________78 03 00 00 00 00 00 00

O endereço do porto está em forma investida (78 03), então o endereço é:

0378 em hexadecimal. É necessário fazer nota que este endereço pode ser diferente em outro PC.

(Q é escrito e então entra para deixar 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.

Analisador da porta paralela

Este analisador é usado para determinar o endereço funda do porto e também permite visualizar o conteúdo das inscrições em forma contínua e em formato binário e 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.

Envia e lendo de dados do porto

Remessa de dados para o porto

O paralelo o porto pode ser usado como uma comunicação direta com o PC, deste modo é possível desenvolver aplicações dentro tempo-real que precisa de um tempo rápido de resposta.

O acesso é levado escrever um byte (8 pedaços) em certa inscrição. Este byte deveria recorrer a cada um dos pedaços da inscrição. Isto significa que ele/ela deveria ser definido o byte para escrever em sistema binário.

Por exemplo se nós queremos escrever na inscrição de dados o pedaço D0 e o pedaço D2 o byte então que é:

0	0	0	0	0	1	0	1	= 5 em decimal
D7	D6	D5	D4	D3	D2	D1	D0	Inscrição de dados

Então, deveria ser escrito 5 na inscrição de dados (bases de endereço):

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}

Lendo de dados do porto

A leitura de dados é levada fora accesando um byte da certa inscrição. Ao fazer a leitura que deveria se tornar o byte para binário determinar o ou os pedaços que interessam. Note que a inscrição estatal só deveria ser lida, quer dizer, o base+1 de endereço.

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 exemplo, se o fato erudito for semelhante a 96, significa que os pedaços S5 e S6 são ativos (eles têm um nível alto, um 1).

0	1	1	0	0	0	0	0	= 96 em decimal
S7	S6	S5	S4	S3	S2	S1	S0	Inscrição estatal

Enmascaramiento

Tanto na remessa como recepção de dados binários, eles são levados fora operações a pedaços nível. Estas operações permitem isolar um mais pedaços. Este processo é denominado enmascaramiento.

Por exemplo, saber se certo pedaço que foi erudito da inscrição estatal está em um nível alto (1 lógico) que a pessoa pode fazer a operação "E" lógica (E) da leitura com um valor que é de elevar 2 à posição que ocupa aquele pedaço no byte, e então levar a cabo a comparação.

Se o pedaço que é querido que saiba for o pedaço 5, então a operação é:

Masc:=2^5=32

(Byte_leido E masc)

No caso que o pedaço 5 está em um nível alto:

Byte_leido

0	1	1	0	0	0	0	0	96
S7	S6	S5	S4	S3	S2	S1	S0	Posição

Máscara = 32

32 = máscara

No caso que o pedaço 5 não está em um nível alto:

Byte_leido

0	1	0	1	0	0	0	0	80
S7	S6	S5	S4	S3	S2	S1	S0	Posição

Máscara = 32

0 & lt; & gt; máscara

Se o pedaço 5 for 1, então o resultado é 16, ou semelhante a masc.

Fazendo a comparação:

Se (Byte_leido E masc) = masc então

Começando

/* as ações para levar a cabo quando o 4to pedaço é 1 */

Fim

Se o pedaço 5 for 0, então o resultado sempre é 0, que que é diferente a masc.

No caso de é querido que isso leve fora o enmascaramiento de mais que um pouco, ele/ela é levado fora a soma os valores.

Por exemplo Mascare para o pedaço 5 e os 7

Masc = 2^5+2^7=160

Novedades en nuestro Blog: Blog Puerto Paralelo
Comentarios, aportes, consultas, visite nuestro Foro: Foro Puerto Paralelo

Contador gratuito

Home