CAN Bus. Built for Noise, Multi-Master, and 30 Years of Automotive Abuse

In the mid-1980s, Bosch needed a way to let dozens of ECUs in a car share data without stringing individual wires between every pair of nodes. The solution had to survive ignition noise, temperature swings from −40°C to 125°C, and cable runs of several metres. That's CAN. It's been in every car sold in Europe since 1993, and it shows up in industrial machinery, medical devices, and robotics for exactly the same reasons.

The two things that make CAN unusual compared to everything else in this series: it uses a differential pair (not single-ended signals), and it has non-destructive arbitration. multiple nodes can start transmitting at the same time and the protocol resolves the conflict automatically, without either frame being corrupted.

Differential signaling. why CAN ignores noise

Single-ended signals (like TTL UART or I2C) are measured relative to ground. If a noise spike hits the wire, the receiver sees it as a voltage change and may misinterpret the bit. CAN measures the difference between two wires, CAN-H and CAN-L.

State      CAN-H    CAN-L    H − L
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Recessive   2.5V    2.5V      0V   → logic 1
Dominant    3.5V    1.5V     +2V   → logic 0

If a noise spike adds 1V to both wires, CAN-H becomes 3.5+1 and CAN-L becomes 1.5+1. The difference is still 2V. The receiver sees nothing wrong. This is called common-mode rejection and it's the reason CAN can run metres of unshielded twisted pair through an engine compartment.

Rendering diagram...

The 120Ω termination resistors at both ends of the bus are not optional. Without them, the signal reflects at the cable end and creates a ghost copy of every transmitted bit. On short benchtop setups this might not cause obvious problems. then you put it in an enclosure with a 2-metre cable and suddenly nothing works. Check termination first when debugging a CAN problem.

Frame structure. messages, not addresses

CAN doesn't have device addresses. It has message IDs. Every node on the bus sees every frame and decides independently whether it cares about it based on the ID.

┌─────┬──────────────┬─────┬──────┬──────────┬──────┬─────┬─────┐
│ SOF │  11-bit ID   │ RTR │ DLC  │ 0–8 data │ CRC  │ ACK │ EOF │
└─────┴──────────────┴─────┴──────┴──────────┴──────┴─────┴─────┘

• SOF (Start of Frame): one dominant bit to wake up receivers
• ID: 11 bits in standard CAN, 29 bits in extended. Lower ID = higher priority.
• DLC: Data Length Code, 0–8 bytes
• CRC: 15-bit polynomial, catches almost all burst errors
• ACK: any correctly-receiving node pulls ACK low. the transmitter verifies this

Non-destructive arbitration

This is the elegant part. When two nodes start transmitting at the same time, they both watch the bus while they transmit. CAN has a physical property: a dominant bit (0) always wins over a recessive bit (1). any node driving dominant swamps any node driving recessive.

So as each node transmits its ID bit by bit, it reads back what's actually on the bus. If it transmitted a 1 but reads a 0, it knows another node sent a dominant bit. that node has a lower ID, and therefore higher priority. The losing node stops immediately and retries after the winning frame ends.

Rendering diagram...

The key word is non-destructive. Node B's frame is never corrupted. Node A's frame isn't lost. it just gets queued. No controller needed, no token passing, no collision detection with retransmission penalty. Lower ID wins immediately, every time.

Error detection. five layers

CAN has five independent mechanisms:

1. CRC check: the receiver recomputes the CRC and compares
2. Frame check: certain bits in the frame have fixed values; wrongs values flag an error
3. ACK check: if no node pulls ACK low, the transmitter knows nobody received it
4. Bit monitoring: each transmitting node reads back its own bits
5. Bit stuffing: after 5 identical bits, a complement bit is inserted. Any violation is an error.

When any of these fails, the detecting node immediately transmits an error frame, which destroys the current message. The sender retries. This happens fast enough that higher-level software usually never sees it.

Fault confinement. broken nodes can't kill the bus

Rendering diagram...

A node that keeps generating errors gets progressively silenced. At Bus Off it stops transmitting entirely. the rest of the bus keeps running. This is why a shorted CAN node in a car doesn't necessarily disable everything. It's a design decision baked into the protocol, not an add-on.

CAN FD (Flexible Data-rate) extends the data payload to 64 bytes and allows the data phase to run faster than the arbitration phase. up to 8Mbps for data. Same electrical layer, same arbitration, just bigger and faster frames. If you're designing something new and CAN is the right choice, CAN FD is worth using from the start.