Indy 10 TCP-Client Strings Lesen

[Corpsman]

Guten Morgen allerseits,

Ich habe mir ein neues Spielzeug (AVR-Net-IO) gekauft und wollte dies nun Gleich ansteuern.

Dieses Tolle Ding kann man mittels IP und Port ansteuern, das funktioniert soweit auch wunderbar.

Delphi-Quellcode:

  // Client erstellen
  IdTCPClient1 := TIdTCPClient.create(self);
  IdTCPClient1.Port := 50290;
  IdTCPClient1.Host := '192.168.168.101';

  // Daten Senden
  If Not IdTCPClient1.Connected Then
    IdTCPClient1.Connect;
  If IdTCPClient1.Connected Then Begin
    IdTCPClient1.IOHandler.WriteLn(Edit1.text + '\r\n');
  End;
  IdTCPClient1.Disconnect;

Mein Problem ist nun das Auslesen der "Antwort" des Boards

Das dies mittels

Delphi-Quellcode:

      memo1.Lines.add(IdTCPClient1.IOHandler.ReadLn());

geht, weis ich zwar, doch es bringt mir nicht viel. Das Board sendet unterschiedlich viele Daten zurück. Im Normalfall ein NAK oder ein ACK beides ist eine Zeile Lang.
Aber ab und zu sendet es mal 3 Zeilen.

Mein Programm hängt sich genau dann auf, wenn ich nicht exakt die Richtige Anzahl an Readln Befehlen benutze.

Leider gibt es irgendwie keinen Befehl wie

Delphi-Quellcode:

  While not (eof) do begin
  end;
// Ich habe zwar 
    While Not IdTCPClient1.IOHandler.InputBufferIsEmpty Do Begin
      memo1.Lines.add(IdTCPClient1.IOHandler.ReadLn());
    End;
// gefunden, aber das ist immer True = es wird nie gelesen

Glücklicherweise weis ich genau wann 3 Zeilen Antworten kommen und wann 1 Zeilen Antworten kommen, kann also einen "Workaround" für das Problem anbieten :

Delphi-Quellcode:

If Not IdTCPClient1.Connected Then
    IdTCPClient1.Connect;
  If IdTCPClient1.Connected Then Begin
    IdTCPClient1.IOHandler.WriteLn(Edit1.text + ' \r\n');
    If lowercase(Edit1.text) = 'version' Then Begin
      memo1.Lines.add(IdTCPClient1.IOHandler.ReadLn());
      memo1.Lines.add(IdTCPClient1.IOHandler.ReadLn());
      memo1.Lines.add(IdTCPClient1.IOHandler.ReadLn());
    End
    Else
      memo1.Lines.add(IdTCPClient1.IOHandler.ReadLn());
  End;
  IdTCPClient1.Disconnect;

Das Problem allerdings ist, dass ich das ganze in eine Komponente packen will die ich "Häufiger" nutzen möchte. Das AVR Board hat einen µ-Controller, den ich natürlich noch Umprogrammieren will. Und wie viele Zeilen die Zukünftigen Antworten haben, dass kann ich natürlich jetzt noch nicht wissen.

Die Frage lautet also : Wie bekommt man heraus wann kein Readln mehr nötig ist?
Oder gibt es tatsächlich nur die Variante, dass ich dies vorher wissen muss ?

P.S.: mit Synapse hab ichs auch versucht ( Hier der Post dazu..

[alzaimar]

Man bekommt das überhaupt nicht heraus.

TCP hat kein 'habe Fertig', d.h. die Gegenstelle kippt ihre Nachrichten einfach in den Socket und die purzeln dann auf der anderen Seite wieder heraus. Woher willst Du denn wissen, wann die andere Seite fertig ist, wenn nicht über eine 'Abmachung', oder eben das 'Protokoll'.

Das Protokoll, also die Regeln, welche Fragen gestellt und welche Antworten in welcher Form gesendet werden, legen fest, wie und auch wie viele Daten übertragen werden.

I.A. definiert das Übertragunsprotokoll eine Art Rahmen, innerhalb dessen die Daten gesendet werden, z.B. STX <Daten> ETX , wobei STX und ETX besondere Zeichen sind. (STX) wird manchmal weggelassen.

Eine andere Möglichkeit wäre <Länge> <Daten>. Es wird also zunächst die Anzahl der zu übertragenen Daten gesendet, und danach die Daten selbst.

Bei beiden Verfahren weiss die Gegenstelle, wann Schluss ist.

Hier werden einfach nur Zeichenketten, durch CR LF getrennt, verschickt. Auch ok. Du musst dann eben pro Frage genau wissen, wie viele Zeilen/Zeichen als Rückantwort gesendet werden.

Definier dir pro Frage eine Klasse und überlasse dann der konkreten Klasse das Einlesen der Antwort.

[Corpsman]

Super,

Danke für die sehr Aufschlussreiche Antwort, damit ist meine Frage erschöpfend beantwortet.

[Edit]

Eins noch, wie kann ich denn nun den Thread schließen ?
Früher ging das in dem man den 1. Post Editiert hat und in die Titelzeile [gelöst] einträgt. Doch irgendwie scheint dies nicht mehr Möglich zu sein.