1:
2:
3:
4:
5:
6:
7:

var
  PortTimeout : _COMMTIMEOUTS;
  PortHandle : Integer;
  PortDCB : TDCB;
  PortNr  : Integer;
  PortState : Cardinal;
  WriteOverlapped,ReadOverlapped,StatusOs: TOverlapped;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

function OpenCOM(Port: byte): boolean; stdcall;
begin
  PortHandle :=
  CreateFile(PChar('\\.\COM'+IntToStr(Port)),GENERIC_READ or GENERIC_WRITE,0,
             nil,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,LongInt(0));
  
  //Overlapped = Asynchron auf Microsoftianisch
 
  {Da wir nun asynchron auf die Schnittstelle zugreifen (weiss der Teufel 
  warum – aber es sieht so aus als wäre diese Art des Zugriffs ab W2K
  praktisch ZWINGEND notwendig – selbst wenn man gar nicht asynchron übertragen will)  
  muss man auch die dafür notwendigen Structs initialisieren}  
  if PortHandle > 0 then
  begin
    Result := true;
    InitOverlapped(WriteOverlapped);
    InitOverlapped(ReadOverlapped);
    InitOverlapped(StatusOs);
  end else Result := false;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:

procedure InitOverlapped(var Overlapped : TOverlapped);
begin
  Overlapped.Offset := 0;
  Overlapped.OffsetHigh := 0;
  Overlapped.Internal := 0;
  Overlapped.InternalHigh := 0;
  Overlapped.hEvent := CreateEvent(nil,True,False,'');
end;                    

1:
2:
3:
4:
5:
6:
7:

procedure CloseCOM; stdcall;
begin
  PurgeComm(PortHandle, PURGE_RXABORT or PURGE_RXCLEAR or PURGE_TXABORT or PURGE_TXCLEAR);
  SetCommMask(PortHandle,0); //unterbricht WaitCommEvent im Polling thread
  CloseHandle(PortHandle);
  PortHandle := 0;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

function ComAvailable(ComNr: byte): boolean; stdcall;
var
  TestHandle : integer;
begin
  TestHandle :=
  CreateFile(PChar('\\.\COM'+IntToStr(ComNr)),GENERIC_READ or GENERIC_WRITE,0,
             nil,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,LongInt(0));
  if (TestHandle <= 0) then
    Result := false
  else
  begin
    Result := true;
    CloseHandle(TestHandle);
  end;
end;                    

1:
2:
3:
4:
5:
6:

function SetBaudRate(baud: cardinal): boolean; stdcall;
begin
  GetCommState(PortHandle,PortDCB);
  PortDCB.BaudRate := baud;
  Result := SetCommState(PortHandle,PortDCB);
end;                    

1:
2:
3:
4:
5:
6:
7:

var PortState: cardinal;

begin
GetCommModemStatus(PortHandle,PortState); //PortHandle erhält man mit CreateFile – kommt später
//Nun die Abfrage – Hier auf Clear to send
if ((Portstate and MS_CTS_ON) <> 0) then Result := true
    else Result := false;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

procedure SetDTR; stdcall;
begin
  if (PortHandle <> 0) then EscapeCommFunction(PortHandle,5);
end;

procedure ClearDTR; stdcall;
begin
  if (PortHandle <> 0) then EscapeCommFunction(PortHandle,CLRDTR);
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:

function SendString(Str: PChar): boolean; stdcall;
var
  written  : cardinal;
  tmpStr : string;
  i: LongBool;
begin
  if (PortHandle <> 0) then
  begin
    tmpStr := string(Str);
    Result := not WriteFile(PortHandle,tmpStr[1],Length(tmpStr),written,@WriteOverlapped);
  end;
end;

function ReadString(var Buf: PChar): Cardinal; stdcall;
var
  StrBuf: string;
  Error,BytesRead: DWORD;
  Status: TComStat;
  RdSuccess: boolean;
begin
  BytesRead := 0;
  if (PortHandle <> -1) then
  begin
    ClearCommError(PortHandle,Error,@Status);
    case Error of
      CE_BREAK,CE_DNS,CE_FRAME,CE_IOE,CE_MODE,CE_OOP,CE_OVERRUN,CE_PTO,CE_RXOVER,
      CE_RXPARITY,CE_TXFULL:
      begin
        BytesRead := 0;
      end
    else
      begin
        SetLength(StrBuf,Status.cbInQue);
        RdSuccess := ReadFile(PortHandle,StrBuf[1],Status.cbInQue,BytesRead,@ReadOverlapped);
        if not RdSuccess then BytesRead := 0;
      end;
    end;
  end;
  if (BytesRead > 0) then
  begin
    Result := BytesRead;
    try
      StrPCopy(Buf,StrBuf);
    except
      Result := 0;
    end;
  end else Result := 0;
end;                    

1:

SetCommMask(PortHandle,0);                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:

type
  TSerialThread = class(TThread)
  protected
    fComEvent: cardinal;
    procedure Execute; override;
  public
    constructor Create;
    property ComEvent: cardinal read fComEvent;
  end;

constructor TSerialThread.Create;
begin
  FreeOnTerminate:= True;
  inherited Create(False);
end;

procedure TSerialThread.Execute;
var
  SerialEvent, WaitResult, BytesRead: Cardinal;
begin
  SetCommMask(PortHandle,EV_CTS or EV_BREAK or EV_DSR or
  EV_ERR or EV_RING or EV_RLSD or EV_RXCHAR or EV_RXFLAG or EV_TXEMPTY);
  if not WaitCommEvent(PortHandle,SerialEvent,@StatusOs) then
  begin
    if (GetLastError = ERROR_IO_PENDING) then
    begin
      WaitResult := WaitForSingleObject(StatusOs.hEvent,INFINITE);
      case WaitResult of
        WAIT_OBJECT_0:
        begin
          if GetOverlappedResult(PortHandle,StatusOs,BytesRead,false) then
            ReleaseEvent(SerialEvent);
        end;
      end;
    end;
  end else ReleaseEvent(SerialEvent);
end;