/// <summary>
/// Decode the data array from serial port and convert to Data Package.
/// </summary>
/// <param name="data">Received byte array</param>
/// <returns>Data package</returns>
public static DataPackage Decode(byte[] data)
{
DataPackage dataPackage = new DataPackage();
dataPackage.TimeSeries = new DateTime[10];
dataPackage.SensorID = data[0];
dataPackage.SensorTYpe = data[1];
dataPackage.Temperature = data[2] << 8;
dataPackage.Battery = data[3] << 8;
if (dataPackage.SensorTYpe == 2)
{
dataPackage.WindSpeed = ((data[4] << 8) + data[5]);
dataPackage.WindDirection = ((data[6] << 8) + data[7]);
}
else if (dataPackage.SensorTYpe == 3)
{
dataPackage.Huminity = ((data[6] << 8) + data[7]);
}
//dataPackage.Huminity = 0;
dataPackage.BoardTime = (data[8] << 24) + (data[9] << 16) + (data[10] << 8) + data[11];
dataPackage.Pressure = ((data[12] << 8) + data[13]);
dataPackage.Time = DateTime.Now;
dataPackage.DataString += DateTime.Now.ToString("o");
dataPackage.DataString += "," + "5001";
dataPackage.DataString += "," + dataPackage.SensorID.ToString();
dataPackage.DataString += "," + dataPackage.SensorTYpe.ToString();
dataPackage.DataString += "," + dataPackage.BoardTime.ToString();
dataPackage.DataString += "," + dataPackage.Temperature.ToString();
dataPackage.DataString += "," + dataPackage.Battery.ToString();
dataPackage.DataString += "," + dataPackage.WindSpeed.ToString();
dataPackage.DataString += "," + dataPackage.WindDirection.ToString();
dataPackage.DataString += "," + dataPackage.Huminity.ToString();
dataPackage.passCrc32 = Crc32Algorithm.IsValidWithCrcAtEnd(data);
if (dataPackage.SensorTYpe != 4)
{
return(dataPackage);
}
dataPackage.PressureList = new int[10];
int i = 12;
for (int j = 0; j < 10; j++)
{
dataPackage.PressureList[j] = ((data[i] << 8) + data[i + 1]);
dataPackage.TimeSeries[j] = dataPackage.Time.AddMilliseconds(100 * j);
dataPackage.DataString += "," + dataPackage.PressureList[j].ToString();
i += 2;
}
//byte[] input = new byte[36];
//data.CopyTo(input, 0);
//Crc32Algorithm.ComputeAndWriteToEnd(input); // CRC32 local test
return(dataPackage);
}
public static IPacket FromBytes(byte[] data)
{
if (data.Length < 7)
{
throw new InvalidLengthException();
}
var rawType = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data));
if (!Enum.IsDefined(typeof(PacketType), rawType))
{
throw new InvalidTypeException();
}
if (!Crc32Algorithm.IsValidWithCrcAtEnd(data))
{
throw new InvalidCrcException();
}
var type = (PacketType)rawType;
var ret = new Packet(type)
{
Length = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 2))
};
var offset = 4;
while (offset < ret.Length)
{
var tag = (Tag)data[offset++];
int len;
if ((data[offset] & 0x80) == 0)
{
len = data[offset++];
}
else
{
len = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, offset));
offset += 2;
}
var res = new byte[len];
Array.Copy(data, offset, res, 0, len);
ret._tags.Add(tag, res);
offset += len;
}
return(ret);
}
public ReceivedWapMessage(byte[] data)
{
if (!Crc32Algorithm.IsValidWithCrcAtEnd(data))
{
throw new FormatException("CRC32 is wrong");
}
MessageType t = (MessageType)data[0];
if (!Enum.IsDefined(typeof(MessageType), t))
{
throw new FormatException("Unknown MessageType");
}
Type = t;
try
{
SequenceNumber = BitConverter.ToUInt64(data, 1);
}
catch (Exception e)
{
throw new FormatException("Could not parse sequence number");
}
try
{
// Parse Endpoint
byte endPointLength = data[9];
EndPoint = Encoding.UTF8.GetString(data, 10, endPointLength);
// get payload
ushort payloadLength = NumberConverter.ToUInt16(data, 10 + endPointLength);
Payload = data
.Skip(2) // type byte, endpoint length byte
.Skip(sizeof(ulong)) // Sequence number
.Skip(endPointLength) // end point length
.Skip(2) // payload length bytes
.Take(payloadLength).ToArray();
}
catch (Exception)
{
// TODO: Some more handling maybe?
throw;
}
}
public object DeserializePacket(Stream source, out int packetId, bool request = false)
{
byte[] data = new byte[PacketHeaderLength];
int readCount = source.Read(data, 0, PacketHeaderLength);
if (readCount != PacketHeaderLength)
{
throw new GameFrameworkException("Invalid Packet Header Length");
}
int length = BitConverter.ToInt32(data, 0);
byte[] packetData = new byte[length];
readCount = source.Read(packetData, 0, length);
if (readCount != length)
{
throw new GameFrameworkException("Invalid Packet Length");
}
object ret = null;
using (MemoryStream stream = new MemoryStream(packetData)) {
int idLength = stream.Read(data, 0, PacketHeaderLength);
if (idLength != PacketHeaderLength)
{
throw new GameFrameworkException("Invalid Packet Id Length");
}
packetId = BitConverter.ToInt32(data, 0);
Type packetType = GetPacketType((Protos.PacketType)packetId, request);
if (packetType == null)
{
throw new GameFrameworkException("Invalid Packet Id: " + packetId.ToString());
}
if (!Crc32Algorithm.IsValidWithCrcAtEnd(packetData, 0, length))
{
throw new GameFrameworkException("Invalid PacketData with Crc32");
}
stream.SetLength(length - 4);
ret = RuntimeTypeModel.Default.Deserialize(stream, null, packetType);
}
return(ret);
}
private void start()
{
int numBytesRead = 0;
int msgOffset = 0;
while (_isProcessing)
{
var n = ReadFromStream(prelude);
numBytesRead += n;
n = ReadFromStream(preludeCRC);
var preludeCRCBytes = preludeCRC.ToArray();
if (BitConverter.IsLittleEndian)
{
Array.Reverse(preludeCRCBytes);
}
numBytesRead += n;
var inputArray = new byte[prelude.Length + 4];
System.Buffer.BlockCopy(prelude, 0, inputArray, 0, prelude.Length);
// write real data to inputArray
Crc32Algorithm.ComputeAndWriteToEnd(inputArray); // last 4 bytes contains CRC
// transferring data or writing reading, and checking as final operation
if (!Crc32Algorithm.IsValidWithCrcAtEnd(inputArray))
{
throw new ArgumentException("invalid prelude CRC");
}
if (!Enumerable.SequenceEqual(inputArray.Skip(prelude.Length).Take(4), preludeCRCBytes))
{
throw new ArgumentException("Prelude CRC Mismatch");
}
var bytes = prelude.Take(4).ToArray();
if (BitConverter.IsLittleEndian)
{
Array.Reverse(bytes);
}
int totalLength = BitConverter.ToInt32(bytes, 0);
bytes = prelude.Skip(4).Take(4).ToArray();
if (BitConverter.IsLittleEndian)
{
Array.Reverse(bytes);
}
int headerLength = BitConverter.ToInt32(bytes, 0);
int payloadLength = totalLength - headerLength - 16;
var headers = new byte[headerLength];
var payload = new byte[payloadLength];
int num = ReadFromStream(headers);
if (num != headerLength)
{
throw new IOException("insufficient data");
}
num = ReadFromStream(payload);
if (num != payloadLength)
{
throw new IOException("insufficient data");
}
numBytesRead += num;
num = ReadFromStream(messageCRC);
var messageCRCBytes = messageCRC.ToArray();
if (BitConverter.IsLittleEndian)
{
Array.Reverse(messageCRCBytes);
}
// now verify message CRC
inputArray = new byte[totalLength];
System.Buffer.BlockCopy(prelude, 0, inputArray, 0, prelude.Length);
System.Buffer.BlockCopy(preludeCRC, 0, inputArray, prelude.Length, preludeCRC.Length);
System.Buffer.BlockCopy(headers, 0, inputArray, prelude.Length + preludeCRC.Length, headerLength);
System.Buffer.BlockCopy(payload, 0, inputArray, prelude.Length + preludeCRC.Length + headerLength, payloadLength);
// write real data to inputArray
Crc32Algorithm.ComputeAndWriteToEnd(inputArray); // last 4 bytes contains CRC
// transferring data or writing reading, and checking as final operation
if (!Crc32Algorithm.IsValidWithCrcAtEnd(inputArray))
{
throw new ArgumentException("invalid message CRC");
}
if (!Enumerable.SequenceEqual(inputArray.Skip(totalLength - 4).Take(4), messageCRCBytes))
{
throw new ArgumentException("message CRC Mismatch");
}
Dictionary <String, String> headerMap = extractHeaders(headers);
string value = null;
if (headerMap.TryGetValue(":message-type", out value))
{
if (value.Equals(":error"))
{
string errorCode = null;
string errorMessage = null;
headerMap.TryGetValue(":error-code", out errorCode);
headerMap.TryGetValue(":error-message", out errorMessage);
throw new SelectObjectContentException(errorCode + ":" + errorMessage);
}
}
if (headerMap.TryGetValue(":event-type", out value))
{
if (value.Equals("End"))
{
// throw new UnexpectedShortReadException("Insufficient data");
this._isProcessing = false;
break;
}
if (value.Equals("Cont") || payloadLength < 1)
{
continue;
}
if (value.Equals("Progress"))
{
ProgressMessage progress = new ProgressMessage();
using (var stream = new MemoryStream(payload))
progress = (ProgressMessage) new XmlSerializer(typeof(ProgressMessage)).Deserialize(stream);
this.Progress = progress;
}
if (value.Equals("Stats"))
{
Console.WriteLine("payload|" + Encoding.UTF7.GetString(payload));
StatsMessage stats = new StatsMessage();
using (var stream = new MemoryStream(payload))
stats = (StatsMessage) new XmlSerializer(typeof(StatsMessage)).Deserialize(stream);
this.Stats = stats;
}
if (value.Equals("Records"))
{
this.Payload.Write(payload, 0, payloadLength);
continue;
}
}
}
this._isProcessing = false;
this.Payload.Seek(0, SeekOrigin.Begin);
this.payloadStream.Close();
}
