CAN — the Controller Area Network — was designed by Robert Bosch GmbH in 1986 to solve a specific problem of that era: the wiring harnesses in luxury cars had become so heavy and so fault-prone that they were starting to be a vehicle-engineering bottleneck. The proposed solution was to replace point-to-point wiring with a shared serial bus that any controller could speak on. Forty years later, that bus is in every car you can buy, and the protocol has survived multiple waves of “modern” networking technologies (FlexRay, MOST, and now Automotive Ethernet) that were each supposed to replace it and each ended up living alongside it instead. There is a lesson in there about engineering durability.
This primer is the long-form monograph version — the one I wish someone had given me when I started writing CAN driver code and ended up debugging arbitration storms at 3 a.m. with a logic analyzer. It is for the engineer who needs more than a datasheet excerpt: who needs to know not just the frame format but why arbitration works the way it does, how bit timing is actually programmed on a controller, what error frames look like on the wire, why CAN-FD exists, and what the difference between SAE J1939 and ISO 15765 actually means in practice. Nine interactive demonstrations along the way: drag the bit timing parameters and watch the segment widths change; force two nodes to arbitrate and see who wins; inject an error and watch the bus state machine respond.
What it covers
Fourteen chapters. About forty-five minutes if you read straight through; designed to be reached for one chapter at a time.
Ch. 01 — Origins & why it still wins. Bosch, 1986. The problem CAN was designed to solve and the design choices that have given it forty-year longevity — multi-master, broadcast, message-based addressing, bit-level arbitration, hardware error detection.
Ch. 02 — The physical layer. Differential signalling on a twisted pair, dominant and recessive bits, the 120 Ω termination resistors and what happens when you forget one of them. ISO 11898-2 high-speed CAN, ISO 11898-3 fault-tolerant CAN, the common-mode range, and the practical bus-length-vs-bit-rate trade.
Ch. 03 — Anatomy of a frame. Standard (11-bit) and extended (29-bit) frames. The arbitration field, the control field, the data field, the CRC field, the ACK slot. Bit stuffing and why it makes timing analysis annoying. Remote, error, and overload frames.
Ch. 04 — Arbitration. The famous one. How CSMA/CR with bitwise non-destructive arbitration works, why the lowest-ID frame wins, why priority is therefore baked into the message ID, and the live demonstration where two nodes attempt to transmit simultaneously and you can watch one of them lose.
Ch. 05 — Bit timing & synchronisation. The hardest chapter for new engineers, and the most important. Synchronisation segment, propagation segment, phase segments 1 and 2, sample point, the resynchronisation jump width. Programming the timing registers on a real CAN controller. Interactive: drag the segment widths and watch the resulting bit and sample point shift.
Ch. 06 — Error handling & bus states. The five error types. Error active, error passive, bus off — the state machine that protects the bus from a single malfunctioning node. The transmit error counter and receive error counter, and how they get incremented and decremented.
Ch. 07 — CAN-FD and the path to CAN-XL. What CAN-FD is (Flexible Data-rate), why it exists (the 8-byte payload limit became painful), the new frame format, the dual-bit-rate phase, and where CAN-XL is headed.
Ch. 08 — Higher-layer protocols. CAN is a data-link layer; the higher layers that engineers actually program against are: SAE J1939 (commercial vehicles), CANopen (industrial automation), ISO 15765 (diagnostic over CAN — your OBD-II port), and increasingly UDS (Unified Diagnostic Services). Each is treated briefly: what it adds, where it’s used.
Ch. 09 — CAN in the EV architecture. The specific role CAN plays in an electric vehicle: BMS-to-VCU communication, inverter command and status, OBC charging-state machine, gateway routing to infotainment and ADAS. The bus topology of a typical EV, the bus segregation between safety-critical and convenience networks, and how Ethernet is starting to take over the bandwidth-hungry corners while CAN holds the rest.
Ch. 10 — Practical notes. The dozen things experienced CAN engineers do automatically that nobody writes down. Acknowledgment behavior on a single-node bench. Why your sniffer shows weird frames during reset. Why bit timing has to match exactly across nodes. The mistakes that cost a sample-rate budget.
Ch. 11 — CAN interface hardware. Vector VN-series, Kvaser, PEAK-PCAN, the open-source CANable, the silicon (TJA1050, MCP2515) — what they are, what they cost, where to use which.
Ch. 12 — XCP — Measurement & Calibration over CAN. The protocol that turns CAN into a debugging channel — letting you read and write live memory inside a running ECU, capture signals at sample rate, and re-tune calibration parameters without recompiling. The slave-master model, the DAQ lists, the role of A2L description files.
Ch. 13 — The tooling ecosystem. DBC files and what they describe. ARXML and how AUTOSAR sees the world. Vector CANalyzer, CANoe, CANape. The fact that the entire industry runs on a small number of file formats and an even smaller number of vendor tools.
Ch. 14 — CANape & CANoe. Two specific Vector tools worth knowing in detail. CANoe for residual bus simulation and ECU testing. CANape for measurement and calibration. The workflows that engineers actually use them for in production environments.
Read it
The monograph lives at its own URL with a warm-paper layout — Cormorant Garamond display, JetBrains Mono for everything technical, double-rule headers. Nine interactive demonstrations are wired up to the relevant chapters.
← Back to Autonomy