Parallel port Interfacing Tutorial

Introduction

           Parallel port is a simple and inexpensive tool for building computer controlled devices and projects. The simplicity and ease of programming makes parallel port popular in electronics hobbyist world. The parallel port is often used in Computer controlled robots, Atmel/PIC programmers, home automation, ...etc... Here a simple tutorial on parallel port interfacing and programming with some examples.

           Everybody knows what is parallel port, where it can be found, and for what it is being used. the primary use of parallel port is to connect printers to computer and is specifically designed for this purpose. Thus it is often called as printer Port or Centronics port (this name came from a popular printer manufacturing company 'Centronics' who devised some standards for parallel port). You can see the parallel port connector in the rear panel of your PC. It is a 25 pin female (DB25) connector (to which printer is connected). On almost all the PCs only one parallel port is present, but you can add more by buying and inserting ISA/PCI parallel port cards.

Parallel port modes           The IEEE 1284 Standard which has been published in 1994 defines five modes of data transfer for parallel port. They are,

      1) Compatibility Mode       2) Nibble Mode      3) Byte Mode      4) EPP      5) ECP

           The programs, circuits and other information found in this tutorial are compatible to almost all types of parallel ports and can be used without any problems (Not tested, just because of confidence ! ). More information on parallel port operating modes can be found here.

HardwareThe pin outs of DB25 connector is shown in the picture below

                 

The lines in DB25 connector are divided in to three groups, they are

      1) Data lines (data bus)      2) Control lines      3) Status lines

           As the name refers , data is transferred over data lines , Control lines are used to control the peripheral and of course , the peripheral returns status signals back computer through Status lines. These lines are connected to Data, Control And Status registers internally . The details of parallel port signal lines are given below

Pin No (DB25)

Signal name

DirectionRegister - bit

Inverted

1 nStrobe Out Control-0 Yes

2 Data0 In/Out Data-0 No

3 Data1 In/Out Data-1 No

4 Data2 In/Out Data-2 No

5 Data3 In/Out Data-3 No

6 Data4 In/Out Data-4 No

7 Data5 In/Out Data-5 No

8 Data6 In/Out Data-6 No

9 Data7 In/Out Data-7 No

10 nAck In Status-6 No

11 Busy In Status-7 Yes

12Paper-

Out In Status-5 No

13 Select In Status-4 No

14 Linefeed Out Control-1 Yes

15 nError In Status-3 No

16 nInitialize Out Control-2 No

17nSelect-Printer

Out Control-3 Yes

18-25 Ground - - -

Parallel port registers           As you know, the Data, Control and status lines are connected to there corresponding registers inside the computer. So by manipulating these registers in program , one can easily read or write to parallel port with programming languages like 'C' and BASIC.

The registers found in standard parallel port are ,

      1) data register      2) Status register      3) Control register

           As there names specifies, Data register is connected to Data lines, Control register is connected to controll lines and Status lregistyer is connected to Status lines. (Here the word connection does not mean that there is some physical connection between data/control/status lines. The

registers are virtually connected to the corresponding lines.). So what ever you write to these registers , will appear in corresponding lines as voltages, Of course, you can measure it with a multimeter. And What ever you give to Parallel port as voltages can be read from these registers(with some restrictions). For example , if we write '1' to Data register , the line Data0 will be driven to +5v. Just like this ,we can programmatically turn on and off any of the data lines and Control lines.

Where these registers are ?           In an IBM PC, these registers are IO mapped and will have unique address. We have to find these addresses to to work with parallel port. For a typical PC , the base address of LPT1 is 0x378 and of LPT2 is 0x278. The data register resides at this base address , status register at baseaddress + 1 and the control register is at baseaddress + 2. So once we have the base address , we can calculate the address of each registers in this manner. The table below shows the register addresses of LPT1 and LPT2

Register LPT1 LPT2

data registar(baseaddress + 0) 0x378 0x278

status register (baseaddress + 1) 0x379 0x279

control register (baseaddress + 2) 0x37a 0x27a

Programming Concepts           Almost all programming languages allow programmers to access parallel port using some library functions. For example , Borland C is providing "Inportb" and "Outportb" functions to read or write IO mapped peripherals. But the examples provided here in this tutorial is written VC++ and can be easily ported to other compilers like Borland C and Turbo C. Visual Basic does not have any functions or support to access parallel port directly, but it is possible to add such capabilities to your VB application by writing a dll in VC++ and calling its exported functions from VB. VC++ provides two functions to access IO mapped peripherals, '_inp' for reading and '_outp' for writing. These functions are declared in "conio.h".

Hardware for testing sample programs            The schematic diagram of the test circuit is shown below. It is recommended to build this circuit before testing the sample programs

Sample program in VC++

           Writing a parallel port interfacing program in VC++ is very easy. Here is the steps to write your first parallel port interfacing application in VC++.

           Start VC++ IDE , Select 'New' from File menu.Then select ?Win32 Console Application? from ?Projects? tab(picture-3). enter project name as ?partest1? , then click OK button.

Picture-3

Now you can see a dialog box with caption ?Win32 Console Application - step 1 of 1? (picture-4).

Picture-4

Select ?a simple Application? and click Finish. Now open exaple1.cpp from ?fileview? and replace the existing code with the code given below.

#include "stdafx.h"#include "conio.h"#include "stdio.h"#include "string.h"#include "stdlib.h"

int main(int argc, char* argv[]){

short data;

if(argc<2){

printf("Usage\n\n");printf("partest1.exe ,,\n\n\n");return 0;

}

if(!strcmp(argv[1],"read")){

data = _inp(atoi(argv[2])); printf("Data read from parallel port

is ");printf("%d\n\n\n\n",data);

}

if(!strcmp(argv[1],"write")){

_outp(atoi(argv[2]),atoi(argv[3])); printf("Data written to parallel

port is ");printf("%s\n\n\n\n\n",argv[3]);

}return 0;

}

           Build the project and copy partest1.exe to "c:\".

How to Test The Program ?

           Connect The assembled hardware shown above to your PC's parallel port. Open DOS command window Move to "C:\" and type "partest1 write 888 255" and press enter. If everything is correct , LED1 to LED8 in the hardware will glow. You may be doubtful about the command line parameters passed to the program. Here 888(0x378) is the address of the parallel port data register and 255 is the data to be written to parallel port data register. if you enter "partest1 read 888" to command line , the program will read parallel port data register and display it. This will blindly read the contents of parallel port data register , but not the data present on data lines. To read the data from the data lines , we will have to enable the bidirectional data transfer first. To enable Biirectional data transfer just set the "Bidirectional" bit (bit 5) in control register. This is done by writing 32 to control register. The command "partest1 write 890 32" will do this. After entering this command you can read the status of switches in the hardware using the command "partest1 read 888"

Want to know more about parallel port..?, get this book

NOTE: This sample program will not work on Windows NT/2000 or XP if you run the program on these machines , it will show an error. use new Inpout32.dll on NT/2000/XP machines

Inpout32.dll for WIN NT/2000/XP

The Problem

             Writing programs to talk with parallel port was pretty easy in old DOS days and in

Win95/98 too. We can use Inporb and outportb or _inp() or _Outp functions in our program without any problem if we are running the program on Dos or WIN95/98. But entering to the new era of NT clone operating systems like WIN NT4, WIN2000, WINXP, all this simplicity goes away. Being interested in Parallel port interfacing and programming you might have experienced the problems in writing a program that can talk to parallel port successfully in NT based operating systems. When we are trying to run a program which is written using the the conventional software functions like Inporb, outportb, _inp() or _Outp on a WINNT or WIN2000 system, it will show an error message that "The exception privileged instruction occurred in the application at location ....". The picture of such a messagebox is given below.

             Staring to this messagebox, you might have been thinking that "did i make a mistake in my program ?" it is working fine on WIN98 ... Who is guilty here. 'Nobody' that is the answer. Then why it is happening like this ..? The answer is in the next paragraph

                 Being a very secure operating system, Windows NT assigns some privileges and restrictions to different types of programs running on it.It classifies all the programs in to two categories , User mode and Kernel mode ie; running in ring3 and ring0 modes. user mode programs are running in ring3 mode and Kernel mode programs are running in ring0 mode. The programs you generally write falls in the user mode category. The user mode programs are restricted to use certain instructions like IN, OUT etc.. Whenever the operating system find that a user mode program is trying to execute such instructions , the operating system stops execution of those programs and will display an error message. Eventually our interfacing programs stops where they are executing IN or OUT instructions to read or write data to parallel port. But in the same time Kernel mode programs are in no way restricted in executing such instructions. Device drivers are capable of running in kernel mode. So the workaround for the above stated problem is to write a kernel mode driver capable of reading and writing data to parallel port and let the user mode program to communicate with it. Writing a driver is not an easy job for even experienced programmers. But writing a simple driver for communicating with parallel port is a simple task when drivers like USB, sound card etc.. are concerned. Even though you get a working driver from somewhere else, installing and configuring it can be very cumbersome task.

The Solution

                 Introducing Inpout32.dll for WIN 98/NT/2000/XP. This dll have the following features

1) Works seamless with all versions of windows (WIN 98, NT, 200 and XP)

2) Using a kernel mode driver embedded in the dll

3) No special software or driver installation required

4) Driver will be automatically installed and configured automatically when the dll is loaded

5) No special APIs required only two functions Inp32 and Out32

6) Can be easily used with VC++ and VB

7) Functions are compatible with Jan Axelsons Inpout32.dll (available at www.lvr.com). So this dll can be used with the sample programs available with the book Parallel Port Complete, without any modification.

How Inpout32.dll works

If you don't know what is Inpout32.dll, please read it here and then continue.

How it works

The outstanding feature of Inpout32.dll is , it can work with all the windows versions without any modification in user code or the DLL itself. This tutorial describes how it is achieved, what programming methods used, what are the APIs used, etc.... The Dll will check the operating system version when functions are called, and if the operating system is WIN9X, the DLL will use _inp() and _outp functions for reading/writing the parallel port. On the other hand, if the operating system is WIN NT, 2000 or XP, it will install a kernel mode driver and talk to parallel port through that driver. The user code will not be aware of the OS version on which it is running. This DLL can be used in WIN NT clone operating systems as if it is WIN9X. The flow chart of the program is given below.

The two important building blocks of this program are

1) A kernel mode device driver embedded in the DLL in binary form

2) The DLL itself

Kernel mode driver Hwinterface.sys

The source code of Hwinterface.sys kernel mode driver is located in "kernel_mode_driver_source" directory. Where "hwinterfacedrv.c" is the main application source file. Three functions implemented in the driver are

1) 'DriverEntry' , Called when driver is loaded. Creates device object and symbolic links.

2) 'hwinterfaceUnload', Called when driver is unloaded, performs clean up

3) 'hwinterfaceDeviceControl', handles calls made through DeviceIOControl API. Performs reading writing to the parallel port according to the control code passed.

The DLL Inpout32

The functions in the DLL are implemented in two source files, "inpout32drv.cpp" and "osversion.cpp". osversion.cpp checks the version of operating system. "inpout32drv.cpp" does installing the kernel mode driver, loading it , writing/ reading parallel port etc... The two functions exported from inpout32.dll are

1) 'Inp32', reads data from a specified parallel port register.

2) 'Out32', writes data to specified parallel port register.

the other functions implemented in Inpout32.dll are

1) 'DllMain', called when dll is loaded or unloaded. When the dll is loaded , it checks the OS version and loads hwinterface.sys if needed.

2) 'Closedriver', close the opened driver handle. called before unloading the driver.

3) 'Opendriver', open a handle to hwinterface driver.

4) 'inst' , Extract 'hwinterface.sys' from binary resource to 'systemroot\drivers' directory and creates a service. This function is called when 'Opendriver' function fails to open a valid handle to 'hwinterface' service.

5) 'start' , starts the hwinterface service using Service Control Manager APIs.

6) 'SystemVersion' Checks the OS version and returns appropriate code.

What is hwinterface.ocx ActiveX control

It is an activex control with same features of Inpout32.dll. It can be used either with VC++ or VB. But it gives great convenience when used with VB. Data can be written to parallel port using Outport method and can be read using Inport method.

A Tutorial on creating DLLs with VC++

          Visual basic is very fast and easy tool for developing applications with high degree of user friendliness , but it lacks some important functionalities like direct access to hardware, multythreading(Activex servers allows some type of multythreading !). The easy and effective solution for this problem is to write a DLL. But beginners experiance problems in understanding how to write a dll. .Here is a simple tutorial on writing DLLs with Visual C++. I assume that you know a little bit Visual Basic and ?C? programming.

What is Static linking and Dynamic linking ?

         The libraries can be linked to the executable in two ways . one is static linking and the other is dynamic linking. Static linking is the methode used to combine the library routines with the application. When bulding the program , the linker will search all the libraries for the unresolved functions called in the program and if found, it will copy the corresponding object code from the library and append it to the executable. The linker will keep searching until there are no more unresolved function references. This is the most common methode for linking libraries.This methode boasts of ease of implementation and speed but will generate bulky executables. In dynamic linking , the required functions are compliled and stored in a library with extension ?.DLL?. Unlike static linking, no object code is copied in to the executable from the libraries.Insted of that, the executable will keep the name of the DLL in which the required function resides. and when the executable is running , it will load the DLL and call the required functions from it. This methode yealds an executable with small footprint , but have to compromise on speed a little.

Example 1

Objetive

Create a Dynamically linkable library which can calculate and return the sum of two numbers passed to it.

Tools required

visual C++ 6 , Visual basic 6

Writing The DLL

Start VC++ IDE , select ?New? from File menu. Then select ?Win32 Dynamic - link library? from ?Projects? tab(picture-1). enter project name as ?example1? , then click OK button. Now you can see a dialog box with caption ?Win32 Dynamic - Link library - step 1 of 1? (picture-2).

                                                                  Picture 1

                                                                         Picture 2

Select ?a simple DLL project? and click Finish. Now open exaple1.cpp from ?fileview? (picture-

3)                                                                         Picture 3

add these lines in to example1.cpp

int _stdcall sum(int x , int y){return x+y;}

It is a simple function which returns the sum of numbers passed to it.

Now our function is ready. The next step is to create a ?.def? file which informs the linker to export our function.Select ?New? from ?File? menu and then select ?text File? from ?Files? tab.Give it a name ?example1.def?. Now you can see an empty file . Add these lines in to ?example1.def?

LIBRARY EXAMPLE1

EXPORTSsum @1

Select ?Build example1.dll? from ?build? menu. The build process should complete without any errors. If any error occures , correct it and rebuild again. Oce the build process is completed successfuly , you can see ?example1.dll? in ?debug? directory.

Now we have successfuly built the Dll and it is the time to test it. For testing the DLL we have to write a small program in VB. Open a new project in Visual Basic. Place three text box and a command button like in picture 4.

                                                                                    Picture 4

Copy the code given bellow , to the code window

Private Declare Function sum Lib "example1.dll" (ByVal x As Long, ByVal y As Long) As Long Private Sub Command1_Click()Text3.Text = Str(sum(CInt(Text1.Text), CInt(Text2.Text)))End Sub

copy example 1.dll to ?windows? or ?system? directory . Then run VB ,enter some values to text1 and text2 and click ?Calculate? button. If you can see the sum in text3, you have completed example1 successfuly ! cangratulations !.

Download the source code and project files for example1

Example 2

Objetive

Create a Dynamically linkable library which can calculate and return the sum of two numbers passed to it.

Tools required

visual C++ 6 , Visual basic 6

Writing The DLL

Create a new win32 DLL project in VC++ just like in the previous example. insert the statement given below before main

#include ?string.h?

Insert the following code after main

char* _stdcall to_upper(char *lowerstring){_strupr(lowerstring);return lowerstring;

}

Create a def file and insert the following code

LIBRARY example2

EXPORTSto_upper          @1

Now save the project, build it and copy example2.dll to ?windows? or ?system? directory.

Create a new project in VB, place a text box and command button the form paste the following code to code window.

Private Declare Function to_upper Lib "example2.dll" (ByVal text As String) As String

Private Sub Command1_Click()

If (Text1.text) = "" ThenExit SubEnd If

MsgBox to_upper(Text1.text)End Sub

Run the program and enter some lower case characters in textbox.It should display a messagebox with same characters with case changed.

Download the source code and project files for example2

Example 3

Objetive

Create a DLL which can read/write data to parallel port

This DLL is a very useful for interfacing parallel/serial ports. Since Visual Basic does not have any facility to communicate with parallel port directly , programmers will have to write code for accessing parallel port in a DLL and should be called from VB. In this DLL , in this dll , accessing the device registers is done using functions _Inp() and _Outp(), which is declared in ?conio.h? . More details about these functions can be found at MSDN online .

We will export two functions from the DLL.One is for reading from a device register and the other is for writing to the device register. Let these functions be InPort() and OutPort(). InPort() will take one parameter ie; the address of the register to be read. and Outport will take two ie; the address of the register to which the data to be written and the data itself.

Note: to do this project , You need to have some knowledge in Parallel port interfacing.

Tools required

visual C++ 6 , Visual basic 6

Writing The DLL

Create a new win32 DLL project in VC++ like in the previous examples. insert the statement given below before main

#include ?conio.h?

Insert the following code after main

short _stdcall InPort(short portaddress){return _inp(portaddress);}

void _stdcall OutPort(short portaddress,short data){_outp(portaddress,data);}

create a .def file with name example3.def and insert the following code

LIBRARY example3

EXPORTS

InPort        @1OutPort    @2

now save the project and build example3.dll.for testing the dll , create a new project in visual basic.Create a form like in picture5.

                                                                                          Picture 5

Add the following code to code window

Private Declare Function InPort Lib "example3.dll" (ByVal portaddress As Integer) As Integer Private Declare Function OutPort Lib "example3.dll" (ByVal portaddress As Integer, ByVal data As Integer) As Integer

Private Sub Command1_Click()OutPort 888, 10 'Val("&h" + Text2.Text), Val(Text1.Text)End Sub

Private Sub Command2_Click()Text3.Text = Str(InPort(Val("&h" + Text2.Text))End Sub

Run the program and enter some value in text1. the n click ?Write it? button. Again click the ?Read it? button , now if text2 displays the number which you entered in text1 , your dll is working successfuly.

Download the source code and project files for example3

IEEE 1284.3 and 1284.4Advances in High-Speed Parallel Port Performance and Port Sharing

From it's humble beginnings as a Printer Port on the original IBM PC, the Parallel Port has become one of the most common connectors on the Personal Computer today. Virtually every PC shipped over the past 18 years has had a parallel port interface on it. Originally this port was used just for driving 'fast' dot matrix printers. Today the parallel port is used to interface to almost every PC peripheral in use. Printers, scanners, data acquisition, CD ROM, tape drives, high speed modems and digital cameras are some of the peripherals that can be purchased and used today.

From 1981 until 1994 there was tremendous growth in the power, performance and capabilities of the PC. Unfortunately there was very little change in the performance of the parallel port. In 1994 this all changed with the release of IEEE Std. 1284-1994. This standard defined new protocols and new interface models that would enable a 50 to 100x performance increase in the capabilities of the parallel port. With the efforts of the IEEE 1284.3 and 1284.4 committees these enhancements are continuing today.

This presentation will provide an introduction to the state and future of the parallel port interface and the associated protocol stack.

Prior to the 1284 standard the PC parallel port model was a simple register set that the host driver could access. In order to transfer data the host driver was required to access the register and manage all the handshaking and data transfer. Since the parallel port was mapped into the ISA bus I/O space the fastest the driver could access the port was 1Mbyte per second. With an overhead of 4 port accesses per data transfer this put a limit of 250Kbytes per second as the fastest the PC could transfer data using the Centronics printer protocol. It would require nearly 100% of the PC utilization in order to achieve this rate. In order to keep the PC responsive actual data rates were on the order of 50KB/S to 150KB/S.

The 1284 standard provided new data transfer protocols that could be implemented in an enhanced register model. One of the key advantages of this was that the register model could remain backward compatible with the existing model but add enhanced features for better data transfer. This was achieved by implementing hardware state machines that would offload the data transfer handshaking form the host driver. The Enhanced Parallel Port (EPP) and Extended Capabilities Port (ECP) are these advanced modes.These modes enable data transfer rates of over 1MB/S with reduced host utilization on today's ISA ports, and 3-5MB/S on future PCI implementations.

Printing, reading or writing from tape, and other peripheral communication can consume a significant percentage of the parallel port bandwidth when active. In reality though, these activities do not occur very often and use very little of the overall available bandwidth. This means that a significant PC resource is being wasted. To use this additional potential the IEEE 1284.3 committee developed a protocol to allow sharing of the parallel port by multiple peripherals. The Daisy Chain protocol is the result of this effort.

Devices that adhere to this protocol (DC devices) have two connectors on them. One connector connects to the host port of the PC or the Pass Through port of another DC device. The other connector is the pass through port. This port replicates, or passes through the signals from the host port when the peripheral is not communicating with the host. The Daisy Chain protocol allows four peripherals to share a single parallel port and still attach an older 'legacy' peripheral. In this way, like the 1284 standard, backwards compatibility with the existing installed base is preserved.

The wire protocol that is used for 1284.3 is "out of band" to the 1284 defined protocols. This allows all DC devices to utilize the full capabilities of the 1284 standard. The 1284.3 protocol provides the means to address individual devices on the parallel port chain

and to select a particular device for use by the host. When a DC device is selected the 'downstream' devices and the legacy device do not see any activity on the parallel port. To these devices the parallel port is idle.

One advantage of standardizing on the switching protocol is to enable the use of a common software driver on the host PC. The host driver, possibly provided by the Operating System, can then provide the switching services for the host application. The 1284.3 Service Provider Interface defines the types of services that are required by client applications. These services will be provided by the host.

This 1284.3 SPI is responsible for determining how many devices are attached to the parallel port and discovering what they are. This information is obtained by the 1284 device ID method for LPT plug and play. To the client application it appears that the DC device is the only device attached to the parallel port. The 1284.3 SPI driver manages the switching and selection of the peripheral.

Once you have a software layer to provide the basic port enumeration services it is a natural extension to include the data transfer functions. The 1284.3 Data Link interface defines these services. With a full software interface to the parallel port we are able to achieve independence from the actual hardware interface. This makes it easier to migrate to newer and faster hardware without effecting the client applications.

The 1284.3 Data Link defines a packet protocol that enables the delivery of packets of data to other side of the interface. This creates a connection-less, peer to peer relationship between the host and the peripheral. The header provides information on the data length and the transport protocol being used. This ensures that the data is only delivered to the appropriate client. The data length is used to enable DMA for the reception of data.

At this point the 1284/1284.3 protocol stack provides a software interface that is independent of the actual hardware implementation. With the appropriate implementation of the data link the parallel port could be used with many different transport protocols. Although this is true, there was no transport layer that could take advantage of the features of the 1284 interface. In particular the channel capabilities of the EPP and ECP modes.

The IEEE 1284.1 committee had defined a printer management standard that could operate over networks or direct attached interfaces. They requested that the IEEE develop a transport protocol that would take advantage of the 1284 standard parallel port capabilities but also be suitable for other physical interfaces. One of the main requirements was that the transport layer be able to maintain multiple conversations, or sessions, between the PC and the peripheral. In addition to this the protocol should ensure that one conversation cannot block another. An example of blocking is what you see in older Centronics interfaces. If the paper should run out of the printer or you open the tray to add more paper you can no longer communicate with the printer. With 1284.4 these functions should be independent and not effect one another.

The IEEE 1284.4 committee was established to develop and define this transport protocol. After analysis of various existing protocols, such as PPP and the MFP IS16550, it was determined that the Multiple Logical Channels (MLC) protocol developed by Hewlett-Packard and Genoa Technology met the general requirements for this standard. QualityLogic™ (formerly Genoa Technology) and HP offered this protocol as the basis for the 1284.4 standard. While MLC was the basis for 1284.4, the final standard is not backward compatible with MLC.

The 1284.4 protocol allows a device to carry on multiple, concurrent exchanges of data and/or control information with another device across a single point-to-point link. Blocking of one data exchange has no effect on the others. While the protocol was required to operate over the 1284 interface it may also operate over other interfaces such as USB and IEEE 1394.

1284.4 defines a packet protocol that enables this communication. Within the packet is the identity of the source and destination endpoints, client data, as well as control and credit information. Credit is the flow control method that is used to ensure that channel blocking does not occur.

With credit the target of a data transfer gives the source of the data an indication of how much data it is guaranteed to accept. In this way the source can never send more data than the target can accept. Upon initialization both sides negotiate for how much data needs to be transferred and in what packet sizes.

The source and target identities define a connection between the sides. A source may communicate with multiple target endpoints. In this way one client can communicate with multiple services on the target. A scanner is one example of how this may operate. The scanner application on the host may need to communicate with two functions on the scanner peripheral. The first function may be the scanner control and status monitor. The application will then establish a conversation between itself and this function on the scanner. At some point a page to be scanned may be inserted. Now the scanner can request the establishment of a connection between the scan engine and the host application. Now we have two independent conversations established between the PC and the peripheral.

This model can be extended to many different conversations. Conversations may occur between devices on different physical interfaces. The advantage of 1284.4 is that it can port to other PC related interfaces by the implementation of the appropriate software interface. This means that a client application on the PC can communicate with devices on multiple physical interfaces without any changes.

In conclusion, the parallel port is being enhanced by new hardware and software support. With backward compatibility and a huge installed base this interface will provide a convenient and powerful port for future peripherals. This presentation will provide an introduction to the protocol stack and issues involved in developing parallel port peripherals.