12.8 Time-outs on an IO Port

12.8 Time-outs on an I/O Port

One problem with the repeat..until loop in the previous section is that it could spin indefinitely as it waits for the printer to become ready to accept additional input. If someone turns the printer off, or if the printer cable becomes disconnected, the program could freeze up, forever waiting for the printer to become available. Usually, it's a better idea to inform the user when something goes wrong rather than allowing the system to hang. Typically, great programmers handle this problem by including a time-out period in the loop, which once exceeded causes the program to alert the user that something is wrong with the peripheral device.

You can expect some sort of response from most peripheral devices within a reasonable amount of time. For example, even in the worst case, most printers will be ready to accept additional character data within a few seconds of the last transmission. Therefore, something is probably wrong if 30 seconds or more have passed without the printer accepting a new character. If the program is written to detect this kind of problem, it can pause, asking the user to check the printer and tell the program to resume printing once the problem is resolved.

Choosing a good time-out period is not an easy task. In doing so, you must carefully balance the irritation of possibly having the program incorrectly claim that something is wrong, with the pain of having the program lock up for long periods when there actually is something wrong. Both situations are equally annoying to the end user.

An easy way to create a time-out period is to count the number of times the program loops while waiting for a handshake signal from a peripheral. Consider the following modification to the repeat..until loop of the previous section:

 mov( 9, dx );         // Initialize DX with the address of the status port.  mov( 30_000_000, ecx );  // Time-out period of approximately 30 seconds,                           // assuming port access time is about 1 microsecond.  HandshakeLoop:      in( dx, al );        // Get the parallel port status into the AL register.      and( , al );      // Clear Z flag if the HO bit is set.  loopz HandshakeLoop;     // Decrement ECX and loop while ECX <> 0 and                           // the HO bit of AL contains a zero.  if( ecx <> 0 ) then      // Okay to write another byte to the printer data port here.  else      // We had a time-out condition if we get here.  endif; 

This code will exit once the printer is ready to accept data or when approximately 30 seconds have expired . You might question the 30-second figure, after all, a software-based loop (counting down ECX to zero) should run at different speeds on different processors. However, don't miss the fact that there is an in instruction inside this loop. The in instruction reads a port on the ISA bus and that means this instruction will take approximately one microsecond to execute (about the fastest operation on the ISA bus). Hence, one million times through the loop will take about a second (plus or minus 50 percent, but close enough for our purposes). This is true almost regardless of the CPU frequency.