CAN Bus vs RS485 for Service Robot Battery Packs: Choosing the Interface You Can Support for a Decade
At a glance: CAN and RS485 share a wire and little else. The choice is not about which is faster, it is about who owns the message definitions four years from now, what happens when a replacement pack arrives with a different baud rate, and whether your field team can diagnose a bus fault without a protocol analyser. This article compares the two on the quantities a robot pack actually reports, gives the object and register maps side by side, and lists the five lines that belong in the purchase specification.
Most battery specifications for service robots arrive as a single line: “RS485 communication”. It is a safe-looking line and it hides a decade of consequences. RS485 is a physical layer, so the specification has told you how the electrons travel and nothing about what they mean. Two vendors can both ship “RS485 communication” and neither pack will talk to the other's charger, because one used Modbus RTU with a proprietary register map and the other used a plain ASCII protocol behind a vendor identity byte. CAN is no better on its own — it is also only a data link layer — but the service-robot world has converged on CANopen profiles that make the pack a describable object rather than a black box.
This matters more on a robot than on a vehicle, because a robot pack is a consumable. It is swapped, reordered, superseded, and occasionally supplied by a second source when the original is out of stock. Every one of those events is a test of the interface you specified in year one. What follows is the comparison we would want if we were on the buying side of it.

Why the Bus Choice Outlives the Robot
The robot chassis has a service life of seven to ten years. The pack in it does not. On a commercial cleaning or delivery fleet, packs are cycled hard enough that the first replacement typically lands in year two or three, and the fleet that started on one pack model often ends up on a second and third as the original is discontinued. The protocol is the only part of that chain that has to be stable across all three.
That produces an asymmetry most procurement teams miss. The cost of a slightly more expensive CAN-capable BMS is a one-off. The cost of discovering in year four that replacement packs speak a variant your fleet software does not parse is a re-integration project, and it lands at the worst possible moment — mid-life, with 60 units in service and a warranty conversation already open.
There is a second, quieter cost. Every protocol your field team cannot read is a truck roll. A pack that reports a plausible state of charge but has one cell group drifting will pass a visual inspection and fail three weeks later; the difference between catching that with a laptop and a CAN dongle, and catching it after a roadside stoppage, is entirely a function of whether the diagnostic objects were standardised.
The Electrical Differences That Decide It
The short answer: CAN is a multi-master differential bus with hardware arbitration, automatic retransmission and per-node error confinement, defined by ISO 11898-2 at the transceiver level; RS485 is a differential physical layer with no framing, no arbitration and no error handling, so every one of those properties has to be supplied by the protocol and the software above it. CAN gives you the robustness in silicon, RS485 makes you build it.
That single difference drives the practical consequences:
| Property | CAN / CANopen | RS485 / Modbus RTU |
|---|---|---|
| Framing & arbitration | In hardware; 11-bit or 29-bit identifiers, priority by ID | None at the wire; master polls each slave in turn |
| Multi-master | Yes, any node may transmit when the bus is idle | No, one master; slaves only answer |
| Error detection | CRC-15, bit stuffing, acknowledgement per frame | CRC-16 in Modbus; no acknowledgements at the physical layer |
| Node behaviour on fault | Error counters in hardware; node detaches after 255 errors (bus-off) and can recover | Node keeps transmitting garbage; behaviour is whatever the application implements |
| Typical robot bitrate | 250 kbit/s or 500 kbit/s (max 1 Mbit/s truncated for stub length) | 19,200 or 115,200 bit/s (9600 for long trunks) |
| Practical trunk length | ~40 m at 1 Mbit/s, 250 m at 250 kbit/s | ~1,200 m at 9600 bit/s, ~100 m at 115 kbit/s |
| Termination | 120 Ω at both ends, stubs under 0.3 m | 120 Ω at both ends, daisy chain, no star |
| Isolation | Standard on 2.5 kV and 5 kV transceivers | Optional; must be specified explicitly |
| Standard data model | CiA 301 object dictionary; CiA 418/419 for batteries | None. Register map is vendor-defined. |
The bitrate row is where the honest engineering conversation happens. A CAN bus at 500 kbit/s moves a 100 A current reading in under a millisecond; that is fast enough to catch a contactor weld before the second sample. A Modbus RTU loop at 19,200 bit/s polling 8 packs takes roughly 100 ms per full sweep, which is fine for state of charge and far too slow for protection. In practice nobody relies on the comms bus for protection — the BMS trips locally — but a specification that claims “real-time monitoring” over a polled RS485 loop is claiming something the wire cannot deliver.
What the Same Data Looks Like on Each Bus
This table is the part of the comparison that is genuinely hard to find elsewhere, because vendor documentation describes one protocol and never the other. The quantities are the ones a service robot's fleet layer actually consumes. CANopen addresses are from the manufacturer-specific range of the object dictionary, which is where most pack vendors place their extended data — CiA 418 covers the standard set and nearly every vendor extends it.
| Quantity | CANopen object | Modbus holding register | Typical scaling |
|---|---|---|---|
| State of charge | 0x2000 sub 1 (or CiA 418 0x2A00) | 0x0000 | 0.1 % or 1 %, unsigned |
| Pack voltage | 0x2001 sub 1 | 0x0001 | 10 mV or 1 mV, unsigned |
| Pack current | 0x2001 sub 2 | 0x0002 | 10 mA, signed, + = charge |
| Cell temperatures (4) | 0x2002 sub 1–4 | 0x0004–0x0007 | 0.1 °C, signed offset −40 |
| State of health | 0x2003 sub 1 | 0x0008 | 1 %, unsigned |
| Cycle count | 0x2003 sub 2 | 0x0009–0x000A | 1 cycle, 32-bit over two registers |
| Cell voltage min / max | 0x2004 sub 1 / 2 | 0x000E / 0x000F | 1 mV, unsigned |
| Charge / discharge MOS state | 0x2005 sub 1 / 2 | 0x0012 bits 0–1 | 0 = open, 1 = closed |
| Protection flags | 0x2006 (bitfield) | 0x0013 (bitfield) | 16 defined bits |
| Firmware version | 0x100A (identity object) | 0x00F0 | ASCII 2 chars per register |
Two things are worth noticing. First, the CANopen column carries structure: the object dictionary is self-describing, so a tool can enumerate what a pack supports and read the data type and scaling without a vendor document. The Modbus column carries nothing but addresses, so the meaning lives entirely in a PDF, and if the PDF is for revision B and the pack is revision C, you find out by reading a wrong number rather than by getting an error.
Second, multi-register values behave differently. A 32-bit cycle count split across two Modbus registers can be torn — read the low word, get an increment, then read the high word, and the pair describes a value that never existed. The fix is to read both in one request and validate, or to place the 32-bit value at an address the vendor guarantees is updated atomically. CANopen avoids the problem by putting the value in a single object with a declared 32-bit type.


Termination, Addressing and the Pack-Swap Problem
Both buses need 120 Ω at each end of the trunk, and both fail in the same way when they do not get it: intermittent errors that appear under vibration and disappear on the bench. CAN is more forgiving of a missing terminator at low bitrate and less forgiving of a long stub; RS485 tolerates a stub and not a star topology. Neither tolerates a third terminator in the middle, which is exactly what happens when a replacement pack ships with one factory-fitted because the vendor assumes a point-to-point link.
The addressing question is where multi-pack robots get interesting. A cleaning robot with a swappable pack and a stationary spare charger may have two packs on one bus, and they cannot both answer to the same node ID.
- CANopen sets the node ID with a DIP switch or a stored parameter, typically in the range 1–127. The node ID also determines the default COB-IDs for its PDOs and heartbeats, so two packs at the same ID do not just collide, they collide in a way that makes both look alive and both look wrong.
- Modbus RTU uses slave addresses 1–247, usually set the same way. A duplicate address produces a timeout on every poll of that address, which at least fails loudly.
The practical answer is a documented addressing scheme and a physical label on every pack: pack 1 is node 1, charger-resident pack is node 2, and the spare that lives in the van is set to node 1 or 2 before it leaves the depot. The failure this prevents is subtle and expensive — a swapped pack that joins the bus with a duplicate ID can shadow the healthy pack's data, so the fleet layer reports a plausible state of charge from the wrong battery.
Five Questions to Put in the Purchase Specification
These are the lines that convert a vague interface promise into something enforceable. Ask them of every pack vendor, and expect a document, not an answer.
- Who owns the message definitions? For CANopen, is there an EDS/DBC file, and will the vendor supply it with a version number and keep it current? For Modbus, is there a register map with scaling, data types, byte order and the revision it applies to? An interface without a machine-readable definition is not an interface, it is an informal arrangement.
- What is the default baud rate and can it be changed without vendor software? A pack that defaults to 250 kbit/s and can only be reconfigured with a Windows tool the integrator does not have is a pack you cannot drop into an existing bus.
- What is the heartbeat and timeout behaviour? CANopen uses a heartbeat producer or node guarding; a fleet layer needs to know the interval and what the pack does when the master goes quiet. Absent this, packs either reboot on a brief network hiccup or continue on stale commands.
- Which transceiver part number, and what isolation? For RS485 this is the single most predictive line in the datasheet. A non-isolated transceiver on a robot with a 48 V traction system and a motor drive is a latent failure. Specify the part family and the isolation voltage.
- What happens on a hot swap? Does the pack re-enumerate cleanly, does it clear its fault latch, and does it report a plausible state of charge immediately or after a full cycle? A pack that reports 100 % for the first ten minutes after a swap will strand a robot.
When RS485 Is Still the Right Answer
RS485 is not the wrong choice; it is the cheaper choice with a narrower correctness envelope. It remains the right answer in three situations.
Legacy fleets. If the site already runs 40 robots on Modbus RTU packs and the CMMS already parses those registers, moving to CANopen is a data-migration project with no operational upside. Keep the interface, and insist on the register map being formally revisioned.
Long trunks with cheap nodes. A parking structure with charging bays at 200 m intervals and a single polled loop is an RS485 problem, and CAN at 250 kbit/s would need repeaters to cover the same distance.
When the integrator owns both ends. If the same team builds the pack interface and the fleet layer, the absence of a standard data model costs nothing, because the mapping lives in code under version control. The cost of RS485 appears when the two ends come from different companies, which is the normal case in a growing fleet.
What you give up either way is speed and error confinement. Budget for it: if the bus is polled, do not design any feature that depends on sub-100 ms refresh, and make sure protection decisions are made inside the pack, not in the fleet layer.

Failure Modes You Will Actually See
Whichever bus is specified, the same short list of faults accounts for most downtime. Knowing them in advance is what turns a fault from an outage into a ticket.
Bus-off with no recovery. A CAN node that accumulates 255 transmit errors detaches itself. Most stacks recover automatically after the bus-idle condition, but some do not, and the pack then appears dead to the robot while its own LEDs show normal operation. Ask the vendor explicitly whether automatic bus-off recovery is enabled and what the recovery time is.
Stale state of charge after a swap. The most common field complaint on swappable-pack robots. The pack's fuel gauge needs a few minutes under load to converge after a swap, and in that window it reports either full or a value carried over from its last session. The robot then either leaves with a pack that is nearly empty or refuses to leave with a full one. Mitigation is a short load pulse at swap and a fleet rule that ignores state of charge for the first two minutes.
CRC and exception counters climbing. On Modbus, an exception response or a CRC error rate above roughly one in a thousand polls indicates a wiring problem — a missing terminator, a stub, or a shield bonded at both ends and now carrying a ground loop. The numbers are in the protocol; the mistake is not logging them. A fleet layer that records exception counts per pack turns a mysterious intermittent into a maintenance action.
A third-party pack that talks but disagrees. The quietest failure. A replacement pack with the correct node ID and baud rate but a different register scaling reports temperatures in whole degrees where the fleet expects tenths, so every reading looks plausible and every thermal trend is wrong by 10×. This is the argument for checksummed identity objects and for a fleet layer that rejects values outside a sanity envelope rather than trusting them.

What This Means for a Specification
For a new fleet where the pack and the fleet software come from different suppliers, specify CAN with CANopen and require an EDS. The object dictionary is worth more than the bitrate, because it is what makes a replacement pack a swap rather than a project. Require the EDS version in the acceptance documents, and test it by plugging in a pack from a different production lot during commissioning.
For a fleet that is already on RS485, do not rewrite the bus. Instead formalise what is informal: get the register map under revision control, log exception counters per pack, and write the five specification questions into the next supply agreement so the fourth pack generation does not arrive undocumented. The RS485 interface details worth specifying in depth are covered in our guide to RS485 battery specifications for service robots, and the wider protocol landscape including BMS register mapping and charge-dock handshaking is in service robot battery communication protocols.
Either way, the interface is a ten-year commitment attached to a two-year consumable. Treat the choice as a procurement decision with a maintenance tail, not as an electrical detail, and the fourth pack generation will be a purchase order instead of an integration programme.
