Haukcode.ArtNet

using System.Net;
using Haukcode.ArtNet;

// Get local network interface
var localIp = IPAddress.Parse("192.168.1.100");
var subnetMask = IPAddress.Parse("255.255.255.0");

// Create ArtNet client
using var client = new ArtNetClient(localIp, subnetMask);

// Prepare DMX data (512 channels)
var dmxData = new byte[512];
dmxData[0] = 255;  // Channel 1 at full brightness
dmxData[1] = 128;  // Channel 2 at 50%
dmxData[2] = 0;    // Channel 3 off

// Send to universe 1 (broadcast)
await client.SendDmxData(
    address: null,           // null = broadcast
    universeId: 1,
    dmxData: dmxData);

using System.Net;
using System.Threading.Channels;
using System.Threading.Tasks;
using Haukcode.ArtNet;
using Haukcode.ArtNet.Packets;
using Haukcode.ArtNet.Internal;

var localIp = IPAddress.Parse("192.168.1.100");
var subnetMask = IPAddress.Parse("255.255.255.0");

// Create a channel to receive packets
var channel = Channel.CreateUnbounded<ReceiveDataPacket>();

// Create client with packet handler
using var client = new ArtNetClient(
    localAddress: localIp,
    localSubnetMask: subnetMask,
    channelWriter: async (packet) => await channel.Writer.WriteAsync(packet),
    channelWriterComplete: () => channel.Writer.Complete());

// Process incoming packets
await foreach (var receivedPacket in channel.Reader.ReadAllAsync())
{
    if (receivedPacket.Packet is ArtNetDmxPacket dmxPacket)
    {
        Console.WriteLine($"Received DMX on Universe {dmxPacket.Universe + 1}");
        Console.WriteLine($"Channel 1: {dmxPacket.DmxData[0]}");
    }
}

using var client = new ArtNetClient(localIp, subnetMask);

// Send DMX data to multiple universes
await client.SendDmxData(null, 1, dmxDataUniverse1);
await client.SendDmxData(null, 2, dmxDataUniverse2);
await client.SendDmxData(null, 3, dmxDataUniverse3);

// Send sync to apply all changes simultaneously
await client.SendSync(null);

using var client = new ArtNetClient(localIp, subnetMask);

// Send ArtPoll to discover devices
await client.QueuePacketForSending(
    destination: null,  // broadcast
    packet: new ArtPollPacket());

// Handle ArtPollReply packets in your packet handler
// (see "Receiving DMX Data" example for packet handling setup)

using Haukcode.ArtNet.Packets;

using var client = new ArtNetClient(localIp, subnetMask);

// Send a trigger command
var triggerPacket = new ArtTriggerPacket
{
    OemCode = 0x6A6B,     // Your OEM code
    Key = 0x03,            // Command: Select show
    SubKey = 1,            // Show ID
    Data = new byte[512]   // Optional payload
};

await client.QueuePacketForSending(null, triggerPacket);

using Haukcode.ArtNet;
using Haukcode.ArtNet.Rdm;
using Haukcode.ArtNet.Rdm.Packets.Product;

// First, discover RDM devices by sending ArtTodRequest
// Then send RDM commands to discovered devices

var deviceUid = new UId(0x1234, 0x56789ABC);  // Device UID from TOD
var universeId = 1;
var deviceIp = IPAddress.Parse("192.168.1.50");

// Get device label
var getLabel = new DeviceLabel.Get();
await client.SendRdm(getLabel, deviceIp, (short)universeId, deviceUid);

// Handle RDM responses in your packet handler
// Parse RdmPacket from ArtRdmPacket.RdmData

public class LightingController : IDisposable
{
    private readonly ArtNetClient client;
    
    public LightingController(IPAddress localIp, IPAddress subnetMask)
    {
        client = new ArtNetClient(localIp, subnetMask);
    }
    
    public async Task SetChannel(ushort universe, int channel, byte value)
    {
        var dmxData = new byte[512];
        dmxData[channel - 1] = value;  // DMX channels are 1-indexed
        
        await client.SendDmxData(null, universe, dmxData);
    }
    
    public void Dispose() => client.Dispose();
}

public class DmxMonitor
{
    private readonly Dictionary<int, byte[]> universeData = new();
    
    public async Task StartMonitoring(IPAddress localIp, IPAddress subnetMask)
    {
        var channel = Channel.CreateUnbounded<ReceiveDataPacket>();
        
        using var client = new ArtNetClient(
            localIp, subnetMask,
            async (p) => await channel.Writer.WriteAsync(p),
            () => channel.Writer.Complete());
        
        await foreach (var packet in channel.Reader.ReadAllAsync())
        {
            if (packet.Packet is ArtNetDmxPacket dmx)
            {
                int universe = dmx.Universe + 1;
                universeData[universe] = dmx.DmxData.ToArray();
                
                Console.WriteLine($"Universe {universe}: " +
                    $"Seq {dmx.Sequence}, Channels: {dmx.DmxData.Length}");
            }
        }
    }
}

public ArtNetClient(
    IPAddress localAddress,
    IPAddress localSubnetMask,
    Func<ReceiveDataPacket, Task>? channelWriter = null,
    Action? channelWriterComplete = null,
    int port = 6454,
    UId? rdmId = null)

// Send DMX data
Task SendDmxData(
    IPAddress? address, 
    ushort universeId, 
    ReadOnlyMemory<byte> dmxData, 
    bool important = false)

// Send sync packet
Task SendSync(IPAddress? address)

// Send any ArtNet packet
Task QueuePacketForSending(
    IPAddress? destination, 
    ArtNetPacket packet, 
    bool important = false)

// Send RDM packet (requires Haukcode.ArtNet.Rdm)
Task SendRdm(
    RdmPacket packet,
    IPEndPoint destination,
    short universe,
    UId targetId)

IPEndPoint LocalEndPoint { get; }      // Local endpoint
IPAddress BroadcastAddress { get; }    // Broadcast address
UId RdmId { get; }                     // RDM UID