mehrere Thread-Instanzen

[alzaimar]

Unabhängig davon, das es irgendwie nicht richtig funktioniert, würde ich niemals einen Thread so schreiben, das er endlos pollt. Windows ist ein ereignisgesteuertes System, Du solltest also eventorientiert arbeiten.

Erzeuge doch einfach deine TComPort-Instanzen für jeden Port, werte im OnStatechanged, OnDataReceived (oder wie die Ereignisse heißen) die Statii (Statusse?) aus und empfange die Daten in OnDataReceived. Da der 'Sender' (also hier die TComPort-Instanz) mitgeschickt wird, weisst Du genau, auf welchem Port etwas anliegt.

So wird das System unnötig blockiert, weil es ja ständig einen Status abfragt. Das war früher in DOS-Zeiten usus, aber heute sagt uns doch Windows, wer, ob, wann und was am COM-Port rumzuppelt.

Du kannst Dir das auch vermutlich mit einem 'WaitForMultipleObjects' selbst basteln, aber es ist schon 5,6 Jahre her, das ich mich mit COM rumschlagen musste...

[Whookie]

Also wie schon oben gesagt, das pollen im Execute ist sicher nicht die feine englische Art. Mit WaitCommEvent und einer Overlapped-Struktur bereitest du die Comm-Events vor. Über eigene Events kannst Du dir das Öffnen/Schließen und Beenden deines Threads realisieren. Mit WaitForMultipleObjects wartest du dann:

Delphi-Quellcode:

procedure TCommThread.Execute;
var
  Handles: Array[0..3] Of THandle;
  dummy: DWord;
begin
  Handles[0] := hTerminateEvent;
  Handles[1] := iOverlapped.hEvent;
  Handles[2] := hClosePortEvent;
  Handles[3] := hOpenPortEvent;
  repeat
    WaitCommEvent(FCommHandle, FEvtMask, @iOverlapped); // Init Wait (returnes immediately, because of overlapped event)
    Case WaitForMultipleObjects(4, @Handles, FALSE, INFINITE) Of   // Wait for an event to occur
      WAIT_OBJECT_0+0: Begin
                         Terminate;
                         Break;
                       End;
      // Zeichen empfangen
      WAIT_OBJECT_0+1: Begin
                         If GetOverlappedResult(FCommHandle, iOverlapped, dummy, FALSE) Then Begin
                           If ClearCommError(FCommHandle, fErrorMask, @fCT) Then Begin
                             If (fEvtMask=EV_RXCHAR) And (fCT.cbInQue=0) Then Continue; // restart loop!!

                             If Assigned(FOnThreadEvent) Then Synchronize(DoOnThreadEvent);
                           End
                           Else GetLastError; // returns 6 (INVALID_HANDLE)
                         End
                         Else Begin
                           dummy := GetLastError; // reset error
                           ResetEvent(iOverlapped.hEvent); // new 30.6.2003 (reset false event)
                         End;
                       End;

      // Schnittstelle schließen
      WAIT_OBJECT_0+2:
      Begin
        CloseHandle(fCommHandle);
        fCommHandle := INVALID_HANDLE_VALUE;
        ResetEvent(hClosePortEvent);
      End;

      // Schnittstelle öffnen
      WAIT_OBJECT_0+3:
      Begin
        InitializePort;
        ResetEvent(hOpenPortEvent);
      End;


      else Begin
        // Should never happen (DON'T EXIT)
      End;
    End;
  until Terminated;

  CloseHandle(FCommHandle);
  fCommHandle := INVALID_HANDLE_VALUE;

  CloseHandle(iOverlapped.hEvent);
  CloseHandle(hTerminateEvent);
  CloseHandle(hClosePortEvent);
  CloseHandle(hOpenPortEvent);
end;

Das ist ein Auszug aus meiner eigenen Komponente, das Schreiben besorgt ein eigener WriteThread - für alle Comms gemeinsam.

[Luckie]

Wie wäre es mit WorkerThreads? QueueUserWorkItem Jemad hier im Forum hat eine ähnliche Funktionalität auch mal selber implementiert. Musst du mal etwas im Forum suchen. Leider fällt mir der Autor nicht mehr ein.

[alzaimar]

:stupid: Ich, hier

Ich muss aber nochmal betonen, das das unnötig ist. Wie Whookie schon gezeigt hat, sollte das nur mit einem einzigen Thread ablaufen.