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:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:

  procedure ReceiveBytes(ComHandle: THandle; Overlapped: TOverlapped);
  var
    BufSize, BytesRead, Dummy: DWORD;
    ComStat: TComStat;
  begin
    if ClearCommError(ComHandle, Dummy, @ComStat) then
    begin
      BufSize := ComStat.cbInQue;
      SetLength(FLastReceived, BufSize);
      if ReadFile(ComHandle, // Port handle
        FLastReceived[1],    // Pointer to data to read
        BufSize,             // Number of bytes to read
        BytesRead,           // Pointer to number of bytes read
        @Overlapped)         // Overlapped structure
        and (BytesRead > 0) then
        SendMessage(FTargetHandle, WM_DATARECEIVED, WParam(FLastReceived), 0);
    end;
  end;

var
  Overlapped: TOverlapped;
  EventMask, Dummy, SignalState: DWORD;
  EventHandles: array[0..1] of THandle;
  DCB: TDCB;
  TimeOut: TCommTimeouts;
begin
  SetThreadName;

  if FComHandle <> INVALID_HANDLE_VALUE then
  begin
    DCB.DCBlength := SizeOf(DCB);
    DCB.BaudRate := 9600;
    DCB.Flags := 1; // binary --> set always
    DCB.wReserved := 18;
    DCB.XonLim := 256;
    DCB.XoffLim := 256;
    DCB.ByteSize := 8;
    DCB.Parity := NoParity;
    DCB.StopBits := 0;
    DCB.XonChar := #17;
    DCB.XoffChar := #19;
    DCB.ErrorChar := #0;
    DCB.EofChar := #0;
    DCB.EvtChar := #0;
    DCB.wReserved1 := 37563;
    if SetCommState(FComHandle, DCB) then
    begin
      GetCommTimeOuts(FComHandle, TimeOut);

      TimeOut.ReadIntervalTimeOut := MaxInt;
      TimeOut.ReadTotalTimeoutMultiplier := 0;
      TimeOut.ReadTotalTimeoutConstant := 0;

      TimeOut.WriteTotalTimeoutMultiplier := 100;
      TimeOut.WriteTotalTimeoutConstant := 1000;
      if SetCommTimeouts(FComHandle, TimeOut) then
      begin
         // Set the event mask.
        if SetCommMask(FComHandle, EV_RXCHAR) then
        begin
          // Create an event object for use by WaitCommEvent.
          FillChar(Overlapped, SizeOf(Overlapped), 0);
          Overlapped.hEvent := CreateEvent(
            nil,    // default security attributes
            True,   // manual-reset event
            True,   // not signaled
            nil     // no name
          );

          // Initialize the rest of the OVERLAPPED structure to zero.
          Overlapped.Internal := 0;
          Overlapped.InternalHigh := 0;
          Overlapped.Offset := 0;
          Overlapped.OffsetHigh := 0;

          EventHandles[0] := FStopWaitingEvent;
          EventHandles[1] := Overlapped.hEvent;
          repeat
            WaitCommEvent(FComHandle, EventMask, @Overlapped);
            SignalState := WaitForMultipleObjects(2, @EventHandles, False, INFINITE);
            if (SignalState = WAIT_OBJECT_0 + 1)
              and GetOverlappedResult(FComHandle, Overlapped, Dummy, False) then
              ReceiveBytes(FComHandle, Overlapped);
          until SignalState <> (WAIT_OBJECT_0 + 1);
          SetCommMask(FComHandle, 0);
          PurgeComm(FComHandle, PURGE_TXCLEAR or PURGE_RXCLEAR);
          CloseHandle(Overlapped.hEvent);
        end;
      end;
    end;
    FileClose(FComHandle);
  end;
end;