ParaPort Documentation

Global Operating Model

To use ParaPort, its driver must first be installed by the Windows "Add/Remove Hardware Wizard".

Client applications ( executables ) do not access directly the driver, but use the Application Programming Interface ( "API" ) of the "ParaPort.dll" dynamic library. They generally follows these steps:

• load the "ParaPort.dll"
• use functionality "open a port" to get a HANDLE ( in the sense of Microsoft's Windows API ) to a port
• if needed, get information about the port
• write data to or read data from the port by "executing a cycle" or
• close the port, when not needed anymore

The ParaPortUtility application uses the underlying dll and driver to set or clear pins of the parallel port.

System Architecture

Data Model

The central information item of ParaPort is a "cycle". This is a structure ( in the sense of C or C++ ) containing seven bytes:

• one byte for each of the three accessed registers of the parallel port with
• a corresponding mask byte and
• a byte containing a "repeat factor".

A special direction bit ( 0x20 ) of the control register determines whether the data register is used as output ( bit cleared ) or input ( bit set ).

As example:

• To set the pin 7 of the parallel port to logical high ( 5 Volt TTL ), the structure member PARAPORT_CYCLE::Data must be set to 0x20 ( in comparison with the data table ). PARAPORT_CYCLE::MaskData must also set to 0x20.
• To clear the pin 7 ( logical low = 0 Volt TTL ), PARAPORT_CYCLE::Data must be set to 0x00. PARAPORT_CYCLE::MaskData must set to 0x20.

Timing Model

Each cycle is seen as one moment in time. But since there are CPU instructions to execute on the PC and electronic reaction on parallel port hardware, the following timing diagrams can be measured on the parallel port:

• if the direction bit 0x20 of the control register is cleared ( data register is output ):
  1. configure data register as output
  2. write data register ( * )
  3. write control register ( * )
  4. apply the "repeat factor" to waste time ( to enable connected hardware to react )
  5. read status register ( * )
• if the direction bit 0x20 of the control register is set ( data register is input ):
  1. configure data register as input
  2. write control register ( * )
  3. apply the "repeat factor" to waste time ( to enable connected hardware to react )
  4. read data register ( * )
  5. read status register ( * )

All register are written or read ( the lines marked with "*" ) only, if the correspondent mask byte is not equal to 0x00.

Repeat Factor

The following figure has been measured with a logical analyser during the execution of the sample application "sampleRepeatFactor". As you can see in the source code, different pulses has been generated using each two cycles.

Each cycle lasts approximate 5 micro seconds. By setting the byte PARAPORT_CYCLE::RepeatFactor in the structure, a cycle can be extended ( e.g.: cycles 3, 5, 7 ).

To extend the time between pulses, the cycles 2, 4, 6 should get a value > 0 for the byte PARAPORT_CYCLE::RepeatFactor.

Pulsed or Clocked Input / Output

During one cycle, the state of the pins can be set, cleared or read. To realize "Pulsed or Clocked I/0", two cycles are needed for each pulse, if the hardware is "edge driven". In other cases, three cycles are needed.

As example 1:

To write 0xAE on the data register with a clock (e.g.: _Strobe), two cycles are needed:

• Cycle 1 configures the data register as output and puts 0xAF on the parallel port. Then the _Strobe signal line is triggered and the repeat factor is applied.
• Cycle 2 resets the _Strobe signal line and puts into the data register 0x00 as the default value on idle time. If an other value ( e.g.: 0xFF ) is wanted, Data must be changed; if the last set value ( here 0xAE ) is wanted, the MaskData must set to 0x00. If the default state of the data register is input, the bit 0x20 must be set in the Control structure member.

As example 2:

To read a byte from the data register with a clock (e.g.: _Strobe), two cycles are needed:

• Cycle 1 configures the data register as input, the _Strobe signal line is triggered and the repeat factor is applied. Then the data register will be read and the value will be stored in the Data structure member.
• Cycle 2 resets the _Strobe signal line and puts into the data register ( here, its default state is "output" ) 0x00 as the default value on idle time. If an other value ( e.g.: 0xFF ) is wanted, Data must be changed; if the last set value ( here 0xAE ) is wanted, the MaskData must set to 0x00. If the default state of the data register is input, the bit 0x20 must be set in the Control structure member.

Overview

ParaPort offers to its client applications written in C or C++ an Application Programming Interface ( API ) for the exported functions of ParaPort.dll.

The C interface of ParaPort is implemented in the header file "ParaPort.h" and presents all C type definitions and function prototypes needed to access the dll.

The C++ interface of ParaPort contains C++ classes which wraps the C functions and C structures:

• The class ParaPortCycle in header file "ParaPortCycle.h" proposes "get" / "set" access methods to the members of the C structure PARAPORTCYCLE.
• The class ParaPortDll in header file "ParaPortDll.h" does the standard work of a DLL client to load the DLL ( ::LoadLibrary( ) ), determine the addresses of the DLL exported functions ( ::GetProcAddress( ) ) etc.

The usage of ParaPort can be viewed in source code of the sample program.

Software Architecture

API "open a port"

Description:

Before writing data to or reading data from the parallel port using ParaPortCycle, the client application must get a handle from ParaPort to a port by specifying its name ( e.g.: "LPT1" ). This handle will be used to call the other methods.

Method:

HANDLE openPort( const char* PortName );

Parameter:

Return value:

API "get information about a port"

Description:

The following information can be extracted from a port:

• the port address
• the port mode

API "execute cycle"

Description:

This is the central functionality to write data to or read data from the parallel port.

Types:

typedef struct {
  UCHAR Reserved;
  UCHAR Data;
  UCHAR Status;
  UCHAR Control;
  UCHAR MaskData;
  UCHAR MaskStatus;
  UCHAR MaskControl;
  UCHAR RepeatFactor;
} PARAPORT_CYCLE;
      

Method:

BOOL executeCycle( HANDLE Handle, PARAPORT_CYCLE* ParaPortCycle, int Count );

Parameter:

Return value:

API "direct register access"

Description:

This functionality gives direct access to the parallel port registers. These functions have the __stdcall declarators, so they can be called from Visual Basic applications.

Types:

PARAPORT_ADDRESS

Methods:

PARAPORT_ADDRESS getPortAddress( const char* PortName );

UCHAR input( PARAPORT_ADDRESS Address );

UCHAR output( PARAPORT_ADDRESS Address, UCHAR Byte ); 

Parameter:

Return value:

API "close a port"

Description:

If a port is no more accessed, the client application must close the handle of the port.

Method:

BOOL closePort( HANDLE Handle );

Parameter:

Return value:

API "error handling"

Description:

All methods of ParaPort uses the error handling mechanism of Windows by using the functions ::SetLastError( ) and ::GetLastError( ) from Windows API. ParaPort specific errors are C defines in the custom range beyond 0x20000000. There are also some common Windows errors returned by the functions.

ParaPort specific defines:

Windows errors:

API "dll singleton"

Description:

The C++ interface implements the singleton design pattern for the class ParaPortDll.

The client application normally uses only one instance of the class, which is created by the first call of the static method getSingleton( ). Following calls of this method do not create any new objects, but return the address of the instance created by the first call.

If the object is no longer needed, it can be deleted by calling the method deleteSingleton( ).

Method:

static ParaPortDll* getSingleton( );

static void deleteSingleton( );

Driver "ParaPort.sys"

"ParaPort.sys" is a Windows kernel driver following Microsoft's Windows Driver Model (WDM). The driver can be controlled ( start, stop, install, uninstall ) via the "Device Manager" of the computer.

Application "ParaPortUtility.exe"

ParaportUtility is a simple dialog box based windows application which can be used to set or clear pins on parallel port connectors. To be operational, the application needs the driver "ParaPort.sys" being installed and the "ParaPort.dll" must be visible to "ParaPortUtility.exe".

The Graphical User Interface consists of the following sections:

• "Port Parameter": select the parallel port. The detected ports of the computer are displayed in the combo box.
• "Data Register": read ( "Input" ) or write ( "Output" ) a byte on the parallel port. The byte can be specified as hexadecimal value or with check boxes.
• "Status Register" displaying the state of the 5 input lines.
• "Control Register": set or clear the 4 output control lines.
• On the bottom of the dialog box, there is one button "Execute Cycle" to transfer Data to/from the parallel port and a second to exit the application.

A checked box in the "Data Register", "Status Register" or "Control Register" ( e.g.: like "Pin9: D7" ) means that the correspondent pin on the parallel port connector has 5 Volt TTL. An unchecked box means 0 Volt TTL.

Frequently Asked Questions

FAQ General

Can ParaPort be used on a Windows NT4 systems?

Can ParaPort be used as a simple I/O like "inp( )", "outp( )"?

eMail with Virus "W32.Sobig.E@mm"!

FAQ about "ParaPort.dll"

Why do you not supply a "*.lib" file for linking directly your DLL?

The singleton implementation of class "ParaPortDll" is not the one published in "Design Patterns: Elements of Reusable Object-Oriented Software".

How to read data from parallel port with "ParaPortDll"?

ParaPortCycle Cycle[ 1 ];
UCHAR MaskData =   PARAPORT_MASK_DATA_D2
                 | PARAPORT_MASK_DATA_D3
                 | PARAPORT_MASK_DATA_D4;
Cycle[ 0 ].setMaskStatus( PARAPORT_MASK_STATUS_PAPEREND );
Cycle[ 0 ].setDataInput( );
Cycle[ 0 ].setMaskData( MaskData );
Dll->executeCycle( Handle, Cycle, 1 );
UCHAR Data = Cycle[ 0 ].getData( );
bool PaperEnd = Cycle[ 0 ].isStatusPaperEnd( );

When executing sample applications, "ParaPort.dll" cannot be found!

How to access the ParaPort.dll from a MFC application?

How to access the ParaPort.dll from a Visual Basic application?

How to access the ParaPort.dll from a .NET / C# application?

FAQ about the driver "ParaPort.sys"

Does the ParaPort driver support the interrupt mechanism of the parallel port?

FAQ about "ParaPortUtility"

none ( ? )