Tach Frank!

am 13 Oct 98 um 08:09:56 schrieb Frank McCormick an all:

 FM> The code I use to initialize the com port is as follows;

 FM> Function ModemInit(P: Byte; var PHandle: HFile): Boolean;
 FM> var
 FM>   Com: string[6];
 FM>   Action: ulong;
 FM>   Error: apiret;
 FM> Begin
 FM>   Com := 'COM' + Char(P + 48) + #0;
 FM>   Error := DosOpen({at}Com[1], PHandle, Action, 0, $0000,
 FM>                    OPEN_ACTION_OPEN_IF_EXISTS, OPEN_ACCESS_READWRITE OR
 FM>                    OPEN_SHARE_DENYNONE, nil);
 FM>   if Error  NO_ERROR then PHandle := 0;
 FM>   FPort := PHandle;
 FM>   if PHandle = 0 then ModemInit := FALSE else ModemInit := TRUE;
 FM> End;
This is code to open an inactive COM port. You don't need to do that since
you have already an active handle. So just use it. Just for the fun of it
here some of my code (used in MxXEd/2). It creates a custom
"devicedriver" so I can just use standard Read and Write
functions on a TEXT file variable. If you like it, feel free to use it but
mention my name somewhere.

UNIT uTWMComFile;

INTERFACE

USES
  Use32,
  OS2Def,
  OS2Base,
  VPUtils,
  SysUtils;

TYPE
  eComPort = CLASS( exception )
  END;

  tWatchdogErrorCodes = (weCarrierLost, weTimeout, wePortClosed);
  tWatchdogErrorProc = PROCEDURE(_ErrCode: tWatchdogErrorCodes);
  tWatchdogTimeoutProc = PROCEDURE(_TenthsRemaining: SmallInt);

  pComPortRec = ^tComPortRec;
  tComPortRec = RECORD
                  WatchdogThreadHandle: TID;
                  WatchdogInactivity: SmallInt;
                  WatchdogMaxInactivity: SmallInt;
                  WatchdogErrorProc: tWatchdogErrorProc;
                  WatchdogTimeoutProc: tWatchdogTimeoutProc;
                END;

PROCEDURE ComPortAssignHandle(VAR _F: TEXT; _ComHandle: hFile;
                              _Timeout: SmallInt;
                              _TimeoutProc: tWatchdogTimeoutProc;
                              _ErrorProc: tWatchdogErrorProc);
FUNCTION  ComPortGetBaudrate(VAR _F: TEXT): SmallWord;
FUNCTION  ComPortCheckCarrier(VAR _F: TEXT): BOOLEAN;
FUNCTION  ComPortSetMaxInactivity(VAR _F: TEXT; _Tenths: SmallInt): SmallInt;
FUNCTION  ComPortGetMaxInactivity(VAR _F: TEXT): SmallInt;
FUNCTION  ComPortReadChar(VAR _F: TEXT; VAR c: Char): BOOLEAN;

IMPLEMENTATION

FUNCTION ComPortReadChar(VAR _F: TEXT; VAR c: Char): BOOLEAN;
VAR
  rc: ApiRet;
  BytesRead: ULONG;
BEGIN
  rc := DosRead(tTextRec(_F).Handle, c, 1, BytesRead);
  IF rc0 THEN
    Raise eComPort.CreateFmt('RemoteReadCharNoWait.DosRead, rc=%d',[rc]);
  Result := (BytesRead=1);
  IF Result THEN
    WITH pComPortRec({at}tTextRec(_F).UserData)^ DO
      WatchdogInactivity:=WatchdogMaxInactivity;
END;

FUNCTION ComPortCheckCarrier(VAR _F: TEXT): BOOLEAN;
  VAR
    Status : BYTE;
    Bytes : ULONG;
    Dummy : ULONG;
    rc : APIRet;
  BEGIN
  rc:=DosDevIOCtl(tTextRec(_F).Handle,IOCTL_ASYNC,ASYNC_GETMODEMINPUT,
                  NIL,0,{at}Dummy,
                  {at}Status,SizeOf(Status),{at}Bytes);
  Result:=(Status AND $80)>0;
END;

FUNCTION ComPortGetBaudrate(VAR _F: TEXT): SmallWord;
  VAR
    Baudrate : USHORT;
    Bytes : ULONG;
    Dummy : ULONG;
    rc : APIRet;
  BEGIN
  rc:=DosDevIOCtl(tTextRec(_F).Handle,IOCTL_ASYNC,ASYNC_GETBAUDRATE,
                  NIL,0,{at}Dummy,
                  {at}Baudrate,SizeOf(Baudrate),{at}Bytes);
  Result:=Baudrate;
END;

FUNCTION ComPortWatchdogFunc( _pF: POINTER): LongInt;
  VAR
    F: ^tTextRec;
    WasInactive: BOOLEAN;
  BEGIN
  F := _pF;
  WasInactive := true;
  WITH pComPortRec({at}F^.UserData)^ DO BEGIN
    REPEAT
      DosSleep(100);
      IF F^.Mode=fmClosed THEN BEGIN
        IF Assigned(WatchdogErrorProc) THEN
          WatchdogErrorProc(wePortClosed);
        DosExit(0, 0);
      END;
      IF WatchdogMaxInactivity=-1 THEN
        WasInactive:=True
      ELSE BEGIN
        IF WasInactive THEN BEGIN
          WatchdogInactivity:=WatchdogMaxInactivity;
          WasInactive := False;
        END;
        Dec(WatchdogInactivity);
        IF Assigned(WatchdogTimeoutProc) THEN
          WatchdogTimeoutProc(WatchdogInactivity);
        IF NOT ComPortCheckCarrier(TEXT(F^)) THEN BEGIN
          IF Assigned(WatchdogErrorProc) THEN
            WatchdogErrorProc(weCarrierLost);
          DosExit(0, 0);
        END;
      END;
    UNTIL (WatchdogInactivity=0);
    IF Assigned(WatchdogErrorProc) THEN
      WatchdogErrorProc(weTimeout);
  END;
  DosExit(0, 0);
END;

FUNCTION  ComPortSetMaxInactivity(VAR _F: TEXT; _Tenths: SmallInt): SmallInt;
  BEGIN
  WITH pComPortRec({at}tTextRec(_F).UserData)^ DO BEGIN
    Result := WatchdogMaxInactivity;
    WatchdogMaxInactivity := _Tenths;
  END;
END;

FUNCTION  ComPortGetMaxInactivity(VAR _F: TEXT): SmallInt;
  BEGIN
  Result := pComPortRec({at}tTextRec(_F).UserData)^.WatchdogMaxInactivity;
END;

// Device driver functions

FUNCTION ComPortWrite(VAR _F: tTextRec): LongInt;
  VAR
    Written:LongInt;
  BEGIN
  WITH _F DO BEGIN
    Result:=DosWrite(Handle,BufPtr^,BufPos,Written);
    BufPos:=0;
    DosResetBuffer(Handle)
  END;
END;

FUNCTION ComPortRead(VAR _F: tTextRec): Longint;
  VAR
    Count:LongInt;
  BEGIN
  WITH _F DO BEGIN
    REPEAT
      Result:=DosRead(Handle,(BufPtr+BufPos)^,BufSize-BufPos,Count);
      IF Result=0 THEN BEGIN
        Inc(BufEnd,Count);
        WITH pComPortRec({at}_F.UserData)^ DO
          WatchdogInactivity := WatchdogMaxInactivity;
      END ELSE
        Exit;
    UNTIL Count>0;
  END;
END;

FUNCTION ComPortReturn(VAR _F: tTextRec): LongInt;
  BEGIN
  Result:=0;
END;

FUNCTION ComPortOpen(VAR _F: tTextRec): LongInt;
  BEGIN
  WITH _F DO BEGIN
    CloseFunc := {at}ComPortReturn;
    IF Mode=fmInput THEN BEGIN
      InOutFunc:={at}ComPortRead;
      FlushFunc:={at}ComPortReturn;
    END ELSE BEGIN
      Mode := fmOutput;
      InOutFunc := {at}ComPortWrite;
      FlushFunc := {at}ComPortWrite;
    END;
  END;;
  Result:=0;                 { I/O result = 0: success }
END;

PROCEDURE ComPortAssignHandle(VAR _F: TEXT; _ComHandle: hFile;
                              _Timeout: SmallInt;
                              _TimeoutProc: tWatchdogTimeoutProc;
                              _ErrorProc: tWatchdogErrorProc);
  BEGIN
  WITH tTextRec(_F) DO BEGIN
    Handle := _ComHandle;
    Mode := fmClosed;
    BufSize := SizeOf(Buffer);
    BufPtr := {at}Buffer;
    OpenFunc := {at}ComPortOpen;
    StrCopy({at}Name,'HotComPortHandle');
    WITH pComPortRec({at}UserData)^ DO BEGIN
      WatchdogMaxInactivity := _Timeout;
      WatchdogTimeoutProc := _TimeoutProc;
      WatchdogErrorProc := _ErrorProc;
      WatchdogThreadHandle := VPBeginThread( ComPortWatchdogFunc, 8192, {at}_F );
    END;
  END;
END;

END.

MfG :-)
Thomas

--- MxXEd/2 1.02