Probleme beim Empfangen von UDP-Paketen

[heltef]

Ich hab hier mal ein Screenshot von einem Paket in Wireshark
Anhang 43096

Anhang 43097


@himitsu
Ich habe in Delphi mit Threads noch nie gearbeitet. Könntest du mir zeigen wie ich es korrekt lösen würde? Danke

[Captnemo]

Naja, wenn's auf einem jungfräulichen Rechner ohne Wireshark auch nicht geht, wird's wohl am Source liegen. Poste doch mal den kompletten Source.

[heltef]

Hier ist der Komplette Code... Viel ist da zwar nicht drin, aber vielleicht habe ich auch was vergessen

Code:

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, IdUDPServer, IdGlobal, IdSocketHandle,
  IdComponent, Vcl.StdCtrls, IdBaseComponent, IdUDPBase;

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    IdUDPServer1: TIdUDPServer;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure IdUDPServer1Status(ASender: TObject; const AStatus: TIdStatus;
      const AStatusText: string);
    procedure IdUDPServer1UDPRead(AThread: TIdUDPListenerThread;
      const AData: TIdBytes; ABinding: TIdSocketHandle);
    procedure FormDestroy(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  IdUDPServer1.DefaultPort:=50001;
  IdUDPServer1.Active:=true;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  IdUDPServer1.Active:=false;
end;

procedure TForm1.IdUDPServer1Status(ASender: TObject; const AStatus: TIdStatus;
  const AStatusText: string);
begin
  Memo1.Lines.Add('Status'+AStatusText);
end;

procedure TForm1.IdUDPServer1UDPRead(AThread: TIdUDPListenerThread;
  const AData: TIdBytes; ABinding: TIdSocketHandle);
var
  sText:String;
begin
  sText := BytesToString(AData);
  Memo1.Lines.Add(sText);
end;

end.

[himitsu]

Zitat:

Zitat von Captnemo (Beitrag 1300531)

wird's wohl am Source liegen.

Wie MichaelT es erwähnte, muß es garnicht am eigenem Programm liegen, sondern am Code/Firmware/Hardware des Senders (Arduino).
Wireshark verbiegt hier einiges an der Konfiguration, da kann es z.B. sein, daß "ungültige" Packete plötzlich vom System durchgelassen werden, welche sonst abgelehnt würden.

Über TThread.Synchronize und anonyme Methoden kann man sehr leicht den Thread wechseln.
Hier von irgendeinem Thread in den MainThread (wenn man sich in einer TThread-Instanz befindet, dann am Besten direkt

Delphi-Quellcode:

Synchronize(procedure ...

).
Und mit TThread.CreateAnonymousThread in einem Thread ausführen (da, wo man sonst von TThread ableitet und Execute überschreibt ... nur halt mal bissl anders).
Bei anonymen Methoden kann man schön Variablen übergeben lassen, was sonst bissl schwerer wird, da Threadmethoden für Synchronize und Execute keine Parameter haben dürfen.

Delphi-Quellcode:

procedure TForm1.IdUDPServer1UDPRead(AThread: TIdUDPListenerThread;
  const AData: TIdBytes; ABinding: TIdSocketHandle);
var
  sText: String;
begin
  sText := BytesToString(AData);  // das kann im Thread bleiben (muß es aber nicht ... kommt drauf an, ob BytesToString threadsave ist)
  TThread.Synchronize(nil, procedure
    begin
      Memo1.Lines.Add(sText);  // Zugriff auf's Memo muß in den Hauptthread
    end;
end;

[heltef]

Hallöchen zusammen,

ich hab hier auch mal den Code vom Mikrocontroller (Arduino)
zur Hardware.. Der Arduino ist mit einem ENC28J60 (Netzwerk-Controller) verbunden.

Code:

#include <EtherCard.h>

static unsigned int CSPIN_ENC28J60 = 53;

byte macMy[]         = {0x00, 0x22, 0xF9, 0x01, 0x30, 0xDA }; //MAC vom Arduino
byte ipMy[]          = {192, 168, 2, 200}; //IP vom Arduino
byte ipDestination[] = {192, 168, 2, 99}; //Ziel Ip Des Paketes
byte ipGateway[]     = {192, 168, 2, 1}; //Router IP

const int portPcEmpfangen = 50001;

byte Ethernet::buffer[1000];

char msg[] = {"Hello World"};

void setup() {
  ether.begin(sizeof Ethernet::buffer, macMy, CSPIN_ENC28J60);
  ether.staticSetup(ipMy, ipGateway);

  while (ether.clientWaitingGw())
  {
    ether.packetLoop(ether.packetReceive());
  }
}

void loop()
{
  ether.sendUdp(msg, sizeof msg, portPcEmpfangen, ipDestination, portPcEmpfangen);

  word len = ether.packetReceive(); // go receive new packets
  word pos = ether.packetLoop(len); // respond to incoming pings

  ether.packetLoop(ether.packetReceive());
  delay(1000);
}

Und hier noch die Parameter der Methode sendUdp:

void EtherCard::sendUdp (const char* data, uint8_t len, uint16_t sport, const uint8_t* dip, uint16_t dport)

Sends a UDP packet.
Parameters
data Pointer to data
len Size of payload (maximum 220 octets / bytes)
sport Source port
dip Pointer to 4 byte destination IP address
dport Destination port

-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/-/

Mein Delphi Programm habe ich in der Sache Threads nachgearbeitet

Gruß Fabi

[Captnemo]

Warum schreibst du dir nicht schnell mal ein Windowsprogramm, welches dir die gleichen Daten von einem Windows-PC schickt. Dann weißt du recht schnell ob es beim Empfangen hapert, und kannst das gleich mal im Netzwerk auf verschiedenen Rechner ausprobieren.

[Mavarik]

Zitat:

Zitat von himitsu (Beitrag 1300488)

IdUDPServer1.OnUDPRead wird doch bestimmt im Thread der er Connection ausgeführt, was nicht der HauptThread ist. :?:

"wird doch bestimmt?"

emmm... nööö :stupid:

Zitat:

Zitat von ..\Source\Indy10\Core\IdUDPServer.pas

Delphi-Quellcode:

        // and only synchronize the OnUDPRead event handler so that descendants
        // do not need to be synchronized unnecessarily. Probably just have
        // TIdUDPServer.DoUDPRead() use TIdSync when ThreadedEvent is false...
        if FServer.ThreadedEvent then begin
          UDPRead;
        end else begin
          Synchronize(UDPRead);
        end;

Mavarik

[Sir Rufo]

Schön dass man gar nicht hoffen/glauben muss ob da was in welchem Thread-Kontext läuft, mann kann es einfach abfragen:

Delphi-Quellcode:

if TThread.Current.ThreadId = MainThreadID then
  // ich im MainThread
else
  // ich NICHT im MainThread

[mjustin]

Zitat:

Zitat von Sir Rufo (Beitrag 1300823)

Schön dass man gar nicht hoffen/glauben muss ob da was in welchem Thread-Kontext läuft, mann kann es einfach abfragen:

Delphi-Quellcode:

if TThread.Current.ThreadId = MainThreadID then
  // ich im MainThread
else
  // ich NICHT im MainThread

Für Anwender von Delphi 2009: das kompiliert zwar, ist aber erst in einer späteren Version (Build 14.0.3455.22156) brauchbar: http://qc.codegear.com/wc/qcmain.aspx?d=67726 (darin ist auch ein Workaround enthalten)

Siehe auch: Delphi TThread.CurrentThread and EAccessViolation - Is This a Bug or My Incompetence..?

[heltef]

Hallöchen zusammen,

ich habe es mal gemacht wie Captnemo es vorgeschlagen hatte.. Ich hab ein Windows Programm geschrieben und siehe da... Es funktioniert alles ohne Wireshark.

So ist Delphi ausgeschlossen und muss somit wohl am Mikrocontroller liegen. Ich werde jetzt mal mit Wireshark die Pakete vergleichen und mal sehen wo sie sich unterscheiden.

Dankeschön für eure Hilfe. Noch ein schönes Restwochenende
Fabi