In the previous post we've seen how to send and receive data on the serial port with Python and plot it live using a pretty GUI.
Notice that the sender script (sender_sim.py) is just sending one byte at a time. The "chunks" of data in the protocol between the sender and receiver are single bytes. This is simple and convenient, but hardly sufficient in the general sense. We want to be able to send multiple-byte data frames between the communicating parties.
However, there are some challenges that arise immediately:
- The receiver is just receiving a stream of bytes from the serial port. How does it know when a message begins or ends? How does it know how long the message is?
- Even more seriously, we can not assume a noise-free channel. This is real, physical hardware stuff. Bytes and whole chunks can and will be lost due to electrical noise. Worse, other bytes will be distorted (say, a single bit can be flipped due to noise).
To see how this can be done in a safe and tested manner, we first have to learn about the basics of the Data Link Layer in computer networks.
Let's now see a completely worked-out example that demonstrates how this works.
Suppose we define the following protocol:
- Start flag: 0x12
- End flag: 0x13
- Escape (DLE): 0x7D
And the sender wants to send the following data message (let's ignore its contents for the sake of the example - they're really not that important). The original data is in (a):
The data contains two flags that need to be escaped - an end flag at position 2 (counting from 0, of course!), and a DLE at position 4.
The sender's data link layer  turns the data into the frame shown in (b) - start and end flags are added, and in-message flags are escaped.
Let's see how the receiver handles such a frame. For demonstration, assume that the first byte the receiver draws from the serial port is not a real part of the message (we want to see how it handles this). In the following diagram, 'Receiver state' is the state of the receiver after the received byte. 'Data buffer' is the currently accumulated message buffer to pass to an upper level:
A few things to note:
- The "stray" byte before the header is ignored: according to the protocol each frame has to start with a header, so this isn't part of the frame.
- The start and end flags are not inserted into the data buffer
- Escapes (DLEs) are correctly handled by a special state
- When the frame is finished with an end flag, the receiver has a frame ready to pass to an upper level, and comes back waiting for a header - a new frame.
Finally, we see that the message received is exactly the message sent. All the protocol details (flags, escapes and so on) were transparently handled by the data link layer .
There are several methods of handling framing in communications, although most are unsuitable to be used on top of the serial port. Among the ones that are suitable, the most commonly used is byte stuffing. By defining a couple of "magic value" flags and careful rules of escaping, this framing methods is both robust and easy to implement as a software layer. It is also widely used as PPP depends on it.
Finally, it's important to remember that for a high level of robustness, it's required to add some kind of error checking into the protocol - such as computing a CRC on the message and appending it as the last word of the message, which the receiver can verify before deciding that the message is valid.
|||The Data Link Layer is layer 2 in the OSI model. In the TCP/IP model it's simply called the "link layer".|
|||The serial port can be configured to add parity bits to bytes. These days, this option is rarely used, because:|
- A single parity bit isn't a very strong means of detecting errors. 2-bit errors fool it.
- Error handling is usually done by stronger means at a higher level.
|||For example Ethernet (802.3) uses 12 octets of idle characters between frames.|
|||You might run into the term DLE - Data Link Escape, which means the same thing. I will use the acronyms DLE and ESC interchangeably.|
|||Just like quotes and escape characters in strings! In C: "I say \"Hello\"". To escape the escape, repeat it: "Here comes the backslash: \\ - seen it?"|
|||I'd love to hear why this XOR-ing is required. One simple reason I can think of is to prevent the flag and escape bytes appearing "on the line" even after they're escaped. Presumably this improves resynchronization if the escape byte is lost?|
|||Which is just a fancy way to say "a protocol wrapping function", since the layer is implemented in software.|
|||Such transparency is one of the greatest ideas of layered network protocols. So when we implement protocols in software, it's a good thing to keep in mind - transparency aids modularity and decoupling, it's a good thing.|