THE PARALLEL PORT (Parallel ports)
Parallel Port

PARALLEL PORT

Home

Programming and access to ports

 

parallel port base address 

Firstly some procedure is due to have to be able to determine which is the base address of the port.

As it were said previously, the parallel port has its base address in two-way traffic consecutive of memory. Then the content of these directions of memory is due to read, in order to determine if a port exists and which is its direction.

 

MSDOS

Under MSDOS the external command can be used debug.exe in the following way:

Exec the command: debug.exe, soon appears the symbol -

Write after this sign d 40:0008

Depending on the equipment  appears the state  of the memory of the following form: (the data can vary)

0040:0000 ______________________78 03 00 00 00 00 00 00

The direction of the port is in inverted form (78 03), then the direction is:

0378 in hexadecimal. It is possible to make notice that this direction can be different in other PC.

(Write Q to leave debug.exe)

In Turbo Pascal with assembler

Program buscar_base;

use crt;

Var bases: Word;

begin

asm

mov ax, 0040h {Colocar 0040h in reg. Ax}

mov is, ax { the segment is with the value of ax}

mov ax, es: [if] { in ax the content of the memory direction [0040: 0008]}

mov bases, ax; {update the  bases variable with the value of ax}

end;

writeln (“the base address in decimal is: ”, bases);

end.

 

In Turbo Pascal

Program buscar_base;

use crt;

Var bases: Word;

Begin

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

writeln (“the base address in decimal is: ”, it bases);

end.

 

 

 

parallel port Analyzer

This analyzer is used to determine the base address of the port and in addition he allows to visualize the content of the records  in continuous form and binary format and hexadecimal.

This program compiles with Turbo Pascal.

{File analisis.pas}

{Analyzing of state of the Parallel port}

{Author: Juan Carlos Galarza Roca}

{December of 1997}

{Version: 1.0}

Program analisis_PP;

use 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;

{This manejador is used to temporizar the unfolding of

exploration indicator, so that the reading becomes of

data and simultaneously the indicator unfolds}

var

a,

b,

x,

Y: Integer;

begin

if sw_m_t=0 then begin;

{sw_m_t is the flag of the manejador of tasks

This flag is updated by the program

main

}

x: =whereX;

and: =whereY;

{keeps the position from the cursor in the screen}

tick: =tick+1;

{The variable tick is increased every 18.20677500572 seconds}

a: =6;

b: =3;

textcolor (7);

gotoxy (39+a, b); write (“Exploring… ”);

textcolor (2);

case 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, and);

{Devolver the original position of the cursor}

end;

end;

{$F-, S+}

begin

cursor_off;

tick: =0;

{Colocar the manejador of tasks}

GetIntVec ($1C, puntero_int_1C);

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

clrscr;

it dir_base: =memW [$0040: 0008];

dir_estado: =dir_base+1;

dir_control: =dir_base+2;

textcolor (2);

gotoxy (23,2); writeln (“Analyzing of the Parallel port”);

textcolor (9);

gotoxy (8,4); writeln (“Directions: ”);

textcolor (9);

gotoxy (10,5); writeln (“Data: ”, dec_a_hexa (it dir_base), “(h)”);

gotoxy (10,6); writeln (“Been: ”, dec_a_hexa (dir_estado), “(h)”);

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

{Main repetivo Cycle}

repeat

sw_m_t: =1;

textcolor (9);

gotoxy (34,4); writeln (“Been: ”);

gotoxy (36,5); write (“Data: ”, port [dir_base]: 3, “(d)”);

dec_bin (port [dir_base]); write (“(b)”);

gotoxy (36,6); write (“Been: ”, 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 (“Registry of Data”);

gotoxy (25,10); write (“Pins 9 8 7 6 5 4 3 2”);

gotoxy (25,11); write (“Name D7 D6 D5 D4 D3 D2 D1 D0”);

textcolor (2);

gotoxy (25,12); write (“Value”); dec_bin2 (port [dir_base]);

textcolor (7);

gotoxy (9,14); write (“Registry of State”);

gotoxy (25,15); write (“15 Pins 11 10 12 13 ** ** **”);

gotoxy (25,16); write (“Name - S7 S6 S5 S4 S3 ** ** **”);

textcolor (2);

gotoxy (25,17); write (“Value”); dec_bin2 (port [dir_estado]);

textcolor (7);

gotoxy (9,19); write (“Registry of Control”);

gotoxy (25,20); write (“Pins ** ** ** ** 17 16 14 1”);

gotoxy (25,21); write (“Name ** ** ** ** - C3 C2 - C1 - C0”);

textcolor (2);

gotoxy (25,22); write (“Value”); dec_bin2 (port [dir_control]);

textcolor (2);

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

textcolor (7);

sw_m_t: =0;

delay (100);

until keypressed;

cursor_on;

{Manejador Restaurar of tasks}

SetIntVec ($1C, puntero_int_1C);

end.

 

 

 

Shipment and reading of data of the port

Shipment from data to the port

The parallel port can be used like a direct communication with the PC, in this way is possible to develop applications in time-real that need a fast response time.

The access is made writing a byte (8 bits) in certain record. This byte must talk about to each one of the bits of the record. This means that the byte is due to define to write in binary system.

For example if we want to write in the data recoprd the bit D0 and the bit then D2 the byte is:

 

0

0

0

0

0

1

0

1

= 5 In decimal

D7

D6

D5

D4

D3

D2

D1

D0

data record

 

Soon, one is due to write 5 in the data record (base address):

Notes:

dir_base and dir_estado it is of Word type, and data is of type byte.

In Turbo Pascal

Port [dir_base]: =5;

In C

Outportb (it dir_base, 5);

In assembler

mov dx, dir_base {Direccionar in dx the base address}

mov to, 5 {Colocar in ² to ² number 5}

out dx, to {Enviar to the port}

 

Reading of data of the port

The reading of data is made accesando a byte of the certain registry. When doing the reading is due to turn the binary byte to determining he or the bits that interest. Notice that only the state registry is due to read, that is, the direction base+1.

In Turbo Pascal

Var data: byte;

data: =Port [dir_estado];

In C

unsigned int data;

dato=inportb (dir_estado);

In assembler

    mov dx, dir_estado {Direccionar dx with the registry of state of the port}

    in a, dx {Leer of the port. In the registry ² to ² is the read data}

     

For example, if the read data is equal to 96, it means that the bits S5 and S6 are active (they have a high level, a 1).

0

1

1

0

0

0

0

0

= 96 In decimal

S7

S6

S5

S4

S3

S2

S1

S0

Registry of state

 

Masking

As much in the shipment as reception of binary data, operations at level of bits are made. These operations allow to isolate one more bits. This process denominates masking.

For example, to know if certain bit that has been ***reflxed mng of the state registry it is in a high level (1 logical one) is possible to be conducted the operation “and” logic (AND) of the reading with a value that turns out to elevate 2 to the position that occupies that bit in the byte, and soon to make the comparison.

If the bit that is desired to know is bit 5, then the operation is:

Masc: =2^5=32

(Byte_leido AND masc)

In the case that bit 5 is in a high level:

Byte_leido

0

1

1

0

0

0

0

0

96

S7

S6

S5

S4

S3

S2

S1

S0

Position

AND

0

0

1

0

0

0

0

0

Mask = 32

It is

0

0

1

0

0

0

0

0

32= mask

 

In the case that bit 5 is not in a high level:

Byte_leido

0

1

0

1

0

0

0

0

80

S7

S6

S5

S4

S3

S2

S1

S0

Position

AND

0

0

1

0

0

0

0

0

Mask = 32

It is

0

0

0

0

0

0

0

0

0 <> mask

 

If bit 5 is 1, then the result is 16, or equal to masc.

Making the comparison:

If (Byte_leido AND masc) = masc then

Beginning

/* the actions to make when 4to bit is 1 *

Aim

If bit 5 is 0, then the result always is 0, which is different from masc.

In case it is desired to make the camouflage of more of a bit, it is made the sum the values.

Ej. Mask for bit 5 and the 7

Masc= 2^5+2^7=160

 

Questions? pparalelo@hotmail.com

Try searching here:  

 

Look our Blog: Parallel Ports Blog
Forum: Parallel Ports forum
PCI Parallel port cards

 

 

 

 

Google
 

 

Home