public override EnOceanPacket ToPacket()
{
var data = new List <byte>();
data.Add((byte)Rorg);
data.AddRange(Data.Span.ToArray()); //TODO: Change to Packet function
//source id
data.AddRange(_idBase.ToArray());
data.Add(0x30);
var optionalData = new List <byte>();
//optional data
optionalData.Add(3);
optionalData.Add(0xFF);
optionalData.Add(0xFF);
optionalData.Add(0xFF);
optionalData.Add(0xFF);
optionalData.Add(0xFF); //dBM
optionalData.Add(0); //security level
var headerBuf = new List <byte>();
headerBuf.Add(0x55);
headerBuf.Add((byte)(data.Count >> 8));
headerBuf.Add((byte)data.Count);
headerBuf.Add(7);
headerBuf.Add((byte)EnOcean.PacketType.RadioErp1);
return(EnOceanPacket.CreateNew(headerBuf.ToArray(), data.ToArray(), optionalData.ToArray()));
}
private RadioErp1Packet CreatePacket(string data)
{
var byteData = Automatica.Core.Driver.Utility.Utils.StringToByteArray(data);
var packet = EnOceanPacket.Parse(byteData);
var telegram = EnOceanTelegramFactory.FromPacket(packet) as RadioErp1Packet;
return(telegram);
}
public void Test_PackageParse()
{
var byteData =
Automatica.Core.Driver.Utility.Utils.StringToByteArray("55000A0701EBA500010948FF0000000001FFFFFFFF490066");
var packet = EnOceanPacket.Parse(byteData);
Assert.Equal(EnOcean.PacketType.RadioErp1, packet.PacketType);
Assert.Equal(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF }, packet.DestinationId);
Assert.Equal((byte)73, packet.Dbm);
Assert.False(packet.SecurityLevel);
}
public void WriteFrame(EnOceanPacket frame)
{
try
{
_stream.Write(frame.RawData.ToArray(), 0, frame.RawData.Length);
Logger.Logger.Instance.LogHexOut(frame.RawData);
}
catch (Exception e)
{
Logger.Logger.Instance.LogError($"Could not write frame {e}", e);
}
}
public void Test_PackageParseNoLearnMode()
{
var byteData = Automatica.Core.Driver.Utility.Utils.StringToByteArray("55000707017AD508019C20150001FFFFFFFF500088");
var packet = EnOceanPacket.Parse(byteData);
var radioErp1 = new RadioErp1Packet();
radioErp1.FromPacket(packet);
Assert.False(RadioErp1Packet.IsTechIn(radioErp1));
Assert.Equal(EnOcean.PacketType.RadioErp1, packet.PacketType);
Assert.False(packet.SecurityLevel);
}
public void Test_Telegram1()
{
var byteData = Automatica.Core.Driver.Utility.Utils.StringToByteArray("55000A0701EBA500008E48FFA8AB000001FFFFFFFF560073");
var packet = EnOceanPacket.Parse(byteData);
var telegram = EnOceanTelegramFactory.FromPacket(packet) as RadioErp1Packet;
Assert.NotNull(telegram);
Assert.IsType <RadioErp1Packet>(telegram);
Assert.Equal(Rorg.FourBs, telegram.Rorg);
}
public override void FromPacket(EnOceanPacket packet)
{
packet.ParseData();
Packet = packet;
Rorg = (Rorg)packet.Data.Span[0];
var dataLength = GetRorgDataSize(Rorg);
Data = packet.Data.Slice(1, dataLength);
SenderId = packet.Data.Slice(dataLength + 1, 4);
Status = packet.Data.Span[packet.Data.Length - 1];
Logger.Logger.Instance.LogDebug($"RadioERP1 Packet {Rorg} from {Automatica.Core.Driver.Utility.Utils.ByteArrayToString(SenderId)} Data: {Automatica.Core.Driver.Utility.Utils.ByteArrayToString(Data)}");
}
public override EnOceanPacket ToPacket()
{
var header = new List <byte>();
header.Add(0x55);
header.Add(0x00);
header.Add(0x01);
header.Add(0x00);
header.Add(0x05); // COMMON_COMMAND
var data = new List <byte>();
data.Add((byte)_command); // command type
return(EnOceanPacket.CreateNew(header.ToArray(), data.ToArray(), new byte[0]));
}
private async Task <EnOceanPacket> ReadFrameInternal()
{
try
{
var firstChar = (byte)_stream.ReadByte();
await Task.Delay(100);
if (firstChar == EnOcean.SyncByte)
{
var dataLen = new byte[2];
var dataLenRead = await _stream.ReadAsync(dataLen, 0, 2);
if (dataLenRead == 2)
{
var dataLenShort = BitConverter.ToUInt16(dataLen.Reverse().ToArray(), 0);
var optLen = (byte)_stream.ReadByte();
var packetType = (byte)_stream.ReadByte();
var crc8Header = (byte)_stream.ReadByte();
var header = new byte[] { firstChar, dataLen[0], dataLen[1], optLen, packetType, crc8Header };
var data = new byte[dataLenShort];
Memory <byte> dataMemory = new Memory <byte>(data);
var read = await _stream.ReadAsync(dataMemory);
if (read == dataLenShort)
{
var optData = new byte[optLen];
Memory <byte> optMemory = new Memory <byte>(optData);
read = await _stream.ReadAsync(optMemory);
if (read == optLen)
{
var crcData = (byte)_stream.ReadByte();
var packet = EnOceanPacket.Parse(new Memory <byte>(header), dataMemory, optMemory, crcData);
Logger.Logger.Instance.LogHexIn(packet.RawData);
return(packet);
}
}
else
{
Logger.Logger.Instance.LogDebug($"In buffer length to short {read}/{dataLenShort}");
}
}
else
{
Logger.Logger.Instance.LogDebug($"Could not read length of package");
}
}
else
{
Logger.Logger.Instance.LogDebug($"Invalid sync byte received {firstChar}");
if (_stream.BytesToRead > 0)
{
return(await ReadFrameInternal());
}
}
}
catch (IOException ioe)
{
Logger.Logger.Instance.LogError($"Could not read frame {ioe}", ioe);
Close();
Thread.Sleep(100);
Open();
}
catch (Exception e)
{
Logger.Logger.Instance.LogError($"Could not read frame {e}", e);
}
return(null);
}
public override void FromPacket(EnOceanPacket packet)
{
throw new NotImplementedException();
}
public abstract void FromPacket(EnOceanPacket packet);
public override void FromPacket(EnOceanPacket packet)
{
ReturnCode = (ReturnCode)packet.Data.Span[0];
}