Virtual Interfaces#

There are quite a few implementations for CAN networks that do not require physical CAN hardware. The built in virtual interfaces are:

Comparison#

The following table compares some known virtual interfaces:

Name

Availability

Applicability

Implementation

Within Process

Between Processes

Via (IP) Networks

Without Central Server

Transport Technology

Serialization Format

virtual (this)

included

Singleton & Mutex (reliable)

none

udp_multicast (doc)

included

UDP via IP multicast (unreliable)

custom using msgpack

christiansandberg/ python-can-remote

external

Websockets via TCP/IP (reliable)

custom binary

windelbouwman/ virtualcan

external

ZeroMQ via TCP/IP (reliable)

custom binary [1]

Common Limitations#

Guaranteed delivery and message ordering is one major point of difference: While in a physical CAN network, a message is either sent or in queue (or an explicit error occurred), this may not be the case for virtual networks. The udp_multicast bus for example, drops this property for the benefit of lower latencies by using unreliable UDP/IP instead of reliable TCP/IP (and because normal IP multicast is inherently unreliable, as the recipients are unknown by design). The other three buses faithfully model a physical CAN network in this regard: They ensure that all recipients actually receive (and acknowledge each message), much like in a physical CAN network. They also ensure that messages are relayed in the order they have arrived at the central server and that messages arrive at the recipients exactly once. Both is not guaranteed to hold for the best-effort udp_multicast bus as it uses UDP/IP as a transport layer.

Central servers are, however, required by interfaces 3 and 4 (the external tools) to provide these guarantees of message delivery and message ordering. The central servers receive and distribute the CAN messages to all other bus participants, unlike in a real physical CAN network. The first intra-process virtual interface only runs within one Python process, effectively the Python instance of VirtualBus acts as a central server. Notably the udp_multicast bus does not require a central server.

Arbitration and throughput are two interrelated functions/properties of CAN networks which are typically abstracted in virtual interfaces. In all four interfaces, an unlimited amount of messages can be sent per unit of time (given the computational power of the machines and networks that are involved). In a real CAN/CAN FD networks, however, throughput is usually much more restricted and prioritization of arbitration IDs is thus an important feature once the bus is starting to get saturated. None of the interfaces presented above support any sort of throttling or ID arbitration under high loads.