Can Bus vs RS485 Bus: A Detailed Comparison

The popular buses currently are as follows:

Characteristics of CAN Bus:

1. An internationally standardized industrial field bus, reliable transmission, and high real-time performance; 2. Long transmission distance (up to 10Km) and fast transmission rate (up to 1MHz bps); 3. A single bus can connect up to 110 nodes, and it is easy to expand the number of nodes; 4. Multi-master structure, with equal status for all nodes, facilitating regional networking and high bus utilization; 5. High real-time performance, non-destructive bus arbitration technology, and no delay for high-priority nodes; 6. Faulty CAN nodes will automatically shut down and disconnect from the bus, without affecting bus communication; 7. Messages are short frame structures with hardware CRC checks, low probability of interference, and extremely low data error rates; 8. Automatic detection of message transmission success or failure, with hardware automatic retransmission, ensuring high transmission reliability; 9. Hardware message filtering function, only receiving necessary information, reducing CPU load, and simplifying software programming; 10. Communication media can use ordinary twisted pairs, coaxial cables, or optical fibers; 11. The CAN bus system structure is simple and has a very high cost-performance ratio.

Characteristics of RS485 Bus:

1. The electrical characteristics of RS-485: Logic “1” is represented by a voltage difference of + (2-6)V between the two wires; Logic “0” is represented by a voltage difference of – (2-6)V. The interface signal level is lower than RS-232-C, making it less likely to damage the interface circuit chips, and this level is compatible with TTL level, facilitating connection with TTL circuits; 2. The maximum data transmission rate of RS-485 is 10Mbps; 3. The RS-485 interface uses a combination of balanced drivers and differential receivers, enhancing common-mode rejection and noise immunity; 4. The maximum transmission distance of RS-485 is 4000 feet, practically reaching 3000 meters. Additionally, RS-232-C only allows one transceiver on the bus at a time, i.e., single-station capability. In contrast, RS-485 supports up to 128 transceivers on the bus, allowing users to easily establish a device network using a single RS-485 interface. However, only one transmitter can send at any time; 5. Due to the good noise immunity, long transmission distance, and multi-station capabilities, RS-485 is the preferred serial interface; 6. As the RS485 interface forms a half-duplex network, it generally requires only two wires, so RS485 interfaces use shielded twisted pairs for transmission.

Comparison of CAN Bus and RS485:

1. Speed and Distance: Both CAN and RS485 can transmit at a high rate of 1Mbit/S for distances not exceeding 100M. However, at low speeds, CAN can reach 10KM at 5Kbit/S, whereas RS485 can only reach approximately 1219 meters even at the lowest rates (without repeaters). Thus, CAN has a significant advantage in long-distance transmission.

2. Bus Utilization: RS485 is a single master-slave structure, meaning only one master can exist on the bus, initiating all communications. It does not issue commands, and subordinate nodes cannot send data until they receive a response from the master. This is to prevent multiple nodes from sending data simultaneously, causing data confusion. In contrast, CAN bus is a multi-master structure, with each node having a CAN controller. When multiple nodes send data, they automatically arbitrate based on the sent ID number, ensuring that bus data does not get mixed up. Moreover, once a node finishes sending, it can detect that the bus is idle and send immediately, eliminating the need for the master to inquire, thereby improving bus utilization and speed. Therefore, systems with high reliability requirements, such as automotive systems, predominantly use CAN bus or similar buses.

3. Error Detection Mechanism: RS485 only specifies the physical layer, lacking a data link layer, making it unable to recognize errors except for physical errors like shorts. This can lead to a situation where a faulty node continuously sends data, causing the entire bus to become paralyzed. Thus, if one node fails, the entire RS485 network goes down. On the other hand, CAN bus has a CAN controller that can detect any errors on the bus. If it detects more than 128 errors, it will automatically lock itself to protect the bus. If it detects errors from other nodes or itself, it will send an error frame to inform other nodes that the data is erroneous, prompting caution. Therefore, in networks where safety is paramount, CAN is very robust.

4. The CAN bus connects to the physical bus via two outputs, CANH and CANL, from the CAN controller interface chip 82C250. The CANH end can only be in a high level or floating state, while the CANL end can only be in a low level or floating state. This ensures that issues like short circuits caused by multiple nodes sending data simultaneously on the RS-485 network do not occur, which could damage certain nodes. Additionally, in severe error situations, CAN nodes have an automatic shutdown output function to prevent operations of other nodes on the bus from being affected, thus avoiding a “deadlock” state in the network due to issues with individual nodes.

5. CAN has a comprehensive communication protocol that can be implemented through CAN controller chips and their interface chips, significantly reducing system development difficulty and shortening development cycles. This is something that RS-485, which only has electrical protocols, cannot compare to.

#define REG_BASE_ADDR 0xA000 // Register base address
unsigned char *SJA_CS_Point = (unsigned char *) REG_BASE_ADDR ;

// Write to SJA1000 register
void WriteSJAReg(unsigned char RegAddr, unsigned char Value) {
*(SJA_CS_Point + RegAddr) = Value;
return;
}

// Read from SJA1000 register
unsigned char ReadSJAReg(unsigned char RegAddr) {
 return (*(SJA_CS_Point + RegAddr));
}

…… for (i=0;i<len;i++) { WriteSJAReg(RegAdr+i,ValueBuf[i]);  }……

……for (i=0;i<len;i++) {  ReadSJAReg(RegAdr+i,ValueBuf[i]);   }……

1. Each program includes the header files it uses
2. Each program includes a common header file, which contains all other header files

#ifndef __CONFIG_H__ // Prevent header file from being included multiple times
#define __CONFIG_H__
#include <8051.h>         // Include 80C51 register definition header file
#include "SJA1000REG.h"         // Include SJA1000 register definition header file

// Define byte operations
#define LOW_BYTE(x)  (unsigned char)(x)
#define HIGH_BYTE(x)  (unsigned char)((unsigned int)(x) >> 8)

// Define oscillator clock and processor clock frequency (users can adjust based on actual conditions)
#define OSCCLK 11059200UL
// Macro definition for MCU clock frequency
#define CPUCLK (OSCCLK / 12)
#endif // __CONFIG_H__

Sending CAN Frames:

char SetSJASendCmd(unsigned char cmd) {
unsigned char ret;
switch (cmd) {
default:
case 0:
        ret = SetBitMask(REG_CAN_CMR, TR_BIT); // Normal sending
break;
case 1:
        ret = SetBitMask(REG_CAN_CMR, TR_BIT|AT_BIT); // Single send
break;
case 2:
        ret = SetBitMask(REG_CAN_CMR, TR_BIT|SRR_BIT);// Self-send
break;
case 0xff:
        ret = SetBitMask(REG_CAN_CMR, AT_BIT);// Stop sending
break;
    }
return ret;
}

unsigned char SJA_CAN_Filter[8] = {    // Define acceptance filter parameters, receive all frames       
0x00, 0x00, 0x00, 0x00,                                                 
// ACR0~ACR3       
0xff, 0xff, 0xff, 0xff                                                         
// AMR0~AMR3
};
unsigned char STD_SEND_BUFFER[11] = {   // CAN sending message buffer       
0x08,   // Frame information, standard data frame, data length = 8       
0xEA, 0x60, // Frame ID = 0x753
0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa  // Frame data
};
void main(void) // Main function, program entry{       
    timerInit();// Initialization
    D1 = 0;       
    SJA1000_RST = 1; // Hardware reset SJA1000       
    timerDelay(50); // Delay 500ms       
    SJA1000_RST = 0;       
    SJA1000_Init(0x00, 0x14, SJA_CAN_Filter);   // Initialize SJA1000, set baud rate to 1Mbps       
    // Infinite loop, main() function cannot return      
    for(;;) {           
        SJASendData(STD_SEND_BUFFER, 0x0);           
        timerDelay(100);         // Delay 1000ms      
    }    
}