Probleme beim Empfangen von UDP-Paketen

[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 von Captnemo:

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 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.