{

mMaxPacketLen = 10000;

mRxReadPtr = 0;

mRxWritePtr = 0;

mBytesLeft = 0;

mBufferLen = mMaxPacketLen + 8;

mRxBuffer = new unsigned char[mBufferLen];

{

if (data.size() == 0 || data.size() > (int)mMaxPacketLen) {

return;

}

QByteArray to_send;

unsigned int len_tot = data.size();

if (len_tot <= 255) {

to_send.append((char)2);

to_send.append((char)len_tot);

} else if (len_tot <= 65535) {

to_send.append((char)3);

to_send.append((char)(len_tot >> 8));

to_send.append((char)(len_tot & 0xFF));

} else {

to_send.append((char)4);

to_send.append((char)((len_tot >> 16) & 0xFF));

to_send.append((char)((len_tot >> 8) & 0xFF));

to_send.append((char)(len_tot & 0xFF));

}

unsigned short crc = crc16((const unsigned char*)data.data(), len_tot);

to_send.append(data);

to_send.append((char)(crc >> 8));

to_send.append((char)(crc & 0xFF));

to_send.append((char)3);

emit dataToSend(to_send);

{

mRxReadPtr = 0;

mRxWritePtr = 0;

mBytesLeft = 0;

{

unsigned short cksum = 0;

for (unsigned int i = 0; i < len; i++) {

cksum = crc16_tab[(((cksum >> 8) ^ *buf++) & 0xFF)] ^ (cksum << 8);

}

return cksum;

{

QVector<QByteArray> decodedPackets;

for(unsigned char rx_data: data) {

unsigned int data_len = mRxWritePtr - mRxReadPtr;

// Out of space (should not happen)

if (data_len >= mBufferLen) {

mRxWritePtr = 0;

mRxReadPtr = 0;

mBytesLeft = 0;

mRxBuffer[mRxWritePtr++] = rx_data;

continue;

}

// Everything has to be aligned, so shift buffer if we are out of space.

// (as opposed to using a circular buffer)

if (mRxWritePtr >= mBufferLen) {

memmove(mRxBuffer, mRxBuffer + mRxReadPtr, data_len);

mRxReadPtr = 0;

mRxWritePtr = data_len;

}

mRxBuffer[mRxWritePtr++] = rx_data;

data_len++;

if (mBytesLeft > 1) {

mBytesLeft--;

continue;

}

// Try decoding the packet at various offsets until it succeeds, or

// until we run out of data.

for (;;) {

int res = try_decode_packet(mRxBuffer + mRxReadPtr, data_len,

&mBytesLeft, decodedPackets);

// More data is needed

if (res == -2) {

break;

}

if (res > 0) {

data_len -= res;

mRxReadPtr += res;

} else if (res == -1) {

// Something went wrong. Move pointer forward and try again.

mRxReadPtr++;

data_len--;

}

}

// Nothing left, move pointers to avoid memmove

if (data_len == 0) {

mRxReadPtr = 0;

mRxWritePtr = 0;

}

}

foreach (QByteArray b, decodedPackets) {

emit packetReceived(b);

}

int *bytes_left, QVector<QByteArray> &decodedPackets)

{

*bytes_left = 0;

if (in_len == 0) {

*bytes_left = 1;

return -2;

}

unsigned int data_start = buffer[0];

bool is_len_8b = buffer[0] == 2;

bool is_len_16b = buffer[0] == 3;

bool is_len_24b = buffer[0] == 4;

// No valid start byte

if (!is_len_8b && !is_len_16b && !is_len_24b) {

return -1;

}

// Not enough data to determine length

if (in_len < data_start) {

*bytes_left = data_start - in_len;

return -2;

}

unsigned int len = 0;

if (is_len_8b) {

len = (unsigned int)buffer[1];

// No support for zero length packets

if (len < 1) {

return -1;

}

} else if (is_len_16b) {

len = (unsigned int)buffer[1] << 8 | (unsigned int)buffer[2];

// A shorter packet should use less length bytes

if (len < 255) {

return -1;

}

} else if (is_len_24b) {

len = (unsigned int)buffer[1] << 16 |

(unsigned int)buffer[2] << 8 |

(unsigned int)buffer[3];

// A shorter packet should use less length bytes

if (len < 65535) {

return -1;

}

}

// Too long packet

if (len > mMaxPacketLen) {

return -1;

}

// Need more data to determine rest of packet

if (in_len < (len + data_start + 3)) {

*bytes_left = (len + data_start + 3) - in_len;

return -2;

}

// Invalid stop byte

if (buffer[data_start + len + 2] != 3) {

return -1;

}

unsigned short crc_calc = crc16(buffer + data_start, len);

unsigned short crc_rx = (unsigned short)buffer[data_start + len] << 8

| (unsigned short)buffer[data_start + len + 1];

if (crc_calc == crc_rx) {

QByteArray res((const char*)(buffer + data_start), (int)len);

decodedPackets.append(res);

return len + data_start + 3;

} else {

return -1;

}