RS-232 vs RS-485 vs CAN: Choosing an Industrial Serial Bus (Physical vs Protocol Layer Is the Key)
RS-232/RS-485/CAN aren’t three competing protocols but two layers: RS-232 (single-ended point-to-point) and RS-485 (differential multi-drop) are physical-layer only, needing a protocol (e.g. Modbus RTU) on top; CAN builds in the data-link layer (framing/arbitration/error handling). This guide explains that key difference and maps to GD32 CAN-FD (G5/H7/F5) and classical CAN (L235).
Not three rivals — two layers
RS-232, RS-485 and CAN are often treated as “three competing protocols,” but a more accurate view is that they sit at two different decision levels. RS-232 and RS-485 are only the “electrical/physical layer” — they just define how voltage moves on the wire, and you still have to add a communications protocol on top (such as Modbus RTU) to actually talk. CAN, by contrast, gives you “physical layer + data-link layer (protocol layer)” together — frame format, multi-master arbitration and error handling are written into the standard and done by the controller in hardware. This “layer” distinction is the most-confused point in industry and the key to selection: distance and node count push you from RS-232 to RS-485; needing built-in real-time multi-master + error handling pushes you to CAN.
RS-232 vs RS-485: single-ended point-to-point vs differential multi-drop
First, the two “pure physical layer” standards. RS-232 is single-ended signaling: each signal’s voltage is referenced to a common ground, so a shifting ground or a longer cable easily causes errors — making it a short-distance (~15m), low-speed, one-to-one (1 driver ↔ 1 receiver) point-to-point interface, typically used for consoles, instruments and legacy PC serial ports. RS-485 switches to differential signaling: it reads the voltage difference between two complementary wires of a twisted pair, so common-mode noise appears on both wires and cancels — giving strong noise immunity, reach to ~1200m, and a multi-drop bus: the standard is 32 unit loads, and with low-load (⅛-UL) receivers you can hang up to ~256 devices (more with repeaters). Top speed is ~10 Mbit/s, but the longer the cable the slower (rule of thumb: bit/s × meters ≤ 10⁸). It’s half-duplex (2-wire) by default; use 4 wires for full-duplex. Key point: the RS-485 standard explicitly “does not specify any communications protocol,” which is why it’s the physical layer beneath industrial Modbus RTU — RS-485 answers “how the wires connect,” Modbus answers “how the messages speak.”
CAN: differential + multi-master + built-in arbitration/error handling
CAN is fundamentally different from the other two: it is differential signaling (CAN_H / CAN_L, physical layer in ISO 11898-2), but the standard also includes a data-link layer (ISO 11898-1) — so it is a multi-master, message-based bus: any node may start transmitting when the bus is idle, and frames are addressed by “message identifier” rather than node address. Most crucially it has “non-destructive bitwise arbitration”: when two nodes transmit at once, the one with the lower (higher-priority) identifier wins without being corrupted or delayed; plus hardware-level error detection and fault confinement via CRC, bit-stuffing, ACK and error frames. In other words, RS-485 gives you “just the electrical layer, add your own protocol,” while CAN gives you “electrical + protocol layer together, with arbitration and error handling built in.” That’s why automotive and industrial control needing real-time priority and error handling prefer CAN.
⚠️ CAN vs CAN-FD and the GD32 map (L235 is classical-CAN only)
CAN itself splits into classical CAN and CAN-FD. Classical CAN carries up to 8 bytes per frame at up to ~1 Mbit/s (often run at 500 kbit/s); for a bigger payload (CAN-FD up to 64 bytes) or a faster data phase (typically ~5–8 Mbit/s, hardware-dependent, and only the data field speeds up) you move to CAN-FD (ISO 11898-1:2015). In GD32 terms: CAN-FD is supported on the GD32G5 (e.g. GD32G553), GD32H7 (e.g. GD32H759) and GD32F5 (F503/F505) series; ⚠️ the GD32L235 has only classical CAN 2.0, no CAN-FD — so if you need CAN-FD, be sure to avoid the L235. Also note: classical-CAN and CAN-FD nodes are not transparently interoperable (a classical node generates error frames when CAN-FD frames appear), so the whole bus must be CAN-FD-capable. (The actual number of CAN-FD modules per series varies by part — check that part’s datasheet.)
How to choose
The selection mindset: ask “layer” first — do I just need an electrical wire (physical layer), or do I need framing/arbitration/error handling too (protocol layer)? That single question separates RS-485 from CAN. Concretely: one-to-one, short distance, legacy equipment (console/instrument/old serial port) → RS-232. Long distance (to ~1200m), many devices on one line, electrically noisy site → RS-485 (remember it’s physical layer only, usually paired with Modbus RTU on top; use 4-wire for simultaneous send/receive). Need real-time, multi-master, message priority and hardware error handling → CAN; also need a big payload / higher throughput → CAN-FD. For the MCU: once you choose CAN-FD, pick from the GD32G5 / GD32H7 / GD32F5 series; low-power with only classical CAN, use the GD32L235; for RS-485/Modbus, pair an external RS-485 transceiver with the MCU’s UART. JLink Technology is an authorized GigaDevice distributor supplying the full range from classical CAN (GD32L235) to CAN-FD (GD32G5/H7/F5); tell us your bus type, distance, node count and real-time/payload needs and we will help with selection and reply with samples, datasheets and pricing.
Products mentioned
GD32G553 Cortex-M33 Digital-Power MCU
The GD32G553 is a high-performance Arm Cortex-M33 (with DSP and single-precision FPU) MCU in GigaDevice’s GD32G5 series at 216MHz, with 256~512KB dual-bank flash and 128KB SRAM (incl. TCMRAM). It integrates four 12-bit ADCs (up to 5.3MSPS), four DACs, eight high-speed comparators, three CAN-FD, a 16-channel high-resolution timer (145ps), and TMU/FAC/FFT math accelerators, with secure boot/AES and IEC 61508 SIL2 — for digital power, EV charging, energy-storage inverters, and servo motor control.
GD32H759 Arm Cortex-M7 600MHz High-Performance MCU
The GD32H759 is a high-performance Arm Cortex-M7 MCU from GigaDevice at 600MHz (L1 cache, double-precision FPU), with up to 3840KB Flash and 1024KB SRAM (ITCM/DTCM, ECC). It integrates 3× CAN-FD, dual Ethernet MAC (with EtherCAT), 2× USB HS/FS, 6× SPI, 2× OSPI, a TFT-LCD controller, and 14-bit ADC — for industrial automation, motor control, and graphical HMI. LQFP100/144/176, BGA.
GD32L235 Cortex-M23 Ultra-Low-Power MCU
The GD32L235 is an ultra-low-power 32-bit Arm Cortex-M23 MCU from GigaDevice at 64MHz, with 64~128KB flash / 12~24KB SRAM. Power is very low: ~66µA/MHz run, 1.8µA deep-sleep (<2µs wake), 0.26µA standby, with low-power LPUART and LPTIMER for always-on tasks. It integrates a 12-bit ADC, DAC and two comparators, USB 2.0 FS and CAN 2.0, in LQFP/QFN and WLCSP25. Versus the cataloged GD32L233, the L235 adds CAN and richer peripherals — for smart locks, metering, wearables, and battery management.
Need these components or design help?
JLink Technology provides parts, datasheets, and engineering support.
Request a Quote