Serial Programming - upload.wikimedia....

Serial DOS
4.7 Terminal Program Revisited
I'm going to go back to the serial terminal program for a bit and this time redo the application
by using an interrupt service routine. There are a few other concepts I'd like to introduce
as well so I'll try to put them in with this example program. From the user perspective, I
would like to add the ability to change the terminal characteristics from the command line
and allow an "end-user" the ability to change things like the baud rate, stop bits, and parity
checking, and allow these to be variables instead of hard-coded constants. I'll explain each
section and then put it all together when we are through.
4.7.1 Serial ISR
This is an example of a serial ISR we can use:
{$F+}
procedure SerialDataIn; interrupt;
var
InputLetter: Char;
begin
if (Port[ComPort[1] + LSR] and $01) > 0 then begin
InputLetter := Chr(Port[ComPort[1] + RBR]);
end; {if}
end;
{$F-}
This isn't that much different from the polling method that we used earlier, but keep in
mind that by placing the checking inside an ISR that the CPU is only doing the check when
there is a piece of data available. Why even check the LSR to see if there is a data byte
available? Reading data sent to the UART is not the only reason why the UART will invoke
an interrupt. We will go over that in detail in a later section, but for now this is good
programming practice as well, to confirm that the data is in there.
By moving this checking to the ISR, more CPU time is available for performing other tasks.
We could even put the keyboard polling into an ISR as well, but we are going to keep things
very simple for now.
4.7.2 FIFO disabling
There is one minor problem with the way we have written this ISR. We are assuming that
there is no FIFO in the UART. The "bug" that could happen with this ISR as it is currently
written is that multiple characters can be in the FIFO buffer. Normally when this happens,
the UART only sends a single interrupt, and it is up to the ISR to "empty" the FIFO buffer
completely.
Instead, all we are going to do is simply disable the FIFO completely. This can be done
using the FCR (FIFO Control Register) and explicitly disabling the FIFO. As an added
precaution, we are also going to "clear" the FIFO buffers in the UART as a part of the
initialization portion of the program. Clearing the FIFOs look like this:
68