public void TestDecoding()
{
Assert.True(decoded1.SequenceEqual(COBS.Decode(encoded1)));
Assert.True(decoded2.SequenceEqual(COBS.Decode(encoded2)));
Assert.True(decoded3.SequenceEqual(COBS.Decode(encoded3)));
Assert.True(decoded4.SequenceEqual(COBS.Decode(encoded4)));
Assert.True(decoded5.SequenceEqual(COBS.Decode(encoded5)));
Assert.True(decoded6.SequenceEqual(COBS.Decode(encoded6)));
Assert.True(decoded7.SequenceEqual(COBS.Decode(encoded7)));
Assert.True(decoded8.SequenceEqual(COBS.Decode(encoded8)));
Assert.True(decoded9.SequenceEqual(COBS.Decode(encoded9)));
}
/// <summary>
/// Threaded function. Loops and checks for incoming packets.
/// </summary>
private void ReceiveThreadDoTask()
{
try
{
byte[] receiveBuffer = new byte[bufferSize];
int bytesReceived = 0;
while (running)
{
while (sendPackets.Count > 0)
{
byte[] serialPacket;
lock (sendLockObject)
{
serialPacket = sendPackets.Dequeue();
}
stream.Write(serialPacket, 0, serialPacket.Length);
}
if (stream.BytesToRead > 0)
{
int x = stream.ReadByte();
if (x == -1)
{
// Debug.LogError("End of Stream!");
// running = false;
continue;
}
if (x == 0)
{
// decode
byte[] decodedBuffer = new byte[receiveBuffer.Length];
int decodedBufferSize = COBS.Decode(ref receiveBuffer, bytesReceived, ref decodedBuffer);
Array.Resize(ref decodedBuffer, decodedBufferSize);
// disect packt
int len = decodedBuffer[0] | (decodedBuffer[1] << 8);
int checksum = decodedBuffer[2] | (decodedBuffer[3] << 8);
int cmd = decodedBuffer[4];
ArduinoDataType dataType = (ArduinoDataType)decodedBuffer[5];
byte[] dataPacket = new byte[decodedBuffer.Length - headerSize];
Array.Copy(decodedBuffer, headerSize, dataPacket, 0, decodedBufferSize - headerSize);
// check length
if (dataPacket.Length != len)
{
Debug.Log(String.Format("Invalid Packet Length. Want: {0} - Have: {1}", len, dataPacket.Length));
continue;
}
// checksum
int packetChecksum = Crc16.ComputeChecksum(dataPacket);
if (checksum != packetChecksum)
{
Debug.Log(String.Format("Invalid Checksum. Want: {0} - Have: {1}", checksum, packetChecksum));
continue;
}
bytesReceived = 0;
// store in queue
lock (receiveLockObject)
{
receivedPackets.Enqueue(new ArduinoBuffer(cmd, dataType, dataPacket));
}
}
else
{
if (bytesReceived >= bufferSize)
{
// TODO handle differently!
bytesReceived = 0;
}
else
{
receiveBuffer[bytesReceived++] = (byte)x;
}
}
}
}
}
catch (ThreadAbortException ex)
{
Debug.Log("Aborting UDP Receiver Thread!");
// Debug.LogException(ex);
}
}
public void Decoding10()
{
byte[] expected10 = COBS.Decode(encoded10);
Assert.IsTrue(expected10.SequenceEqual(decoded10));
}
public void Decoding8()
{
byte[] expected8 = COBS.Decode(encoded8);
Assert.IsTrue(expected8.SequenceEqual(decoded8));
}
public void Decoding9()
{
byte[] expected9 = COBS.Decode(encoded9);
Assert.IsTrue(expected9.SequenceEqual(decoded9));
}
public void Decoding6()
{
byte[] expected6 = COBS.Decode(encoded6);
Assert.IsTrue(expected6.SequenceEqual(decoded6));
}
public void Decoding7()
{
byte[] expected7 = COBS.Decode(encoded7);
Assert.IsTrue(expected7.SequenceEqual(decoded7));
}
public void Decoding5()
{
byte[] expected5 = COBS.Decode(encoded5);
Assert.IsTrue(expected5.SequenceEqual(decoded5));
}
public void Decoding4()
{
byte[] expected4 = COBS.Decode(encoded4);
Assert.IsTrue(expected4.SequenceEqual(decoded4));
}
public void Decoding3()
{
byte[] expected3 = COBS.Decode(encoded3);
Assert.IsTrue(expected3.SequenceEqual(decoded3));
}
public void Decoding2()
{
byte[] expected2 = COBS.Decode(encoded2);
Assert.IsTrue(expected2.SequenceEqual(decoded2));
}
public void Decoding1()
{
byte[] expected1 = COBS.Decode(encoded1);
Assert.IsTrue(expected1.SequenceEqual(decoded1));
}
