private bool ReceiveFrame()
{
// check if enough bytes ready
ushort required_count = this.currentHeader.Length;
if (this.pendingBytes.Count < required_count)
{
return(false);
}
this.ReceiveState = ReceiveStates.ReceiveStartByte;
// create emission description
EmissionDescriptor desc = new EmissionDescriptor(this.currentHeader,
this.pendingBytes.Take(required_count).ToList());
this.mutexEmissions.WaitOne();
this.emissions.Add(desc);
this.mutexEmissions.ReleaseMutex();
// remove emission bytes
this.pendingBytes.RemoveRange(0, required_count);
// invoke callback
if (this.OnEmission != null)
{
this.OnEmission(this, desc);
}
return(true);
}
public void ReceiveBytes(List <byte> bytes)
{
// check start byte
if (bytes[0] != CONSTANTS.FRAME_START_BYTE)
{
throw new Exception("Invalid start byte for custom emission processor");
}
// decode header
int required_count = CONSTANTS.EMISSION_HEADER_SIZE;
if (bytes.Count < required_count)
{
throw new Exception("Invalid byte count for custom emission processor header");
}
EmissionHeader header = new EmissionHeader();
header.Unpack(bytes.Take(required_count).ToList());
// remove header bytes
bytes.RemoveRange(0, required_count);
// decode emission descriptor
required_count = header.Length;
if (bytes.Count < required_count)
{
throw new Exception("Invalid byte count for custom emission processor data");
}
EmissionDescriptor desc = new EmissionDescriptor(header,
bytes.Take(required_count).ToList());
// signal done
this.mutexEmissions.WaitOne();
this.emissions.Add(desc);
this.mutexEmissions.ReleaseMutex();
}
public void SendSimpleDataStream()
{
ulong broadcast = 0x000000000000FFFF;
ulong long_address = 0x0013A20041B764AD;
string text = "";
for (int i = 0; i < CONSTANTS.MAX_FRAME_DATA; i++)
{
text += "x";
} // looks like 84 is the magic number so that the packets dont fragment; should probably start making a transmission/packet/etc class that can hold arrays of these 84 byte transmissions
byte[] data_bytes = Encoding.UTF8.GetBytes(text);
byte[] bytes = factory.CreateSendDataFrame(long_address, data_bytes, 1);
using (SerialRelay relay = new SerialRelay("COM4", this.byteReceiver))
{
relay.SendBytes(bytes);
EmissionDescriptor em = this.byteReceiver.WaitForEmission(EmissionTypes.ExtendedTransmitStatus, 1000);
ExtendedTransmitStatusEmission response = new ExtendedTransmitStatusEmission();
response.Unpack(em.Data);
Console.WriteLine("ID: {0}; Address: 0x{1:X4}; Result: 0x{2:X2}",
response.FrameID, response.Address, response.DeliveryStatus);
bytes = factory.CreateSendDataFrame(response.Address, data_bytes, 1);
for (int i = 0; i < 10; i++)
{
relay.SendBytes(bytes);
em = this.byteReceiver.WaitForEmission(EmissionTypes.ExtendedTransmitStatus, 1000);
response.Unpack(em.Data);
Console.WriteLine("ID: {0}; Address: 0x{1:X4}; Result: 0x{2:X2}",
response.FrameID, response.Address, response.DeliveryStatus);
Assert.AreEqual(0, response.DeliveryStatus);
//System.Threading.Thread.Sleep(10);
}
}
}
public void ProcessEmission(EmissionDescriptor emission)
{
if (emission.Header.FrameType != Emission.EmissionTypes.ReceivePacket)
{
return;
}
ReceivePacketEmission response = new ReceivePacketEmission();
response.Unpack(emission.Data);
List <byte> data = response.Data;
switch (data[0])
{
case CONSTANTS.XM_HEADER_START_BYTE:
this.ProcessTransmissionObjectHeader(data);
break;
case CONSTANTS.XM_PACKET_HEADER_START_BYTE:
this.ProcessTransmissionPacket(data);
break;
default:
break;
}
}
public List <byte> ReceiveBytes()
{
EmissionDescriptor desc = this.emissionProcessor.WaitForEmission(EmissionTypes.ReceivePacket, 1000);
this.emissionProcessor.RemoveEmission(desc.ID);
ReceivePacketEmission response = new ReceivePacketEmission();
response.Unpack(desc.Data);
return(response.Data);
}
internal void SendRawBytes(ulong address, byte[] data)
{
if (data.Length < 1)
{
return;
}
byte[] frame_bytes = this.relay.TranmissionFormatter.FormatDataBytes(address, data);
this.relay.SendBytes(frame_bytes);
EmissionDescriptor desc = this.emissionProcessor.WaitForEmission(EmissionTypes.ExtendedTransmitStatus, 1000);
ExtendedTransmitStatusEmission response = new ExtendedTransmitStatusEmission();
response.Unpack(desc.Data);
if (response.DeliveryStatus != 0)
{
throw new Exception($"Error during data transmission of {data.Length} bytes to {address}");
}
}
public ushort Discover(ulong address)
{
string text = CONSTANTS.DISCOVER;
byte[] data_bytes = Encoding.UTF8.GetBytes(text);
byte[] bytes = this.relay.TranmissionFormatter.FormatDataBytes(address, data_bytes);
relay.SendBytes(bytes);
//
EmissionDescriptor desc = this.emissionProcessor.WaitForEmission(EmissionTypes.ExtendedTransmitStatus, 1000);
ExtendedTransmitStatusEmission response = new ExtendedTransmitStatusEmission();
response.Unpack(desc.Data);
if (response.DeliveryStatus != 0)
{
throw new Exception($"Error while discovering full address for {address}");
}
return(response.Address);
}
public void SendSimpleData()
{
ulong broadcast = 0x000000000000FFFF;
ulong address = 0x0013A20041B764AD;
string text = "xxxxx";
byte[] data_bytes = Encoding.UTF8.GetBytes(text);
byte[] bytes = factory.CreateSendDataFrame(address, data_bytes, 1);
using (SerialRelay relay = new SerialRelay("COM4", this.byteReceiver))
{
relay.SendBytes(bytes);
EmissionDescriptor em = this.byteReceiver.WaitForEmission(EmissionTypes.ExtendedTransmitStatus, 1000);
ExtendedTransmitStatusEmission response = new ExtendedTransmitStatusEmission();
response.Unpack(em.Data);
Console.WriteLine("Frame ID: {0}; Result: {1}",
response.FrameID, response.DeliveryStatus);
Assert.AreEqual(0, response.DeliveryStatus);
}
}
public EmissionDescriptor WaitForEmission(EmissionTypes type, int timeout)
{
EmissionDescriptor desc = null;
DateTime start = DateTime.Now;
while (desc == null)
{
if (DateTime.Now > start + TimeSpan.FromMilliseconds(timeout))
{
throw new TimeoutException("Timeout while waiting for emission");
}
this.mutexEmissions.WaitOne();
int index = this.emissions.FindIndex(em => em.Header.FrameType == type);
if (index > -1)
{
desc = this.emissions[index];
this.emissions.RemoveAt(index);
}
this.mutexEmissions.ReleaseMutex();
}
return(desc);
}
private void EmissionProcessor_OnEmission(object sender, EmissionDescriptor emission)
{
this.transmissionProcessor.ProcessEmission(emission);
}
