Walk-through From CAN Bus to InfluxDB with Grafana

7 minute read

Hardware

Preliminary…

As electronics have gotten more powerful, the need for embedded devices to communicate in a simple, robust, and scalable way has gotten more and more important. The go to network for this has become the CAN (Controller Area Network) Bus. Car manufacturers have been one of the first to adopt the CAN Bus as it is one of the most resilient communication interfaces out there for operating in such a demanding environment. Now we are starting to see CAN crop up in more and more things as the advantages of using a CAN start to win out.

We are going to walk through how to interact with this low level network traffic and bring it out to some higher level storage and visualization tools. This will all be done with free and open source software and reasonably priced hardware for a professional, configurable and widely scalable real-time monitoring and analytics system.

Sensor

For this demo we are going to monitor a temperature sensor over a CAN Bus. This is certainly not the recommended or most economical way to monitor the temperature of your house. But if this were part of a vehicle system with multiple other devices interacting and sensors transmitting data, this same setup should suffice to monitor all the additional traffic that would be present.

To get started we need a sensor and there are basically two different approaches now on how to add sensing to your CAN Bus.

Custom Hardware

The most economical way to add CAN bus sensing to a project is to add it into a microcontroller that is already going to be in the system. You can get up and going to experiment with an OLIMEXINO-STM32 which already has an on-board CAN Bus transceiver to interface with the integrated CAN peripheral on an STM32. However the CAN Bus does tend to be one of the more complicated peripherals on these types of controllers so we will leave those details for another article. I would suggest using one of the integrated sensors below to get up and going quickly.

Integrated Sensor

These kinds of sensors are a bit more expensive as they have the hardware and MCU built in, but they are very handy and could be perfect for many applications.

For this setup we will be using the G4N03RHT from GPS4NET. We will get get into how this sensor works a bit further down.

CAN Bus

A CAN is a differential bus interface to an embedded device. It operates similar to USB in order to handle environmental noise, however arbitration on the bus is built in at the signal level. This means CAN Bus requires no other hardware to add a device on the bus, just wire it into your bus and you are ready to go!

Typical Bit Rate vs Bus Length

Here is a table of bit rates and their corresponding bus lengths. This can vary depending on the noise and traffic in the system, but can be a good guideline. Most common bus speeds tend to be 250k, 500k and 1M bit/s.

Bit rate Bus length
1 Mbit/s 25 m
800 kbit/s 50 m
500 kbit/s 100 m
250 kbit/s 250 m
125 kbit/s 500 m
50 kbit/s 1000 m
20 kbit/s 2500 m
10 kbit/s 5000 m

As this sensor operates by default at 250kbps, we will stick with that.

Gateway Device Setup

We will be using a Rapberry Pi 3 as the main monitoring device or Gateway Controller. Since the Rasperry Pi cannot directly interface to the CAN Bus on it’s own we will need to use an adapter board. One decent option we will be using for this setup is the PiCAN adapter board that uses an onboard SPI interface to talk to a CAN transciever.

Setup with Raspberry Pi and CAN board:

To get started with the Raspberry Pi as a CAN Bus Gateway you need an operating system. Raspian Lite is recommended as you shouldn’t need a terribly complex setup, however a desktop version would work just as well. There are plenty of guides on getting an SD card setup with the image for your OS.

Next you will need something to interface with the CAN Bus. One powerful and rather easy option is to use the PiCAN2 adapter board. There are even versions available that have an integrated power supply to power the device from the CAN Bus itself, as well as dual CAN adapters if that is something you might need.

Hardware install

Here is a document to walk you through the setup of the adapter board. Basically just press it onto the header, install the standoffs, and screw it together. MOST IMPORTANT, be sure to set the solder jumpers as needed, you will likely need to jumper them to work with CAN Cables unless you would like to use this in an OBDII setup.

OS Config

Of course now we need to setup Raspbian to detect our freshly installed adapter board!

First we need to update the OS with the typical:

sudo apt-get update
sudo apt-get upgrade

Next we need to add in the overlay to interface with the CAN bus via the SPI interface that is driving the CANPi2. Open up an editor to /boot/config.txt and add the following at the end:

dtparam=spi=on 
dtoverlay=mcp2515-can0-overlay,oscillator=16000000,interrupt=25 
dtoverlay=spi-bcm2835-overlay

That’s it! Save your changes and reboot the Raspberry Pi: sudo reboot

Wiring

Of course we need to wire this system up. Each sensing device may be a little different, but typically you will need +12V DC, Ground, and CAN High and CAN Low. Sometimes you will have a separate CAN GND which you should use if available.

schematic image

The Raspberry Pi will need a matching connections on the PiCAN board for CAN High, CAN Low and CAN Ground (use the sensor ground if no dedicated CAN Ground). The Raspberry Pi itself will just need USB power if it isn’t powered from the CAN Bus, and Ethernet unless you would like to setup a Wifi interface.

actual wired image

Testing Your CAN interface

Command line

  • http://www.skpang.co.uk/dl/can-test_pi2.zip
    • (Is this special or different from can-utils??)
  • via can-utils 
    git clone https://github.com/linux-can/can-utils.git
cd can-utils
make
sudo make install

CAN Bus Testing with python-can

This is an optional step and depends on your application. For just this single sensor and some minimal visualizations the python-can library and a simple web based plotter or a terminal interface may be a very usable option on the Raspberry Pi. But for doing some serious data crunching and visualizations, it doesn’t take too much to overwhelm the Raspberry Pi using the tools in this article. Below we will take the data processing requirements off of the Raspberry Pi and let a more powerful computer do the work.

Code snippet based on examples to get raw data

SocketCANd setup and configuration for Raspberry Pi:

SocketCAN is a standard networking stack that is used to allow access to a CAN bus. The socketcand project packages this all up and gives us an easy way to setup the interface and run it in the background as a daemon. This will allow us to get the raw data off of the CAN Bus and onto our network.

  • Steps to clone, compile, make, execute
  • Set to run on boot
  • SAVE!

If everything is working here, now would be a great time to make a backup image of your SD card so you can always come and reuse or restore this working image.

At this point it is possible to stop here and use something like Kayak, which is a very powerful open source CAN interface utility. Or we can continue on with an even more flexible and web friendly solution!

Setting up a simple socket interface with Python from another device

coming soon

Scaling raw CAN data

There are plenty of CAN data formats out there from CANOpen, J1939, and other used for cars such as the OBD protocol stack. Some devices may also define thier own protocol structure or just use a very simple implementation over the raw CAN bus. This is just fine as the general idea is usually the same: Figure out where the data is coming from with the address field then get the raw data bytes and scale as needed.

  • CAN Packets

Extended ID vs Standard ID

Packet ID1 ID2 ID3 ID4 D1 D2 D3 D4 D5 D6 D7 D8
  Temperature define/get protocol                    
  Humidity                      
  • Sensor Specific setup
  • J1939 Generic setup

Sending data to a TSDB like InfluxDB and basic queries

Now it is time to install InfluxDB on your server or PC!

InfluxDB

Setting up Grafana and linking to InfluxDB

Grafana

  • Installation instructions here
  • Once setup and running, goto localhost:3000
  • Setup an account
  • Add a datasource

Cost Breakdown

For an Industrial Grade CAN Bus Environmental Monitoring setup

  • CAN Bus Sensor
    • Integrated CAN Device: $85-$150
    • Custom: $30 or less
  • Raspberry Pi: $30
    • SD Card: $10
    • Power USB (optional): $5
  • CAN Adapter Board w/Enclosure: $85
  • Total : ~$155->$215

Potential Optimizations

  • Read-only OS for power safe operation
  • Larger CAN bus for multi point sensing
  • Sensor Meta Data?? Location/type/ranges
  • J1939 detail abstraction with SQLite
  • CAN Bus Writing and simulation
  • InfluxDB Data optimization, retention
  • Filter levels and sampling with Grafana

You May Also Enjoy

SQL when you need it

less than 1 minute read

SQL and databases are something that not many engineers tend to play with. But a database can be a very powerful tool when used proplerly. Often it can get ...

Python for Electrical Engineers

4 minute read

Many developers working close to the metal tend to stick to their knowledge of C/C++ to get things done even when not restricted by their platform, but there...