BB Electronics TV Converter Box PPIO User Manual

Not Recommended for New Installations.

Please contact Technical Support for more information.

Parallel Port Input/Output Converter

Model PPIO

Document No. PPIO2899

B&B Electronics Mfg. Co. Inc.

707 Dayton Road -- P.O. Box 1040 -- Ottawa, IL 61350 USA

Phone (815) 433-5100 -- General Fax (815) 433-5105

Home Page: www.bb-elec.com

Sales e-mail: [email protected] -- Fax (815) 433-5109

Technical Support e-mail: [email protected] -- Fax (815) 433-5104

.PPIO2899 Manual

Cover Page

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

INTRODUCTION

The PPIO allows you to connect your IBM PC (or clone)

computer to the outside world using the computer’s parallel port.

The eight I/O points can be used as either inputs or outputs. As an

output they can control voltages as high as 50 Volts DC and can

handle currents as high as 500 mA DC. As an input they can handle

voltages from 0 to 50 volts with a threshold of 2.5 Volts DC.

CAUTION: Each output of the PPIO can dissipate 1 Watt when

used alone, however, all eight outputs together cannot

dissipate more than 2.25 Watts.

NOTE: The PPIO connects to the parallel port of your computer and

uses most of the available pins on that port. You MUST use a cable

that connects pins 1 through 17 of the DB-25 connector to the PPIO

for it to work properly. To be safe you should use a cable that

connects all 25 pins from connector to connector.

NOTE: The PPIO can only be used with parallel ports that are in

“compatible” or “normal” mode. It will not function properly with

parallel ports in ECP or EPP modes. The mode of the parallel port

can be changed in the BIOS setup by pressing either the F2 key or

DEL key just after the computer begins the boot procedure.

The PPIO comes with sample DOS programs written in

GWBASIC, QuickBASIC, Pascal, and C. These sample programs

can be used "as is" to test the PPIO and to control and display the

status of its I/O pins. Parts of these programs can be used in other

programs to make it easier to interface to the PPIO. Also, by

studying these programs a programmer can learn how to write code

in any language to do a similar job.

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

Packing List

Examine the shipping carton and contents for physical damage.

If there is damage, contact B&B Electronics immediately. The

following items should be in the shipping carton:

PPIO unit

This Instruction Manual

PPIO Sample/Test Disk

If any of the above items is missing contact B&B Electronics

immediately.

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

PC PARALLEL PORT DESCRIPTION

To understand how the PPIO can be controlled you must

first understand how the parallel port works inside the computer. The

parallel port is designed to connect the computer with the outside

world. It can have up to 12 TTL compatible outputs and up to 9 TTL

compatible inputs. It cannot have both at the same time since some

inputs and outputs share pins. Eight of the outputs and five of the

inputs are dedicated. Four of the lines can be either inputs or

outputs.

The main use for the parallel port is to send data to a

printer. The port uses the eight dedicated outputs for data and the

other lines for handshakes. Under normal printer operation, the

computer will put an eight-bit byte on the eight lines (pins 2-9) and

then use the Strobe output (pin 1) to tell the printer to read the data.

Upon receipt of an Acknowledge (pin 10) from the printer the

computer knows that the eight bit word was received. It can then

send the next word. Other lines are used for busy, off line, etc.

All the control of the parallel port is done through software. If

you look at the hardware you find that the parallel port is connected

directly to the computer bus. This means that we can address these

inputs and outputs in any way we want if we do not use the port to

drive a printer.

Each PC has port addresses where the parallel ports, serial

ports, hard disk, etc. can be addressed. These are located in the

address range from 0000H to 03FFH (the H indicates the use of the

hexadecimal numbering system). Each parallel port has one main

port address for outputting data. The next two addresses above that

address are used for handshaking control. For instance, on a typical

computer a parallel port could be located at address 0378H. The

handshaking lines will then be located at 0379H and 037AH. Table 1

shows the correspondence between the bits of the port and the pins

of the DB-25 female connector.

Referring to Table 1, if you output a 01H (which is 00000001

in binary) to your computer’s port 0378H, then pin 2 of the parallel

port’s DB-25 connector will be HIGH and pins 3 through 9 will be

LOW. To do this using GWBASIC you would use the command:

OUT &H378,&H01. Using this method you can output any pattern

you wish on pins 2 through 9 of the parallel port. To turn ON pins 2,

4, 6, and 8 use: OUT &H378,&H55. 55H is the same as 01010101

binary. This port (0378H) can be read as an input, but mostly it is

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

used to read the status of the port. The PPIO does not need to use

this port as an input port.

Again, referring to Table 1, if you input the data on port

0379H, then whatever TTL level pins 15, 13, 12, 10, and 11 are will

show up as bits 3 through 7. The state of bits 0, 1, and 2 will be

unknown since they are not hooked to anything, but they probably

will be HIGH (ONE). Note that the data on pin 11 will be inverted, if

pin 11 is LOW you will get a HIGH on bit 7. The pins with the “bars”

over them are all inverted. This is done by the hardware in the

parallel port over which we have no control. A way to read these pins

using GWBASIC is: A1=INP(&H379). A1 will then have the results of

the input from port address 0379H. Bit 3 of A1 will have the status of

pin 15, bit 4 the status of pin 13, etc.

Note that on the third address (037AH) the pins can be

either inputs or outputs. If you use the GWBASIC command OUT

&H37A,&H01 (00000001 BINARY) then pin 1 will be LOW (because

it is inverted), pins 14 and 17 will be HIGH (they also are inverted),

and pin 16 will be LOW (it is not inverted).

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

378H

379H

37AH

Output

Input

Output

Input

Output

Input

BIT

See

Note 2 Note 2

Table 1

Note 1: X means no connection to any DB-25 pin.

Note 2: Bit 4 of 37AH as an output is used to control the interrupt IRQ7.

When this bit is HIGH, IRQ7 is enabled and when this bit is LOW, IRQ7 is

disabled. As an input, this reads the status of the IRQ7 interrupt to see if it

is enabled or not.

Note 3: The “bars” over the top of some pin numbers indicate that those

signals are inverted (in hardware) from PC's bus to DB-25 pin.

You can also read pins 1, 14, 16, and 17 using the INP(&H37A)

command. For this to work properly, you must first force all the

outputs HIGH. The way the parallel port is wired, if you do not force

the outputs HIGH they will interfere with the inputs. To do this, use

the command OUT &H37A,&H04 (04H is the same as 00000100

binary). Pins 1, 14, and 17 are inverting so a ZERO written to them

forces them HIGH. Pin 16 is non-inverting so the ONE written to it

forces it HIGH. After issuing the OUT command you can then do a

A2=INP(&H37A) that will read the TTL levels on those pins. In this

case the four upper bits (bits 4-7) will be unknown, but will probably

be HIGH.

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

There are three port addresses that are normally used on a PC

for parallel ports: 3BCH, 378H, and 278H. When your PC is reset or

turned on these three addresses are scanned by the BIOS in the

order shown above. The first one that the BIOS finds with a parallel

port installed is assigned the logical name LPT1. The second, LPT2,

etc. You can connect the PPIO to a port located at any of these

three addresses. During power up the computer will assign that port

a logical name but we will ignore it and communicate to the port

directly.

If you are using a base address of 0278H the I/O port addresses

in Table 1 would change to 0278H, 0279H, and 027AH. With a base

address of 03BCH the addresses are 03BCH, 03BDH, and 03BEH.

Check your computer manual to find out which address your parallel

port has. It is also possible to purchase a special parallel port from

B&B Electronics that can be set at any address in the I/O port

address space from 0000H to 03FFH.

The above parallel port information is true for the vast majority of

the PC compatible ports. However, a few computer manufacturers

have chosen to make their parallel ports non-standard. On some

battery powered computers pins are disabled to save power. Some

ports may also have extra “direction control” bits. If you have

problems where one or more bits are always on or off you should

check your owner's manual. You may have to enable the port or set

the “direction bit” correctly to get the port to work with the PPIO. If a

pin is missing you may have to install a different parallel port card to

get the PPIO to work properly.

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

PPIO DESCRIPTION & CONNECTION

The PPIO makes use of the eight output pins (pins 2 through 9)

at address 378H to drive its eight outputs. It uses the upper four bits

of address 379H (pins 13, 12, 10, and 11) for the upper four input

bits of the PPIO. It uses the lower four input bits of address 37AH

(pins 1, 14, 16, and 17) for the lower four input bits of the PPIO. This

assumes you are using the same port addresses as in Table 1. In

this way the PPIO can have eight inputs or eight outputs. Refer to

Figure 1 for the PPIO schematic.

Each pin of the PPIO is bi-directional. It can be used as either an

input or an output. Referring to Figure 1 you will see that PPIO bit 0

can be driven by pin 2 of the parallel port or it can be read by pin 1 of

the parallel port. The drivers are open collector Darlington

transistors that can sink up to 500 mA and are protected by “kick

back” diodes that are connected to the positive power supply. These

outputs can handle voltages as high as 50 Volts DC. If bit 0 of port

0378H is HIGH, pin 2 of the parallel port is HIGH and the PPIO

output pin will be LOW and can sink 500 ma. If bit 0 goes LOW, pin

2 will go LOW and the PPIO transistor will go OFF.

To use PPIO I/O bit 0 as an input you first set bit 0 of port 378H

LOW to turn OFF the driver transistor. From then on, if you force the

PPIO bit 0 to ground, a LOW will show up on pin 1 of the DB-25

connector. If you look at Table 1 you will note that pin 1 is inverting

in the computer parallel port. This means that a LOW on pin 1 will

show up as a HIGH in the computer. This is called negative true

logic. The PPIO receivers are set up as inverters or non-inverters to

compensate for the inverting and non-inverting inputs of the parallel

port.

All you have to remember is that if you force one of the PPIO I/O

bits to ground, it will be a ONE when you read it in the computer. If

you leave the PPIO I/O pin open or force it HIGH (above 2.5 volts), it

will be a ZERO when you read it in the computer.

PPIO I/O bits 0 through 3 are connected to bits 0 through 3 of

port 037AH and PPIO I/O bits 4 through 7 are connected to bits 4

through 7 of port 0379H. (This assumes that you are using a parallel

port at 0378H in your computer.) A LOW on any PPIO I/O pin will

show up as a HIGH on the corresponding bit in the computer.

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

Figure 1

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

CONTROLLING THE PPIO USING GWBASIC

Refer to the fragment of GWBASIC code in Figure 2 to see how

to input the bits and make one 8-bit word.

100 OUT &H37A,&H04:

REM This disables the 37AH Outputs

REM inside of the computer

REM so that we can use

REM 37AH as an input port.

REM It also disables

REM the IRQ7 interrupt.

120

140

160

180

200

300 A1=INP(&H37A) AND &H0F: REM Input the

320

340

360

380

REM lower 4 bits

REM and mask OFF

REM (force to 0)

REM the upper 4 bits.

400 A2=INP(&H379) AND &HF0: REM Input the high 4 bits

420

440

REM and mask OFF

REM the lower 4 bits.

460 IB=A1 OR A2 :

480

REM This combines them

REM into one Input Byte.

Figure 2

The above assumes that you are using a parallel port located at

0378H. If you are using a different port you will have to replace the

hex addresses shown with the proper ones for your port. Refer also

to the PPIO.BAS program on the supplied disk for an example of

how to use GWBASIC to interface with the PPIO.

To output bits from the computer to the PPIO interface (still

using GWBASIC and the above 0378H example) use the following

line:

500 OUT &H378,OB

Where OB is the byte you want to output. If, for instance, you want

to turn ON (force LOW) PPIO bit 0, you must turn ON (force HIGH)

bit 1 of the variable OB. This can be done by ORing OB with &H01.

If you want to turn OFF (force HIGH or open) the same PPIO pin you

must turn OFF (force LOW) bit 1 of OB. Do this by ANDing OB with

NOT &H01. Use the data Table 2 to handle all eight PPIO bits.

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

I/O Bit

Force I/O ON

(Low)

Force I/O OFF

(High)

OR &H01

OR &H02

OR &H04

OR &H08

OR &H10

OR &H20

OR &H40

OR &H80

AND NOT &H01

AND NOT &H02

AND NOT &H04

AND NOT &H08

AND NOT &H10

AND NOT &H20

AND NOT &H40

AND NOT &H80

Table 2

The big advantage of using the ANDing and ORing as shown in

Table 2 is that it makes each PPIO pin independent. If you have, for

instance, PPIO bit 2 ON and all of the rest of the bits OFF then your

variable OB will be equal to 04H (00000100 binary). PPIO bit 2 will

be LOW or ON. If you then want to turn ON bit 3 do the following:

500 OB=OB OR &H08

520 OUT &H378,OB

Bit 3 will go LOW and bit 2 will stay LOW. At that time OB will be

equal to &H0C (00001100 binary). To turn OFF bit 3 do the

following:

700 OB=OB AND NOT &H08

720 OUT &H378,OB

Bit 3 will go HIGH or open and bit 2 will stay LOW. By using the OR

and AND NOT commands in Table 2, bit 3 has been turned ON and

OFF without disturbing any of the other PPIO Bits.

You may also use the PPIO with some pins as inputs and some

pins as outputs. There can be any number of each and in any order.

Remember that before you can use a PPIO pin as an input you must

first force the output driver on that pin OFF by putting a ZERO on

that bit. For example suppose we want to use bits 0, 1, and 2 as

outputs and bits 3, 4, 5, 6, and 7 as inputs. We also want bit 1 to be

ON (or LOW) when we start the program. We need to turn OFF bits

3, 4, 5, 6, and 7 so we can use them as inputs and turn ON the

output bit 1. You should modify Figure 2 to add the following line:

180 OUT &H378,&H02

From then on you can use the first three lines of Table 2 to

control the three outputs and lines 220-320 of Figure 2 to input data.

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

When you input the 8-bit word using lines 300-460 of Figure 2,

note that you also get the status of the outputs. If some I/O bits are

used by the PPIO as outputs the status of the bits you read will tell

you the status of the PPIO outputs. If PPIO output bit 0 is LOW then

bit 0 of IB (the variable InputByte) will be HIGH (1). This can be used

to check that the PPIO hardware is connected and is working

properly. If, through a fault, a PPIO bit is shorted to ground then,

when you read that bit it will be HIGH no matter what you output to

the PPIO bit. If there are no shorts or inputs that are LOW on the

PPIO pins then any byte you output should come back the same

when you input.

A good way to test for shorts is by outputting a &HAA (10101010

binary) and checking to see that the input is the same. Then output

a &H55 (01010101 binary) and check the input. This tests for both

pin-to-pin shorts and shorts to ground. At the same time this tests

that the PPIO is plugged in properly and you have the correct port

selected. This will not work if any of the PPIO pins are connected to

a device that is grounding or holding a pin LOW. If you have this

problem you will have to ignore these bits when you read the port.

NOTE: If the PPIO is connected properly and the upper four outputs

(4 - 7) are functional, but the lower four outputs (0 - 3) are not

functional, the parallel port may be in ECP or EPP mode. It must be

in “compatible” or “normal” mode for the PPIO to work properly. The

mode of the parallel port can be changed in the BIOS setup by

pressing either the F2 key or DEL key just after the computer begins

the boot procedure.

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

CONTROLLING THE PPIO USING PASCAL

The PPIO disk includes two source code files as an example of

using the PPIO with the Pascal programming language. PPIO.PAS

is the main routine of the example program. PPIOUNIT.PAS

contains the routines for communicating with the PPIO. In the rest of

this section, we assume that you know the Pascal programming

language. Consult your reference manuals if you need help with the

language.

The Pascal Unit, PPIOUNIT.PAS handles communication with

the parallel port. It defines five variables. They are defined as:

Input_Byte

Output_Byte

Base_Address

Status_Address

Control_Address

: BYTE;

: WORD;

{ Byte that’s read from PPIO }

{ Byte that’s written to PPIO }

{ Base address of Parallel Port }

{ Status Register Address }

{ Control Register Address }

No function outside the Unit can directly access these variables.

Functions outside the Unit call functions within the Unit to modify

and return the value of these variables.

The procedure Set_Start, sets the variable Base_Address,

Status_Address, Control_Address and Output_Byte. It also sets up

the initial state of the parallel port. The function is defined as:

PROCEDURE Set_Start(Address:WORD; Init:BYTE);

BEGIN

Base_Address

Status_Address

Control_Address

:= Address;

{Parallel Port Base Address}

:= Base_address+1; {Parallel Port Status Address}

:= Base_Address+2; {Parallel Port Control Address}

PORT[Base_Address]:= Init;

{Write Init Value to Output Address}

{Put Init value In the Output_Byte Var}

Output_Byte

:= Init;

END; {Set_Start}

This function must be the first one used, because all other functions

assume that the variables have been set.

The Procedure, Set_IRQ_OFF, tells the parallel port not to

generate any interrupts. This should be called immediately after

Set_Start. It is defined as:

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

PROCEDURE Set_IRQ_Off;

BEGIN

PORT[Control_Address] := $04;{Write 4 to disable IRQ}

END; {Set_IRQ_Off}

The function, In_Byte, returns the value of the variable,

Input_Byte. It is defined as:

FUNCTION In_Byte : Byte;

BEGIN

In_Byte := Input_Byte;

End; { In_Byte }

Notice that this does not read the value of the parallel port. The

function Read_Input_Bit reads the port.

The function, Out_Byte, returns the value of the variable

Output_Byte. It is defined as:

FUNCTION Out_Byte : Byte;

BEGIN

Out_Byte := Output_Byte;

End; { Out_Byte }

Notice that this does not read the parallel port. It only returns the

value of Output_Byte.

The function, Read_Input_Bit, returns the status of the specified

input line. The function is defined as:

FUNCTION Read_Input_Bit (Bit_Number:BYTE) : BYTE;

BEGIN

Input_Byte := (PORT[Status_Address] AND $F0)

OR (PORT[Control_Address] AND $0F) ;

IF ( (Input_Byte AND (1 SHL Bit_Number) ) = 0 ) THEN

Read_Input_Bit := 0

ELSE

Read_Input_Bit := 1;

END; {Read_Input_Bit}

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

The parallel port’s status register stores the upper nibble (four

bits) of the input line status. Since the smallest value that can be

read from the port is a byte, some work must be done to get only the

upper nibble’s value. We read a byte from the status register and

bitwise AND it with F0h (240 decimal, 11110000 binary). This sets

the lower nibble of the byte to zero.

The parallel port’s control register stores the low nibble of the

input line status. A method, similar to the one used to get the high

nibble, extracts the low nibble. We read a byte from the control

This sets the upper nibble of the byte to zero.

Now, combine both bytes into one value by bitwise ORing them

together. This value is stored in the variable Input_Byte. At this point,

the upper nibble of Input_Byte is the same as the upper nibble of the

status register and the lower nibble of Input_Byte is the same as the

lower nibble of the control register.

To return the status of a specific line, a test is done to determine

the state of the line’s corresponding bit stored in Input_Byte. To

determine the bit’s state, all other bits of Input_Byte are set to zero.

This is done by bitwise ANDing Input_Byte with the mask value of

the desired line shown in the following table.

Mask Value

Line

Hex

01h

02h

04h

08h

10h

20h

40h

80h

Decimal

Binary

00000001

00000010

00000100

00001000

00010000

00100000

01000000

10000000

128

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

Notice that in the binary representation of the mask value, line

zero’s mask has bit number zero set, and line one’s mask has bit

number one set, etc. So, instead of retrieving the mask value from a

table, the value is calculated by shifting 00000001b (1 decimal, 01

hexadecimal) right the same number of times as the desired line

number. Once the mask value is calculated, it is bitwise ANDed with

Input_Byte. If the resulting value is non-zero, the line is ON and a

boolean TRUE is returned, otherwise a boolean FALSE is returned.

For example:

Line_Number = 3

Status Register Value = 01010101b

Control Register Value = 10101010b

01010101b (Status Register)

AND

11110000b (F0h mask)

01010000b

10101010b (Control Register)

00001111b (0Fh mask)

AND

00001010b——> OR

00001010b

01011010b

00000001b (1 decimal)

shift-right 3(Line_Number)= AND

00001000b(bit mask)

00001000b

The function, Output_Bit, returns the status of the selected

output line. The function is defined as:

FUNCTION Output_Bit (Bit_Number:BYTE) : BYTE;

BEGIN

If ( ( Output_Byte AND (1 SHL Bit_Number ) ) = 0 THEN

Output_Bit : = 0

ELSE

Output_Bit : = 1;

END; {Output_Bit}

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

As with the function, In_Byte, the mask value is calculated by

shifting 00000001b right the same number of times as the desired

line number. Once the mask value is calculated, it is bitwise ANDed

with Output_Byte. If the resulting value is non-zero, the line is ON

and a boolean TRUE is returned, otherwise a boolean FALSE is

returned. Notice that this function gets its value from Output_Byte

that is set when we use the function, Set_Output_Bit. The value is

not read from the port.

For example:

Line_Number = 3

Output_Byte = 10101010b

00000001b

shift-right 3 (Line_Number) =

AND

00001000b

10101010b (Output_Byte)

00001000b

The function, Set_Output_Bit, sets the selected output line ON of

OFF. The function is defined as:

PROCEDURE Set_Output_Bit ( Bit_Number,Output:BYTE ) ;

BEGIN

Output_Byte := ( (Output_Byte AND ( ( 1 SHL Bit_Number)

XOR $FF) ) OR (Output SHL Bit_Number) ) ;

Port [Base_Address] : = Output_Byte;

END; {Set_Output_Bit}

The variable, Output_Byte, stores the status of the output lines.

When a bit in Output_Byte is set to a one, its corresponding output

line is ON, when it is set to a zero, the line is OFF. To set a bit to the

specified status, the bit must first be cleared. To do this, 00000001b

is shifted right for the desired line number and bitwise exclusive

ORed with FFh (255 decimal, 11111111 binary) to produce a mask

value. This mask value has all bits set to one except for the desired

line. It is bitwise ANDed with Output_Byte to clear the desired bit.

Now, having cleared the bit, it can be set to the specified state.

Since the state is either a zero or one, we can shift it right for the

desired line number to get another mask value. This value is then

bitwise ORed with the cleared value to obtain the new value of

Output_Byte. The final step is to write Output_Byte to the parallel

port.

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

For example:

Output_Byte

= 01010101b

Line_Number = 3

Status = 1

00000001b (1 decimal)

shift-right 3 (Line_Number) =

00001000b

XOR 11111111b

11110111b (mask 1)

AND

01010101b (Output_Byte)

01010101b

00000001b (Status)

shift-right 3 (Line_Number) = OR

00001000b (mask 2)

01011101b (New Output_Byte)

For an example of an application that uses these functions, look

at the source code in PPIO.PAS.

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

CONTROLLING THE PPIO USING C

The PPIO disk includes three source code files as an example

of using the PPIO with the C programming language. PPIO.C is the

main routine of the example program. PPIOFUNC.C contains the

routines for communicating with the PPIO. PPIOFUNC.H contains

the function prototypes and definitions for use by PPIOFUNC.H and

PPIO.C. In the rest of this section, we assume that you know the C

programming language. Consult your reference manuals if you need

help with the language.

PPIOFUNC.H makes some definitions used in the rest of this

section.

#define Status_Address Base_Address+1

#define Control_Address Base_Address+2

typedef enum { false=0, true=1 } boolean;

The module, PPIOFUNC.C, handles communication with the

parallel port. It defines three variables that all functions inside the

module can access. They are defined as:

unsigned char Input_Byte;

unsigned char Output_Byte;

unsigned int Base_Address;

No function outside the module can directly access these

variables. Functions outside the module call functions within the

module to modify and return the value of these variables.

The function, Set_Start(), sets the variables Base_Address and

Output_Byte. It also sets up the initial state of the parallel port. The

function is defined as:

void Set_Start(unsigned int Address, unsigned char Init)

{

Base_Address = Address;

Output_Byte = Init;

outport(Base_Address, Output_Byte);

}

This function must be the first one used, because all other functions

assume that variable, Base_Address, has been set.

PPIO2899 Manual

B&B Electronics Mfg Co Inc – 707 Dayton Rd - PO Box 1040 - Ottawa IL 61350 - Ph 815-433-5100 - Fax 815-433-5104

The function, Set_IRQ_OFF(), tells the parallel port not to

generate any interrupts. This should be called immediately after

Set_Start(). It is defined as:

void Set_IRQ_Off(void)

{

outport (Control_Address, 0x04);

}

The function, In_Byte(), returns the value of the variable,

Input_Byte. It is defined as:

unsigned int In_Byte(void)

{

return (Input_Byte);

}

Notice that this does not read the value of the parallel port. The

function Read_Input_Bit() reads the port.

The function, Out_Byte(), returns the value of the variable

Output_Byte. It is defined as:

unsigned int Out_Byte(void)

{

return (Output_Byte);

}

Notice that this does not read the parallel port, it only returns the

value of Output_Byte.

The function, Read_Input_Bit(), returns the status of the

specified input line. The function is defined as:

boolean Read_Input_Bit(unsigned char Line_Number)

{

Input_Byte = (inport(Status_Address) & 0xF0) |

(inport(Control_Address) & 0x0F);

return ( ((Input_Byte & (1 << Line_Number)) != 0) );