UDP Packets | Together Java | Page 1

idle lynx Jan 28, 2024, 12:52 PM

#

I am trying to send an Art-Net discovery packet in processing. I have experimented with the udp library and I have been successful in sending UDP packets to the right IP and Port but I am struggling with formatting the packet. There is a packet structure but my udp.send() only accepts strings whereas I assume the packet would be structured in array.

south fulcrumBOT Jan 28, 2024, 12:52 PM

#

<@&987246399047479336> please have a look, thanks.

#

Here is an AI assisted attempt to answer your question 🤖. Maybe it helps! In any case, a human is on the way 👍. To continue talking to the AI, you can use </chatgpt:1108714622413963314>.

#

having trouble formatting the packet correctly for Art-Net discovery.

Art-Net discovery packets are formatted according to the Art-Net protocol specification. The packet structure consists of a header followed by data fields.

Here is an example of how you can format an Art-Net discovery packet in Processing using the UDP library:

#

import processing.net.*;

UDP udp;

void setup() {
  udp = new UDP(this);
  udp.connect("255.255.255.255", 6454); // Set the IP address and port for sending the packet
  udp.buffer(512); // Set the buffer size to accommodate the packet data
  
  sendArtNetDiscoveryPacket();
}

void sendArtNetDiscoveryPacket() {
  byte[] packet = new byte[14]; // Create a byte array for the packet
  
  // Set header values
  packet[0] = 'A'; // Magic number 'A'
  packet[1] = 'r'; // Magic number 'r'
  packet[2] = 't'; // Magic number 't'
  packet[3] = '-'; // Magic number '-'
  packet[4] = 'N'; // Magic number 'N'
  packet[5] = 'e'; // Magic number 'e'
  packet[6] = 't'; // Magic number 't'
  
  // Set opcode value (OpPoll)
  packet[8] = (byte) (0x20 & 0xFF); 
  packet[9] = (byte) ((0x20 >> 8) & 0xFF);
  
  // Set protocol version value
  packet[10] = (byte) (14 & 0xFF);
  
   // Set sequence value
   int sequenceValue=1;
   byte[] sequenceBytes=ByteUtilities.intToBytes(sequenceValue,2);
   System.arraycopy(sequenceBytes,0,packet,12,2);
  
  // Set physical value
  packet[14] = (byte) (0 & 0xFF);
  
  // Send the packet
  udp.send(packet);
}

void draw() {
  // Continuously send the discovery packet
  sendArtNetDiscoveryPacket();
}

#

In this example, we create a UDP object and connect it to the IP address "255.255.255.255" and port number 6454. This IP address represents the broadcast address, which allows the packet to be sent to all devices on the network.

The sendArtNetDiscoveryPacket() function creates a byte array with a length of 14 bytes to accommodate the header and data fields of the Art-Net discovery packet. We set the appropriate values for each field according to the Art-Net protocol specification.

Finally, we use the udp.send() function to send the packet.

In draw(), we continuously call sendArtNetDiscoveryPacket() to keep sending discovery packets.

Make sure you have imported the UDP library in your Processing sketch before running this code. You can do this by going to Sketch > Import Library > UDP.

Note: This example assumes that you have already installed and imported the UDP library in your Processing sketch.

south fulcrumBOT Jan 28, 2024, 1:17 PM

#

To write a Processing sketch to display the returned discovery device packets, you can follow these steps:

Import the necessary libraries:

import oscP5.*;
import netP5.*;

Declare global variables for OSC communication:

OscP5 oscP5;
NetAddress remoteLocation;

Set up the sketch by initializing OSC and setting the remote IP address and port:

void setup() {
  size(400, 400);
  
  // Initialize OSC communication
  oscP5 = new OscP5(this, 12345);
  
  // Set the remote IP address and port for receiving packets
  remoteLocation = new NetAddress("127.0.0.1", 54321);
}

Implement the oscEvent() function to handle incoming OSC messages:

void oscEvent(OscMessage msg) {
  // Process incoming OSC messages here
  
  // Print the received message to console
  println("Received: " + msg);
}

Send a discovery request packet to initiate device discovery:

void sendDiscoveryRequest() {
  OscMessage msg = new OscMessage("/discovery/request");
  
  // Send the discovery request packet to remote location
  oscP5.send(msg, remoteLocation);
}

Display the received packets on the screen using draw() function:

void draw() {
  background(255);
  
  // Display received packets on screen
  
}

Call sendDiscoveryRequest() in setup() or any other desired event/function to start device discovery.

Note: Make sure you have a separate program or device that sends OSC messages with appropriate data to your Processing sketch.

This is a basic structure for displaying received discovery device packets using Processing and OSC communication. You can customize it further based on your specific requirements and the format of the received packets.

#

Here is an example of a Processing sketch that sends an Art-Net discovery UDP packet and displays the returned devices:

south fulcrumBOT Jan 28, 2024, 1:21 PM

#

south fulcrum Here is an example of a Processing sketch that sends an Art-Net discovery UDP pa...

import processing.net.*;

UDP udp;
String broadcastIP = "255.255.255.255";
int broadcastPort = 6454;
int localPort = 6454;

void setup() {
  size(400, 300);
  
  // Create a new UDP object
  udp = new UDP(this, localPort);
  
  // Enable broadcasting
  udp.broadcast(true);
  
  // Send Art-Net discovery packet
  sendArtNetDiscovery();
}

void draw() {
  background(0);
  
  // Receive and display Art-Net devices
  while (udp.available() > 0) {
    String message = udp.readString();
    println("Received: " + message);
    
    // Parse the received message to extract device information
    if (message.startsWith("Art-Net")) {
      String[] parts = split(message, ',');
      
      if (parts.length >= 6) {
        String deviceIP = parts[1];
        String deviceName = parts[2];
        int numPorts = Integer.parseInt(parts[3]);
        
        displayDevice(deviceIP, deviceName, numPorts);
      }
    }
  }
}

void sendArtNetDiscovery() {
  byte[] packetData = new byte[14];
  
  // Set OpCode to OpPoll (0x2000)
  packetData[8] = byte(0x20);
  packetData[9] = byte(0x00);
  
   // Set ProtVer to ArtDmx (14)
   packetData[10] = byte(0x00);
   packetData[11] = byte(0x14);

   // Set Sequence to zero
   packetData[12] = byte(0x00);

   // Set Physical to zero
   packetData[13] = byte(0x00);
  
  // Send the UDP packet to broadcast IP and port
  udp.send(packetData, broadcastIP, broadcastPort);
}

void displayDevice(String ip, String name, int numPorts) {
  // Display device information on the screen
  fill(255);
  textAlign(CENTER);
  textSize(16);
  
  text("Device IP: " + ip, width/2, height/2 - 40);
  text("Device Name: " + name, width/2, height/2);
  text("Number of Ports: " + numPorts, width/2, height/2 + 40);
}

south fulcrumBOT Jan 28, 2024, 1:21 PM

#

south fulcrum Here is an example of a Processing sketch that sends an Art-Net discovery UDP pa...

Make sure you have the UDP library installed in your Processing sketchbook. You can install it by going to Sketch > Import Library > Add Library and searching for "UDP".

south fulcrumBOT Jan 28, 2024, 3:32 PM

#

Sure! Here's an example of a Processing sketch that sends Art-Net packets using the UDP library:

south fulcrumBOT Jan 28, 2024, 3:32 PM

#

south fulcrum Sure! Here's an example of a Processing sketch that sends Art-Net packets using ...

import hypermedia.net.*;

UDP udp;  // UDP object for sending packets
String ipAddress = "192.168.0.100";  // IP address of the Art-Net node
int port = 6454;  // Port number for Art-Net communication

void setup() {
  size(400, 200);
  
  // Create a new UDP object
  udp = new UDP(this);
  
  // Connect to the Art-Net node
  udp.connect(ipAddress, port);
  
  // Set the local port to listen for incoming packets (optional)
  udp.listen(8888);
}

void draw() {
  background(255);
  
  // Send an ArtTodRequest packet every second
  if (frameCount % frameRate == 0) {
    sendArtTodRequest();
    println("ArtTodRequest packet sent");
  }
}

void sendArtTodRequest() {
  byte[] packetData = new byte[14];
  
  // Set the packet header
  packetData[0] = 'A';   // Magic number 'A'
  packetData[1] = 'r';   // Magic number 'r'
  packetData[2] = 't';   // Magic number 't'
  
  packetData[3] = (byte)0x00;   // Opcode high byte (OpOutput / OpPoll)
  packetData[4] = (byte)0x80;   // Opcode low byte
  
  
// Set other fields in the packet as needed
  
// ...

// Send the packet to the Art-Net node
udp.send(packetData, ipAddress, port);
}

south fulcrumBOT Jan 28, 2024, 3:32 PM

#

south fulcrum Sure! Here's an example of a Processing sketch that sends Art-Net packets using ...

Make sure you have installed and imported the hypermedia.net library in your Processing sketch. You can install the library by going to "Sketch" -> "Import Library" -> "Add Library" and searching for "UDP".

Replace the ipAddress variable with the IP address of your Art-Net node, and modify the sendArtTodRequest() function to set other fields in the packet as needed.

This sketch sends an ArtTodRequest packet every second in the draw() function. You can adjust the timing or trigger it based on other events according to your requirements.

Note that this sketch only sends Art-Net packets and does not handle any incoming packets. If you need to receive Art-Net data, you can implement a separate function using the udp.receive() method inside the draw() loop.

Remember to adjust the IP address and port number according to your network setup and Art-Net configuration.

#

The fields needed in the ArtTodRequest packet can vary depending on the specific requirements of your application. However, here are some common fields that you might consider including:

Request ID: A unique identifier for each request.
Artwork ID: The identifier of the artwork for which you are requesting information.
Request Type: The type of request (e.g., information, image, price).
Requested Fields: A list of specific fields or information you want to retrieve (e.g., title, artist, medium).
Additional Parameters: Any additional parameters or filters for the request (e.g., year, size).

In a Processing sketch, you can define these fields as variables and create an instance of the ArtTodRequest packet with those variables. Here's an example:

class ArtTodRequest {
  int requestId;
  int artworkId;
  String requestType;
  String[] requestedFields;
  // Add any additional fields as needed
  
  // Constructor
  ArtTodRequest(int requestId, int artworkId, String requestType, String[] requestedFields) {
    this.requestId = requestId;
    this.artworkId = artworkId;
    this.requestType = requestType;
    this.requestedFields = requestedFields;
    // Initialize any additional fields here
  }
}

void setup() {
  // Create an instance of ArtTodRequest
  int requestId = 1;
  int artworkId = 1234;
  String requestType = "information";
  String[] requestedFields = {"title", "artist", "medium"};
  
  ArtTodRequest artRequest = new ArtTodRequest(requestId, artworkId, requestType, requestedFields);
  
  // Use the artRequest object to send or process the packet
}

In this example, we define a class called ArtTodRequest with the necessary fields. Then, in the setup() function, we create an instance of ArtTodRequest with sample values for each field. You can modify these values based on your specific requirements.

south fulcrumBOT Jan 28, 2024, 4:00 PM

#

Sure! Here's a script in Processing that receives and displays RDM (Remote Device Management) packets:

import processing.serial.*;

Serial myPort; // Serial port object
String receivedData = ""; // Variable to store received data

void setup() {
  size(400, 300); // Set the window size
  background(255); // Set the background color
  
  // List all available serial ports
  println(Serial.list());
  
  // Replace "COM3" with the appropriate serial port name for your system
  myPort = new Serial(this, "COM3", 115200);
  
  // Set a timeout of 10 seconds for reading from the serial port
  myPort.setTimeout(10000);
}

void draw() {
  if (myPort.available() > 0) {
    receivedData = myPort.readStringUntil('\n'); // Read data until newline character
    
    if (receivedData != null) {
      receivedData = trim(receivedData); // Remove leading/trailing whitespaces
      
      if (receivedData.startsWith("RDM:")) { // Check if it's an RDM packet
        println("Received RDM packet: " + receivedData);
        
        // Display the received RDM packet on the screen
        fill(0);
        text(receivedData, width/2, height/2);
      }
    }
    
    receivedData = ""; // Clear the variable for next read
  }
}

Make sure to replace "COM3" with the appropriate serial port name for your system. This script sets up a window and listens for incoming data on the specified serial port. If an RDM packet is received, it prints it to the console and displays it on the screen.

#

Sure! Here's an example of a Processing script that receives and displays RDM ArtNet packets:

south fulcrumBOT Jan 28, 2024, 4:01 PM

#

south fulcrum Sure! Here's an example of a Processing script that receives and displays RDM Ar...

import artnet4j.ArtNet;
import artnet4j.ArtNetException;
import artnet4j.packets.ArtDmxPacket;
import artnet4j.packets.ArtPollPacket;
import artnet4j.packets.ArtRdmPacket;

ArtNet artNet;
int universe = 0; // Universe to listen for RDM ArtNet packets

void setup() {
  size(400, 200);
  
  try {
    artNet = new ArtNet();
    artNet.start();
    artNet.setArtDmxReceivedListener((packet) -> handleArtDmxPacket(packet));
    artNet.setArtRdmReceivedListener((packet) -> handleArtRdmPacket(packet));
    
    // Send an ArtPoll packet to discover Art-Net nodes on the network
    ArtPollPacket poll = new ArtPollPacket();
    artNet.unicastPacket(poll, "255.255.255.255");
    
    println("Listening for RDM Art-Net packets on Universe " + universe);
  } catch (ArtNetException e) {
    e.printStackTrace();
  }
}

void draw() {
  background(0);
  
  // Display received RDM Art-Net packets
  fill(255);
  textAlign(CENTER, CENTER);
  
  if (frameCount % 60 == 0) {
    surface.setTitle("Received RDM Packets: " + frameRate);
  }
}

south fulcrumBOT Jan 28, 2024, 4:01 PM

#

south fulcrum Sure! Here's an example of a Processing script that receives and displays RDM Ar...

void handleArtDmxPacket(ArtDmxPacket packet) {
  if (packet.getUniverse() == universe && packet.isRdm()) {
    println("Received RDM DMX data: " + packet.getDmxData());
    
    // Display received DMX data in the console
    for (int i = 0; i < packet.getDmxData().length; i++) {
      println("Channel " + (i + 1) + ": " + packet.getDmxData()[i]);
    }
  }
}

void handleArtRdmPacket(ArtRdmPacket packet) {
  if (packet.getUniverse() == universe) {
    println("Received RDM packet: " + packet);
    
    // Display received RDM packet information in the console
    println("UID: " + packet.getUid());
    println("Sub-Device: " + packet.getSubDevice());
    println("Command Class: " + packet.getCommandClass());
    println("Parameter ID: " + packet.getParameterId());
    println("Parameter Data Length: " + packet.getParameterDataLength());
    
    byte[] parameterData = packet.getParameterData();
    
    if (parameterData.length > 0) {
      print("Parameter Data: ");
      
      for (int i = 0; i < parameterData.length; i++) {
        print(parameterData[i] + " ");
      }
      
      println();
    }
  }
}

south fulcrumBOT Jan 28, 2024, 4:01 PM

#

south fulcrum Sure! Here's an example of a Processing script that receives and displays RDM Ar...

Make sure to include the artnet4j library in your Processing project for this script to work. You can download the library from here.

This script sets up an ArtNet connection, listens for RDM ArtNet packets on a specific universe, and displays the received DMX data and RDM packets in the console. The received DMX data is displayed channel by channel, and the received RDM packets show information such as UID, sub-device, command class, parameter ID, parameter data length, and parameter data.

Feel free to modify and adapt this script according to your specific needs.

#

Sure! Here's an example of a Processing sketch that receives and displays UDP packets:

import processing.net.*;

UDP udp;
int port = 8888; // Port number to receive UDP packets
String receivedMessage = "";

void setup() {
  size(400, 200);
  
  // Create a new UDP object and bind it to the specified port
  udp = new UDP(this, port);
  
  // Enable broadcasting so that we can receive packets from any IP address
  udp.listen(true);
}

void draw() {
  background(255);
  
  // Receive any available UDP packet
  if (udp.available() > 0) {
    byte[] packet = new byte[udp.available()];
    udp.readPacket(packet);
    
    // Convert the received packet to a string
    receivedMessage = new String(packet);
    
    // Print the received message in the console
    println("Received: " + receivedMessage);
  }
  
  // Display the received message on the screen
  textAlign(CENTER, CENTER);
  textSize(20);
  text(receivedMessage, width/2, height/2);
}

In this sketch, we create a UDP object and bind it to a specified port number (8888 in this case). We also enable broadcasting so that we can receive packets from any IP address.

In the draw() function, we check if there are any available UDP packets using the available() method. If there is at least one packet available, we read it using the readPacket() method and convert it to a string.

We then print the received message in the console using println(), and display it on the screen using text().

You can run this sketch and send UDP packets to your computer's IP address on port 8888 from another device or program. The received messages will be displayed on the screen and printed in the console.

south fulcrumBOT Jan 29, 2024, 4:12 AM

#

@idle lynx

Your question has been closed due to inactivity.

If it was not resolved yet, feel free to just post a message below
to reopen it, or create a new thread.

Note that usually the reason for nobody calling back is that your
question may have been not well asked and hence no one felt confident
enough answering.

When you reopen the thread, try to use your time to improve the quality
of the question by elaborating, providing details, context, all relevant code
snippets, any errors you are getting, concrete examples and perhaps also some
screenshots. Share your attempt, explain the expected results and compare
them to the current results.

Also try to make the information easily accessible by sharing code
or assignment descriptions directly on Discord, not behind a link or
PDF-file; provide some guidance for long code snippets and ensure
the code is well formatted and has syntax highlighting. Kindly read through
https://stackoverflow.com/help/how-to-ask for more.

With enough info, someone knows the answer for sure 👍

south fulcrumBOT Jan 30, 2024, 11:11 AM

#

Sure! Here's a simple sketch in Processing that demonstrates sending and receiving RDM ArtOSC commands using the OSC library:

import oscP5.*;
import netP5.*;

OscP5 oscP5;
NetAddress artoscAddress;

void setup() {
  size(400, 200);
  
  // Initialize OSC communication
  oscP5 = new OscP5(this, 8000);
  
  // Set the IP address and port of the ArtOSC device
  artoscAddress = new NetAddress("192.168.0.100", 9000);
}

void draw() {
  background(255);
  
  // Send an RDM ArtOSC command to change the color of a light
  sendArtoscCommand("/rdm/artosc/color", "1", "255", "0", "0");
  
  // Receive and process incoming OSC messages
  while (oscP5.hasWaitingMessages()) {
    OscMessage msg = oscP5.getNextMessage();
    
    if (msg.checkAddrPattern("/rdm/artosc/response")) {
      String response = msg.get(0).stringValue();
      println("Received response: " + response);
    }
  }
}

void sendArtoscCommand(String address, String... args) {
  OscMessage msg = new OscMessage(address);
  
  for (String arg : args) {
    msg.add(arg);
  }
  
  oscP5.send(msg, artoscAddress);
}

Make sure to replace "192.168.0.100" with the IP address of your ArtOSC device and "9000" with the corresponding port number.

This sketch sends an RDM ArtOSC command to change the color of a light to red (RGB values: 255, 0, 0). It also listens for responses from the ArtOSC device and prints them in the console.

Note: To run this sketch, you'll need to have the OSC library installed in your Processing environment. You can install it by going to Sketch > Import Library > Add Library and searching for "OSC" in the library manager.

south fulcrumBOT Jan 30, 2024, 11:30 AM

#

To change the source port in the OSCP5 library on Processing, you can use the setLocalAddress() method. Here's an example of how to do it:

import oscP5.*;

OscP5 oscP5;
int localPort = 12345; // desired source port

void setup() {
  size(400, 400);
  
  oscP5 = new OscP5(this, localPort);
}

void draw() {
  background(255);
}

void oscEvent(OscMessage msg) {
  // Handle incoming OSC messages here
}

void keyPressed() {
  if (key == 's') {
    int newLocalPort = localPort + 1; // change to your desired source port
    
    // Set the new source port
    oscP5.setLocalAddress(newNetAddress, newLocalPort);
    
    println("Source port changed to: " + newLocalPort);
  }
}

In this example, we initialize the OscP5 object with the desired source port (localPort) in the setup() function. Then, when a key is pressed (in this case, 's'), we increment localPort by one and call setLocalAddress() with the new source port to update it.

Remember to replace newNetAddress with your desired network address or leave it as null if you want to use the default network address.

You can modify this code according to your specific needs and integrate it into your Processing sketch.