Serial and Parallel Port Programming with VB6: Hardware Control from Address 0x378 to Industrial Heritage

# Serial and Parallel Port Programming with Visual Basic 6.0: Hardware Control from Address 0x378 to Industrial Heritage

*Original Record ID: 12850 (EN) / 934 (TR)*
*Category: Open Source & Developer Tools / Retro Programming*
*Author: DigiLiner Research Group*

—

## Cold Opening: The Unstoppable Clock on the Factory Floor

Autumn 1999. In the stamping bay of an automotive parts manufacturing facility stands a beige desktop tower running Windows 98. Fastened to its rear panel, a heavy 25-pin parallel port (DB-25) cable connects directly to an eight-channel relay board and an array of industrial optical sensors. On the CRT monitor rests a Visual Basic 6.0 form, styled with battleship-gray pushbuttons and a solid navy title bar. The moment an operator clicks the button, a distinct mechanical click echoes across the floor: a single byte dispatched to address 0x378 pulls a 5-volt relay coil, setting a hydraulic press in motion.

Nearly thirty years have passed. The software landscape has reinvented itself through WebAssembly, microservice containers, and neural network engines. Yet across thousands of manufacturing plants, power station control rooms, and medical diagnostic analyzers worldwide, that identical VB6 form is still running.

Why? Because Visual Basic 6.0 was the leanest tool in software history for reducing the distance between a graphical user interface and raw copper wires down to zero.

—

## 1. The Golden Era and Ring 3 Freedom

During the mid-1990s across MS-DOS and Windows 95/98 environments, accessing physical hardware was remarkably unconstrained. The operating system maintained no rigid boundary between processor Ring 3 (user space) and Ring 0 (kernel space). A developer writing in C or Visual Basic could invoke the native x86 machine instructions `IN` and `OUT` to read from or write to any physical I/O port address mapped on the motherboard.

The parallel printer port (LPT1) stood as the crown jewel of physical computing. The 25-pin D-Sub connector located on the PC chassis placed 8 standard TTL-level (0V to 5V) digital output lines directly under software command. No microcontroller firmware had to be flashed; no custom USB vendor drivers were required. A single line of code could illuminate an LED, trigger a triac, or cycle a stepper motor driver.

—

## First Twist: The Windows NT Wall and Kernel Protection

When Windows NT 4.0, Windows 2000, and Windows XP superseded consumer DOS-based operating systems in the late 1990s, millions of industrial VB6 control suites suffered catastrophic failure overnight.

The dialog box was unmistakable:
`Privileged Instruction (Exception 0xC0000096)`.

To ensure system stability and enterprise security, the Windows NT architecture blocked user-space (Ring 3) programs from executing direct `IN` and `OUT` instructions via the CPU Task State Segment I/O Permission Bit Map (TSS IOPB) [1]. Whenever an unprivileged process attempted to touch address 0x378 directly, the Intel x86 CPU threw a hardware trap, and the NT kernel terminated the offending application on the spot.

At this critical juncture, hardware engineers devised an ingenious bridge: **`Inpout32.dll`**.

### Unlocking the Kernel Door: The `Inpout32.dll` Architecture

`Inpout32.dll` inserted a lightweight kernel-mode driver (`hwinterface.sys`) between the user-mode VB6 application and the Windows NT kernel executive. The VB6 application executed standard Win32 DLL calls; the DLL dispatched an I/O Control Code (IOCTL) to its kernel driver, which performed the physical port read or write at Ring 0 privilege before returning control back to user space [2].

—

## 2. Anatomy of the Parallel Port: The Three Hardware Registers

To operate the physical LPT1 port effectively, developers must understand the 3 foundational x86 hardware registers underlying the 25-pin interface:

“`
+————————————————————————-+
| LPT1 PARALLEL PORT REGISTER MAP |
+——————-+—————-+———–+————————+
| Register Name | Port Address | Direction | Physical DB-25 Pins |
+——————-+—————-+———–+————————+
| 1. Data Register | 0x378 (&H378) | Out / In | Pins 2 – 9 (D0 – D7) |
| 2. Status Register| 0x379 (&H379) | Read-Only | Pins 10, 11, 12, 13, 15|
| 3. Control Register 0x37A (&H37A) | Read/Write| Pins 1, 14, 16, 17 |
+——————-+—————-+———–+————————+
“`

“`
DB-25 Parallel Port Connector (Female / Chassis Panel)
13 1
o o o o o o o o o o o o o
o o o o o o o o o o o o
25 14
[Pins 2-9: Data (D0-D7)] [Pins 18-25: Ground (GND)]
“`

### A. Data Register (Base + 0 -> 0x378)
The primary 8-bit bidirectional data bus. Writing an integer between 0 and 255 immediately sets the electrical potential of the physical data pins:
– Bit 0 -> Pin 2 (D0)
– Bit 1 -> Pin 3 (D1)
– …
– Bit 7 -> Pin 9 (D7)

### B. Status Register (Base + 1 -> 0x379)
Reads 5 incoming digital sensor signals from industrial limit switches and optocouplers:
– Bit 3 (Pin 15: Error / Fault)
– Bit 4 (Pin 13: Select In)
– Bit 5 (Pin 12: Paper End / Empty)
– Bit 6 (Pin 10: ACK – Acknowledge)
– Bit 7 (Pin 11: BUSY) -> **Caution: Electrically inverted at the hardware level!**

### C. Control Register (Base + 2 -> 0x37A)
Originally established to issue commands to dot-matrix printers, providing 4 output lines:
– Bit 0 (Pin 1: Strobe) -> **Inverted**
– Bit 1 (Pin 14: Auto Feed) -> **Inverted**
– Bit 2 (Pin 16: Initialize)
– Bit 3 (Pin 17: Select Printer) -> **Inverted**

—

## Second Twist: The Hardware Inversion Trap

The most maddening pitfall encountered by engineers interfacing with parallel ports is this: **Writing a logical 1 to certain register bits drives the corresponding physical pin to 0 Volts!**

When the Centronics printer interface standard was codified, discrete hardware NOT logic gates (inverters) were wired into specific signal traces:
1. **The BUSY Pin (Pin 11) on the Status Port:** When an external sensor supplies +5V to the pin, Bit 7 in register 0x379 reads **0**. When the pin is pulled to 0V ground, Bit 7 reads **1**!
2. **The Strobe, AutoFeed, and SelectInput Lines on the Control Port:** Asserting these physical pins requires writing 0 to the register; writing 1 de-asserts them.

Software drivers must compensate for this hardware inversion through bitwise XOR (`Xor`) operations before handing data to application business logic.

—

## 3. Practical VB6 Parallel Port Implementation

The following production-grade module utilizes `Inpout32.dll` to drive an 8-channel relay module while reading industrial sensors across Windows XP, 7, 10, and 11 environments:

### Module Code: `modParallelPort.bas`

“`basic
Attribute VB_Name = “modParallelPort”
Option Explicit

‘ Inpout32.dll Win32 API Declarations
Public Declare Function Inp32 Lib “inpout32.dll” Alias “Inp32” (ByVal PortAddress As Integer) As Integer
Public Declare Sub Out32 Lib “inpout32.dll” Alias “Out32” (ByVal PortAddress As Integer, ByVal Value As Integer)

‘ Standard LPT1 Hardware Port Addresses
Public Const LPT1_DATA As Integer = &H378
Public Const LPT1_STATUS As Integer = &H379
Public Const LPT1_CONTROL As Integer = &H37A

‘ Function to Drive an 8-Channel Industrial Relay Module
Public Sub SetRelayState(ByVal RelayNumber As Integer, ByVal State As Boolean)
Dim currentVal As Integer
currentVal = Inp32(LPT1_DATA)

If State Then
‘ Set target bit to 1 (Bitwise OR logic)
currentVal = currentVal Or (2 ^ (RelayNumber – 1))
Else
‘ Clear target bit to 0 (Bitwise AND NOT logic)
currentVal = currentVal And Not (2 ^ (RelayNumber – 1))
End If

Out32 LPT1_DATA, currentVal
End Sub

‘ Function to Read Sensor from Status Port (Inversion Compensated)
Public Function ReadSensor(ByVal PinNumber As Integer) As Boolean
Dim statusVal As Integer
statusVal = Inp32(LPT1_STATUS)

Select Case PinNumber
Case 11 ‘ Pin 11: BUSY (Electrically inverted in hardware)
ReadSensor = ((statusVal And &H80) = 0)
Case 10 ‘ Pin 10: ACK
ReadSensor = ((statusVal And &H40) <> 0)
Case 12 ‘ Pin 12: Paper End
ReadSensor = ((statusVal And &H20) <> 0)
Case 13 ‘ Pin 13: Select In
ReadSensor = ((statusVal And &H10) <> 0)
Case 15 ‘ Pin 15: Error
ReadSensor = ((statusVal And &H8) <> 0)
Case Else
ReadSensor = False
End Select
End Function
“`

—

## 4. RS-232 Serial Port Programming: Mastering `MSComm32.ocx`

While the parallel port excelled at high-speed localized control, communication spanning distances greater than a few meters or interfacing with intelligent hardware (PLCs, digital scales, barcode scanners) belonged exclusively to the **RS-232 Serial Port (COM)** standard.

Visual Basic 6.0 provides the `MSComm32.ocx` ActiveX control for serial communications. MSComm operates via two distinct operational patterns:
1. **Polling Pattern:** A Timer control periodically queries `MSComm1.Input`. This pattern is inefficient, hogs CPU cycles, and risks serial buffer overruns.
2. **Event-Driven Pattern:** The `OnComm` event handler is utilized. The moment even a single byte enters the UART receive buffer, Windows triggers this interrupt routine automatically [1].

### Production Form Code: Interrupt-Driven Bidirectional Telemetry

“`basic
VERSION 5.00
Object = “{648A5603-2C6E-101B-82B6-000000000014}#1.1#0”; “MSCOMM32.OCX”
Begin VB.Form frmSerialControl
Caption = “DigiLiner RS-232 Telemetry Station”
ClientHeight = 4500
ClientWidth = 6800
Begin MSCommLib.MSComm MSComm1
Left = 240
Top = 240
_ExtentX = 1005
_ExtentY = 1005
_Version = 393216
End
Begin VB.TextBox txtIncomingLog
Height = 2655
Left = 240
MultiLine = -1 ‘True
ScrollBars = 2 ‘Vertical
Top = 840
Width = 6255
End
Begin VB.CommandButton btnOpenPort
Caption = “Open Port”
Height = 495
Left = 240
Top = 3720
Width = 1455
End
Begin VB.CommandButton btnSendCommand
Caption = “Send Query (PING)”
Height = 495
Left = 1920
Top = 3720
Width = 2055
End
End

Option Explicit

Private Sub Form_Load()
On Error GoTo ErrorHandler

‘ Configure Serial Port Parameters
MSComm1.CommPort = 1 ‘ Bind to COM1
MSComm1.Settings = “9600,N,8,1” ‘ 9600 Baud, No Parity, 8 Data Bits, 1 Stop Bit
MSComm1.InputMode = comInputModeText ‘ Text mode (use comInputModeBinary for byte streams)

‘ Buffer and Event Notification Thresholds
MSComm1.RThreshold = 1 ‘ Trigger OnComm upon receipt of every 1 byte!
MSComm1.SThreshold = 1 ‘ Notify when transmit buffer empties
MSComm1.InputLen = 0 ‘ Read entire incoming buffer in one call

Exit Sub
ErrorHandler:
MsgBox “Initialization Error: ” & Err.Description, vbCritical
End Sub

Private Sub btnOpenPort_Click()
On Error GoTo ErrorHandler
If Not MSComm1.PortOpen Then
MSComm1.PortOpen = True
btnOpenPort.Caption = “Close Port”
txtIncomingLog.Text = txtIncomingLog.Text & “[INFO] COM1 Port opened at 9600-8-N-1.” & vbCrLf
Else
MSComm1.PortOpen = False
btnOpenPort.Caption = “Open Port”
txtIncomingLog.Text = txtIncomingLog.Text & “[INFO] COM1 Port closed.” & vbCrLf
End If
Exit Sub
ErrorHandler:
MsgBox “Failed to Open Port! Device in use or unavailable: ” & Err.Description, vbExclamation
End Sub

Private Sub btnSendCommand_Click()
If MSComm1.PortOpen Then
‘ Dispatch ASCII PING command with carriage return and line feed
MSComm1.Output = “PING” & vbCrLf
Else
MsgBox “Please open the serial port first!”, vbExclamation
End If
End Sub

‘ Event-Driven Hardware Communications Handler
Private Sub MSComm1_OnComm()
Select Case MSComm1.CommEvent
Case comEvReceive
‘ Data available inside UART receive FIFO buffer!
Dim strReceived As String
strReceived = MSComm1.Input
txtIncomingLog.Text = txtIncomingLog.Text & strReceived
txtIncomingLog.SelStart = Len(txtIncomingLog.Text) ‘ Auto-scroll to end

Case comEvCTS
txtIncomingLog.Text = txtIncomingLog.Text & “[STATUS] CTS (Clear To Send) line changed state.” & vbCrLf
Case comEvDSR
txtIncomingLog.Text = txtIncomingLog.Text & “[STATUS] DSR (Data Set Ready) line changed state.” & vbCrLf
Case comBreak
txtIncomingLog.Text = txtIncomingLog.Text & “[WARNING] Hardware Break condition detected!” & vbCrLf
Case comFrame
txtIncomingLog.Text = txtIncomingLog.Text & “[ERROR] UART Framing Error (Baud rate mismatch)!” & vbCrLf
Case comOverrun
txtIncomingLog.Text = txtIncomingLog.Text & “[ERROR] UART FIFO Buffer Overrun (Data loss occurred)!” & vbCrLf
End Select
End Sub
“`

—

## Third Twist: Why Modern USB Converters Fail with Parallel Ports

If you purchase a modern $10 blue molded “USB to Parallel (DB-25)” cable and attempt to control relays via `Inpout32.dll`, you will meet immediate failure.

Here is why:
1. **USB Printer Class (Class 07):** Commodity USB-to-Parallel adapters (utilizing Prolific PL2305 or CH340S silicon) do not present themselves to Windows as genuine LPT ports. They register as standard USB Printing Support devices.
2. **Absence of Address 0x378:** These converters do not allocate physical I/O registers at `0x378` or `0x278` in motherboard address space. They merely stream bulk print spool packets. Arbitrary individual pin manipulation (bit-banging) is unsupported.

### The Modern Hardware Solution:
To achieve direct bit-level parallel port control on a 64-bit Windows 10/11 desktop, two genuine paths exist:
– **Install a True PCI-Express (PCIe) LPT Expansion Card:** PCIe controller cards map real physical I/O register blocks (for instance, at address `0xE010`) into system memory, allowing `Inpout32` to read and write directly to silicon pins.
– **Utilize an FTDI FT2232H / FT232H USB Module:** These chips support asynchronous bit-bang mode through FTDI’s native D2XX driver architecture, driving 8 pins as a virtual high-speed LPT interface in nanoseconds [2].

—

## 5. Sustaining the VB6 Runtime on Windows 11

Under its long-standing **”It Just Works”** support commitment, Microsoft continues to ship the core Visual Basic 6.0 runtime engine (`msvbvm60.dll`) pre-installed across 64-bit editions of Windows 10 and Windows 11 [1].

However, the most prevalent deployment error when registering legacy OCX and DLL components on 64-bit platforms is this:

“`cmd
REM WRONG: Copying to 64-bit System32 directory and registering from there
regsvr32 C:\Windows\System32\MSCOMM32.OCX <-- WILL FAIL OR REMAIN INVISIBLE! ``` ### The Correct Operational Procedure: 1. Copy `MSCOMM32.OCX` and `INPOUT32.DLL` into `C:\Windows\SysWOW64\`. 2. Launch the Command Prompt (cmd) **As Administrator**. 3. Execute the registration: ```cmd cd C:\Windows\SysWOW64 regsvr32 MSCOMM32.OCX ``` When Windows confirms *"DllRegisterServer in MSCOMM32.OCX succeeded"*, the 32-bit Windows-on-Windows (WoW64) subsystem has registered the component properly. --- ## Closing: An Engineering Lesson from Address 0x378 Today, web software stacks routinely download 400 megabytes of `node_modules` dependencies merely to style a button on a web form. In 1998, Visual Basic 6.0 controlled the cooling towers of an entire industrial complex using a single 16-bit integer. Visual Basic 6.0 was not an immaculate language: it lacked object-oriented implementation inheritance, provided primitive memory bounds checks, and encouraged risky error masking via `On Error Resume Next`. Yet it never placed opaque layers of abstraction between the engineer and the machine. A byte written to address 0x378 was electricity itself. Perhaps the true reason manufacturing plants cannot abandon VB6 is not stubborn nostalgia, but the unshakeable reliability of simplicity. 1. *Do layered microservice abstractions unnecessarily extend debugging times during physical hardware faults?* 2. *When modernizing a quarter-century-old industrial control suite, should your priority be preserving a proven, working system or rewriting it from scratch in a modern language?* --- ### Verified References & Further Reading - [1] **Jan Axelson Official Publication:** *Serial Port Complete: COM Ports, USB Virtual COM Ports, and Ports for Embedded Systems*. Lakeview Research. URL: `https://janaxelson.com/serport.htm` - [2] **High Performance Parallel Port Interfacing:** *Parallel Port Complete: Programming, Interfacing, & Using the PC's Parallel Printer Port & InpOut32 Driver Architecture*. URL: `https://www.lvr.com/parport.htm`