{---------------------------------------------------------}
{  Project : Async12 for Windows                          }
{  By      : Ir. G.W van der Vegt                         }
{---------------------------------------------------------}
{  Based on the following TP product :                    }
{                                                         }
{  ASYNC12 - Interrupt-driven asyncronous                 }
{            communications for Turbo Pascal.             }
{                                                         }
{            Version 1.2 - Wedensday June 14, 1989        }
{            Copyright (C) 1989, Rising Edge Data Services}
{                                                         }
{            Permission is granted for non-commercial     }
{            use and distribution.                        }
{                                                         }
{            Author : Mark Schultz                        }
{                                                         }
{---------------------------------------------------------}
{                                                         }
{ -Because of the complex nature of serial I/O not all    }
{  routines are 100% tested. I don't feel/am/will ever be }
{  responsible for any damage caused by this routines.    }
{                                                         }
{ -Some routines don't work (yet) because some fields are }
{  mentioned in the BP7 help file but are missing in      }
{  Wintypes. The routines are SetCTSmode, SetRTSMode &    }
{  SoftHandshake.                                         }
{                                                         }
{ -Some routines can't be implemented in windows. They    }
{  are listed behind the end.                             }
{                                                         }
{ -From the original ASYNC12 code, only the syntax, some  }
{  high level pascal code and pieces of comment are used. }
{  Due to the different way windows handels devices, all  }
{  assembly codes couldn't be reused and was rewritten in }
{  Borland Pascal. I used parts of ASYNC12 because I find }
{  it a very complete package for Serial I/O and it works }
{  very well too. Sources were supplied and documented    }
{  very well.                                             }
{                                                         }
{---------------------------------------------------------}
{  Date   .Time  Revision                                 }
{  ------- ----  ---------------------------------------- }
{  9406017.1200  Creation.                                }
{---------------------------------------------------------}

Library Async12w;

Uses
  Winprocs,
  Wintypes;

{****************************************************************************}

{----Public definition section}

TYPE
  T_eoln     = (C_cr,C_lf);

CONST
  C_MaxCom   = 4;                   {----Supports COM1..COM4}
  C_MinBaud  = 110;
  C_MaxBaud  = 256000;

TYPE
  C_ports      = 1..C_MaxCom;       {----Subrange type to minimize programming errors}

{****************************************************************************}

{----Private definition section}

CONST
  portopen   : Array[C_ports] OF Boolean = (false,false,false,false);   {----Open port flags    }
  cids       : ARRAY[C_ports] OF Integer = (-1,-1,-1,-1);               {----Device ID's        }
  inbs       : ARRAY[C_ports] OF Word    = ( 0, 0, 0, 0);               {----Input  buffer sizes}
  outbs      : ARRAY[C_ports] OF Word    = ( 0, 0, 0, 0);               {----Output buffer sizes}
  txdir      = 0;                                                       {----Used for FlushCom  }
  rxdir      = 1;                                                       {----Used for FlushCom  }
  fon        = 1;                                                       {----Used for Handshakes}
  foff       = 0;                                                       {----Used for Handshakes}
  eolns      : ARRAY[C_ports] OF T_eoln  = (C_cr,C_cr,C_cr,C_cr);       {----Eoln characters    }

VAR
{----Don't seem to be declared in Wintypes, neccesary to fake}
  foutx,
  foutxCTSflow,
  fRTSflow   : Byte;

{****************************************************************************}
{*                                                                          *}
{*  Procedure ComReadCh(ComPort:Byte) : Char; External;                     *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom)                          *}
{*                                                                          *}
{*  Returns character from input buffer of specified port.  If the buffer   *}
{*  is empty, the port # invalid or not opened, a Chr(0) is returned.       *}
{*                                                                          *}
{****************************************************************************}

Function ComReadCh(comport:C_ports) : Char; Export;

Var
  stat : TComStat;
  ch   : Char;
  cid  : Integer;

Begin
  ComReadCh:=#0;

  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        cid:=cids[comport];

      {----See how many characters are in the rx buffer}
        If (GetCommError(cid,stat)=0) AND
           (stat.cbInQue>0)           AND
           (ReadComm(cid,@ch,1)=1)
          THEN ComReadCh:=ch;
      End;
END; {of ComReadCh}

{****************************************************************************}
{*                                                                          *}
{*  Function ComReadChW(ComPort:Byte) : Char; External;                     *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom)                          *}
{*                                                                          *}
{*  Works like ComReadCh, but will wait until at least 1 character is       *}
{*  present in the specified input buffer before exiting.  Thus, ComReadChW *}
{*  works much like the ReadKey predefined function.                        *}
{*                                                                          *}
{****************************************************************************}

Function ComReadChW(comport:C_ports) : Char; Export;

Var
  stat : TComStat;
  ch   : Char;
  ok   : Boolean;
  cid  : Integer;

Begin
  ComReadChW:=#00;

  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        cid:=cids[comport];
        ok :=false;

      {----See how many characters are in the rx buffer}
        REPEAT
          IF (GetCommError(cid,stat)<>0)
            THEN ok:=True
            ELSE
              BEGIN
                IF (stat.cbInQue<>0)       AND
                   (ReadComm(cid,@ch,1)=1)
                  THEN ComReadChW:=ch;
                ok:=true;
              END;
        UNTIL ok;
      End;
END; {of ComReadChW}

{****************************************************************************}
{*                                                                          *}
{*  Procedure ComWriteCh(ComPort:Byte; Ch:Char); External                   *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom)                          *}
{*  Ch:Char       ->  Character to send                                     *}
{*                                                                          *}
{*  Places the character [Ch] in the transmit buffer of the specified port. *}
{*  If the port specified is not open or nonexistent, or if the buffer is   *}
{*  filled, the character is discarded.                                     *}
{*                                                                          *}
{****************************************************************************}

Procedure ComWriteCh(comport:C_ports; Ch:Char); Export;

VAR
  stat : TComStat;
  cid  : Integer;

BEGIN
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        cid:=cids[comport];

        IF (GetCommError(cid,stat)=0)   AND
           (stat.cbOutQue<outbs[comport])
          THEN TransmitCommChar(cid,ch);
      End;
END; {of CommWriteCh}

{****************************************************************************}
{*                                                                          *}
{*  Procedure ComWriteChW(ComPort:Byte; Ch:Char); External;                 *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom)                          *}
{*  Ch:Char       ->  Character to send                                     *}
{*                                                                          *}
{*  Works as ComWriteCh, but will wait until at least 1 free position is    *}
{*  available in the output buffer before attempting to place the character *}
{*  [Ch] in it.  Allows the programmer to send characters without regard to *}
{*  available buffer space.                                                 *}
{*                                                                          *}
{****************************************************************************}

Procedure ComWriteChW(comport:C_ports; Ch:Char); Export;

VAR
  stat : TComStat;
  cid  : Integer;
  rdy  : Boolean;

BEGIN
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        cid:=cids[comport];
        rdy:=False;

        REPEAT
          IF (GetCommError(cid,stat)<>0)
            THEN rdy:=true
            ELSE
              IF (stat.cbOutQue<outbs[comport])
                THEN rdy:=TransmitCommChar(cid,ch)=0;
        UNTIL rdy;
      End;
End; {of ComWriteChW}

{****************************************************************************}
{*                                                                          *}
{*  Procedure ClearCom(ComPort:Byte); IO:Char)                              *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom).                         *}
{*                    Request ignored if out of range or unopened.          *}
{*  IO:Char       ->  Action code; I=Input, O=Output, B=Both                *}
{*                    No action taken if action code unrecognized.          *}
{*                                                                          *}
{*  ClearCom allows the user to completely clear the contents of either     *}
{*  the input (receive) and/or output (transmit) buffers.  The "action      *}
{*  code" passed in <IO> determines if the input (I) or output (O) buffer   *}
{*  is cleared.  Action code (B) will clear both buffers.  This is useful   *}
{*  if you wish to cancel a transmitted message or ignore part of a         *}
{*  received message.                                                       *}
{*                                                                          *}
{****************************************************************************}

Procedure ClearCom(ComPort:C_Ports;IO:Char); Export;

Var
  cid  : Integer;

Begin
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        cid:=cids[comport];

        Case Upcase(IO) OF
          'I' : FlushComm(cid,rxdir);
          'B' : Begin
                  FlushComm(cid,rxdir);
                  FlushComm(cid,txdir);
                End;
          'O' : FlushComm(cid,txdir);
        End;
      End;
End; {of ClearComm}

{****************************************************************************}
{*                                                                          *}
{*  Procedure ComBufferLeft(ComPort:Byte; IO:Char) : Word                   *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom).                         *}
{*                    Returns 0 if Port # invalid or unopened.              *}
{*  IO:Char       ->  Action code; I=Input, O=Output                        *}
{*                    Returns 0 if action code unrecognized.                *}
{*                                                                          *}
{*  ComBufferLeft will return a number (bytes) indicating how much space    *}
{*  remains in the selected buffer.  The INPUT buffer is checked if <IO> is *}
{*  (I), and the output buffer is interrogated when <IO> is (O).  Any other *}
{*  "action code" will return a result of 0.  Use this function when it is  *}
{*  important to avoid program delays due to calls to output procedures or  *}
{*  to prioritize the reception of data (to prevent overflows).             *}
{*                                                                          *}
{****************************************************************************}

Function ComBufferLeft(ComPort:C_ports; IO:Char) : Word; Export;

VAR
  stat : TComStat;
  cid  : Integer;

Begin
  ComBufferLeft := 0;

  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        cid:=cids[comport];

        IF (GetCommError(cid,stat)=0)
          THEN
            CASE Upcase(IO) OF
              'I' : ComBufferLeft:=inbs [comport]-stat.cbInQue;
              'O' : ComBufferLeft:=outbs[comport]-stat.cbOutQue;
            END;
      End;
End; {ComBufferLeft}

{****************************************************************************}
{*                                                                          *}
{*  Procedure ComWaitForClear(ComPort:Byte)                                 *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom).                         *}
{*                    Exits immediately if out of range or port unopened.   *}
{*                                                                          *}
{*  A call to ComWaitForClear will stop processing until the selected out-  *}
{*  put buffer is completely emptied.  Typically used just before a call    *}
{*  to the CloseCom procedure to prevent premature cut-off of messages in   *}
{*  transit.                                                                *}
{*                                                                          *}
{****************************************************************************}

Procedure ComWaitForClear(ComPort:C_ports); Export;

Var
  stat  : TComStat;
  cid   : Integer;
  Empty : Boolean;

Begin
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        cid  :=cids[comport];
        empty:=false;

        REPEAT
          IF (GetCommError(cid,stat)<>0)
            THEN empty:=true
            ELSE empty:=stat.cbOutQue=0
        UNTIL empty;
      End;
End; {ComWaitForClear}

{****************************************************************************}
{*                                                                          *}
{*  Procedure ComWrite(ComPort:Byte; St:String)                             *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom).                         *}
{*                    Exits immediately if out of range or port unopened.   *}
{*  St:String     ->  String to send                                        *}
{*                                                                          *}
{*  Sends string <St> out communications port <ComPort>.                    *}
{*                                                                          *}
{****************************************************************************}

Procedure ComWrite(ComPort:C_ports; St:String); Export;

Var
  X : Byte;

Begin
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      For X := 1 To Length(St) Do
        ComWriteChW(ComPort,St[X]);
End; {of ComWrite}

{****************************************************************************}
{*                                                                          *}
{*  Procedure ComWriteln(ComPort:Byte; St:String);                          *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom).                         *}
{*                    Exits immediately if out of range or port unopened.   *}
{*  St:String     ->  String to send                                        *}
{*                                                                          *}
{*  Sends string <St> with a CR and LF appended.                            *}
{*                                                                          *}
{****************************************************************************}

Procedure ComWriteln(ComPort:C_ports; St:String); Export;

Var
  X : Byte;

Begin
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        For X := 1 To Length(St) Do
          ComWriteChW(ComPort,St[X]);
        ComWriteChW(ComPort,#13);
        ComWriteChW(ComPort,#10);
      End;
End; {of ComWriteln}

{****************************************************************************}
{*                                                                          *}
{*  Procedure Delay(ms:word);                                               *}
{*                                                                          *}
{*  ms:word       ->  Number of msec to wait.                               *}
{*                                                                          *}
{*  A substitute for CRT's Delay under DOS. This one will wait for at least *}
{*  the amount of msec specified, probably even more because of the task-   *)
{*  switching nature of Windows. So a msec can end up as a second if ALT-TAB*}
{*  or something like is pressed. Minumum delays are guaranteed independend *}
{*  of task-switches.                                                       *}
{*                                                                          *}
{****************************************************************************}

Procedure Delay(ms : Word);

Var
  theend,
  marker  : Longint;

Begin
{----Potentional overflow if windows runs for 49 days without a stop}
  marker:=GetTickCount;
{$R-}
  theend:=Longint(marker+ms);
{$R+}

{----First see if timer overrun will occure and wait for this,
     then test as usual}
  If (theend<marker)
    Then
      While (GetTickCount>=0) DO;

{----Wait for projected time to pass}
  While (theend>=GettickCount) Do;
End; {of Delay}

{****************************************************************************}
{*                                                                          *}
{*  Procedure ComWriteWithDelay(ComPort:Byte; St:String; Dly:Word);         *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom).                         *}
{*                    Exits immediately if out of range or port unopened.   *}
{*  St:String     ->  String to send                                        *}
{*  Dly:Word      ->  Time, in milliseconds, to delay between each char.    *}
{*                                                                          *}
{*  ComWriteWithDelay will send string <St> to port <ComPort>, delaying     *}
{*  for <Dly> milliseconds between each character.  Useful for systems that *}
{*  cannot keep up with transmissions sent at full speed.                   *}
{*                                                                          *}
{****************************************************************************}

Procedure ComWriteWithDelay(ComPort:C_ports; St:String; Dly:Word); Export;

Var
  X   : Byte;

Begin
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        ComWaitForClear(ComPort);
        For X := 1 To Length(St) Do
          Begin
            ComWriteChW(ComPort,St[X]);
            ComWaitForClear(ComPort);
            Delay(dly);
          End;
      End;
End; {of ComWriteWithDelay}

{****************************************************************************}
{*                                                                          *}
{* Procedure ComReadln(ComPort:Byte; Var St:String; Size:Byte; Echo:Boolean)*}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom).                         *}
{*                    Exits immediately if out of range or port unopened.   *}
{*  St:String     <-  Edited string from remote                             *}
{*  Size:Byte;    ->  Maximum allowable length of input                     *}
{*  Echo:Boolean; ->  Set TRUE to echo received characters                  *}
{*                                                                          *}
{*  ComReadln is the remote equivalent of the standard Pascal READLN pro-   *}
{*  cedure with some enhancements.  ComReadln will accept an entry of up to *}
{*  40 printable ASCII characters, supporting ^H and ^X editing commands.   *}
{*  Echo-back of the entry (for full-duplex operation) is optional.  All    *}
{*  control characters, as well as non-ASCII (8th bit set) characters are   *}
{*  stripped.  If <Echo> is enabled, ASCII BEL (^G) characters are sent     *}
{*  when erroneous characters are intercepted.  Upon receipt of a ^M (CR),  *}
{*  the procedure is terminated and the final string result returned.       *}
{*                                                                          *}
{****************************************************************************}

Procedure ComReadln(ComPort:C_ports; Var St:String; Size:Byte; Echo:Boolean); Export;

Var
  Len,X : Byte;
  Ch    : Char;
  Done  : Boolean;

Begin
  St:='';
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        Done := False;
        Repeat
          Len:=Length(St);
          Ch :=Chr(Ord(ComReadChW(ComPort)) And $7F);

          Case Ch Of
            ^H : If Len>0
                  Then
                    Begin
                      Dec(Len);
                      St[0]:=Chr(Len);
                      If Echo Then ComWrite(ComPort,#8#32#8);
                    End
                  Else ComWriteChW(ComPort,^G);
            ^J : If eolns[comport]=C_lf
                   Then
                     Begin
                       Done:=True;
                       If Echo Then ComWrite(ComPort,#13#10);
                     End;
            ^M : If eolns[comport]=C_cr
                   Then
                     Begin
                       Done:=True;
                       If Echo Then ComWrite(ComPort,#13#10);
                     End;
            ^X : Begin
                   St:='';
                   If Len=0 Then ComWriteCh(ComPort,^G);
                   If Echo
                     Then
                       For X:=1 to Len Do
                         ComWrite(ComPort,#8#32#8);
                 End;
          #32..
          #127 : If Len<Size
                   Then
                     Begin
                       Inc(Len);
                       St[Len]:=Ch;
                       St[0]:=Chr(Len);
                       If Echo Then ComWriteChW(ComPort,Ch);
                     End
                   Else
                     If Echo Then ComWriteChW(ComPort,^G);
          Else
            If Echo Then ComWriteChW(ComPort,^G)
          End;
        Until Done;
      End;
End; {of ComReadln}

{****************************************************************************}
{*                                                                          *}
{*  Procedure SetRTSMode(ComPort:Byte; Mode:Boolean; RTSOn,RTSOff:Word)     *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom).                         *}
{*                    Request ignored if out of range or unopened.          *}
{*  Mode:Boolean  ->  TRUE to enable automatic RTS handshake                *}
{*  RTSOn:Word    ->  Buffer-usage point at which the RTS line is asserted  *}
{*  RTSOff:Word   ->  Buffer-usage point at which the RTS line is dropped   *}
{*                                                                          *}
{*  SetRTSMode enables or disables automated RTS handshaking.  If [MODE] is *}
{*  TRUE, automated RTS handshaking is enabled.  If enabled, the RTS line   *}
{*  will be DROPPED when the # of buffer bytes used reaches or exceeds that *}
{*  of [RTSOff].  The RTS line will then be re-asserted when the buffer is  *}
{*  emptied down to the [RTSOn] usage point.  If either [RTSOn] or [RTSOff] *}
{*  exceeds the input buffer size, they will be forced to (buffersize-1).   *}
{*  If [RTSOn] > [RTSOff] then [RTSOn] will be the same as [RTSOff].        *}
{*  The actual handshaking control is located in the interrupt driver for   *}
{*  the port (see ASYNC12.ASM).                                             *}
{*                                                                          *}
{****************************************************************************}

Procedure SetRTSmode(ComPort:C_ports; Mode:Boolean; RTSOn,RTSOff:Word); Export;

Var
  dcb : tdcb;
  cid : Integer;

Begin
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        cid:=cids[comport];

        If GetCommState(cid,dcb)=0
          Then
            Begin
              With dcb Do
                Case mode of
                  True  : Begin
                            fRTSflow:=fon;
                            Xonlim  :=inbs[comport]-RTSon ;
                            Xofflim :=inbs[comport]-RTSoff;
                          End;
                  False : Begin
                            fRTSflow:=foff;
                          End;
                End;
              SetCommState(dcb);
            End;
      End;
End; {of SetRTSmode}

{****************************************************************************}
{*                                                                          *}
{*  Procedure SetCTSMode(ComPort:Byte; Mode:Boolean)                        *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom).                         *}
{*                    Request ignored if out of range or unopened.          *}
{*  Mode:Boolean  ->  Set to TRUE to enable automatic CTS handshake.        *}
{*                                                                          *}
{*  SetCTSMode allows the enabling or disabling of automated CTS handshak-  *}
{*  ing.  If [Mode] is TRUE, CTS handshaking is enabled, which means that   *}
{*  if the remote drops the CTS line, the transmitter will be disabled      *}
{*  until the CTS line is asserted again.  Automatic handshake is disabled  *}
{*  if [Mode] is FALSE.  CTS handshaking and "software" handshaking (pro-   *}
{*  vided by the SoftHandshake procedure) ARE compatable and may be used    *}
{*  in any combination.                                                     *}
{*                                                                          *}
{****************************************************************************}

Procedure SetCTSMode(ComPort:Byte; Mode:Boolean); Export;

Var
  dcb : tdcb;
  cid : Integer;

Begin
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        cid:=cids[comport];

        If GetCommState(cid,dcb)=0
          Then
            Begin
              Case mode of
                True  : foutxCTSflow:=fon;
                False : foutxCTSflow:=foff;
              End;
              SetCommState(dcb);
            End;
      End;
End; {of SetCTSmode}

{****************************************************************************}
{*                                                                          *}
{*  Procedure SoftHandshake(ComPort:Byte; Mode:Boolean; Start,Stop:Char)    *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom).                         *}
{*                    Request ignored if out of range or unopened.          *}
{*  Mode:Boolean  ->  Set to TRUE to enable transmit software handshake     *}
{*  Start:Char    ->  START control character (usually ^Q)                  *}
{*                    Defaults to ^Q if character passed is >= <Space>      *}
{*  Stop:Char     ->  STOP control character (usually ^S)                   *}
{*                    Defaults to ^S if character passed is >= <Space>      *}
{*                                                                          *}
{*  SoftHandshake controls the usage of "Software" (control-character)      *}
{*  handshaking on transmission.  If "software handshake" is enabled        *}
{*  ([Mode] is TRUE), transmission will be halted if the character in       *}
{*  [Stop] is received.  Transmission is re-enabled if the [Start] char-    *}
{*  acter is received.  Both the [Start] and [Stop] characters MUST be      *}
{*  CONTROL characters (i.e. Ord(Start) and Ord(Stop) must both be < 32).   *}
{*  Also, <Start> and <Stop> CANNOT be the same character.  If either one   *}
{*  of these restrictions are violated, the defaults (^Q for <Start> and ^S *}
{*  for <Stop>) will be used.                                               *}
{*                                                                          *}
{****************************************************************************}

Procedure SoftHandshake(ComPort:Byte; Mode:Boolean; Start,Stop:Char); Export;

Var
  dcb : tdcb;
  cid : integer;

Begin
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        cid:=cids[comport];

        If GetCommState(cid,dcb)=0
          Then
            Begin
              Case mode of
                True  : Begin
                          foutx:=fon;
                          If (start IN [#00..#31]) And (start<>stop)
                            Then dcb.Xonchar:=start
                            Else dcb.Xonchar:=^Q;
                          If (stop  IN [#00..#31]) And (start<>stop)
                            Then dcb.Xoffchar:=stop
                            Else dcb.Xoffchar:=^S;
                        End;
                False : foutx:=foff;
              End;
              SetCommState(dcb);
            End;
      End;
End; {of Softhandshake}

{****************************************************************************}
{*                                                                          *}
{*  Function ComExist(ComPort:Byte) : Boolean                               *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom)                          *}
{*                    Returns FALSE if out of range                         *}
{*  Returns TRUE if hardware for selected port is detected & tests OK       *}
{*                                                                          *}
{****************************************************************************}

Function ComExist(ComPort:C_ports) : Boolean; Export;

VAR
  mode : String;
  dcb  : tdcb;

Begin
  If (ComPort IN [1..C_MaxCom])
    Then
      Begin
        mode:='COM'+Chr(Comport+Ord('0'))+' 19200,N,8,1'#0;
        ComExist:=(BuildCommDCB(@mode[1],dcb)=0);
      End
    Else ComExist:=false;
End; {of Comexist}

{****************************************************************************}
{*                                                                          *}
{*  Function ComTrueBaud(Baud:Longint) : Real                               *}
{*                                                                          *}
{*  Baud:Longint  ->  User baud rate to test.                               *}
{*                    Should be between C_MinBaud and C_MaxBaud.            *}
{*  Returns the actual baud rate based on the accuracy of the 8250 divider. *}
{*                                                                          *}
{*  The ASYNC12 communications package allows the programmer to select ANY  *}
{*  baud rate, not just those that are predefined by the BIOS or other      *}
{*  agency.  Since the 8250 uses a divider/counter chain to generate it's   *}
{*  baud clock, many non-standard baud rates can be generated.  However,    *}
{*  the binary counter/divider is not always capable of generating the      *}
{*  EXACT baud rate desired by a user.  This function, when passed a valid  *}
{*  baud rate, will return the ACTUAL baud rate that will be generated.     *}
{*  The baud rate is based on a 8250 input clock rate of 1.73728 MHz.       *}
{*                                                                          *}
{****************************************************************************}

Function ComTrueBaud(Baud:Longint) : Real; Export;

Var
  X : Real;
  Y : Word;

Begin
  X := Baud;
  If X < C_MinBaud Then X := C_MinBaud;
  If X > C_MaxBaud Then X := C_MaxBaud;
  ComTrueBaud := C_MaxBaud / Round($900/(X/50));
End; {of ComTrueBaud}

{****************************************************************************}
{*                                                                          *}
{* Function Lstr(l : Longint) : String;                                     *}
{*                                                                          *}
{* l:Longint       ->  Number converted to a string                         *}
{*                                                                          *}
{* This function converts longint l to a string.                            *}
{*                                                                          *}
{****************************************************************************}

Function Lstr(l : Longint) : String;

Var
  s : String;

Begin
  Str(l:0,s);
  Lstr:=s;
End; {of Lstr}

{****************************************************************************}
{*                                                                          *}
{*  Procedure ComParams(ComPort:Byte; Baud:Longint;                         *}
{*                      WordSize:Byte; Parity:Char; StopBits:Byte);         *}
{*                                                                          *}
{*  ComPort:Byte   ->  Port # to initialize.  Must be (1 - C_MaxCom)        *}
{*                     Procedure aborted if port # invalid or unopened.     *}
{*  Baud:Longint   ->  Desired baud rate.  Should be (C_MinBaud - C_MaxBaud)*}
{*                     C_MinBaud or C_MaxBaud used if out of range.         *}
{*  WordSize:Byte  ->  Word size, in bits.  Must be 5 - 8 bits.             *}
{*                     8-bit word used if out of range.                     *}
{*  Parity:Char    ->  Parity classification.                               *}
{*                     May be N)one, E)ven, O)dd, M)ark or S)pace.          *}
{*                     N)one selected if classification unknown.            *}
{*  StopBits:Byte  ->  # of stop bits to pad character with.  Range (1-2)   *}
{*                     1 stop bit used if out of range.                     *}
{*                                                                          *}
{*  ComParams is used to configure an OPEN'ed port for the desired comm-    *}
{*  unications parameters, namely baud rate, word size, parity form and     *}
{*  # of stop bits.  A call to this procedure will set up the port approp-  *}
{*  riately, as well as assert the DTR, RTS and OUT2 control lines and      *}
{*  clear all buffers.                                                      *}
{*                                                                          *}
{****************************************************************************}

Procedure ComParams(ComPort:C_ports; Baud:LongInt; WordSize:Byte; Parity:Char; StopBits:Byte); Export;

Var
  mode : String;
  cid  : Integer;
  dcb  : tdcb;

Begin
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        cid:=cids[comport];

      {----Like COM1 9600,N,8,1}
        mode:='COM'+Chr(Comport+Ord('0'))+' '+Lstr(baud)+','+Upcase(Parity)+','+Lstr(Wordsize)+','+Lstr(stopbits)+#0;
        IF (BuildCommDCB(@mode[1],dcb)=0)
          Then
            Begin
              dcb.id:=cid;
              SetCommState(dcb);
            End;
      End;
End; {of ComParams}

{****************************************************************************}
{*                                                                          *}
{*  Function OpenCom(ComPort:Byte; InBufferSize,OutBufferSize:Word):Boolean *}
{*                                                                          *}
{*  ComPort:Byte        ->  Port # to OPEN (1 - C_MaxCom)                   *}
{*                          Request will fail if out of range or port OPEN  *}
{*  InBufferSize:Word   ->  Requested size of input (receive) buffer        *}
{*  OutBufferSize:Word  ->  Requested size of output (transmit) buffer      *}
{*  Returns success/fail status of OPEN request (TRUE if OPEN successful)   *}
{*                                                                          *}
{*  OpenCom must be called before any activity (other than existence check, *}
{*  see the ComExist function) takes place.  OpenCom initializes the        *}
{*  interrupt drivers and serial communications hardware for the selected   *}
{*  port, preparing it for I/O. Once a port has been OPENed, a call to      *}
{*  ComParams should be made to set up communications parameters (baud rate,*}
{*  parity and the like).  Once this is done, I/O can take place on the     *}
{*  port. OpenCom will return a TRUE value if the opening procedure was     *}
{*  successful, or FALSE if it is not.                                      *}
{*                                                                          *}
{****************************************************************************}

Function OpenCom(ComPort:C_ports; InBufferSize,OutBufferSize:Word) : Boolean; Export;

Var
  cid  : Integer;
  comp : String;

Begin
  OpenCom := False;
  If    (ComPort IN [1..C_MaxCom]) And
     Not(portopen[ComPort])      And
         ComExist(comport)
    Then
      Begin
        comp:='COM'+Chr(comport+Ord('0'))+#0;
        cid:=OpenComm(@comp[1],InBufferSize,OutBufferSize);
        If (cid>=0)
          Then
            Begin
              cids [comport]     :=cid;
              inbs [comport]     :=InBufferSize;
              outbs[comport]     :=OutBufferSize;
              portopen[comport]:=true;
            End;
        OpenCom:=(cid>=0);
      End;
End; {of OpenCom}

{****************************************************************************}
{*                                                                          *}
{*  Procedure CloseCom(ComPort:Byte)                                        *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to close                                       *}
{*                    Request ignored if port closed or out of range.       *}
{*                                                                          *}
{*  CloseCom will un-link the interrupt drivers for a port, deallocate it's *}
{*  buffers and drop the DTR and RTS signal lines for a port opened with    *}
{*  the OpenCom function.  It should be called before exiting your program  *}
{*  to ensure that the port is properly shut down.                          *}
{*  NOTE:  CloseCom shuts down a communications channel IMMEDIATELY,        *}
{*         even if there is data present in the input or output buffers.    *}
{*         Therefore, you may wish to call the ComWaitForClear procedure    *}
{*         before closing the ports.                                        *}
{*                                                                          *}
{****************************************************************************}

Procedure CloseCom(ComPort:C_ports); Export;

Var
  cid : integer;

Begin
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      Begin
        cid:=cids[comport];
        portopen[comport]:=Not(CloseComm(cid)=0);
      End;
End; {of CloseCom}

{****************************************************************************}
{*                                                                          *}
{*  Procedure CloseAllComs                                                  *}
{*                                                                          *}
{*  CloseAllComs will CLOSE all currently OPENed ports.  See the CloseCom   *}
{*  procedure description for more details.                                 *}
{*                                                                          *}
{****************************************************************************}

Procedure CloseAllComs; Export;

Var
  X : C_ports;

Begin
  For X := 1 To C_MaxCom Do
    If portopen[X] Then CloseCom(X);
End; {of CloseAllComs}

{****************************************************************************}
{*                                                                          *}
{*  Procedure ComSetEoln(ComPort:C_ports;EolnCh : T_eoln)                 *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # for which to alter the eoln character          *}
{*                    Request ignored if port closed or out of range.       *}
{*  EolnCh:T_eoln ->  Eoln character needed                                 *}
{*                                                                          *}
{*  With this function one can toggle the eoln character between cr and lf. *}
{*                                                                          *}
{****************************************************************************}

Procedure ComSetEoln(ComPort:C_ports;EolnCh : T_eoln); Export;

Begin
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then eolns[comport]:=EolnCh;
End; {of ComSetEoln}

{****************************************************************************}
{*                                                                          *}
{*  Function  ComGetBufsize(ComPort:C_ports;IO : char)                      *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # for which to retrieve the buffersize           *}
{*                    Request ignored if port closed or out of range.       *}
{*  IO:Char       ->  Action code; I=Input, O=Output                        *}
{*                    Returns 0 if action code unrecognized.                *}
{*                                                                          *}
{*  This function will return the buffer size defined for a serial port.    *}
{*                                                                          *}
{****************************************************************************}

Function ComGetBufsize(ComPort:C_ports;IO : Char) : WORD; Export;

Begin
  ComGetBufSize:=0;
  If (ComPort IN [1..C_MaxCom]) And
     (portopen[ComPort])
    Then
      CASE Upcase(IO) OF
        'I' : ComgetBufSize:=inbs [comport];
        'O' : ComgetBufSize:=outbs[comport];
      END;
End; {of ComGetBufferSize}

{****************************************************************************}

Exports
  ComReadCh         index  1,
  ComReadChW        index  2,
  ComWriteCh        index  3,
  ComWriteChW       index  4,
  ClearCom          index  5,
  ComBufferLeft     index  6,
  ComWaitForClear   index  7,
  ComWrite          index  8,
  ComWriteln        index  9,
  ComWriteWithDelay index 10,
  ComReadln         index 11,
  SetRTSmode        index 12,
  SetCTSMode        index 13,
  SoftHandshake     index 14,
  ComExist          index 15,
  ComTrueBaud       index 16,
  ComParams         index 17,
  OpenCom           index 18,
  CloseCom          index 19,
  CloseAllComs      index 20,
  ComSetEoln        index 21,
  ComGetBufSize     index 22;

Begin
End.

{----The following procedures/functions from the async12 }
{    package are not available                           }

{****************************************************************************}
{*                                                                          *}
{*  Procedure SetDTR(ComPort:Byte; Assert:Boolean);                         *}
{*                                                                          *}
{*  ComPort:Byte    ->  Port # to use (1 - C_MaxCom)                        *}
{*                      Call ignored if out-of-range                        *}
{*  Assert:Boolean  ->  DTR assertion flag (TRUE to assert DTR)             *}
{*                                                                          *}
{*  Provides a means to control the port's DTR (Data Terminal Ready) signal *}
{*  line.  When [Assert] is TRUE, the DTR line is placed in the "active"    *}
{*  state, signalling to a remote system that the host is "on-line"         *}
{*  (although not nessesarily ready to receive data - see SetRTS).          *}
{*                                                                          *}
{****************************************************************************}

Procedure SetDTR(ComPort:Byte; Assert:Boolean);

Begin
End; {of SetDTR}

{****************************************************************************}
{*                                                                          *}
{*  Procedure SetRTS(ComPort:Byte; Assert:Boolean)                          *}
{*                                                                          *}
{*  ComPort:Byte    ->  Port # to use (1 - C_MaxCom)                        *}
{*                      Call ignored if out-of-range                        *}
{*  Assert:Boolean  ->  RTS assertion flag (Set TRUE to assert RTS)         *}
{*                                                                          *}
{*  SetRTS allows a program to manually control the Request-To-Send (RTS)   *}
{*  signal line.  If RTS handshaking is disabled (see C_Ctrl definition     *}
{*  and the the SetRTSMode procedure), this procedure may be used.  SetRTS  *}
{*  should NOT be used if RTS handshaking is enabled.                       *}
{*                                                                          *}
{****************************************************************************}

Procedure SetRTS(ComPort:Byte; Assert:Boolean);

Begin
End; {of SetRTS}

{****************************************************************************}
{*                                                                          *}
{*  Procedure SetOUT1(ComPort:Byte; Assert:Boolean)                         *}
{*                                                                          *}
{*  ComPort:Byte    ->  Port # to use (1 - C_MaxCom)                        *}
{*                      Call ignored if out-of-range                        *}
{*  Assert:Boolean  ->  OUT1 assertion flag (set TRUE to assert OUT1 line)  *}
{*                                                                          *}
{*  SetOUT1 is provided for reasons of completeness only, since the         *}
{*  standard PC/XT/AT configurations do not utilize this control signal.    *}
{*  If [Assert] is TRUE, the OUT1 signal line on the 8250 will be set to a  *}
{*  LOW logic level (inverted logic).  The OUT1 signal is present on pin 34 *}
{*  of the 8250 (but not on the port itself).                               *}
{*                                                                          *}
{****************************************************************************}

Procedure SetOUT1(ComPort:Byte; Assert:Boolean);

Begin
End;  {of SetOUT1}

{****************************************************************************}
{*                                                                          *}
{*  Procedure SetOUT2(ComPort:Byte; Assert:Boolean)                         *}
{*                                                                          *}
{*  ComPort:Byte    ->  Port # to use (1 - C_MaxCom)                        *}
{*                      Call ignored if out-of-range                        *}
{*  Assert:Boolean  ->  OUT2 assertion flag (set TRUE to assert OUT2 line)  *}
{*                                                                          *}
{*  The OUT2 signal line, although not available on the port itself, is     *}
{*  used to gate the 8250 <INTRPT> (interrupt) line and thus acts as a      *}
{*  redundant means of controlling 8250 interrupts.  When [Assert] is TRUE, *}
{*  the /OUT2 line on the 8250 is lowered, which allows the passage of the  *}
{*  <INTRPT> signal through a gating arrangement, allowing the 8250 to      *}
{*  generate interrupts.  Int's can be disabled bu unASSERTing this line.   *}
{*                                                                          *}
{****************************************************************************}

Procedure SetOUT2(ComPort:Byte; Assert:Boolean);

Begin
End; {of SetOUT2}

{****************************************************************************}
{*                                                                          *}
{*  Function CTSStat(ComPort:Byte) : Boolean                                *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom)                          *}
{*                    Call ignored if out-of-range                          *}
{*  Returns status of Clear-To-Send line (TRUE if CTS asserted)             *}
{*                                                                          *}
{*  CTSStat provides a means to interrogate the Clear-To-Send hardware      *}
{*  handshaking line.  In a typical arrangement, when CTS is asserted, this *}
{*  signals the host (this computer) that the receiver is ready to accept   *}
{*  data (in contrast to the DSR line, which signals the receiver as        *}
{*  on-line but not nessesarily ready to accept data).  An automated mech-  *}
{*  ansim (see CTSMode) is provided to do this, but in cases where this is  *}
{*  undesirable or inappropriate, the CTSStat function can be used to int-  *}
{*  terrogate this line manually.                                           *}
{*                                                                          *}
{****************************************************************************}

Function CTSStat(ComPort:Byte) : Boolean;

Begin
End; {of CTSstat}

{****************************************************************************}
{*                                                                          *}
{*  Function DSRStat(ComPort:Byte) : Boolean                                *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom)                          *}
{*                    Call ignored if out-of-range                          *}
{*  Returns status of Data Set Ready (DSR) signal line.                     *}
{*                                                                          *}
{*  The Data Set Ready (DSR) line is typically used by a remote station     *}
{*  to signal the host system that it is on-line (although not nessesarily  *}
{*  ready to receive data yet - see CTSStat).  A remote station has the DSR *}
{*  line asserted if DSRStat returns TRUE.                                  *}
{*                                                                          *}
{****************************************************************************}

Function DSRStat(ComPort:Byte) : Boolean;

Begin
End; {of DSRstat}

{****************************************************************************}
{*                                                                          *}
{*  Function RIStat(ComPort:Byte) : Boolean                                 *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom)                          *}
{*                    Call ignored if out-of-range                          *}
{*                                                                          *}
{*  Returns the status of the Ring Indicator (RI) line.  This line is       *}
{*  typically used only by modems, and indicates that the modem has detect- *}
{*  ed an incoming call if RIStat returns TRUE.                             *}
{*                                                                          *}
{****************************************************************************}

Function RIStat(ComPort:Byte) : Boolean;

Begin
End; {of RIstat}

{****************************************************************************}
{*                                                                          *}
{*  Function DCDStat(ComPort:Byte) : Boolean                                *}
{*                                                                          *}
{*  ComPort:Byte  ->  Port # to use (1 - C_MaxCom)                          *}
{*                    Call ignored if out-of-range                          *}
{*                                                                          *}
{*  Returns the status of the Data Carrier Detect (DCD) line from the rem-  *}
{*  ote device, typically a modem.  When asserted (DCDStat returns TRUE),   *}
{*  the modem indicates that it has successfuly linked with another modem   *}
{*  device at another site.                                                 *}
{*                                                                          *}
{****************************************************************************}

Function DCDStat(ComPort:Byte) : Boolean;

Begin
End; {of DCDstat}

{ ---------------    WINDOWS INTERFACE UNIT -------------------- }

Unit WinAsync;

Interface

CONST
  C_MaxCom   = 4;             {----supports COM1..COM4                        }
  C_MinBaud  = 110;           {----min baudrate supported by windows 3.1      }
  C_MaxBaud  = 256000;        {----max baudrate supported by windows 3.1      }

TYPE
  T_eoln     = (C_cr,C_lf);   {----used to change EOLN character from cr to lf}
  C_ports    = 1..C_MaxCom;   {----subrange type to minimize programming errors}


Function  ComReadCh(comport:C_ports)  : Char;
Function  ComReadChW(comport:C_ports) : Char;
Procedure ComReadln(ComPort:C_ports; Var St:String; Size:Byte; Echo:Boolean);

Procedure ComWriteCh(comport:C_ports; Ch:Char);
Procedure ComWriteChW(comport:C_ports; Ch:Char);
Procedure ComWrite(ComPort:C_ports; St:String);
Procedure ComWriteln(ComPort:C_ports; St:String);
Procedure ComWriteWithDelay(ComPort:C_ports; St:String; Dly:Word);

Procedure ClearCom(ComPort:C_Ports;IO:Char);
Function  ComBufferLeft(ComPort:C_ports; IO:Char) : Word;
Procedure ComWaitForClear(ComPort:C_ports);

Procedure SetRTSmode(ComPort:C_ports; Mode:Boolean; RTSOn,RTSOff:Word);
Procedure SetCTSMode(ComPort:Byte; Mode:Boolean);
Procedure SoftHandshake(ComPort:Byte; Mode:Boolean; Start,Stop:Char);

Function  ComExist(ComPort:C_ports) : Boolean;
Procedure ComParams(ComPort:C_ports; Baud:LongInt; WordSize:Byte; Parity:Char; StopBits:Byte);
Function  ComTrueBaud(Baud:Longint) : Real;
Function  OpenCom(ComPort:C_ports; InBufferSize,OutBufferSize:Word) : Boolean;

Procedure CloseCom(ComPort:C_ports);
Procedure CloseAllComs;
Procedure ComSetEoln(ComPort:C_ports;EolnCh : T_eoln);

Function ComGetBufsize(ComPort:C_ports;IO : Char) : WORD;

Implementation

Function  ComReadCh(comport:C_ports)  : Char;                                  external 'async12w';
Function  ComReadChW(comport:C_ports) : Char;                                  external 'async12w';
Procedure ComWriteCh(comport:C_ports; Ch:Char);                                external 'async12w';
Procedure ComWriteChW(comport:C_ports; Ch:Char);                               external 'async12w';
Procedure ClearCom(ComPort:C_Ports;IO:Char);                                   external 'async12w';
Function  ComBufferLeft(ComPort:C_ports; IO:Char) : Word;                      external 'async12w';
Procedure ComWaitForClear(ComPort:C_ports);                                    external 'async12w';
Procedure ComWrite(ComPort:C_ports; St:String);                                external 'async12w';
Procedure ComWriteln(ComPort:C_ports; St:String);                              external 'async12w';
Procedure ComWriteWithDelay(ComPort:C_ports; St:String; Dly:Word);             external 'async12w';
Procedure ComReadln(ComPort:C_ports; Var St:String;Size:Byte; Echo:Boolean);   external 'async12w';
Procedure SetRTSmode(ComPort:C_ports; Mode:Boolean; RTSOn,RTSOff:Word);        external 'async12w';
Procedure SetCTSMode(ComPort:Byte; Mode:Boolean);                              external 'async12w';
Procedure SoftHandshake(ComPort:Byte; Mode:Boolean; Start,Stop:Char);          external 'async12w';
Function  ComExist(ComPort:C_ports) : Boolean;                                 external 'async12w';
Function  ComTrueBaud(Baud:Longint) : Real;                                    external 'async12w';
Procedure ComParams(ComPort:C_ports; Baud:LongInt; WordSize:Byte;
                                     Parity:Char; StopBits:Byte);              external 'async12w';
Function  OpenCom(ComPort:C_ports; InBufferSize,OutBufferSize:Word) : Boolean; external 'async12w';
Procedure CloseCom(ComPort:C_ports);                                           external 'async12w';
Procedure CloseAllComs;                                                        external 'async12w';
Procedure ComSetEoln(ComPort:C_ports;EolnCh : T_eoln);                         external 'async12w';

Function ComGetBufsize(ComPort:C_ports;IO : Char) : WORD;                      external 'async12w';


End.

{ ------------------------------   TEST PROGRAM  ----------------------- }

Program Asynctst;

Uses
  Wincrt,
  Asyncwin;

{----Demo main program for Async12w}

Var
  p : Byte;
  s : string;
  i : Integer;

Begin
  Write('Enter serial port number [1..4] : '); readln(p);
  IF ComExist(p) And OpenCom(p,1024,1024)
    Then
      Begin
        ComParams(p,9600,8,'N',1);

      {----Hayes modems echo a cr,lf so lf as eoln char is easier to program.
           The cr is skipped also. Default eoln character is cr, equivalent
           to BP's readln procedure}
        ComSetEoln(p,c_lf);
        Writeln('Enter a Hayes Command, like ATX1');
        Readln(s);
        If (s<>'')
          THEN
            BEGIN
              Write('Sending...');
              ComWriteWithDelay(p,s+#13#10,500);
              Writeln(' ok, press <enter> to continue.');

              Readln;
              Repeat
                Write('[',CombufferLeft(p,'I'):3,']');
                ComReadln(p,s,255,false);
                Writeln('[',ComBufferLeft(p,'I'):3,']',s);
              Until (ComBufferLeft(p,'I')=1024);
            END;
        CloseCom(p);
      End
    Else Writeln('Error opening COM',p,' port');
END.