private void OnReceive(IAsyncResult state)
{
EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
if (PortOpen)
{
try
{
ArtNetReceiveData receiveState = (ArtNetReceiveData)(state.AsyncState);
if (receiveState != null)
{
receiveState.DataLength = EndReceiveFrom(state, ref remoteEndPoint);
//Protect against UDP loopback where we receive our own packets.
if (LocalEndPoint != remoteEndPoint && receiveState.Valid)
{
LastPacket = DateTime.Now;
ProcessPacket((IPEndPoint)remoteEndPoint, ArtNetPacket.Create(receiveState));
}
}
}
catch (Exception ex)
{
OnUnhandledException(ex);
}
finally
{
//Attempt to receive another packet.
StartReceive();
}
}
}
protected override void OnReadPacket(byte[] buffer, int length, IPEndPoint source)
{
var recieveState = new ArtNetRecieveData();
recieveState.buffer = buffer;
recieveState.DataLength = length;
var artNetPacket = ArtNetPacket.Create(recieveState);
if (0 < receiveLimit && receivedDataQueue.Count < receiveLimit)
{
lock (receivedDataQueue)
receivedDataQueue.Enqueue(artNetPacket);
if (artNetPacket.OpCode == ArtNet.Enums.ArtNetOpCodes.Dmx)
{
var dmxPacket = (ArtNetDmxPacket)artNetPacket;
var universe = dmxPacket.Universe;
var dmxData = dmxPacket.DmxData;
var mergedDmxData = DmxMerge.GetMergedDmxData(universe, dmxData, dmxMergeMode, source);
if (!universeDmxDataMap.ContainsKey(universe))
{
universeDmxDataMap.Add(universe, Enumerable.Repeat((byte)0, 512).ToArray());
}
System.Buffer.BlockCopy(mergedDmxData, 0, universeDmxDataMap[universe], 0, mergedDmxData.Length);
if (!updateUniverseQueue.Contains(universe))
{
lock (updateUniverseQueue)
updateUniverseQueue.Enqueue(universe);
}
}
}
}
async void Run()
{
artnetUdpClient = new UdpClient(artNetPort);
groupEP = new IPEndPoint(IPAddress.Any, artNetPort);
ArtNetPacket anpacket = null;
try
{
while (true)
{
Console.WriteLine("...");
byte[] bytes = artnetUdpClient.Receive(ref groupEP);
anpacket = await ArtNetPacket.Unpack(groupEP, bytes);
Console.WriteLine("Received broadcast from {0} :\n{1}\n", groupEP.ToString(), anpacket?.ToString());
}
}
catch (Exception ex)
{
Console.WriteLine("EXCEPTION : " + ex.ToString());
}
finally
{
artnetUdpClient.Close();
}
}
private void ProcessPacket(IPEndPoint source, ArtNetPacket packet)
{
if (packet != null)
{
if (NewPacket != null)
{
NewPacket(this, new NewPacketEventArgs <ArtNetPacket>(source, packet));
}
}
}
void Communicator_DataReceived(object sender, UdpPacket e)
{
var packet = new ArtNetPacket(e.EndPoint, e.RawData);
if (packet.IsValid)
{
//Console.WriteLine("{0}: Code: {1} - {2}", e.EndPoint, packet.OpCode, e.RawData.Length);
RoutePacket(packet);
}
}
public void OnArtNet(ArtNetPacket packet)
{
opCode = packet.OpCode;
protocol = packet.Protocol;
if (opCode == ArtNetOpCodes.Dmx)
{
dmxData = ((ArtNetDmxPacket)packet).DmxData;
}
}
public void TestPacketSerialization()
{
var data = new ArtNetData();
var pollReply = new ArtPollReply
{
IP = IPAddress.Parse("127.0.0.1").GetAddressBytes(),
Port = 0x1936,
Mac = NetworkInterface.GetAllNetworkInterfaces()
.Where(nic => nic.OperationalStatus == OperationalStatus.Up && nic.NetworkInterfaceType != NetworkInterfaceType.Loopback)
.Select(nic => nic.GetPhysicalAddress().GetAddressBytes())
.FirstOrDefault(),
GoodInput = new byte[] { 0x08, 0x08, 0x08, 0x08 },
GoodOutput = new byte[] { 0x80, 0x80, 0x80, 0x80 },
PortTypes = new byte[] { 0xc0, 0xc0, 0xc0, 0xc0 },
ShortName = "ShortName Test",
LongName = "Art.Net LongName Test",
EstaManLo = 0,
VersInfoH = 6,
VersInfoL = 9,
SubSwitch = 0,
OemHi = 0,
Oem = 0xFF,
UbeaVersion = 0,
Status1 = 0xd2,
SwMacro = 0,
SwRemote = 0,
Style = StyleCodes.StNode,
NumPortsHi = 0,
NumPortsLo = 4,
Status2 = 0x08,
BindIp = IPAddress.Parse("127.0.0.1").GetAddressBytes(),
SwIn = new byte[] { 0x01, 0x02, 0x03, 0x04 },
SwOut = new byte[] { 0x01, 0x02, 0x03, 0x04 },
GoodOutput2 = new byte[] { 0x80, 0x80, 0x80, 0x80 },
NodeReport = "NodeReport Test",
Filler = new byte[168]
};
data.Buffer = pollReply.ToArray();
var altPacket = ArtNetPacket.FromData(data);
Assert.AreEqual(altPacket.OpCode, pollReply.OpCode);
var pollReplyPacket = altPacket.Cast <ArtPollReply>();
Assert.AreEqual(pollReplyPacket.ShortName, pollReply.ShortName);
Assert.AreEqual(pollReplyPacket.LongName, pollReply.LongName);
Assert.AreEqual(pollReplyPacket.NodeReport, pollReply.NodeReport);
Assert.Pass();
}
public void OnArtNet(ArtNetPacket packet)
{
opCode = packet.OpCode;
protocol = packet.Protocol;
if (opCode == ArtNetOpCodes.Dmx)
{
var dmxPacket = (ArtNetDmxPacket)packet;
universe = dmxPacket.Universe;
dmxData = dmxPacket.DmxData;
}
}
private void ProcessPacket(IPEndPoint source, ArtNetPacket packet)
{
if (packet != null)
{
if (NewPacket != null)
{
NewPacket(this, new NewPacketEventArgs <ArtNetPacket>(source, packet));
}
ArtRdmPacket rdmPacket = packet as ArtRdmPacket;
if (rdmPacket != null && NewRdmPacket != null)
{
RdmPacket rdm = RdmPacket.ReadPacket(new RdmBinaryReader(new MemoryStream(rdmPacket.RdmData)));
NewRdmPacket(this, new NewPacketEventArgs <RdmPacket>(source, rdm));
}
}
}
/// <summary>
/// Unicasts a <see cref="ArtNetPacket"/> to a recipient at a certain interval
/// </summary>
public CancellationTokenSource SendToIpWithInterval(ArtNetPacket packet, IPAddress ip, int ms)
{
CancellationTokenSource cts = new();
new Thread(() =>
{
while (true)
{
if (cts.IsCancellationRequested)
{
break;
}
SendToIp(packet, ip);
Thread.Sleep(ms);
}
}).Start();
RunningIntervals.Add(cts);
return(cts);
}
void Communicator_DataReceived(object sender, UdpPacket e)
{
var packet = new ArtNetPacket(e.EndPoint, e.RawData);
Debug.Log("Received From: " + e.EndPoint);
if (packet.IsValid)
{
universe = packet.RawData[14] % 16;
net = packet.RawData[15];
subnet = packet.RawData[14] / 16;
for (int i = 0; i < 512; i++)
{
DMXdata[i] = packet.RawData[18 + i];
}
for (int i = 0; i < 170; i++)
{
DMXpix[universe * 170 + i] = new Color32(DMXdata[i * 3], DMXdata[i * 3 + 1], DMXdata[i * 3 + 2], 255);
}
}
}
protected override void OnReadPacket(byte[] buffer, int length, IPEndPoint source)
{
if (recieveState == null)
{
recieveState = new ArtNetRecieveData();
}
recieveState.buffer = buffer;
recieveState.DataLength = length;
var artNetPacket = ArtNetPacket.Create(recieveState);
if (0 < receiveLimit && receivedDataQueue.Count < receiveLimit)
{
lock (receivedDataQueue)
receivedDataQueue.Enqueue(artNetPacket);
if (artNetPacket.OpCode == ArtNet.Enums.ArtNetOpCodes.Dmx)
{
var dmxPacket = (ArtNetDmxPacket)artNetPacket;
var universe = dmxPacket.Universe;
var dmxData = dmxPacket.DmxData;
var mergedDmxData = DmxMerge.GetMergedDmxData(universe, dmxData, dmxMergeMode);
if (dmx == null)
{
dmx = new byte[512][];
}
if (dmx[universe] == null)
{
dmx[universe] = new byte[512];
}
System.Buffer.BlockCopy(mergedDmxData, 0, dmx[universe], 0, mergedDmxData.Length);
if (!updateUniverseQueue.Contains(universe))
{
lock (updateUniverseQueue)
updateUniverseQueue.Enqueue(universe);
}
}
}
}
private void OnRecieve(IAsyncResult state)
{
EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
if (!open)
{
return;
}
try
{
ArtNetData recieveState = (ArtNetData)(state.AsyncState);
if (recieveState == null)
{
// Packet was invalid continue receiving
ReceiveArtNet();
}
recieveState.DataLength = EndReceiveFrom(state, ref remoteEndPoint);
// Protect against UDP loopback where we recieve our own packets.
if (LocalEndPoint != remoteEndPoint && recieveState.Valid)
{
LastPacket = DateTime.Now;
var packet = ArtNetPacket.FromData(recieveState);
if (packet == null)
{
ReceiveArtNet();
}
NewPacket?.Invoke(this, new NewPacketEventArgs <ArtNetPacket>((IPEndPoint)remoteEndPoint, packet));
}
}
catch (Exception ex)
{
UnhandledException?.Invoke(this, new UnhandledExceptionEventArgs(ex, false));
}
ReceiveArtNet();
}
/// <summary>
/// 接收数据回调函数
/// </summary>
/// <param name="state">状态信息以及自定义数据</param>
private void OnRecieve(IAsyncResult state)
{
EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
if (PortOpen)
{
try
{
// 获取自定义数据
ArtNetRecieveData recieveState = (ArtNetRecieveData)(state.AsyncState);
if (recieveState != null)
{
// 结束挂起的、从指定 IP 地址 进行异步读取
recieveState.DataLength = EndReceiveFrom(state, ref remoteEndPoint);
// 防止UDP环回，不接收自己发出的数据包.
if (remoteEndPoint != LocalEndPoint && recieveState.Valid)
{
LastPacket = DateTime.Now;
// 根据接收数据的 OpCode 来创建对应的 ArtNet 数据包对象并开始解析
ProcessPacket((IPEndPoint)remoteEndPoint, ArtNetPacket.Create(recieveState));
}
}
}
catch (Exception ex)
{
OnUnhandledException(ex);
}
finally
{
// 继续接收下一个数据包
StartRecieve();
}
}
}
void RoutePacket(ArtNetPacket packet)
{
if (PacketReceived != null)
{
PacketReceived(this, packet);
}
switch (packet.OpCode)
{
case OpCode.OpPoll:
if (PollPacketReceived != null)
{
PollPacketReceived(this, new ArtPollPacket(packet));
}
break;
case OpCode.OpDmx:
if (DmxPacketReceived != null)
{
DmxPacketReceived(this, new ArtDmxPacket(packet));
}
break;
}
}
public void Send(ArtNetPacket packet)
{
Send(packet, BroadcastAddress);
}
public void Send(ArtNetPacket packet, IPAddress destAddr)
{
SendTo(packet.ToArray(), new IPEndPoint(destAddr, Port));
}
/// <summary>
/// Unicasts a <see cref="ArtNetPacket"/> to a recipient
/// </summary>
public void SendToIp(ArtNetPacket packet, IPAddress ip)
{
SendTo(packet.ToArray(), new IPEndPoint(ip, Port));
}
/// <summary>
/// 点播方式发送 ArtNet 数据包
/// </summary>
/// <param name="packet">ArtNet 数据包</param>
/// <param name="remote">目标 终结点</param>
public void Send(ArtNetPacket packet, IPEndPoint remote)
{
SendTo(packet.ToArray(), remote);
}
/// <summary>
/// 广播方式发送 ArtNet 数据包
/// </summary>
/// <param name="packet">ArtNet 数据包</param>
public void Send(ArtNetPacket packet)
{
Send(packet, new IPEndPoint(BroadcastAddress, Port));
}
public void Send(ArtNetPacket packet, IPAddress remoteIP)
{
SendTo(packet.ToArray(), new IPEndPoint(remoteIP, Port));
}
public void Send(ArtNetPacket packet, RdmEndPoint address)
{
SendTo(packet.ToArray(), new IPEndPoint(address.IpAddress, Port));
}
public void Send(ArtNetPacket packet)
{
SendTo(packet.ToArray(), new IPEndPoint(BroadcastAddress, Port));
}
