IL PORTO PARALLELO

 

Programmazione ed accesso a porto parallelo

 

 
 

Detecciónde la direzione basi di la  porta parallela

Innanzitutto deve aversi qualche procedimento per potere determinare quale la direzione è basi del porto.

Come si disse anteriormente, la porta parallela ha la sua direzione basi a memoria su due direzioni consecutive. Allora deve leggersi a memoria il contenuto di queste direzioni, al fine di determinare se esiste un porto e quale la sua direzione è.

MS-DOS

Sotto MS-DOS può usare il comando esterno debug.exe il seguente modo:

Eseguire il comando: dopo debug.exe, appare il simbolo -

Scrivere dopo questo segno d 40:0008

Dipendendo dalla squadra appare un rovesciato della memoria della seguente forma: , i dati possono variare,

0040:0000 ______________________78 03 00 00 00 00 00 00

La direzione del porto si trova in forma invertita (78 03), allora la direzione è:

0378 in hexadecimal. Sta fare notare che questa direzione può essere differente in altri PC.

, Si iscrive q e dopo enter per uscire da debug.exe,

In Turbo Pascal con assemblatore

Program buscar_base;

usa crt;

Var basi: word;

begin

asm

mov ax, 0040h {Collocare 0040h nel reg. Ax}

mov ex, ax {Indirizzare il segmento ex col valore di ax}

mov ax, es:[si] {Collocare a memoria in ax il contenuto della direzione [0040:0008]}

mov basi, ax; {Aggiornare la variabile base col valore di ax}

end;

writeln', La direzione basi su decimale è: ', basi,;

end.

   

In Turbo Pascal

Program buscar_base;

usa crt;

Var base:word;

Begin

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

writeln ('La direzione basi su decimale è: ', basi);

end.

 

 

Analizzatore di la  porta parallela

Questo analizzatore si usa per determinare la direzione basi del porto ed inoltre permette di visualizzare il contenuto dei registri in forma continua ed in formato binario e hexadecimal.

Questo programma si compila con Turbo Pascal.

{Archivio analisis.pas}

{Analizzatore di stato del Porto Parallelo}

{Autore: Juan Carlos Galarza Roca}

{Dicembre di 1997}

{Versione: 1.0}

Program analisis_PP;

usa crt, due, catena, utili;

var

dir_base,

dir_estado,

dir_control: Word;

puntero_int_1C: Pointer;

tick: Integer;

sw_m_t: Integer;

{$F+,S-,W -}

procedure manejador; interrupt;

{Questo manejador si usa per temporizzare lo spiegamento di quello

indicatore di esplorazione, in modo che si faccia la lettura di

dati e contemporaneamente si spieghi l'indicatore}

var

a,

b,

x,

e: Integer;

begin

if sw_m_t=0 then begin;

{sw_m_t è la bandiera del manejador di compiti

Questa bandiera è aggiornata per il programma

principale

}

x:=whereX;

y:=whereY;

{si guarda la posizione dal cursore sullo schermo}

tick:=tick+1;

{ La variabile tick si incrementa ogni 18,20677500572 secondi}

a:=6;

b:=3;

textcolor(7,;

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

textcolor(2,;

sposi 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,;

{Restituire la posizione originale del cursore}

end;

end;

{$F-,S+}

begin

cursor_off;

tick:=0;

{Collocare il manejador di compiti}

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 ('Analizzatore del Porto Parallelo',;

textcolor(9,;

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

textcolor(9,;

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

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

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

{Ciclo repetivo principale}

repeat

sw_m_t:=1;

textcolor(9,;

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

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

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

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

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

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

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

textcolor(7,;

gotoxy(9,9,; write ('Registro di Dati',;

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

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

textcolor(2,;

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

textcolor(7,;

gotoxy(9,14,; write ('Registro di Stato',;

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

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

textcolor(2,;

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

textcolor(7,;

gotoxy(9,19,; write ('Registro di Controllo',;

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

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

textcolor(2,;

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

textcolor(2,;

gotoxy(8,24);write (' [Copyrigth (c) 1997 per JCGR Soft < pparalelo@hotmail.com >]');

textcolor(7,;

sw_m_t:=0;

delay(100,;

until keypressed;

cursor_on;

{Restaurare manejador di compiti}

SetIntVec($1C,puntero_int_1C,;

end.

 

 

 

scrittura e lettura

scrittura di dati alla porta

La porta parallela può essere usato come in questo modo una comunicazione diretta col PC, è possibile sviluppare applicazioni in tempo-accampamento che abbiano bisogno di un rapido tempo di risposta.

L'accesso si realizza scrivendo un byte, 8 bits, in registro determinato. Questo byte deve riferirsi ad ognuno dei bits del registro. Questo significa che si deve definire il byte a scrivere in sistema binario.

Per esempio se vogliamo scrivere nel registro di dati il bit D0 ed il bit D2 il byte allora è:

 

0

0

0

0

0

1

0

1

= 5  En decimale

D7

D6

D5

D4

D3

D2

D1

D0

Registro di dati

 

Dopo, deve scriversi 5 nel registro di dati, direzione basi,:

Note:

dir_base e dir_estado è di tipo word, e dato è di tipo byte.

In Turbo Pascal

Port[dir_base]:=5;

In C

Outportb(dir_base, 5,;

In assemblatore

mov dx, dir_base {Indirizzare in dx la direzione basi}

mov al, 5 {Collocare in ² al ² il numero 5}

out dx, al {Inviare al porto}

 

Lettura di dati del porto

La lettura di dati si realizza accesando un byte del registro determinato. Facendo la lettura deve convertirsi il byte a binario per determinare egli o i bits che interessino. Noti che deve leggersi solo il registro di stato, cioè, la direzione base+1.

In Turbo Pascal

Var dato: byte;

dato:=Port[dir_estado];

In C

unsigned int dato;

dato=inportb(dir_estado,;

In assemblatore

    mov dx, dir_estado {Indirizzare dx col registro di stato del porto}

    in a quello, dx {Leggere del porto. Nel registro ² al ² sta il dato colto}

     

Per esempio, se il dato colto è uguale a 96, significa che i bits S5 e S6 stanno activos(tienen un livello alto, un 1.

0

1

1

0

0

0

0

0

= 96  En decimale

S7

S6

S5

S4

S3

S2

S1

S0

Registro di stato

 

Enmascaramiento

Tanto nell'invio come accoglienza di dati binari, si realizzano operazioni a livello di bits. Queste operazioni permettono di isolare uno più bits. Questo processo si denomina enmascaramiento.

Per esempio, per sapere se determinato bit che si è letto del registro di stato sta in un livello alto, 1 logico, si può fare l'operazione "E" logica (AND) della lettura con un valore che deriva da elevare 2 alla posizione che occupa quello bit nel byte, e dopo realizzare il paragone.

Se il bit che si desidera conoscere è il bit 5, allora l'operazione è:

Masc:=2^5=32

, Byte_leido AND masc,

Nel caso che il bit 5 stia in un livello alto:

Byte_leido

0

1

1

0

0

0

0

0

96

S7

S6

S5

S4

S3

S2

S1

S0

Posizione

AND

0

0

1

0

0

0

0

0

Maschera = 32

Risulta

0

0

1

0

0

0

0

0

32 = maschera

 

Nel caso che il bit 5 non stia in un livello alto:

Byte_leido

0

1

0

1

0

0

0

0

80

S7

S6

S5

S4

S3

S2

S1

S0

Posizione

AND

0

0

1

0

0

0

0

0

Maschera = 32

Risulta

0

0

0

0

0

0

0

0

0 <> maschera

 

Se il bit 5 è 1, allora il risultato è 16, o uguale a masc.

Facendo il paragone:

Se, Byte_leido AND masc, = masc allora

Inizio

/* le azioni a realizzare quando il 4to bit è 1 */

Fine

Se il bit 5 è 0, il risultato è allora sempre 0, egli quale è differente a masc.

In caso che si desideri realizzare l'enmascaramiento di più di un bit, si realizza la somma i valori.

Es. Maschera per il bit 5 ed il 7

Masc = 2^5+2^7=160

 

Se desidera ma informazione di la  Porta Parallela, non dubiti di comunicarsi con  pparalelo@hotmail.com

Google