protected void RaiseRdmPacketSent(NewPacketEventArgs <RdmPacket> packetInfo)
{
if (RdmPacketSent != null)
{
RdmPacketSent(this, packetInfo);
}
}
private void Socket_NewPacket(object sender, NewPacketEventArgs <ArtNetPacket> e)
{
if (e.Packet.OpCode == ArtNetOpCodes.Dmx)
{
if (this.timestamper == null)
{
this.timestamper = Stopwatch.StartNew();
}
var packet = e.Packet as ArtNetDmxPacket;
UniverseData universeData;
if (!this.universes.TryGetValue(packet.Universe, out universeData))
{
// Unknown universe
return;
}
var dmxData = RawDmxData.Create(
millisecond: (ulong)this.timestamper.ElapsedMilliseconds,
sequence: packet.Sequence,
universe: packet.Universe,
data: packet.DmxData);
this.writer.AddData(dmxData);
}
}
protected override void ProcessPacket(NewPacketEventArgs packetInfo)
{
DirectoryAgentAdvertPacket advert = packetInfo.Packet as DirectoryAgentAdvertPacket;
if (advert != null)
{
ProcessDAAdvert(advert, packetInfo.SourceEndPoint);
}
ServiceRequestPacket request = packetInfo.Packet as ServiceRequestPacket;
if (IsReplyRequired(request))
{
SendServiceReply(packetInfo.SourceEndPoint, packetInfo.Packet.Header.XId);
}
ServiceAcknowledgePacket acknowledge = packetInfo.Packet as ServiceAcknowledgePacket;
if (acknowledge != null)
{
RaiseServiceRegistered();
}
AttributeRequestPacket attributeRequest = packetInfo.Packet as AttributeRequestPacket;
if (IsReplyRequired(attributeRequest))
{
SendAttributeReply(packetInfo.SourceEndPoint, packetInfo.Packet.Header.XId);
}
}
void socket_NewDiscovery(object sender, NewPacketEventArgs<StreamingAcnDiscoveryPacket> e)
{
if (e.Packet != null)
{
AvailableUniverses = new HashSet<int>(e.Packet.UniverseDiscovery.Universes);
}
}
protected virtual void RaiseRdmPacketSent(NewPacketEventArgs <RdmPacket> args)
{
if (RdmPacketSent != null)
{
RdmPacketSent(this, args);
}
}
void acnSocket_NewRdmPacket(object sender, NewPacketEventArgs <RdmPacket> e)
{
if (e.Packet is ManufacturerLabel.GetReply)
{
ProcessManufacturerLabel(e.Source, e.Packet);
}
if (e.Packet is DeviceLabel.GetReply)
{
ProcessDeviceLabel(e.Source, e.Packet);
}
if (e.Packet is EndpointLabel.GetReply)
{
ProcessEndpointLabel(e.Source, e.Packet);
}
if (e.Packet is EndpointMode.GetReply)
{
ProcessEndpointMode(e.Source, e.Packet);
}
if (e.Packet is EndpointToUniverse.GetReply)
{
ProcessEndpointUniverse(e.Source, e.Packet);
}
if (e.Packet is EndpointList.Reply)
{
ProcessEndpointList(e.Source, e.Packet);
}
}
void transport_NewRdmPacket(object sender, NewPacketEventArgs <RdmPacket> e)
{
if (!pause)
{
if (InvokeRequired)
{
BeginInvoke(new EventHandler <NewPacketEventArgs <RdmPacket> >(transport_NewRdmPacket), sender, e);
return;
}
DateTime timeStamp = DateTime.Now;
ListViewItem newItem = new ListViewItem(string.Format("{0}{1}", timeStamp.ToLongTimeString(), timeStamp.Millisecond.ToString()));
newItem.SubItems.Add(e.Packet.Header.ParameterId.ToString());
newItem.SubItems.Add(e.Packet.Header.Command.ToString());
newItem.SubItems.Add(((RdmResponseTypes)e.Packet.Header.PortOrResponseType).ToString());
newItem.SubItems.Add(e.Packet.Header.SourceId.ToString());
newItem.SubItems.Add(e.Packet.Header.DestinationId.ToString());
newItem.SubItems.Add(e.Packet.Header.SubDevice.ToString());
newItem.SubItems.Add(e.Source.Address.ToString());
newItem.SubItems.Add(e.Packet.Header.MessageCount.ToString());
newItem.SubItems.Add(e.Packet.Header.TransactionNumber.ToString());
packetView.Items.Add(newItem);
}
}
protected void RaiseNewRdmPacket(NewPacketEventArgs <RdmPacket> packetInfo)
{
if (NewRdmPacket != null)
{
NewRdmPacket(this, packetInfo);
}
}
void socket_NewPacket(object sender, NewPacketEventArgs <StreamingAcnDmxPacket> e)
{
StreamingAcnDmxPacket dmxPacket = e.Packet as StreamingAcnDmxPacket;
if (dmxPacket != null)
{
receiveData.DmxData = dmxPacket.Dmx.Data;
}
}
void socket_NewRdmPacket(object sender, NewPacketEventArgs <Acn.Rdm.RdmPacket> e)
{
RdmPacket replyPacket = broker.ProcessPacket(e.Packet);
if (replyPacket != null)
{
socket.SendRdm(replyPacket, new RdmEndPoint(e.Source), e.Packet.Header.SourceId);
}
}
void socket_NewPacket(object sender, NewPacketEventArgs <StreamingAcnDmxPacket> e)
{
StreamingAcnDmxPacket dmxPacket = e.Packet as StreamingAcnDmxPacket;
if (dmxPacket != null)
{
DecodeDmxData(dmxPacket);
}
}
void socket_NewRdmPacket(object sender, NewPacketEventArgs <RdmPacket> e)
{
if (InvokeRequired)
{
BeginInvoke(new EventHandler <NewPacketEventArgs <RdmPacket> >(socket_NewRdmPacket), sender, e);
return;
}
rdmTrace.Items.Add(string.Format("{0}:{1} from {2}:{3}", e.Packet.Header.Command.ToString(), e.Packet.Header.ParameterId.ToString(), e.Source.ToString(), ""));
}
private void OnReceivePollPacket(object sender, NewPacketEventArgs <ArtNetPacket> e)
{
newPacket = true;
if (e.Packet.OpCode == ArtNet.Enums.ArtNetOpCodes.Poll)
{
artnet.Send(pollReplayPacket);
Debug.Log("Received --- Poll Command: " + e.Source.ToString());
}
}
protected override void Socket_NewPacket(object sender, NewPacketEventArgs <ArtNetPacket> e)
{
base.Socket_NewPacket(sender, e);
switch (e.Packet.OpCode)
{
case ArtNet.ArtNetOpCodes.ArtTrigger:
DebugPrintArtTrigger(e.Packet as ArtNet.Packets.ArtTriggerPacket);
break;
}
}
void OnInput(object sender, NewPacketEventArgs <ArtNetPacket> args)
{
if (args.Packet.OpCode == ArtNet.Enums.ArtNetOpCodes.Dmx)
{
var dmxPacket = args.Packet as ArtNetDmxPacket;
if (dmxPacket.Universe == ArtNetUniverse)
{
m_DMXData = dmxPacket.DmxData;
}
}
}
void socket_NewRdmPacket(object sender, NewPacketEventArgs <RdmPacket> e)
{
PortList.Reply ports = e.Packet as PortList.Reply;
if (ports != null)
{
Ports = ports.PortNumbers;
if (PortsChanged != null)
{
PortsChanged(this, EventArgs.Empty);
}
}
}
void socket_NewPacket(object sender, NewPacketEventArgs<StreamingAcnDmxPacket> e)
{
bool isLocked = false;
StreamingAcnDmxPacket dmxPacket = e.Packet as StreamingAcnDmxPacket;
if (dmxPacket != null)
{
recieveData.DmxData = dmxPacket.Dmx.Data;
isLocked = (lockAddress != 0 && lockAddress == dmxPacket.Framing.SyncPacketAddress);
}
Locked = isLocked;
}
private static void ArtnetReceived(object sender, NewPacketEventArgs <ArtNetPacket> e)
{
if (!(e.Packet is ArtNetDmxPacket dmxPacket))
{
return;
}
if (dmxPacket.Universe != _universe)
{
return;
}
if (dmxPacket.DmxData.SequenceEqual(_lastFrame))
{
return;
}
Console.WriteLine("Got new ArtNet Packet");
_lastFrame = dmxPacket.DmxData;
for (int i = 0; i < _sshClients.Count; i++)
{
var client = _sshClients[i];
var dmxStartChannel = i * 2;
var whiteValue = dmxPacket.DmxData[dmxStartChannel];
var blueValue = dmxPacket.DmxData[dmxStartChannel + 1];
var valueToSend = 0;
if (blueValue > 127)
{
valueToSend |= 1;
}
if (whiteValue > 127)
{
valueToSend |= 2;
}
Console.WriteLine($"AP {client.ConnectionInfo.Host} Color {valueToSend}");
if (client.IsConnected)
{
using (var sc = client.CreateCommand($"echo '{valueToSend.ToString(CultureInfo.InvariantCulture)}' > /proc/gpio/led_pattern"))
{
sc.Execute();
}
}
}
}
void socket_NewPacket(object sender, NewPacketEventArgs <StreamingAcnDmxPacket> e)
{
StreamingAcnDmxPacket dmxPacket = e.Packet as StreamingAcnDmxPacket;
if (example != null)
{
example.UpdateData(dmxPacket.Framing.Universe - 1, dmxPacket.Dmx.Data);
if (dmxPacket.Framing.SyncPacketAddress == 0)
{
example.Draw(TimeSpan.FromMilliseconds(10));
}
}
}
/// <summary>
/// Processes the packet and returns a response.
/// </summary>
/// <param name="packetInfo">The <see cref="Acn.Sntp.Sockets.NewPacketEventArgs"/> instance containing the event data.</param>
protected void ProcessPacket(NewPacketEventArgs packetInfo)
{
NtpData data = packetInfo.Packet;
data.LeapIndicator = LeapIndicator.NoWarning;
data.VersionNumber = 4;
data.Mode = NtpMode.Server;
data.Stratum = NtpStratum.PrimaryReference;
data.RootDispersion = 0;
data.RootDelay = 0;
data.ReferenceID = "LOCL";
data.ReceiveTimestamp = packetInfo.RecievedTime;
data.CopyTransmitToOriginate();
data.TransmitTimestamp = DateTime.UtcNow;
socket.Send(packetInfo.SourceEndPoint, data);
}
/// <summary>
/// ArtNet Socket 接收事件绑定函数
/// </summary>
/// <param name="sender">Socket 对象</param>
/// <param name="e">ArtNet 事件参数对象</param>
private void OnReceiveDmxPacket(object sender, NewPacketEventArgs <ArtNetPacket> e)
{
// 标记接收到了新的数据包
newPacket = true;
if (e.Packet.OpCode == ArtNet.Enums.ArtNetOpCodes.Dmx)
{
var packet = latestReceivedDMX = e.Packet as ArtNetDmxPacket;
// 如果新数据包不等于现有的，那么再更新
//if (packet.DmxData != _dmxData)
//{
// _dmxData = packet.DmxData;
//}
var subNet = packet.Universe / 16;
var universe = packet.Universe % 16;
lock (dmxDataMap)
{
// 如果数据包中包含 该 SubNet 和 Universe 直接复制，没有则创建新的键值对
if (dmxDataMap.ContainsKey(subNet) && dmxDataMap[subNet].ContainsKey(universe))
{
dmxDataMap[subNet][universe] = packet.DmxData;
}
else if (dmxDataMap.ContainsKey(subNet))
{
dmxDataMap[subNet] = new Dictionary <int, byte[]>()
{
{ universe, packet.DmxData }
};
}
else
{
dmxDataMap.Add(subNet, new Dictionary <int, byte[]>()
{
{ universe, packet.DmxData }
});
}
Debug.Log("Received --- DMX Command: " + e.Source.ToString() + $" [SubNet: {subNet}, Universe: {universe}]");
}
}
}
void acnSocket_NewRdmPacket(object sender, NewPacketEventArgs <RdmPacket> e)
{
if (e.Packet is EndpointList.Reply)
{
ProcessEndpointList(e.Source, e.Packet);
}
if (e.Packet is EndpointListChange.Reply)
{
ProcessEndpointListChange(e.Source, e.Packet);
}
if (e.Packet is EndpointDevices.Reply)
{
ProcessDeviceList(e.Source, e.Packet);
}
if (e.Packet is EndpointDeviceListChange.Reply)
{
ProcessDeviceListChange(e.Source, e.Packet);
}
}
static void artnet_NewPacket(object sender, NewPacketEventArgs<ArtNetPacket> e)
{
if (e.Packet.OpCode == ArtNet.Enums.ArtNetOpCodes.Dmx)
{
var packet = e.Packet as ArtNet.Packets.ArtNetDmxPacket;
Console.Clear();
s_mutex.WaitOne();
Console.WriteLine("New Packet of length " + packet.DmxData.Length.ToString() + " in universe " + packet.Universe.ToString());
// We expect RGB values (1 byte/channel)
for (var i = 0; i < packet.DmxData.Length / 3; i++)
{
s_dmxValues[packet.Universe, i*3] = packet.DmxData[i];
s_dmxValues[packet.Universe, i*3 + 1] = packet.DmxData[i*3 + 1];
s_dmxValues[packet.Universe, i*3 + 2] = packet.DmxData[i*3 + 2];
Color current = Color.FromArgb(packet.DmxData[i*3], packet.DmxData[i*3 + 1], packet.DmxData[i*3 + 2]);
s_dmxColours[packet.Universe, i] = current;
};
s_mutex.ReleaseMutex();
}
}
void socket_NewPacket(object sender, NewPacketEventArgs <TCNetPacket> e)
{
if (e.Packet is TCNetTime)
{
TimecodePacket = (TCNetTime)e.Packet;
}
if (e.Packet is TCNetError)
{
BeginInvoke(new Action <TCNetError>(ProcessError), e.Packet);
}
if (e.Packet is TCNetBigWaveform)
{
DumpWaveform("BigWaveform.txt", ((TCNetBigWaveform)e.Packet).WaveformData);
}
if (e.Packet is TCNetSmallWaveform)
{
DumpWaveform("SmallWaveform.txt", ((TCNetSmallWaveform)e.Packet).WaveformData);
}
}
static void artnet_NewPacket(object sender, NewPacketEventArgs <ArtNetPacket> e)
{
if (e.Packet.OpCode == ArtNet.Enums.ArtNetOpCodes.Dmx)
{
var packet = e.Packet as ArtNet.Packets.ArtNetDmxPacket;
Console.Clear();
s_mutex.WaitOne();
Console.WriteLine("New Packet of length " + packet.DmxData.Length.ToString() + " in universe " + packet.Universe.ToString());
// We expect RGB values (1 byte/channel)
for (var i = 0; i < packet.DmxData.Length / 3; i++)
{
s_dmxValues[packet.Universe, i *3] = packet.DmxData[i];
s_dmxValues[packet.Universe, i *3 + 1] = packet.DmxData[i * 3 + 1];
s_dmxValues[packet.Universe, i *3 + 2] = packet.DmxData[i * 3 + 2];
Color current = Color.FromArgb(packet.DmxData[i * 3], packet.DmxData[i * 3 + 1], packet.DmxData[i * 3 + 2]);
s_dmxColours[packet.Universe, i] = current;
}
;
s_mutex.ReleaseMutex();
}
}
private void Socket_NewPacket(object sender, NewPacketEventArgs<ArtNetPacket> e)
{
if (e.Packet.OpCode == ArtNetOpCodes.Dmx)
{
if (this.timestamper == null)
this.timestamper = Stopwatch.StartNew();
var packet = e.Packet as ArtNetDmxPacket;
UniverseData universeData;
if (!this.universes.TryGetValue(packet.Universe, out universeData))
// Unknown universe
return;
var dmxData = RawDmxData.Create(
millisecond: this.timestamper.ElapsedMilliseconds,
sequence: packet.Sequence,
universe: packet.Universe,
data: packet.DmxData);
this.writer.AddData(dmxData);
}
}
/// <summary>
/// Called when a new sync packet is recieved
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Socket_NewSynchronize(object sender, NewPacketEventArgs <StreamingAcnSynchronizationPacket> e)
{
string sourceIp = e.Source.Address.ToString();
Dispatcher.BeginInvoke(new Action(() =>
{
if (!SyncIps.Contains(sourceIp))
{
SyncIps.Add(sourceIp);
}
if (!SeenIps.Contains(sourceIp))
{
SeenIps.Add(sourceIp);
}
if (SeenIps.Count == SyncIps.Count)
{
example.Draw(TimeSpan.Zero);
SeenIps = new List <string>();
}
}));
}
public void OnReceive(object sender, NewPacketEventArgs <ArtNetPacket> e)
{
newPacket = true;
if (e.Packet.OpCode == ArtNet.Enums.ArtNetOpCodes.Dmx)
{
var packet = latestReceivedDMX = e.Packet as ArtNetDmxPacket;
if (packet.DmxData != _dmxData)
{
_dmxData = packet.DmxData;
}
var universe = packet.Universe;
if (dmxDataMap.ContainsKey(universe))
{
dmxDataMap[universe] = packet.DmxData;
}
else
{
dmxDataMap.Add(universe, packet.DmxData);
}
}
}
protected override void ProcessPacket(NewPacketEventArgs packetInfo)
{
DirectoryAgentAdvertPacket daAdvert = packetInfo.Packet as DirectoryAgentAdvertPacket;
if (daAdvert != null)
{
DirectoryAgent = new DirectoryAgentInformation(daAdvert.Url, packetInfo.SourceEndPoint);
}
ServiceReplyPacket serviceReply = packetInfo.Packet as ServiceReplyPacket;
if (serviceReply != null)
{
ProcessServiceReply(serviceReply, packetInfo.SourceEndPoint);
}
AttributeReplyPacket attributeReply = packetInfo.Packet as AttributeReplyPacket;
if (attributeReply != null)
{
ProcessAttributeReply(attributeReply, packetInfo.SourceEndPoint);
}
}
protected abstract void ProcessPacket(NewPacketEventArgs packetInfo);
void socket_NewPacket(object sender, NewPacketEventArgs e)
{
ProcessPacket(e);
}
private void socket_NewPacket(object sender, NewPacketEventArgs<StreamingAcnDmxPacket> e)
{
log.Debug("Received DMX packet on ACN stream");
}
void socket_RdmPacketSent(object sender, NewPacketEventArgs <RdmPacket> e)
{
RaiseRdmPacketSent(e);
}
