UDP Empfangen / ArtNet / ArtDMX

[ljmarkus]

Hallo..

ich muss Daten Auslesen die per UDP im Netz gesendet werden.

In diesem Anhnag (pdf) habe ich mal ein Frame mit Ethereal angehängt:
Packet Artnet

Es handelt sich dabei um das ArtNet Protokoll von Artistic Licence
Artnet Protokoll

Wie kann ich jetzt die Daten empfangen und Auswerten ?
Wichtig für sind zb.unter ArtDMX packet - Universe und die DMX data.

Indy habe ich installiert.

Würde mich sehr freuen wenn mir da ein paar etwas hilfe stellung geben könnten, da ich Anfänger bin.


Danke, Markus

[generic]

Ethereal hat netter Weise das Paket schon dekodiert.
Grundsätzlich empfängst du per Indy mit dem UDP-Client ein Pakete.
Dann hast du erstmal ein Haufen von Binärdaten.

Diese brauchst du dann nur zu dekodieren. Ich hab gerade keine Zeit mir die Protokolspezifikation anzusehen. Das werde ich wohl erst am Wochenende schaffen.
Ich gehe mal von einer festen Satzlänge aus.

Paket von hinten nach vorne gelesen:
Das DMX-Frame mit den 512 Werten.
Dann Spezifikation welche Universe und die Datenlänge (sollte aber immer 512)

Welches Gerät / welche Software nutzt du um die Pakete zu generieren?
Weil das Thema interesiert mich auch:
kleine Fotogallerie über Job's von mir

[ljmarkus]

So ich habe mal versucht den String zu Empfangen:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var get : string;

begin
IdUDPClient1.Active := true;
get := IdUDPClient1.ReceiveString(572);
memo2.Text := get;
end;

aber leider bleibt das Memofeld leer.
Port ist fest im Object eingetragen.



@generic
Als pc interfaces nutze ich nen ganzen haufen die USB DMX If's von DE.
Für dieses aktuelle Project wird als Software MADRIX eingesetzt.


lg, markus

[generic]

das das memo leer bleibt ist eine einfache erklärung.
sobald ein byte/universe/kanal #0 ist, dann ist das "textende" für das memo.

du musst schon das binär lesen bzw. dann binär verarbeiten und dann als text umwandeln.

gibt die MADRIX software ein signalraus im demomodus (ohne lizenz/dongle)?

[ljmarkus]

ok, wir kann ich denn anders an die sache gehen ?

ne, ohne Dongle wird kein signal ausgegeben. hab die pro version.


lg, markus

[sirius]

Gibt es nicht sowas wie RecieveBuf. Du musst doch das Paket eh noch auseinanderbasteln.
Dann baust du dir einen Record für den Header, z.B. so:

Delphi-Quellcode:

type PHeader=^THeader
     THeader=packed record
      HeaderInfo1: TIrgendetwas;
      HeaderInfo2: Integer;
      ....
      data:array[0..0] of char;
end;

....

procedure Txxx.RecieveBuf(const buf; ...);
var Header:PHeader;
    Data:pointer;
begin
  Header:=buf;
  //hier kannst du den Header analysieren ((und zum Beispiel die Länge des Datanpaketes ausrechnen/auslesen
  
  //zum ansprechen der Daten
  Data:=@Header^.data;
  //oder wenn das Datenpaket ein String ist:
  setlength(Datenstring,laenge); //Länge aus HeaderInfos
  move(Header^.data,Datenstring[1],lanege);
  ...
end;

[ljmarkus]

so, nun werden die Daten in eine Datei geschrieben.

Delphi-Quellcode:

procedure TForm1.IdUDPServer1UDPRead(Sender: TObject; AData: TStream; 
  ABinding: TIdSocketHandle); 

var x:string;


begin

AData.Position:=0;
SetLength(x,AData.Size);
AData.ReadBuffer(x[1],AData.Size);



writeln(datei1, x);     // in datei test1.txt schreiben
end;

Mit einem HEX Viewer kann ich dann die richtigen Daten sehen. Nur wie kann ich die jetzt umwandeln und auf gewisse punkte
zugreifen ?

Danke, Markus

[shmia]

Zitat:

Zitat von ljmarkus

Mit einem HEX Viewer kann ich dann die richtigen Daten sehen. Nur wie kann ich die jetzt umwandeln und auf gewisse punkte
zugreifen ?

Ganz einfach, die Daten sind in einem String.
Angenommen du sollst an Position 15-16 einen 16 Bit Integer auslesen.

Delphi-Quellcode:

var
  x : string; // die empfangenen Daten
  p : PChar;  
  wert : Word;
begin
  x := ...;
  p := PChar(x);   // Zeiger auf die Daten
  wert := PWord(p+15)^;
end;

Noch angenehmer wird die Sache, wenn du einen Record hast, der die Datenstruktur repräsentiert.

Delphi-Quellcode:

TArtDMXRequest = packed record
  Version: Word;    // die Inhalte sind rein fiktiv
  Counter: DWord;
  ...
end;

var
  request : TArtDMXRequest
  x : string;
begin

  // Sicherheitsprüfung
  if Length(x) < sizeof(request) then
    raise Exception.Create('zu wenig Daten!');

  // Daten vom String auf Record kopieren
  Move(x[1], request, SizeOf(request));
  request.Counter := request.Counter + 1; // Beispiel für Zugriff

[ljmarkus]

ok, nur wie ist es wenn ich zb. auf Position 18 einen 8 Bit auslesen möchte.

Zitat:

Ganz einfach, die Daten sind in einem String.
Angenommen du sollst an Position 15-16 einen 16 Bit Integer auslesen.

Delphi-Quellcode:

var
  x : string; // die empfangenen Daten
  p : PChar;  
  wert : Word;
begin
  x := ...;
  p := PChar(x);   // Zeiger auf die Daten
  wert := PWord(p+15)^;
end;

[shmia]

Zitat:

Zitat von ljmarkus

ok, nur wie ist es wenn ich zb. auf Position 18 einen 8 Bit auslesen möchte.

Man muss immer aufpassen, ob man mit 0 oder 1 anfängt zu zählen.
In folgendem Beispiel gehe ich davon aus, dass die Zählweise mit 1 beginnt:

Delphi-Quellcode:

var 
  x : string; // die empfangenen Daten 
  p : PChar;  
  wert : Byte; 
begin 
  x := ...; 
  p := PChar(x);   // Zeiger auf die Daten 
  wert := PByte(p+17)^; // das 18. Byte
  if (wert and $80) <> 0 then
     ShowMessage('das höchstwertige Bit des 18. Byte ist gesetzt');
end;

[generic]

Ok, ich hab mir das Protokoll angeschaut.

Auf Seite 19 findest du eine Paketbeschreibung für dein Paket welches du brauchst.
Ich würde ein packed Record definieren der der Spezifikation entspricht. Diesen kann du dann Blockweise einlesen.
Der Trick ist an der Stelle Length. Anschliessend werden dann die Daten übertragen.

Delphi-Quellcode:

  artdmx_header = packed record
    ID: String[8]; // Art-Net #0
    OpCode: word;
    ProtVerH,
    ProtVer: Byte;
    Sequence: Byte;
    Physical: Byte;
    Universe: Word;
    case laenge: boolean of
      true: (
         Lengthhi,
         lengthlow: byte;
       );
      false: ( Length: word );
  end;

Den vollen Record vom Interface Lesen und dann noch in length Anzahl von Bytes weiterlesen.
Dort stehen dann die Kanalwerte. Also nach dem Record bis Anzahl.

[ljmarkus]

Ich habe es heute Nachmittag dann so gelöst. Is glaube ich nicht die schönste und beste Sache, aber funktioniert.

Delphi-Quellcode:

procedure TForm1.IdUDPServer1UDPRead(Sender: TObject; AData: TStream;
  ABinding: TIdSocketHandle);

var i: Word;
    Universe: Word;
    Opcode: Word;
    x: string;
    p: PChar;

begin

AData.Position:=0;
SetLength(x,AData.Size);
AData.ReadBuffer(x[1],AData.Size);

p := PChar(x);

Opcode := PWord(p+8)^;      // Opcode auswerten
if Opcode = 20480 then      // wenn ArtDMX data packet dann an Universe weiterleiten
  begin
    edit2.Text := 'ArtDMX data packet (0x5000)';
    Universe := PWord(p+14)^;     // Universe
    if Universe = 0 then for i := 0 to 511 do DMXOutBuffer0[i] := PByte(p+18+i)^;      // Universe 0
    if Universe = 1 then for i := 0 to 511 do DMXOutBuffer1[i] := PByte(p+18+i)^;      // Universe 1
    if Universe = 2 then for i := 0 to 511 do DMXOutBuffer2[i] := PByte(p+18+i)^;      // Universe 2
    if Universe = 3 then for i := 0 to 511 do DMXOutBuffer3[i] := PByte(p+18+i)^;      // Universe 3
    if Universe = 4 then for i := 0 to 511 do DMXOutBuffer4[i] := PByte(p+18+i)^;      // Universe 4
    if Universe = 5 then for i := 0 to 511 do DMXOutBuffer5[i] := PByte(p+18+i)^;      // Universe 5
    if Universe = 6 then for i := 0 to 511 do DMXOutBuffer6[i] := PByte(p+18+i)^;      // Universe 6
    if Universe = 7 then for i := 0 to 511 do DMXOutBuffer7[i] := PByte(p+18+i)^;      // Universe 7
    if Universe = 8 then for i := 0 to 511 do DMXOutBuffer8[i] := PByte(p+18+i)^;      // Universe 8
    if Universe = 9 then for i := 0 to 511 do DMXOutBuffer9[i] := PByte(p+18+i)^;      // Universe 9
    if Universe = 10 then for i := 0 to 511 do DMXOutBuffer10[i] := PByte(p+18+i)^;      // Universe 10
    if Universe = 11 then for i := 0 to 511 do DMXOutBuffer11[i] := PByte(p+18+i)^;      // Universe 11
    if Universe = 12 then for i := 0 to 511 do DMXOutBuffer12[i] := PByte(p+18+i)^;      // Universe 12
    if Universe = 13 then for i := 0 to 511 do DMXOutBuffer13[i] := PByte(p+18+i)^;      // Universe 13
    if Universe = 14 then for i := 0 to 511 do DMXOutBuffer14[i] := PByte(p+18+i)^;      // Universe 14
    if Universe = 15 then for i := 0 to 511 do DMXOutBuffer15[i] := PByte(p+18+i)^;      // Universe 15
  end;

end;

lg, Markus

[ljmarkus]

so jetzt klemmt es bei mir ......

Berechnung der Länge (Ergebnis = 512)

Delphi-Quellcode:

var     LengthHi      : Byte;      // length of DMX512 data array High byte
        Length        : Byte;      // Low Byte
begin
...

LengthHi  := PByte(p+16)^;           // Länge
Length    := PByte(p+17)^;

Label1.Caption := ????????

mit Ethereal sehe ich die richtigen Bytes: 02 00
Wie muss ich das umwandeln und rechnen damit Dezimal 512 raus kommt damit ich das
auf einem Label.Caption anzeigen kann.

Finde den Weg nicht.

lg, markus

[sirius]

Ui, das ist ja Big Endain.
LengthHi*256+Length :zwinker: (256=2^8)

[ljmarkus]

@ sirius
Vielen Dank. Da wäre ich jetzt so nit drauf gekommen.


Nun das nächste Problemchen,

ArtNet senden:

Delphi-Quellcode:

var DMXInBuf, ArtDMXOutBuf: arry[0..511] of byte;
    
    i: integer;

begin
for i := 0 to 511 do ArtDMXOutBuf[i] := DMXInBuf[i];    // ? Richtig 

// Send packet
idUDPClient1.Send('2.255.255.255',6454,('Art-Net'#0#0#80#0#14#0#0#0#0#2#0)+ ? die 512 Channel Werte
end;

Danke, Markus

[sirius]

Ist das ein String hinten? Ich kenne Indy nicht.

Du kannst ja den String in einer For-Schleife mit chr(Channel-Wert) zusammensetzen.

[ljmarkus]

IdUDPClient1.Send ist ein (AData: String);

ich bekomme ja die DMX In Daten vom Interface als Wert für channel 1 00-FF.

um die 512 Channel ins Netz zu senden muss ich ja:
.Send('2.225.255.255',6454,'Art-Net'#0#0#80#0#14#0#0#0#0#2#0 ab hier die DMX Werte...

Beispiel: Channel 1 = 0(0), Channel 2 = FF(255) Channel 3 = 7F(127) = 00FF7F......

Nur wie bekomme ich das in den String?

lg, markus

[ljmarkus]

*gelöscht*

[sirius]

Zitat:

um die 512 Channel ins Netz zu senden muss ich ja:
.Send('2.225.255.255',6454,'Art-Net'#0#0#80#0#14#0#0#0#0#2#0 ab hier die DMX Werte...

Beispiel: Channel 1 = 0(0), Channel 2 = FF(255) Channel 3 = 7F(127) = 00FF7F......

Meinst du dann etwa so:
.Send('2.225.255.255',6454,'Art-Net'#0#0#80#0#14#0#0#0#0#2#0[b]#0#255#127

Delphi-Quellcode:

s:='Art-Net'#0#0#80#0#14#0#0#0#0#2#0;
for i:=0 to ... do s:=s+chr(ArtDMXOutBuf[i]);
//oder so (wenn da wirklich '00FF7F' als string stehen soll)
for i:=0 to ... do s:=s+inttohex(ArtDMXOutBuf[i],2);

(Schneller ist aber noch die Länge des Strings vorher zu setzen und dann die einzelnen Elemente zu füllen.)

[ljmarkus]

Hallo.

genau das habe ich gesucht *g*

Delphi-Quellcode:

s:='Art-Net'#0#0#80#0#14#0#0#0#0#2#0;
for i:=0 to ... do s:=s+chr(ArtDMXOutBuf[i]);

da der String ja nur 255 argumente haben darf, muste ich mehere Strings in einen String packen.


Danke, Markus

[sirius]

Zitat:

da der String ja nur 255 argumente haben darf, muste ich mehere Strings in einen String packen.

Wieso nimmst du shortstring?

[ljmarkus]

hmm,

s: string;
ist bei mir so in den VAR.
wie muss es denn lauten damit es ein long string ist ?

so schaut es derzeit aus:

Delphi-Quellcode:

procedure TForm1.ArtNetSend(Sender: TObject);
var i: integer;
  buffer_0_1: string;     // Buffer Universe 0 - Teil 1/4
  buffer_0_2: string;     // Buffer Universe 1 - Teil 2/4
  buffer_0_3: string;
  buffer_0_4: string;

begin
if U0.Checked then begin
  for i:= 0 to 127 do buffer_0_1:= buffer_0_1+chr(Inbu0[i]);
  for i:= 128 to 255 do buffer_0_2:= buffer_0_2+chr(InBu0[i]);
  for i:= 256 to 382 do buffer_0_3:= buffer_0_3+chr(InBu0[i]);
  for i:= 383 to 511 do buffer_0_4:= buffer_0_4+chr(InBu0[i]);
  IdUDPClient1.Send(('Art-Net')+head0+buffer_0_1+buffer_0_2+buffer_0_3+buffer_0_4);
end;

end;

lg, markus

[sirius]

Ah, da hast du was verwechselt.

Delphi-Quellcode:

var 
    kurz:shortstring; //255 Zeichen
    lang:string;      //2 GB

Du hast problemlos Platz in einem string.

[ljmarkus]

Aha, jetzt hab ich es Verstanden.

Danke, Markus