Async Serielle Übertragung - Thread hängt beim beenden

[TUX_der_Pinguin]

Moin DPler,

ich habe mir eine Klasse zusammengestrickt um eine serielle Kommunikation herzustellen. Dazu wird erst die Verbindung
aufgebaut und anschließend ein Thread gestartet der auf der Schnittstelle läuscht ob Daten ankommen.

Alles klappt wunderbar jedoch soll die Verbindung getrennt werden bzw. der Thread beendet werden, doch dann hängt
die Anwendung für ca. 20 sekunden lang, ohne ersichtlichen Grund und das ist doch eine etwas unschöne Verzögerung.

Ich habe eine Beispiel Anwendung erstellt die zeigen soll, wie ich die Schnittstelle öffne und wie die Klasse arbeitet.
Die Klasse befindet sich in der angehängten Datei uRS232.pas.

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, uRS232;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure OnRead(RChar: Char);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    Serial : TSerial;
  end;

var
  Form1: TForm1;

implementation


{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  //Objekt erstellen
  Serial := TSerial.Create;

  //Schnittstellenparameter setzen
  Serial.SetParam('COM1', 1200, 8, 0, 0, 4113, 1024, 1024);

  //Verbindung herstellen...
  if not Serial.Connect then Application.MessageBox('Fehler beim Verbinden mit der Schnittstelle!', 'Fehler', 48);

  if Serial.Connected then begin
    //Empfangs und Sendepuffer leeren
    Serial.ClearBuffer;

    //Ereignis zuweisen
    Serial.OnThreadRead := OnRead;

    //Thread für asynchrone Übertragung erstellen und starten
    Serial.StartThread;
  end;{if}
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  if Serial.Connected then begin
    //Thread stoppen
    Serial.StopThread;

    //Verbindung trennen
    Serial.Disconnect;

    //Objekt freigeben
    Serial.Free;
  end;{if}
end;

procedure TForm1.OnRead(RChar: Char);
begin
  ShowMessage(RChar);
end;

end.

Hier mal ein Auszug aus der Klasse, mit der folgenden Prozedur will ich den Thread beenden.

Delphi-Quellcode:

procedure TSerial.StopThread;
begin
  AThread.OnRead := nil; //Dies hatte ich zu Testzwecken probiert, brachte keinen erfolg

  ShowMessage('Terminate');
  AThread.Terminate;                              //Thread beenden

  ShowMessage('WaitFor');
  AThread.WaitFor;                                //warten auf Beendigung
  //Hier hängt das Programm ca. 20 Sekunden bis der Thread beendet wurde

  ShowMessage('Free');
  AThread.Free;                                   //Speicher aufräumen
end;

Ich vermute das Problem liegt in der Execute Prozedur des Threads, jedoch habe ich keine Idee wie ich das ändern soll.
So wie ich das sehe bekommt zwar die Prozedur mit das Terminated auf True gesetzt wird jedoch hängt der Thread im "ReadFile"
und wartet auf ein Zeichen auf der Schnittstelle, da dieses jedoch nicht kommt, dauert es ca. 20 sekunden bis der Thread
sich dann doch beendet, ich vermute mal das dies ein TimeOut ist.

Delphi-Quellcode:

procedure TSerialThread.Execute;
Var
  w : DWord;
  P : Pointer;  //Zeiger auf Lesepuffer
  C : Char;     //Lesepuffer
begin
  P := @C;                                                //P zeigt auf C
  repeat
    if (ReadFile(ThCom, P^, 1, W, nil)) then begin        //1 Zeichen lesen
      if Terminated then break;                           //Abbruch
      if Assigned(OnRead) and (W <> 0) then OnRead(C);    //Ereignis auslösen
    end;{if}
  until Terminated;                                       //Endlos Schleife bis die Verbindung getrennt wird
end;

Ich hoffe es gibt eine Möglichkeit dies etwas zu beschleunigen, da das doch arg unschön ist zu warten.

[Reinhard Kern]

Zitat:

Zitat von TUX_der_Pinguin

...Alles klappt wunderbar jedoch soll die Verbindung getrennt werden bzw. der Thread beendet werden, doch dann hängt
die Anwendung für ca. 20 sekunden lang, ohne ersichtlichen Grund und das ist doch eine etwas unschöne Verzögerung.
....
Ich hoffe es gibt eine Möglichkeit dies etwas zu beschleunigen, da das doch arg unschön ist zu warten.

Hallo,

die einfachste, allerdings nicht Delphi-konforme Möglichkeit wäre PurgeComm. Geht auch noch anders aber komplizierter.

Ausserdem gibt es auch ein Terminate Thread API (Kill), aber das ist nur für Notfälle und funktioniert so "gracefull" wie Stecker ziehen.

Gruss Reinhard

[Apollonius]

Das ist eben das Problem an synchronem IO: Du kannst nicht auf äußere Signale reagieren. Ab Windows Vista könntest du vom Hauptthread aus mit CancelIoEx den Thread zurückholen. Eleganter - und auch früher unterstützt - wäre es, auf asynchronen IO umzustellen, d.h. das File-Handle mit dem entsprechenden Flag zu öffnen und bei ReadFile dann eine Overlapped-Struktur zu verwenden. Mit WaitForMultipleObjects kannst du dann gleichzeitig auf das Overlapped-Ereignis und ein Stopp-Ereignis warten. In StopThread setzt du einfach das Stopp-Ereignis und der Thread kehrt praktisch sofort aus WaitForMultipleObjects zurück und beendet sich.

[TUX_der_Pinguin]

Zitat:

Zitat von Apollonius

Das ist eben das Problem an synchronem IO: Du kannst nicht auf äußere Signale reagieren. Ab Windows Vista könntest du vom Hauptthread aus mit CancelIoEx den Thread zurückholen. Eleganter - und auch früher unterstützt - wäre es, auf asynchronen IO umzustellen, d.h. das File-Handle mit dem entsprechenden Flag zu öffnen und bei ReadFile dann eine Overlapped-Struktur zu verwenden. Mit WaitForMultipleObjects kannst du dann gleichzeitig auf das Overlapped-Ereignis und ein Stopp-Ereignis warten. In StopThread setzt du einfach das Stopp-Ereignis und der Thread kehrt praktisch sofort aus WaitForMultipleObjects zurück und beendet sich.

Also der zweite Teil hört sich interessant an, ich habe zwar schon mal irgendwo was von "WaitForMultipleObjects" gelesen
aber wie ich das umsetzen müßte wüßte ich grade nicht, aber ich habe selber noch eine Lösung gefunden wo ich eigentlich
dachte ich hätte diese bereits gepostet.

Naja in meiner Lösung prüfe ich vor jedem aufruf von "ReadFile" ob überhaupt ein Zeichen im Puffer steht und damit
der Thread nicht zu viel CPU Leistung verschluckt lege ich den Thread bei jedem durchlauf kurz schlafen.

Delphi-Quellcode:

procedure TSerialThread.Execute;
Var
  w : DWord;
  P : Pointer;  //Zeiger auf Lesepuffer
  C : Char;     //Lesepuffer
begin
  P := @C;                                                //P zeigt auf C
  repeat
    if (RXBufferCount > 0) and (ReadFile(ThCom, P^, 1, W, nil)) then begin        //1 Zeichen lesen
      if Terminated then break;                           //Abbruch
      if Assigned(OnRead) and (W <> 0) then OnRead(C);    //Ereignis auslösen
    end;{if}
    Sleep(100);
  until Terminated;                                       //Endlos Schleife bis die Verbindung getrennt wird
end;

Delphi-Quellcode:

function TSerialThread.RXBufferCount: Cardinal;
var
  Comstat : _Comstat;
  Errors  : DWord;
begin
  if ClearCommError(ThCom, Errors, @Comstat) then
    result := Comstat.cbInQue
  else
    result := 0;
end;

Ob es die beste Lösung ist weiß ich nicht, aber es funktioniert und die Anwendung hängt nicht mehr beim
beenden des Threads alles läuft flott und die Datenübertragung klappt auch wunderbar soweit.