Best way to implement binary serial protocol in C++ [closed] - c++

Question

Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 2 years ago.
Improve this question
I'm implementing a serial binary protocol with C++ as following format:
| sync word (0xAA) | sync word (0xBB) | message length (2 bytes) | device id (4 bytes) | message type (1 byte) | timestamp (4 bytes) | payload (N bytes) | crc (2 bytes) |
For binary operation, I can only come up C-style way. For example, use memcpy to extract each field with pre-defined offset:
void Parse(string data) {
bool found_msg_head = false;
int i=0;
for (; I<data.size()-1; i++) {
if (data[i] == 0xAA && data[i+1] == 0xBB) {
found_msg_head = true;
break;
}
}
if (found_msg_head) {
uint16_t msg_length;
uint32_t device_id;
// declare fields ...
memcpy(&msg_length, data.c_str()+i+2, 2);
memcpy(&device_id, data.c_str()+i+4, 4);
// memcpy to each field ...
// memcpy crc and validate...
}
}
void SendMsg(const MyMsg& msg)
{
const uint16_t msg_len = sizeof(msg) + 16;
const uint32_t dev_id = 0x01
const uint32_t timestamp = (uint32_t)GetCurrentTimestamp();
const uint8_t msg_type = 0xAB;
char buf[msg_len];
buf[0] = 0xAA;
buf[1] = 0xBB;
memcpy(buf + 2, &msg_len, sizeof(msg_len));
memcpy(buf + 4, &dev_id, sizeof(dev_id));
memcpy(buf + 8, &timestamp, sizeof(timestamp));
memcpy(buf + 12, &msg_type, sizeof(msg_type));
memcpy(buf + 13, &g_msg_num, sizeof(g_msg_num));
memcpy(buf + 14, &msg, sizeof(msg));
uint16_t crc = CalculateCrc16((uint8_t*)buf, sizeof(DevSettingMsg) + 14);
memcpy(buf + sizeof(buf) - 2, &crc, 2);
std::string str(buf, sizeof(buf));
// send str to serial port or other end points...
}
Is there any better way to implement this kind of protocols with C or C++?
If I want to keep my C++ code in C++ style (i.e. use C++ STL only, no memcpy, no & for variable address), what's the equivalent of above C, C++ mixed code in C++ only?
Thanks.

Answer 1

The binary communication protocols are notorious for requiring lots of error-prone boilerplate code. I strongly recommend looking into existing libraries and/or code generation solutions, the CommsChampion Ecosystem could be a good fit.

Answer 2

I recommend documenting your protocol as well as possible.
The X11 protocol specification could be inspirational.
Did you consider re-using some existing communication protocol e.g. HTTP ? Do you care about communication between heterogenous systems and machines with different endianness and word sizes (e.g. a RaspberryPI communicating with an Arduino or a Linux/PowerPC or a Linux/x86-64 server)?
You could use C++ code generators like SWIG, or C code generators like RPCGEN, or in some cases write your own C++ code generator (perhaps with the help of GNU m4 or of GPP or GNU autoconf)
You may use (or adapt) existing C++ frameworks like VMIME (which implement mail related protocols)
You could use existing Web service protocols (HTTP like) with libraries like libonion or Wt.