public void SendRdm(RdmPacket packet, RdmEndPoint targetAddress, UId targetId, UId sourceId)
{
//Fill in addition details
packet.Header.SourceId = sourceId;
packet.Header.DestinationId = targetId;
//Sub Devices
if (targetId is SubDeviceUId)
{
packet.Header.SubDevice = ((SubDeviceUId)targetId).SubDeviceId;
}
//Create Rdm Packet
using (var rdmData = new MemoryStream())
{
var rdmWriter = new RdmBinaryWriter(rdmData);
//Write the RDM packet
RdmPacket.WritePacket(packet, rdmWriter);
//Write the checksum
rdmWriter.WriteNetwork((short)(RdmPacket.CalculateChecksum(rdmData.GetBuffer()) + (int)RdmVersions.SubMessage + (int)DmxStartCodes.RDM));
//Create sACN Packet
var rdmPacket = new ArtRdmPacket();
rdmPacket.Address = (byte)targetAddress.Universe;
rdmPacket.SubStartCode = (byte)RdmVersions.SubMessage;
rdmPacket.RdmData = rdmData.GetBuffer();
Send(rdmPacket, targetAddress);
RdmPacketSent?.Invoke(this, new NewPacketEventArgs <RdmPacket>(new IPEndPoint(targetAddress.IpAddress, Port), packet));
}
}
protected void RaiseNewRdmPacket(RdmEndPoint source, RdmPacket packet)
{
if (NewRdmPacket != null)
{
NewRdmPacket(this, new NewPacketEventArgs <RdmPacket>(source, packet));
}
}
public void SendRdm(List <RdmPacket> packets, RdmEndPoint targetAddress, UId targetId)
{
if (packets.Count < 1)
{
throw new ArgumentException("Rdm packets list is empty.");
}
RdmPacket primaryPacket = packets[0];
//Create sACN Packet
ArtRdmSubPacket rdmPacket = new ArtRdmSubPacket();
rdmPacket.DeviceId = targetId;
rdmPacket.RdmVersion = (byte)RdmVersions.SubMessage;
rdmPacket.Command = primaryPacket.Header.Command;
rdmPacket.ParameterId = primaryPacket.Header.ParameterId;
rdmPacket.SubDevice = (short)primaryPacket.Header.SubDevice;
rdmPacket.SubCount = (short)packets.Count;
MemoryStream rdmData = new MemoryStream();
RdmBinaryWriter dataWriter = new RdmBinaryWriter(rdmData);
foreach (RdmPacket item in packets)
{
RdmPacket.WritePacket(item, dataWriter, true);
}
rdmPacket.RdmData = rdmData.ToArray();
Send(rdmPacket, targetAddress);
}
private void StartRdmDiscovery(RdmEndPoint endpoint)
{
DiscoveryState.Set request = new DiscoveryState.Set();
request.EndpointID = (short)endpoint.Universe;
request.DiscoveryState = DiscoveryState.DiscoveryStates.Full;
rdmNetSocket.SendRdm(request, new RdmEndPoint(endpoint, 0), endpoint.Id);
}
/// <summary>
/// Sends the specified packet using unicast to a specific DJ Tap device.
/// </summary>
/// <param name="packet">The packet to send on the network.</param>
/// <param name="address">The address of the device to send the packet to.</param>
public void Send(DJTapPacket packet, RdmEndPoint address)
{
MemoryStream data = new MemoryStream();
DJTapBinaryWriter writer = new DJTapBinaryWriter(data);
packet.WriteData(writer);
SendTo(data.ToArray(), new IPEndPoint(address.IpAddress, Port));
}
/// <summary>
/// Gets the universe index for a specific endpoint address.
/// </summary>
/// <param name="address">The device address.</param>
/// <returns>
/// The DMX universe that this address resolves to.
/// </returns>
/// <exception cref="System.InvalidOperationException">No transport exists for this device address.</exception>
/// <remarks>
/// The transport may wish to resolve this to an internal addressing scheme.
/// </remarks>
public int ResolveEndpointToUniverse(RdmEndPoint address)
{
IRdmTransport transport = GetTransportForDevice(address.Id);
if (transport == null)
{
throw new InvalidOperationException("No transport exists for this device address.");
}
return(transport.ResolveEndpointToUniverse(address));
}
public RdmDeviceBroker(IRdmSocket socket, UId id, RdmEndPoint address)
{
Id = id;
Address = address;
this.socket = socket;
RegisterHandlers(this);
socket.NewRdmPacket += new EventHandler <NewPacketEventArgs <RdmPacket> >(socket_NewRdmPacket);
}
public void SendRdm(RdmPacket packet, RdmEndPoint targetAddress, UId targetId, UId sourceId)
{
List <RdmRouteBinding> transportsToUse = router.GetTransportsRoutes(targetId);
//Send the packet on all transports.
foreach (RdmRouteBinding binding in transportsToUse)
{
binding.Transport.Socket.SendRdm(packet, targetAddress, targetId, sourceId);
}
}
public void AddKnownDevice(RdmEndPoint endpoint)
{
if (!devices.ContainsKey(endpoint))
{
HealthCheckedTcpSocket device = HealthCheckedTcpSocket.Connect(endpoint, SenderId);
device.UnhandledException += device_UnhandledException;
device.NewRdmPacket += device_NewRdmPacket;
devices.Add(endpoint, device);
}
}
public static HealthCheckedTcpSocket Connect(RdmEndPoint endpoint, Guid senderId)
{
Socket newConnection = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
newConnection.Connect(endpoint);
HealthCheckedTcpSocket socket = new HealthCheckedTcpSocket(newConnection, endpoint.Id, senderId, string.Empty);
socket.Open(endpoint);
return(socket);
}
private void ProcessDeviceListChange(IPEndPoint endpoint, RdmPacket packet)
{
EndpointDeviceListChange.Reply reply = packet as EndpointDeviceListChange.Reply;
if (reply != null && Socket != null)
{
RdmEndPoint source = new RdmEndPoint(endpoint, reply.EndpointID);
EndpointDevices.Get request = new EndpointDevices.Get();
request.EndpointID = reply.EndpointID;
Socket.SendRdm(request, new RdmEndPoint(endpoint, 0), packet.Header.SourceId);
}
}
void slpUser_ServiceFound(object sender, ServiceFoundEventArgs e)
{
foreach (UrlEntry url in e.Urls)
{
RdmEndPoint controlEndpoint = new RdmEndPoint(new IPEndPoint(e.Address.Address, RdmNetSocket.RdmNetPort), 0)
{
Id = UId.ParseUrl(url.Url)
};
ControlEndpoints.Add(controlEndpoint);
DiscoverEndpoints(controlEndpoint);
}
}
private void ProcessDeviceList(IPEndPoint endpoint, RdmPacket packet)
{
EndpointDevices.Reply reply = packet as EndpointDevices.Reply;
if (reply != null)
{
RdmEndPoint source = new RdmEndPoint(endpoint, reply.EndpointID);
foreach (UId id in reply.DeviceIds)
{
NewDeviceFound(this, new DeviceFoundEventArgs(id, source));
}
}
}
public RdmDeviceModel(TreeNode node, IRdmSocket socket, UId id, RdmEndPoint address)
{
CreateHandle();
broker = new RdmDeviceBroker(socket, id, address);
Node = node;
Node.Tag = this;
broker.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(RdmDeviceModel_PropertyChanged);
UpdateNodeName();
}
public RdmDeviceBroker(IEnumerable <IRdmSocket> sockets, UId id, RdmEndPoint address)
{
Id = id;
Address = address;
this.sockets = sockets;
RegisterHandlers(this);
foreach (var socket in sockets)
{
socket.NewRdmPacket += new EventHandler <NewPacketEventArgs <RdmPacket> >(socket_NewRdmPacket);
}
}
private void AddDevice(UId id, RdmEndPoint address)
{
if (!devices.ContainsKey(id))
{
RdmDeviceModel device = new RdmDeviceModel(new TreeNode(id.ToString()), Transport.Socket, id, address);
devices[id] = device;
rdmDevices.Nodes.Add(device.Node);
if (AutoInterogate)
{
device.Interogate();
}
}
}
void dnsSD_ServiceAdded(object o, ServiceBrowseEventArgs args)
{
args.Service.Resolved += delegate(object sender, ServiceResolvedEventArgs e)
{
IResolvableService s = (IResolvableService)e.Service;
foreach (IPAddress address in s.HostEntry.AddressList)
{
RdmEndPoint controlEndpoint = new RdmEndPoint(new IPEndPoint(address, RdmNetSocket.RdmNetPort), 0)
{
Id = UId.ParseUrl(s.TxtRecord["id"].ValueString)
};
ControlEndpoints.Add(controlEndpoint);
DiscoverEndpoints(controlEndpoint);
}
};
args.Service.Resolve();
}
public void SendRdm(RdmPacket packet, RdmEndPoint targetAddress, UId targetId, UId sourceId)
{
if (BlockRDM)
{
return;
}
List <RdmRouteBinding> transportsToUse = router.GetTransportsRoutes(targetId);
//Send the packet on all transports.
foreach (RdmRouteBinding binding in transportsToUse)
{
foreach (IRdmSocket socket in binding.Transport.Sockets)
{
socket.SendRdm(packet, targetAddress, targetId, sourceId);
}
}
}
public void SendRdm(RdmPacket packet, RdmEndPoint targetAddress, UId targetId, UId sourceId)
{
if (BlockRDM)
{
return;
}
//Fill in addition details
packet.Header.SourceId = sourceId;
packet.Header.DestinationId = targetId;
SubDeviceUId id = targetId as SubDeviceUId;
if (id != null)
{
packet.Header.SubDevice = id.SubDeviceId;
}
//Create Rdm Packet
MemoryStream rdmData = new MemoryStream();
RdmBinaryWriter rdmWriter = new RdmBinaryWriter(rdmData);
//Write the RDM sub-start code.
rdmWriter.Write((byte)RdmVersions.SubMessage);
//Write the RDM packet
RdmPacket.WritePacket(packet, rdmWriter);
//Write the checksum
rdmWriter.WriteNetwork((short)RdmPacket.CalculateChecksum(rdmData.GetBuffer()) + (byte)DmxStartCodes.RDM);
//Create sACN Packet
RdmNetPacket dmxPacket = new RdmNetPacket();
dmxPacket.Framing.SourceName = SourceName;
dmxPacket.Framing.EndpointID = (short)targetAddress.Universe;
dmxPacket.RdmNet.RdmData = rdmData.GetBuffer();
SendPacket(dmxPacket, targetAddress);
RaiseRdmPacketSent(new NewPacketEventArgs <RdmPacket>(targetAddress, packet));
}
private void ProcessEndpointList(IPEndPoint endpoint, RdmPacket packet)
{
EndpointList.Reply reply = packet as EndpointList.Reply;
if (reply != null)
{
foreach (int endpointId in reply.EndpointIDs)
{
RdmEndPoint target = new RdmEndPoint(endpoint, endpointId)
{
Id = packet.Header.SourceId
};
DiscoveredEndpoints.Add(target);
EndpointDevices.Get request = new EndpointDevices.Get();
request.EndpointID = (short)endpointId;
if (Socket != null)
{
Socket.SendRdm(request, new RdmEndPoint(endpoint, 0), packet.Header.SourceId);
}
}
}
}
public int ResolveEndpointToUniverse(RdmEndPoint address)
{
throw new NotImplementedException();
}
public DeviceFoundEventArgs(UId id, RdmEndPoint address)
{
this.id = id;
this.ipAddress = address;
}
private void DiscoverEndpoints(RdmEndPoint endpoint)
{
EndpointList.Get getEndpoints = new EndpointList.Get();
getEndpoints.Header.DestinationId = endpoint.Id;
rdmNetSocket.SendRdm(getEndpoints, endpoint, endpoint.Id);
}
public void RemoveKnownDevice(RdmEndPoint endpoint)
{
}
public void Send(ArtNetPacket packet, RdmEndPoint address)
{
SendTo(packet.ToArray(), new IPEndPoint(address.IpAddress, Port));
}
public void SendRdm(RdmPacket packet, RdmEndPoint targetAddress, UId targetId)
{
SendRdm(packet, targetAddress, targetId, RdmId);
}
