CAN FD: Longer Payloads, a Faster Data Phase, and the Loop That Must Close in Time

Classical CAN carries at most eight data bytes, and its bit rate is fixed for the whole frame because arbitration depends on every node reading the identifier at the same rate. Both limits are consequences of the same mechanism rather than arbitrary choices, and lifting them required changing the frame format in ways that are not backward compatible with classical controllers.

Two rates in one frame

The arbitration field has to be transmitted at the nominal rate, because every node must be able to participate in bit-level arbitration and read the identifier. Once arbitration is decided and only one transmitter remains, no node needs to override any bit, so the constraint that forced the slow rate disappears. CAN FD exploits that by switching to a higher data rate for the payload and the CRC, then switching back before the acknowledge slot, because the acknowledge must again be readable by every node at the nominal rate.

The incompatibility is carried by one bit. Classical CAN defines a reserved bit in the control field that a transmitter must send dominant. CAN FD reuses that position as a format bit and sends it recessive, which is precisely why a classical controller cannot accept an FD frame: it sees a recessive where its format requires dominant and raises a form error before it has read any payload. A second bit, later in the control field, requests the rate switch itself; a frame may keep the FD format and stay at the nominal rate throughout, which is how a segment whose transceivers or topology cannot tolerate the fast data phase still carries payloads longer than eight bytes. The format bit and the rate bit are separate decisions, and only the first is irreversible.

The switching points themselves are the tricky part of the design. A transmitter must switch to the data rate at a defined position, and every receiver must switch at the same position. Any mismatch means the receivers sample the data phase at the wrong times, and the frame is lost. The specification defines the switch positions relative to the bit boundaries and requires the transceiver to be fast enough to switch within the intervening time.

The payload length encoding

Eight bytes needs three bits. Sixty-four bytes needs six. CAN FD uses the four-bit field from classical CAN but reinterprets the values above eight, mapping them onto a small set of legal lengths: twelve, sixteen, twenty, twenty-four, thirty-two, forty-eight, and sixty-four. The gaps exist because the length field is only four bits and the designers chose to map the extra eight values onto useful sizes rather than to spend more bits on a precise length.

This has a practical consequence for the CRC. The check sequence length depends on the payload length, because a longer payload needs a stronger check to hold the same residual error probability. Classical CAN uses fifteen bits. CAN FD uses seventeen bits for payloads of sixteen bytes or fewer, and twenty-one bits above that. A receiver must know the payload length before it can check the CRC, and it takes the length from the control field, which is why the check is computed over a field that has already been decoded rather than over the raw bit stream.

Stuffing also moves. In classical CAN the rule applies from the start bit to the end of the CRC sequence. In CAN FD it applies from the start bit to the end of the data field, and then a four-bit stuff count field follows: three bits of count plus a parity bit, holding the number of stuff bits inserted so far modulo eight. Inside the CRC field, stuff bits sit at fixed positions every fourth bit rather than appearing dynamically, so that field has a constant length on the wire whatever the data values are. The declared count gives the receiver something to check: it can verify that it removed the same number of stuff bits the transmitter inserted, which catches a desynchronisation that would otherwise be discovered only when the CRC failed, or not at all.

The symmetry requirement that caps the rate

A transceiver in a CAN network does two things at once during arbitration: it drives the pair, and it reads the pair back to detect whether another node overrode it. That read-back has to complete within the bit time, which means the total delay through the transmitter, the cable, and the receiver must be shorter than one bit.

In the data phase there is no arbitration, so the read-back is not needed for that purpose. But the transceiver is still the same part, and the delay that mattered during arbitration does not disappear. What does matter is a different constraint: the signal must settle before the sample point, and any asymmetry between the two wires of the pair converts common-mode noise into a differential error and shifts the effective sample point.

The parameter that captures this is the symmetry of the differential output and of the receiver’s delay. A transceiver specified for classical CAN at 1 Mbit/s has a bit time of one microsecond, and its internal delays are a small fraction of that. At 5 Mbit/s the bit time is two hundred nanoseconds, and the same delays become a large fraction. Parts intended for FD therefore specify a tighter symmetry, and the achievable data rate is limited by the transceiver rather than by the controller.

This is why FD networks rarely run the data phase at the controller’s maximum. A network with long stubs, multiple connectors, or a star topology rather than a linear bus will show ringing at high data rates, and the ringing interacts with the sample point. The linear bus with short stubs that classical CAN recommends becomes a requirement rather than a preference.

The topology constraint also interacts with termination. The reflection behaviour described in differential signalling and bus termination does not change with rate, but the consequence of a reflection does: at a slow rate the reflection settles before the sample point, and at a fast rate it does not.

Why the acknowledge slot stays slow

The acknowledge field is transmitted at the nominal rate, and this is not an oversight. Every node that received the frame correctly must be able to drive the slot dominant, and every node must be able to see it. If the slot were at the data rate, a node whose transceiver is only fast enough for the nominal rate would be unable to acknowledge, and the transmitter would treat a correctly received frame as lost.

The same reasoning applies to the arbitration field at the start of the next frame. A node that has data to send must be able to begin transmitting at the nominal rate, and it must be able to arbitrate against other nodes. A design in which some nodes are FD-capable and others are not cannot work on a shared bus, because the classical nodes will destroy FD frames, and the FD nodes must still be able to talk to each other at the nominal rate.

The result is a frame whose duration is dominated by its slow parts when the payload is short. A frame with two data bytes gains almost nothing from a fast data phase, because the arbitration field, the control field, the CRC delimiters, the acknowledge, and the end-of-frame are all at the nominal rate. The benefit appears only as the payload grows, which is why FD is used for firmware transfer, calibration data, and aggregated sensor blocks rather than for single-value status messages.

/* duration = nominal-rate overhead plus a data-rate payload term */
static double can_fd_seconds(size_t payload,
                             double nominal_bits, double data_overhead_bits,
                             double nominal_rate, double data_rate)
{
    double data_bits = 8.0 * payload + data_overhead_bits;
    return nominal_bits / nominal_rate + data_bits / data_rate;
}

The two bit counts come from the frame layout for the chosen format and are best taken from a specification table rather than estimated. What the function makes plain is the shape: a fixed nominal-rate overhead plus a payload-proportional term at the fast rate. With eight bytes of payload and a data rate four times the nominal rate, the saving is modest, because the overhead term is paid at the slow rate and the payload term is only sixty-four bits. With sixty-four bytes the payload term dominates and the saving is substantial.

Coexistence and the migration problem

A network that must support both classical and FD nodes has one workable arrangement: separate buses, or a gateway that translates. A single bus cannot carry both, because the format bit that distinguishes them is the bit classical controllers reject, and an FD frame at the nominal rate is no more acceptable to them than one with a fast data phase.

The migration path in practice is a second bus for the FD traffic, or a full replacement of every node on the segment. A gateway that receives classical frames on one side and transmits FD frames on the other is possible, at the cost of latency and of losing the end-to-end arbitration properties: the gateway becomes a single point that must schedule both directions, and its queueing delay enters the response time of every message it forwards. A gateway also breaks the acknowledge semantics, because the transmitter’s acknowledge now comes from the gateway rather than from the node that will consume the data.

What FD does not change

The error handling machinery is unchanged in structure. Error counters, the three states, and fault confinement work the same way, with the same thresholds, because the failure modes they address are about a node’s behaviour rather than about the bit rate. The error types are the same, with the CRC extended and the stuffing rule modified in the CRC field. The behaviour described in error counters and fault confinement applies to an FD network without modification.

What changes is the timing analysis. A frame’s duration is no longer a function of its bit count at one rate, and the worst-case response time of a message depends on which frames are in progress, at which rates, and how the two rates interact with the queueing of lower-priority traffic. The blocking term that a lower-priority frame contributes is now a sum of two rates, and the analysis in message response time and queueing has to account for it.

The practical summary is that FD buys payload capacity and reduces the time spent moving large blocks, and it does not buy determinism, range, or node count. Those remain governed by the same physical layer and the same arbitration mechanism, at the same nominal rate.