If you have built any of the interfaces on my circuits page and now want to know how to actually make use of them, this page is for you. This is a simple introduction to programming the parallel port in Visual Basic.
Note that most of the concepts in this page apply to both 16 bit and 32
bit versions of VB. If you are interested in using QBasic to control
the port, see Programming The Parallel Port In QBasic.
What this document will not do is give you lots of details on using
bi-directional ports, DMA and other advanced topics. This document
assumes that you are familiar with the basic functions of Visual Basic
itself.
Now before we go any
further, we must figure out a way around some limitations built into
Visual Basic. VB cannot directly access the hardware on a system. All hardware requests must go through Windows. Because of this, the closest we can get to manipulating the parallel port
is with the Printer object. While this is all fine and good when you
want to actually print something, it is useless when we want direct
hardware control. There may be API calls to get round this, but as of
yet I have been unable to find any. In order to control the port
directly, we must use something external to our program. It just so
happens that there is a great, free product that does exactly what we want. It is a DLL from a company called SoftCircuits. You can download this DLL from theirProgramming Tools and Libraries page. Use VBASM.DLL (in the VBASM.ZIP package) for VB1, VB2, VB3 or VB4 16Bit. Use WIN95IO.DLL (in the WIN95IO.ZIP package) for VB4 32bit, VB5 or VB6. No matter which one you choose, the DLL file itself must be in the windows\system directory
in any machine the interface control software is to be used or
developed on. Please note that no matter which DLL you use, this won't
work under any Windows NT based system, including WinNT, Win2K, XP,
Vista, Win7 or Windows Server. NT based systems do not allow direct
hardware access to non-drivers.
Now that we have that finished with, let's get to the port. The parallel port is made up of three different sections. These are the data lines, control lines and status lines.
There are 8 data lines, and they are the primary means of getting
information out of the port. In simple projects, you will be
concentrating mostly on the data lines. The control lines are another 4
outputs. They are meant to provide control signals to the printer (such
as form feed or initialize). The status lines are a standard parallel
port's only inputs. There are 5 of them. They were meant to allow the
printer to communicate things such as error, paper out and busy to the
PC.
Each section is accessed by
it's own address and will act independently from the rest. This is
almost as if they were different ports. The addresses are as follows:
|
Port
|
Address (Decimal)
|
Address (Hex)
|
| Data Lines |
888
|
378h
|
| Control Lines |
890
|
37Ah
|
| Status Lines |
889
|
379h
|
You need to know the address of the
port you want to use. You will also need two other things; the command
to access the port and the number you want to set it to. The command
will be explained in a little while. The ports work with numbers. These
can be expressed in hex, binary or decimal, but for this document all
values will be expressed in decimal. It's just easier that way. Anyway,
you operate the port by sending it a number that represents the binary
pattern of the physical outputs on the port. For example, to set the 8
data lines to 11111111, you would send 255. To set them to 00000000 you
would send 0. Note that these are all 8 bit binary numbers, and the port is also 8 outputs. Coincidence? I think not.
Before
we can use any of the functions contained within either DLL, we must
declare them. These declarations are to be placed in any module in your
program in the General_Declarations section.
For 16bit VB (VBASM.DLL), use:
Declare Function vbInp Lib "VBASM.DLL" (ByVal nPort As Integer) As Integer
Declare Sub vbOut Lib "VBASM.DLL" (ByVal nPort As Integer, ByVal nData As Integer)
For 32bit VB (WIN95IO.DLL), use:
Declare Sub vbOut Lib "WIN95IO.DLL" (ByVal nPort As Integer, ByVal nData As Integer)
Declare Sub vbOutw Lib "WIN95IO.DLL" (ByVal nPort As Integer, ByVal nData As Integer)
Declare Function vbInp Lib "WIN95IO.DLL" (ByVal nPort As Integer) As Integer
Declare Function vbInpw Lib "WIN95IO.DLL" (ByVal nPort As Integer) As Integer
Once you declare the functions, you will have two new commands available. These are vbInp and vbOut. vbOut is a statement and is used to send a bit to a port, like the following:
vbOut [port],[number]
We will get to vbInp later.
As you can see, the two parameters required are the port address and
the value we want to set it to. The address can be decimal or hex, as
can the value. Because there are only 8 data lines, we can only send a
maximum of 255 to the port (255 is decimal for binary 11111111). The examples below illustrate sending a few different bit patterns to the data lines.
'set port to 00000000
vbOut 888, 0
'set port to 10000000
vbOut 888, 1
'set port to 01000000
vbOut 888, 2
'set port to 00100000
vbOut 888, 4
'set port to 00010000
vbOut 888, 8
Of course, you can also turn on more than one bit:
'set port to 10110000
vbOut 888, 11
Note
that when you send a bit pattern to the port everything that was there
previously is cleared. This is a convenience and also a annoyance. For
example, what if we want bit 2 to always stay at 1, but want to turn bit
5 on and off in sequence? Every time we set bit 5, bit 2 is turned off,
and vice versa. We will discuss how to get around this when we get to the vbInp function.
The
control lines are just as easy to control, but there are a few
differences. First, the address of the port is 890. Second is that there
are only 4 outputs, so the highest decimal representation of the binary
bit pattern you will be using is 15 (binary 1111).
Outputting
information is easy, and inputting is just as easy. If you actually
want to get information into the computer, you will be using the 5
status lines. Reading the bit pattern of a port is done using the vbInp function. This function is used in the following way:
[variable]=vbInp([port])
So if we wanted to get the current status of the status lines (port 889) we would use:
PortNum%=vbInp(889)
PortNum% would
then contain the decimal representation of the binary bit pattern
present at the 5 status lines. If you try this and get 31 (11111) with
nothing connected to the port don't be surprised. When there is nothing
connected to the input of a TTL logic chip, a high input is usually
assumed.
Not only can you perform inputs on ports actually designed for inputting, but you can also use vbInp to read the status of an output port. For example:
PortNum%=vbInp(888)
The above would set PortNum% to the current value of the data lines (port 888). We can prove this by doing the following:
vbOut 888, 56
PortNum%=vbInp(888)
MsgBox PortNum%
If all is well, the number 56 will appear in a message box on the screen.
Now that we know the vbInp function
we can use it to solve the problem of keeping the state of one bit
while changing the state of another. For that we will define a
subroutine that uses both functions:
SUB OutPort(PortAddress%, OutNum%)
PortState% = vbInp(PortAddress%)
PortNum% = PortState% + OutNum%
vbOut PortAddress%, PortNum%
END SUB
Note how the sub
adds the current port state to the number we send it. This has the
effect of keeping all previous bits at the same state they were in, but
either turning on or off the bit or bits represented by the number we pass to the sub. This also requires a change in the way the function is used. To turn on bit 1, we would:
OutPort 888, 1
This
example assumes a current port status of 0 (00000000). If bit 1 is
already high, you will get unexpected results, so keeping track of the
port is important. To turn bit 1 back off, we would:
OutPort 888, -1
Now this sub introduces a problem. How do we clear everything on the port as if we were doing vbOut 888, 0?
Sending 0 to the sub has no effect (adding or subtracting 0 will always
give you the original number), so we will need to add a statement to
specifically react to a 0. This done by a simple IF...THEN decision:
SUB OutPort(PortAddress%, OutNum%)
PortState% = vbInp(PortAddress%)
PortNum% = PortState% + OutNum%
vbOut PortAddress%, PortNum%
IF OutNum% = 0 THEN vbOut PortAddress%, 0
END SUB
The sub does all
it's normal stuff, but also sets the port to 0 if a 0 was passed to it.
This is a very easy to clear up a port if you create strange bit
patterns by trying to turn a bit on twice. You may want to keep track of
the state you expect the port to be and compare it to the actual state
by using the vbInp function. If the two do not match, clear the port and reset all the the bits using your other variable.
Now
that we know a few useful functions with respect to output, we should
look at a very useful input function. When using the port in software,
you will very likely need to know the status of a single bit at one time
or another. There are various ways of doing this, but I find the
function below to be the most useful:
FUNCTION BitStatus(PortAddress%, BitYouWant%) AS INTEGER
IF PortAddress% = 888 THEN
NumOfBits% = 8
ELSE IF PortAddress% = 889 THEN
NumOfBits% = 5
ELSE
NumOfBits% = 4
REDIM PortBits(NumOfBits%) AS INTEGER
PortNum% = vbInp(PortAddress%)
FOR i = 1 To NumOfBits%
PortBits%(i) = PortNum% MOD 2
PortNum% = FIX(PortNum% / 2)
NEXT I
BitStatus% = PortBits%(BitYouWant%)
END FUNCTION
The function
first decides how many bits it has to work with by looking at the
address of the port. Note that in all other examples it was really
irrelevant if you used decimal or HEX addresses. In this function you
will need to change the numbers if you work in HEX. Now, back to how the
function functions (he he he). After deciding how many bits there are
in the port, it makes an array of the same number of elements. It then
goes through a loop, performing integer division on the number returned
from the port. It performs one division for each bit in the port. This
is probably the easiest way to convert to binary, as VB has no built in
decimal to binary function. Again, if you work in HEX you will have to
adjust the function here. The function then assigns itself the value of
the array element you specify with the BitYouWant% variable.
Well,
that's it. The above is not limited to the parallel port. You can use
it with any sort of interface that uses a standard I/O port. Of course,
this code would not be ideal in controlling the serial port, as a lot of
low level coding would be necessary.
For example, to read bit 5 of port 888, you would use:
Bit5Variable% = BitStatus%(888, 5)
