Packet Design, Checksums, and Timeouts

A receiver that joins mid-stream, or loses a byte, must find the next packet boundary. Three common ways:

• Length field: a header byte gives the packet length. Simple, but one corrupted length makes the receiver misread everything after it; it needs a start marker and a check to recover.
• Delimiter with escaping: a reserved byte marks the end of a packet, and any occurrence of it in the data is replaced by an escape sequence. SLIP uses 0xC0 as END and escapes data bytes 0xC0 and 0xDB as 0xDB 0xDC and 0xDB 0xDD. After an error, the receiver simply waits for the next END.
• Idle gap: silence marks the boundary. Modbus RTU ends a frame after 3.5 character times of silence (fixed at 1750 µs above 19 200 baud). It needs no reserved bytes but requires the sender never to pause mid-packet and the receiver to time gaps precisely.

The sender appends a check value computed over the packet; the receiver recomputes it and discards the packet if it differs. An 8-bit sum of the bytes is cheap, but it cannot see bytes in the wrong order, and changes that add and subtract the same amount cancel.

A cyclic redundancy check treats the packet as a long binary polynomial and appends the remainder of dividing it by a fixed generator polynomial. It costs a little more (a table lookup per byte), and its detection is far stronger. A 16-bit CRC such as the one Modbus uses (generator x¹⁶ + x¹⁵ + x² + 1) detects every error burst up to 16 bits long, every odd number of flipped bits (its generator has x + 1 as a factor) and every pair of flipped bits in codewords up to 32 767 bits long. Random damage beyond that still slips through only about once in 2¹⁶ = 65 536 corrupted packets.

↑ This step uses the figure at the top of the page.

A CRC is identified by more than its polynomial: the initial value, bit order and final XOR must match at both ends. Check an implementation with the standard test message “123456789”: CRC-16/MODBUS gives 0x4B37.

A detected error only discards the packet; recovering it needs the protocol:

• the receiver acknowledges good packets (or the reply itself is the acknowledgement);
• the sender retries after a timeout, a bounded number of times, then reports the failure;
• sequence numbers let the receiver recognise a retry of a packet it has already executed (because only the reply was lost) and answer it again without acting twice. Alternatively, make commands idempotent: “set valve 3 to open” can be repeated safely; “toggle valve 3” cannot.

The request “device 1, read 10 holding registers from 0” is six bytes, 01 03 00 00 00 0A, followed by its CRC-16/MODBUS 0xCDC5 sent low byte first: C5 CD. Modbus RTU characters are 11 bits, so at 9600 baud each takes 1.146 ms. The 8-byte request takes 9.2 ms. The device waits t3.5 = 3.5 × 1.146 ≈ 4.0 ms of silence to see that the request has ended, takes up to 10 ms to process it, and replies with 5 + 2 × 10 = 25 bytes, 28.6 ms. The reply is complete

$$4.0 + 10 + 28.6 \approx 42.7\ \text{ms}$$

after the request ends. A 50 ms timeout leaves only 7 ms of margin; reading 60 registers (125 bytes, 143 ms) with the same timeout would fail every time.