CAN driver and router
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Type Name Latest commit message Commit time
Failed to load latest commit information.
c_src REBAR_DEPS_DIR does the right thing Jan 8, 2015
doc added top makefile, started to do some documentation effort Jun 22, 2010
ebin added directory Jun 8, 2010
include minor fixes Aug 26, 2015
priv using new eapi May 23, 2012
src info show the real device name for can_usb if wildcard is used Nov 3, 2018
.gitignore Added .gitignore Mar 7, 2012 spelling Apr 10, 2016
rebar.config using forked lager Jul 6, 2017


CAN binding for Erlang

CAN or Controller Area Network for short, is a two wire serial protcol for industrial applications.

This implementation currently supports three different backends:

  • can_usb: CANUSB is a USB dongle from LAWICEL AB.
  • can_udp: This is my own invention. A simple repackaging of CAN frames into UDP/IP datagrams sent over local multicast channel.
  • can_sock: A binding to linux SocketCAN interface.

Any number of backend interfaces may be started and attached to the can_router, which is the main interface to receice and send CAN frames.
An application will typically call can_router:attach() and then receive CAN frames from any of the interfaces. To send a frame then simple call can:send/n, this will pass the CAN frame to all the interfaces and connected local applications in the Erlang node.


To build can you will need a working installation of Erlang R15B (or later).
Information on building and installing Erlang/OTP can be found here (more info).

can is built using rebar that can be found here, with building instructions here. rebar's dynamic configuration mechanism, described here, is used so the environment variable REBAR_DEPS should be set to the directory where your erlang applications are located.

can also requires the following applications to be installed:


Clone the repository in a suitable location:

$ git clone git://


Interfaces can be added and remove dynamically, but can also be initialized in the environment like:

{can, [{interfaces,
         [{can_udp, 1, []},
          {can_udp, 2, [{ttl,0}]},
      {can_usb, 1, [{device, "/dev/tty.usbserial-LWQ6UYOM"},
                        {bitrate, 125000}]},
          {can_usb, 2, [{device, "/dev/tty.usbserial-LWQ8CA1K"},
                        {bitrate, 250000}]},
          {can_sock, "can0", []},
          {can_sock, "vcan0", []}]}]}

There is a special "wakeup" frame that can be enabled by setting wakeup to true. This together with wakeup_timeout will make sure that the can bus gets a "dummy" frame sent before the real message when neccesary.

If wakeup_timeout milliseconds (15s) has passed since the interface saw some input frames or no frames where sent from that interface, then the wakeup frame is sent.

{can, [{wakeup, true},
       {wakeup_timeout, 15000},
      {can_usb, 1, [{device, "/dev/tty.usbserial-LWQ8CA1K"},
                        {bitrate, 250000}]}
      {can_usb, 2, [{device, "/dev/tty.usbserial-LWQ6UYOM"},
                        {bitrate, 250000}]}

The wakeup frame looks like this ( maybe configure per interface ? ):


And is sent to the PDO_TX1 for the current target node.

The interfaces in the environment will get under supervision.


Linux ( virtual ) can driver

load the virtual can driver

$ sudo modprobe vcan

Create a virtual CAN network interface called 'vcan0'

$ sudo ip link add dev vcan0 type vcan

Activate a virtual CAN network interface called 'vcan0'

$ sudo ifconfig vcan0 up

Remove a (virtual) CAN network interface 'vcan0'

$ sudo ip link del vcan0

Set bitrate on interface can0 to 250000

 $ sudo ip link set can0 down
 $ sudo ip link set dev can0 type can bitrate 250000
 $ sudo ip link set can0 up

Create a virtual CAN network interface (vcan1)

$ sudo ip link add type vcan





Rebar will compile all needed dependencies.

$ cd can
$ rebar compile
==> can (compile)


$ erl -pa <path>/can/ebin

(Instead of specifing the path to the ebin directory you can set the environment ERL_LIBS.)