Turbo PASCAL Async Manager        version 2.01

Copyright 1986-1990 by Kaleb Axon. All Rights Reserved.


For use with Turbo PASCAL 4.0
                          5.0
                          5.5

(Originally written in Turbo PASCAL 3.01)

The only requirement for freely incorporating this code into your
own programs is that the author of this code be given due credit
wherever is most appropriate (program's opening screen, copyright
page or introduction of manual, etc).

Information on updates and new releases to add to your library of
Turbo PASCAL source will be released from time to time via the
PASCAL net-mail echo, or you may drop me a note with your name
and address (sent to the address below).

If you have any questions or comments, please direct them to:

      Kaleb Axon
      1841 W. Katella St.
      Springfield, MO 65807


The purpose of this unit is to provide access to the serial ports
from Turbo PASCAL.



GENERAL FEATURES AND LIMITATIONS


The Turbo PASCAL Async Manager may access either COM1 or COM2, or
both simultaneously. It is capable of up to 56,000 baud, and
supports any normally combination of data bits, stop bits and
parity.

The TPAsync unit must NEVER be overlaid under any circumstances.
When running in a multi-tasking environment, any program using
the TPAsync unit must be defined as non-swappable; that is to
say, it must be present and in the exact same location in memory
at all times.



PRIMARY FUNCTIONS


These are the functions that are most often used. In fact, these
are the only functions I originally used in my own programming. A
reasonably decent program could be developed using these
functions. Once these primary functions are covered, we will go
on to discuss the extended functions.

----------
The AsyncOpen function opens an async port for access by your
program, and sets up an input buffer. The handle may be 1 or 2.
The handle is used in future calls to indicate which serial port
to access. Note that the handle need not be the same as the com
port. For example, COM1 could be opened using handle #2, and COM2
could be opened using handle #1. This may seem odd, but for my
purposes, it was originally a good idea, and I never saw any need
to change it. The function returns true if the operation was
successful, or false if it failed.

  function AsyncOpen(Handle   : byte;
                     ComPort  : integer;
                     BaudRate : word;
                     Parity   : char;
                     DataBits : integer;
                     StopBits : integer)
                   : boolean;

----------
The AsyncSend procedure sends one character to the specified
serial port.  Output is not buffered.

  procedure AsyncSend(Handle : byte;
                      Ch     : char);

----------
The AsyncBufferRead function reads one character from the
specified serial port if one is available. If a character was
successfully read, the function returns true; otherwise, it
returns false.

  function AsyncBufferRead(    Handle : byte;
                           var C      : char)
                         : boolean;

----------
The AsyncBufferClose procedure closes the specified serial port.

  procedure AsyncClose(Handle : byte);

EXTENDED FUNCTIONS


The AsyncSendString procedure sends a string to the specified
serial port.  Output is not buffered.

  procedure AsyncSendString(Handle : byte;
                            S      : string);

----------
The AsyncBufferCheck function returns true if a character is
currently available from the specified serial port for input via
the AsyncBufferRead function.

  function AsyncBufferCheck(Handle : byte) : boolean;

----------
The Carrier function returns true if the CD (Carrier Detect) pin
on the specified serial port is hot.

  function Carrier(Handle : byte) : boolean;

----------
The AsyncChange procedure changes the baud rate, data bits,
parity and stop bits for the specified serial port without
actually closing the port or clearing the input buffer.

  procedure AsyncChange(Handle   : byte;
                        BaudRate : word;
                        Parity   : char;
                        DataBits : integer;
                        StopBits : integer);

----------
The AsyncCloseKeepDTR procedure closes the specified serial port,
but does not drop the DTR line. AsyncClose causes the carrier to
be dropped on most machines, and AsyncCloseKeepDTR will avoid
dropping the carrier.

  procedure AsyncCloseKeepDTR(Handle : byte);


SAMPLE PROGRAM

{ This program does not implement all the features of the Turbo
  PASCAL Async Manager, but should give a general idea as to how it
  is used. }

program Sample;
uses
  Crt,
  TPAsync;

var
  Ch         : char;
  OldCarrier : boolean;

begin
  if AsyncOpen(1,1,2400,'N',8,1) then
  begin
    WriteLn('COM1 opened successfully; press Ctrl-6 to exit.');
    repeat
      if AsyncBufferRead(1,Ch) then
        Write(Ch);
      if KeyPressed then
      begin
        Ch := ReadKey;
        if Ch <> ^^ then
          AsyncSend(1,Ch);
      end else
        Ch := ^@;
    until Ch = ^^;
    AsyncClose(Ch);
  end else
    WriteLn('Couldn''t open COM1!');
end.