ClientSocket soll viele Server schnell abfragen

[holger_barntrup]

Zitat von ensaron:

Ich musste bei mir nichts an den Pfaden hinzufügen.

Das Demo-Projekt hat in den Projekteinstellungen einen (relativen) Verweis auf das Verzeichnis mit den Quelltext-Dateien. Sofern das Demo-Projekt so ausgeführt wird, wie es in dem Download enthalten war, müsste es eigentlich funktionieren.

Tut es aber leider nicht.

[holger_barntrup]

Mann ist das eine Aktion.

Ich hab das jetzt noch mal deinstalliert und dann nochmal neu.
Jetzt läuft auch die Demo ohne Änderung irgendwelcher Pfade.

Danke euch bis hier erst mal für eure Geduld mit mir.

Ich schaue mir das jetzt mal in Ruhe an.

[ensaron]

Schließe mal Delphi, starte es wieder und öffne das Beispielprojekt (wirklich erst einmal nur öffnen). Wird dabei eine Fehlermeldung (siehe Anhang) angezeigt?

Edit: Ah Super

[holger_barntrup]

Heute hatte ich zeit wieder etwas weiter zu machen. Ich muß sagen ich tue mich echt schwer zumal mein Tagesgeschäft hier nicht nur aus Programmieren besteht. Zwischendurch immer wieder etwas anderes tun zu müssen ist da kontraproduktiv.
Mit dem Beispiel hab ich etwas herum probiert bekomme es aber nicht mal hin zwei Maschinen abzufragen.
Mit einer funktioniert es problemlos.
Wenn ich das alles richtig verstehe müsste ich ja für jede abzufragende Maschine eine eigenen WSocket nehmen und davon die Ereignisse in eigenen Proceduren verarbeiten um die Ergebnisse dann irgendwo hin zu schreiben.

[stahli]

Mal ganz grundsätzlich:

Du könntest Dein Programm ja 50 mal starten, um 50 Maschinen abzufragen. Da läuft also jede Abfrage in einem eigenen Prozess.

Du kannst aber auch in Deinem Programm 50 Threads laufen lassen und in jedem wieder eine eigenständige Abfrage. Ein Thread ist auch ein eigenständiger Prozess.

Dann musst Du alles, was benötigt wird in dem Thread instanziieren.

Ein Problem ist die Ein- und Ausgabe.
Die Eingabe (Verbindung zur jeweiligen Maschine) kannst Du im Thread-Konstruktor übergeben.
Das Ergebnis (z.B. Schreiben in ein Memo) muss mit dem Mainthread synchronisiert werden.

Mit parallelen Schleifen habe ich noch nichts gemacht aber die sind letztlich auch nur eine andere Darstellung von Threads.

[ensaron]

Bei Verwendung von den ICS Komponenten werden keine Threads benötigt - die laufen asynchron und behindern sich damit nicht gegenseitig.

Mal ganz grob skizziert, wie der Test der Verbindungen aussehen könnte:

Delphi-Quellcode:

TNotifyConnectionResult = procedure(const AIp: string; const AErrorCode: Integer; const AInstance: TTestConnection) of object;

TTestConnection = class
private
   FClientSocket: TWSocket;
   FNotifyEvent: TNotifyConnectionResult;
   
   procedure OnClientSessionConnected(Sender: TObject; ErrCode: Word);
public
   procedure TestConnection(const AIp: string; const ANotifyEvent: TNotifyConnectionResult);
end;

TTestForm = class
private
   FListOfIpAddresses: TStringList;
   
   procedure NotifyConnectionResult(const AIp: string; const AErrorCode: Integer; const AInstance: TTestConnection);
   procedure TestAllConnections;
end;

implementation

procedure TTestConnection.TestConnection(const AIp: string; const ANotifyEvent: TNotifyConnectionResult);
begin
   FNotifyEvent := ANotifyEvent;
   FClientSocket.Addr := AIP;
   FClientSocket.Port := cDefaultPort; //oder Port mitgeben
   FClientSocket.OnSessionConnected := OnClientSessionConnected;
   FClientSocket.Connect;
end;

procedure TTestConnection.OnClientSessionConnected(Sender: TObject; ErrCode: Word);
begin
   FNotifyEvent(FClientSocket.Addr, ErrCode, Self); //Code 0: Verbunden, sonst Fehler
end;

//----

procedure TTestForm.TestAllConnections;
var
   IP: string;
   Test: TTestConnection;
begin
   for IP in FListOfIpAddresses do
   begin
      Test := TTestConnection.Create;
      Test.TestConnection(IP, NotifyConnectionResult);
   end;
end;

procedure TTestForm.NotifyConnectionResult(const AIp: string; const AErrorCode: Integer; const AInstance: TTestConnection);
begin
   if AErrorCode = 0 then
      //Erfolgreiche Verbindung anzeigen
   else
      //Verbindung fehlgeschlagen anzeigen
      
   AInstance.Free;
end;

[Michael II]

Zitat:

Wenn ich das alles richtig verstehe müsste ich ja für jede abzufragende Maschine eine eigenen WSocket nehmen und davon die Ereignisse in eigenen Proceduren verarbeiten um die Ergebnisse dann irgendwo hin zu schreiben.

Nebenbei: Wie ensaron auch noch einmal erwähnt: Mehrere Threads sind bei asynchroner Abarbeitung unnötig. ensaron zeigt wie du das alles schön verpackt einbauen kannst.

Wenn du vorher etwas üben willst, empfehle ich dir, dich erst einmal auf eine Maschine zu konzentrieren. Knall eine TWSocket Komponente (WSocket1) auf ein Fenster und definiere via Obejektinspektor was in den Fällen
OnDataAvailable, OnChangeState, und evt. später OnError, OnSocksError, OnSessionClosed geschehen soll.


Sobald alles läuft...

Mehrere Maschinen. Wie du schreibst, nimmst du für jede Verbindung/Maschine einen Socket. Diese Sockets erzeugst du bei Bedarf zur Laufzeit (auf deinem Form befindet sich also immer noch nur eine TWSocket Komponente WSocket1). Ereignisse wie OnDataAvailable, OnChangeState musst für jeden dieser Sockets verarbeiten. Dies hast du aber mit WSocket1 bereits erledigt. Du biegst einfach OnDataAvailable, OnChangeState um:

MeinZurLaufZeitErzeugterSocket.OnDataAvailable := WSocket1DataAvailable;
MeinZurLaufZeitErzeugterSocket.OnChangeState := WSocket1ChangeState;

Damit du unterscheiden kannst, welcher deiner Sockets (Maschinen) ein Ereignis (wie zum Beispiel OnDataAvailable) ausgelöst hat, kannst du wie ensaron zeigt die IPAdresse (und allenfalls den Port) der Zieladresse (Maschine) nutzen. Oder du verwendest die Eigenschaft Tag von TWSocket:

MeinZurLaufZeitErzeugterSocket.Tag := irgendEineEindeutigeNummer;


In WSocket1DataAvailable(Sender: TObject; Error: Word); kannst du dann via

welcherSocketSendetDaten := ( Sender as TWSocket ).tag;

ermitteln, über welche Verbindung Daten ankommen.

[holger_barntrup]

Zitat von Michael II:

Nebenbei: Wie ensaron auch noch einmal erwähnt: Mehrere Threads sind bei asynchroner Abarbeitung unnötig. ensaron zeigt wie du das alles schön verpackt einbauen kannst.

Wenn du vorher etwas üben willst, empfehle ich dir, dich erst einmal auf eine Maschine zu konzentrieren. Knall eine TWSocket Komponente (WSocket1) auf ein Fenster und definiere via Obejektinspektor was in den Fällen
OnDataAvailable, OnChangeState, und evt. später OnError, OnSocksError, OnSessionClosed geschehen soll.


Sobald alles läuft....

Das tut es.

Zitat von Michael II:

Mehrere Maschinen. Wie du schreibst, nimmst du für jede Verbindung/Maschine einen Socket. Diese Sockets erzeugst du bei Bedarf zur Laufzeit (auf deinem Form befindet sich also immer noch nur eine TWSocket Komponente WSocket1). Ereignisse wie OnDataAvailable, OnChangeState musst für jeden dieser Sockets verarbeiten. Dies hast du aber mit WSocket1 bereits erledigt. Du biegst einfach OnDataAvailable, OnChangeState um:

MeinZurLaufZeitErzeugterSocket.OnDataAvailable := WSocket1DataAvailable;
MeinZurLaufZeitErzeugterSocket.OnChangeState := WSocket1ChangeState;

Damit du unterscheiden kannst, welcher deiner Sockets (Maschinen) ein Ereignis (wie zum Beispiel OnDataAvailable) ausgelöst hat, kannst du wie ensaron zeigt die IPAdresse (und allenfalls den Port) der Zieladresse (Maschine) nutzen. Oder du verwendest die Eigenschaft Tag von TWSocket:

MeinZurLaufZeitErzeugterSocket.Tag := irgendEineEindeutigeNummer;


In WSocket1DataAvailable(Sender: TObject; Error: Word); kannst du dann via

welcherSocketSendetDaten := ( Sender as TWSocket ).tag;

ermitteln, über welche Verbindung Daten ankommen.

Danke für eure Geduld mit mir, ich werde mich nächste Woche damit beschäftigen.
Hab heut noch ein paar andere Dinge zu tun.

[Luckie]

Zitat von ensaron:

Bei Verwendung von den ICS Komponenten werden keine Threads benötigt - die laufen asynchron und behindern sich damit nicht gegenseitig.

Mal ganz grob skizziert, wie der Test der Verbindungen aussehen könnte:

Delphi-Quellcode:

TNotifyConnectionResult = procedure(const AIp: string; const AErrorCode: Integer; const AInstance: TTestConnection) of object;

TTestConnection = class
private
   FClientSocket: TWSocket;
   FNotifyEvent: TNotifyConnectionResult;
   
   procedure OnClientSessionConnected(Sender: TObject; ErrCode: Word);
public
   procedure TestConnection(const AIp: string; const ANotifyEvent: TNotifyConnectionResult);
end;

TTestForm = class
private
   FListOfIpAddresses: TStringList;
   
   procedure NotifyConnectionResult(const AIp: string; const AErrorCode: Integer; const AInstance: TTestConnection);
   procedure TestAllConnections;
end;

implementation

procedure TTestConnection.TestConnection(const AIp: string; const ANotifyEvent: TNotifyConnectionResult);
begin
   FNotifyEvent := ANotifyEvent;
   FClientSocket.Addr := AIP;
   FClientSocket.Port := cDefaultPort; //oder Port mitgeben
   FClientSocket.OnSessionConnected := OnClientSessionConnected;
   FClientSocket.Connect;
end;

procedure TTestConnection.OnClientSessionConnected(Sender: TObject; ErrCode: Word);
begin
   FNotifyEvent(FClientSocket.Addr, ErrCode, Self); //Code 0: Verbunden, sonst Fehler
end;

//----

procedure TTestForm.TestAllConnections;
var
   IP: string;
   Test: TTestConnection;
begin
   for IP in FListOfIpAddresses do
   begin
      Test := TTestConnection.Create;
      Test.TestConnection(IP, NotifyConnectionResult);
   end;
end;

procedure TTestForm.NotifyConnectionResult(const AIp: string; const AErrorCode: Integer; const AInstance: TTestConnection);
begin
   if AErrorCode = 0 then
      //Erfolgreiche Verbindung anzeigen
   else
      //Verbindung fehlgeschlagen anzeigen
      
   AInstance.Free;
end;

Wo wird das Objekt "Test" wieder freigegeben?

[holger_barntrup]

Vielleicht noch ganz kurz ein paar Worte zu den CNC-Maschinen.
Die mit denen ich jetzt arbeite und schon seriell abfrage besitzen eine, auf RT Linux basierende, Steuerung die per Netzwerk direkt mit einem Panel PC verbunden ist. Dieser PC dient der Visualisierung und Bedienung der Steuerung die kein eigenes Interface dafür besitzt.
Also ist die CNC-Maschine, von der ich rede, als einfacher PC anzusehen der mit einer 2. Netzwerkverbindung im eigenen Maschinennetzwerk eingebunden ist.
In die Bedienoberfläche(In Delphi programmiert) eingebunden ist ein Server der auf Anfrage den Maschinenstaus und ein paar weiter Daten liefert.

Die fünfzig weiteren Maschinen sollen, so der momentane Stand der Planung, per "ETHERNET TO Digital IO" ins Netz gebracht werden.
Sie besitzen alle eine Steuerung die nicht netzwerkfähig ist und haben auch keinen eigenen IPC. Daher der Umweg über diese Klemme mit der wir anhand von Schalterstellungen und Kontrollleuchten den Maschinenstatus abbilden können. Planung ist noch nicht zu 100% abgeschlossen aber so in der Art wird es werden.

Momentan hab ich leider einige andere wichtige Dinge zu erledigen aber soweit ich etwas mehr Zeit habe werde ich mich mit den ICS beschäftigen.