 |
| |
| ||
|
| |
| ||
Programmazione ed accesso a porto parallelo
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 è.
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.
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 <
textcolor(7,;
sw_m_t:=0;
delay(100,;
until keypressed;
cursor_on;
{Restaurare manejador di compiti}
SetIntVec($1C,puntero_int_1C,;
end.
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}
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 |
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
