When working a legacy VGA graphics display there is sometimes a need to synchronize your code to the VBlank (vertical blank). An example would be using DirectX under Win95. If we have animation running at a frame rate in a dual frame environment, there is no clean way to wait for the VBlank on frames that do not need to flip because it is too easy to miss them as DirectX only waits for the leading edge of the VBlank. Note that in a multithreaded environment there is a chance that we could get preempted by another thread, causing us to miss the VBlank. We could also be preempted just after detecting it, causing us to miss it entirely.

VGA_STATUS   = 03dah       ; VGA Status address
VSYNC_MASK   = 00001000b   ; VSync bit

        mov    edx,VGA_STATUS
        mov    ah,VSYNC_MASK

Loop:   in     al,dx       ; Get VGA status
        test   al,ah       ; Is VSync bit set?
        jz     Loop        ; Jump if not

To get information about the serial and parallel ports of your PC, visit the National Semiconductor web site at www.national.com and download the following PDF data sheets.

Both of these are excellent references for all the I/O information necessary for communicating directly with the serial and parallel ports on your PC.

Normally you do not need to access this port, but what if you have a specialized application that is not communicating with a printer but something else, like a parallel communications device or a dongle (hasp). What if your PC is in reality an embedded system where it runs a display in a Gazebo and as such has no mouse or standard keyboard, but merely a couple of buttons for advancing through a slide presentation. It just powers up and runs an advertisement or is a slot machine using a NLX motherboard or some other embedded device, not necessarily a PC. What if it can be signaled through communications to play something else? What if this same device needs a watchdog to know it failed or dip switches for some kind of addressing or feature selection just by setting some switches? Maybe it drives an LCD (liquid crystal display). (Remember, no keyboard or maybe it drives one directly in parallel.) Or maybe you are just itching to build some hardware to plug into your computer.

Datel used to manufacture a special parallel interface card for the PC. This was designed to connect via a parallel cable to a Game Shark made by InterAct and allowed a PC to be able to connect to various consoles. Hackers built software drivers and tools that allowed them to develop games for some of those consoles such as the old Sony Playstation.

Our little experiment lets us tinker with reading dip switches plugged into the parallel port. You can buy an eight-bank dip switch at your local Radio Shack store (part #275-1301).

The PC parallel port specifications state that:

Figure 17-1. Parallel port to octal switch

First we need to initialize the port that we will consider LPT1, which uses a base address of 378h. We should note that the typical parallel port is set up to be unidirectional and not bidirectional, which means that we normally can only write to the data lines, not read from them. In our initialization function we set the bit, which causes our eight data bits to tri-state, thus making them bidirectional.

Parallel Port Base Address

iPIO_DCR       = 2              ; Device control register

iPIO_DCR_DIR   = 00100000b      ; 20h = direction bit

PPort   dd       378h           ; Using LPT1 for base address


;  Initialize the parallel port
;
;  void PPortInit(void)

PPortInit proc   near
       mov     edx,PPort        ; Get base address
       add     edx,iPIO_DCR     ; Add offset
       in      al,dx            ; Get control bits

       or      al,iPIO_DCR_DIR  ; Set direction bit to tri-state
                                ; For bidirectional access
       out     dx,al            ; Do it!
       ret
PPortInit endp


;  Read switches from the parallel port
;  Note: Only lower 8 bits will be set, upper bits clear
;
;  uint32 PPortRead(void)

PPortRead proc  near
       xor    eax,eax             ; eax=0
       mov    edx,PPort           ; base address is data port
       in     al,dx               ; get 8 bits from port
       ret                        ; return value in EAX
PPortRead endp

Lets look at the C code calling our parallel port functions:

uint 32 n;

PPortInit();
n = PPortRead();

printf("switches =0x%x", n);

You will note that the logic is inverted so when a switch is off, thus leaving the circuit open, a logical 1 is produced, but if the switch is on, thus closing the circuit and shorting the input to ground, a logic 0 occurs. You can think of this as upside-down binary. To solve for this just insert the following:

PPortRead proc    near
       xor      eax,eax         ; eax=0
       mov      edx,PPort       ; base address is data port
       in       al,dx           ; get 8 bits from port
       xor      eax,000000ffh   ; Flip switch bits
       ret                      ; return value in EAX
PPortRead endp

The second XOR just before the RET will flip the switch bits so off=0 and on=1. This will help make life simpler.

I need to mention that there is one little problem with the circuit. Although the specifications of the data port consider the tri-state (float) condition to be a logical 1 until pulled to ground, some computers float with voltage a little low so they are not considered a logical 1. And as such the switches are thought of as always closed. The parallel port has no (+5v) source and as such one of two things need to be done: an external one supplied (battery, etc.) or one leached off all the other control signals, creating a pseudo 5-volt supply. Those signals would obviously have to have their output signals in a high state. That voltage would then need to be connected in series to a pull-up resistor attached to one side of each of the switch terminals, thus giving them a logical high signal. The other switch terminal is connected to ground, so when the switch is closed it pulls the signal low.

DOS had a BIOS function that allowed you to print a TTY message to the output device. But what if you are running an embedded operating system like pSOS or running under Win32? The printf() and TTY functions do not really go anywhere, especially if you are running a full-screen DirectX application. Well, you could always do a kind of printf() out the serial port to a smart terminal. Did you know you could pick up old PS/2 computers from places like Goodwill for $9-$50 still in running condition and looking in pretty good shape? I call them throw-away computers. When running an old DOS version of ProComm, they work great. When they break, you throw them away! The lap-link cable to connect your two computers will probably cost you more than the computer. To reduce my desk footprint I use a very small 9" VGA monochrome monitor and a very small 83-key keyboard. Unfortunately, they are not as cheap. I use a logging library that I recreate for every company I work for. In it I do a single log write and it can optionally go to a disk file, a Notepad window, and/or a particular serial port at a specified baud rate. In Win32 I use the CommAPI so it'll work in all the Win32 platforms, but the following will only work in Win95, DOS, or Linux.

Of course, other operating systems such as embedded systems that allow Real Mode or security access to the I/O ports and interrupts, will work as well. To simplify it I have hard-coded the base address and IRQ information to COM1, but it is really a snap to do a table lookup during the initialization function to set things up and save the actual information needed for the send function.

The PC serial port specifications state that:

Serial Port Table

INTMSK        = 21h           ; Mask register port #

ComAdr   dd    3f8h
ComIO    db    0ch
ComMask  db    0efh

OldMask  db     0             ; Old interrupt mask



; bool ComInit(uint nBaud);

ComInit proc    near
        push    ebp
        mov     ebp,esp
        push    ebx

; Disable 8259 interrupt for IRQ

        in      al,INTMSK         ; Get IRQ bits
        mov     ah,ComMask        ; Clear interrupt bit
        mov     OldMask,al        ; Save them
        not     ah                ; Flip mask into strip
        or      al,ah             ; Disable bit
        out     INTMSK,al         ; Set IRQ bits

; Disable UART interrupts

        mov     edx,ComAdr        ; Port address
        inc     edx               ; (+1) .IER - Interrupt Enable
        mov     eax,0             ; disable UART interrupt bits
        out     dx,al             ; Disable UART interrupts

; Disable all handshaking

        add     edx,3             ; (+4)
        out     dx,al             ; Disable all handshaking

; Set up for appropriate protocol

        dec     edx               ; (+3) .LCR - Line Control
        in      al,dx             ; Get Line Control
        or      al,10000000b      ; Set Divisor Latch Access
        out     dx,al

; Calculate baud rate divisor

        mov     ecx,[ebp+8]
        mov     edx,0
        mov     eax,1843200/16
        div     ecx

; Write baud rate

        mov     edx,ComAdr        ; Port address
        out     dx,al
        inc     edx               ; (+1)
        mov     al,ah
        out     dx,al

; Bits per char and parity

        mov     al,00000011b      ; 8 bits no parity
        add     edx,2             ; (+3) .LCR
        out     dx,al

; Set handshaking lines

        inc     edx               ; (+4) .MCR
        mov     al,00001111b
        out     dx,al

        mov     eax,1             ; Success
        pop     ebx
        pop     ebp
        ret
ComInit endp

; Serial Out  ah=char

Sout  proc    near
      mov     edx,ComAdr
      add     edx,5

$S1:  in     al,dx                ; Get status
      test    al,00100000b        ; Twx Holding Register Empty
      jz      $S1                 ; Jump if still has character

      mov     al,ah               ; Get character
      mov     edx,ComAdr
      out     dx,al
      ret
Sout  endp


; void ComStr(byte *pStr);
;
; Write String

ComStr  proc    near
        push    ebp
        mov     ebp,esp

        mov     ecx,[ebp+arg1]    ; Get string pointer

        mov     ah,[ecx]          ; Get a character
        inc     ecx
        test    ah,ah
        jz      $xit              ; string terminator?

$1:     call    Sout              ; Write a character

        mov     ah,[ecx]          ; Get a character
        inc     ecx
        test    ah,ah             ; string terminator?
        jnz     $1                ; jump if not

$xit:  pop     ebp
       ret
ComStr endp

Let's look at the C code calling our serial port functions:

ComInit(19200);
ComStr("The quick brown fox

");

Since the port number is hard coded to simplify this example, the code is initialized but only the baud rate can be set. Thereafter, zero delimited character strings are written to that serial port through the call to the ComStr() function. In this elementary form, very simple.