64Bit OS -> serielle Schnittstelle benutzen

[AJ_Oldendorf]

So wird der ComPort initialisiert und die Overlapped Struktur erzeugt.

Delphi-Quellcode:

  StrPCopy (NullStr, FPort);
  SerHandle    := CreateFileA (NullStr, Generic_Read or Generic_Write, 0, Nil,
                              Open_Existing,
                              FILE_FLAG_OVERLAPPED, 0);
  if SerHandle <> INVALID_HANDLE_VALUE then
  begin

    if SetupComm (SerHandle, InBuffer, OutBuffer) then
    begin
      FillChar (DCB, SizeOf(DCB), 0);
      DCB.DCBlength  := SizeOf (DCB);
      DCB.BaudRate   := Baud;
      DCB.Flags      := $0001;
      DCB.Parity     := Ord (Parity);
      DCB.ByteSize   := ByteSize;
      DCB.StopBits   := Ord (StopBits);
      DCB.EvtChar    := RXFlagChar;

      if SetCommState (SerHandle, DCB) then
      begin
        With CommTimeOuts do
        begin                                  { TimeOut's  setzen          }
          
        end;
        if SetCommTimeouts(SerHandle, CommTimeOuts) then
        begin
          if RTSCTS = Ja then                  { Hardwarehandshake          }
          begin
            EscapeCommFunction(SerHandle, SETRTS);
            EscapeCommFunction(SerHandle, SETDTR);
          end;
          Case RXEvent of                      { Eventmaske setzen          }
            RXChar   : TmpMask := EV_RXCHAR;   
            RXFlag   : TmpMask := EV_RXFLAG;   
            RXRing   : TmpMask := EV_RING;
            RXCTS    : TmpMask := EV_CTS;
            RXDSR    : TmpMask := EV_DSR;
            else       TmpMask := 0;
          end;

          if SetCommMask(SerHandle, TmpMask) then
          begin
            StrPCopy (NullStr, 'Read_Test');
            rOverlapped.hEvent := CreateEventA (NIL,       { Security attr.   }
                                               True,       { Manuel reset ??  }
                                               False,      { Signaled ??      }
                                               NullStr);   { Signif.name      }
            StrPCopy (NullStr, 'Write_Test');
            wOverlapped.hEvent := CreateEventA (NIL,       { Security attr.   }
                                               True,       { Manuel reset ??  }
                                               False,      { Signaled ??      }
                                               NullStr);   { Signif.name      }
            if (rOverlapped.hEvent <> Null) and
               (wOverlapped.hEvent <> Null) then
            begin
              Success      := True;
              
            end;
          end;
        end;
      end;
    end;
  end
  else 
  begin
    ErrorCode := GetLastError;
  end;

Erwähnenswert ist jetzt noch, dass der Empfang über die Serielle Schnittstelle Asynchron erfolgt.

Delphi-Quellcode:

ReadFile (SerHandle, ReceiveBuffer, InBuffer div 2,
          ReceivedBytes, @rOverlapped);

Dann wartet ein Thread auf Signalisierung in der Overlapped Struktur und arbeitet danach die empfangenen Daten ab.

Das funktioniert laut Debugger noch alles (er kommt überall rein) aber es scheinen nur die ersten 3 Bytes der empfangenen Daten gültig zu sein. Die Länge der Daten stimmt auch noch aber der Dateninhalt ab Byte 3 passt nicht mehr... Hat da jemand eine Idee zu?

Viele Grüße
Alex