Building a CAN API for Arduino DUE

Thank you again keija for you willingness to help with this CAN interface for the Arduino Due. Remember that the ARM Cortex M3 is different from the 8-bit/16-bit RISC architecture we are accustomed from Atmel and it confines any Due development to it. Right now I am finishing some CAN sample tests and minimizing/trimming all non-necesary drivers/services/components to make this project easier. Regards.

Ok. Change of plans. Henceforth I will stay working with the CAN code available through the Arduino IDE. At the end, a CAN library and a couple of sample sketches will be added to the Arduino IDE as tools to send and receive standard (ver.2.0A - 11 bit) and extended (ver.2.0B - 29 bits) messages, but before this, as I stated in previous posts, I have been running some tests of the sample CAN code provided by Atmel in AS6, SAM_BA 2.12 and my SAM3X-EK board. The purpose of these tests is to dissect and obtain a proven minimum CAN code for the SAM3X8E. Finally, once the necessary source code has been chosen (libraries, .h, .c), we will proceed to program the SAM3X8E in Arduino due through the Arduino IDE.

I know the majority of the CAN protocol fans in this forum look forward to have access to the code but for the moment let me show you a picture my SAM3X-EK and a CAN device (sorry for the wiring mess) and also a pseudo-code and an idealized sketch.

For understand a bit better the following pseudo –code, it is healthy to explain briefly about the CAN platform embedded inside the SAM3X8E core.
The SAM3X8H has two CAN Controllers. We will call these controllers CAN0 and CAN1. The SAM3X8H read/writes from/to them through the PIO A and PIO B respectively. Each of these controllers connects one respective bus. Each bus should comprehends only two transmission lines (CANTX/CANRX) but due to the energy efficiency design of the SAM3X8E, it is required the use of two CAN transceivers (one per bus) between the SAM3X8E and the outer world. Also, we will discuss latter about these transceiver and the future shield.
Here the pseudo-code:
Initialization code (setup)

  1. Define CAN0 and CAN1 transfer mailbox structure
  2. Enable the module clock for CAN0 and CAN1
  3. Initialize CAN0 and CAN1, baud rate (baud/s)
  4. Reset all CAN0 and CAN1 mailboxes
  5. Initialize CAN1 mailbox 0 as receiver, frame ID
  6. Initialize CAN0 mailbox 0 as transmitter, frame ID
  7. Prepare transmit ID, data and data length in CAN0 mailbox 0

Main code (loop)

  1. Send out data in CAN0 mailbox 0
  2. Wait for CAN1 mailbox 0 to receive the data
  3. Read the received data from CAN1 mailbox 0

For a user-friendly interface, I will encapsulate the initialization code in a couple of steps that only include baud rate, frame ID, priority, type of message frame (2.0A or 2.0B) and mailbox configuration(transmitter/receiver).

The main code will use the following functions: send, wait and read.
An idelized Arduino Due CAN sketch will look like:

// Idealized CAN sketch for Arduino Due board
// By Palliser 2012


// Required CAN library
#include <can.h>

// Initialize CAN Controllers (defines structure, enable clock)
CANInit CAN0;
CANInit CAN1;

// Mailboxes frame ID 7 and 8
int MB_ID7 = 7;
int MB_ID8 = 8;

// CAN message to turn on Arduino Due pin 13
int CAN_MSG_HIGH_PIN_13 = 0x11223344
// Arduino Due pin 13
int led13 = 13;

void setup()
{
  //CAN baud rate 1Mb/s
  Can.begin(1000000);
  //Reset all CAN0 and CAN1 mailboxes
  Can.MBReset(CAN0);
  Can.MBReset(CAN1);
  //Init CAN0 mailbox 7 as receiver
  Mailbox.mode(CAN0, MB_ID7, RX_Mode);
  // Init CAN1 mailbox 8 as transmitter
  Mailbox.mode(CAN1, MB_ID8, TX_Mode);
  // Prepare transmit information into CAN1 mailbox 8
  CAN_MB_WRITE(CAN1, MB_ID8, CAN_MSG_HIGH_PIN_13);
  // initialize the digital pin as an output.
  pinMode(led13, OUTPUT);
}

void loop()
{
  
  // Send out information in CAN1 mailbox 8
  CAN_MB_SEND(CAN1, MB_ID8);
  
  while(!recv_status){
  }
  if(CAN0_MB_DATA == CAN_MSG_HIGH_PIN_13){
  Serial.println("Test passed");
  digitalWrite(led13, HIGH);}
  else{
  Serial.println("Test ERROR");  
  }
}

Regards.

I like the wiring, sounds good looking forward to it

I’m almost done with my minimize raw CAN 2.0A (11 bit) running in the Arduino Due with a sample sketch. I’m expecting to receive the transceivers in a couple of days (TI SN65HVD234 & SN65HVD235) and build a shield. In the meantime I’ve hooked CANRX0<->CANRX1 and CANTX0<->CANTX1 for looping tests. I hope by mid-next week to upload in github the raw CAN code for revision and comments. Thank you for your patience.

I think this should be the basic foundation of the DUE-CAN library.

Oh please, don't miss the opportunity of calling it the CAN-DUE library, we need more nerd humour around here. LOL :D

Lefty

"No CAN due-sville, babydol" ?

Wow Palliser - you seem to be really focused on this :O thanks for spearheading!

I haven't heard of CAN protocol until reading this thread, so I am wondering (just in case I'm missing out on learning some interesting things): What is "CAN protocol" used for? Automotive applications were mentioned (so I assume car odometer, engine status, etc.), but what other applications can it be or is commonly used for?

Hello giantsfan3. In my case, I started getting interested in the CAN protocol after been involved for over a year integrating a German Battery Manager System (CAN) with a PLC (Modbus RTU). Then, I understood why CAN is one of the most reliable communication protocols I ever seen. In the particular case of the microcontroller inside of the Arduino Due (SAM3X8E), there are about one hundred configurable registers! (status, interruptions, errors, etc.). The CAN protocol has been around for more than 25 years. Just two wires, it offers high-speed communication rate up to 1 Mbits/sec thus allows real-time control. CAN can theoretically link up to 2032 devices (assuming one node with one identifier), excellent error handling and fine fault confinement. Used to operate in robust, electromechanical (noisy) environments like in automotive, also in medical apparatus, textile machines, elevators, agricultural and nautical machinery. There are other CAN-based higher layer protocols like CAN Application Layer (CAL), CAN Kingdom, CANopen and DeviceNet.

Just Google it or Wikipedia. You can check the following compendium of the CAN protocol and uses in the automation industry. http://www.diakom.com.ru/el/communication/can/can_org.pdf

We hope soon, see Arduino Due fans contributing with new cool CAN applications. Regards.

Implementing the CAN physical layer.

For the implementation of the physical layer of the Arduino Due CAN interface, we need a mean to translate the CAN messages to/from differential signals across a physical medium such as a twisted pair cable.

CAN transceivers provide that differential physical layer interface between the data link layer (CAN controller inside the SAM3X8E) and the physical wiring of the CAN bus.

CAN has only two bus voltage states; recessive (driver outputs are high impedance) and dominant (one bus line, CANH, is high and the other, CANL, is low), unlike the traditional differential data transmission where a logic 1 is transmitted as a voltage level high on one noninverting transmission line and low on the inverting line. Correspondingly, Logic 0 is transmitted as low on the noninverting line and high on the inverting line.

For obvious space reasons, we need a shield to mount the transceivers, some pull resistors, capacitors and the CANL CANH connectors.

I have chosen two SN65HVD234 CAN transceivers for my first shield (I am considering to use 235's later). Because I am prototyping, for the board I will use a SchmartBoard (RadioShack 2760259). The shield will provide 2 can ports (CAN0 and CAN1).

Here a picture of the transceivers circuit. It's very simple, just a straight connection with the arduino CAN ports. Later on, I have planned to use some features of these transceivers like high-speed and low power modes that will required 4 more Arduino Due pins (2 EN and 2 RS).

Regarding the code, I already have my Arduino Due talking CAN 2.0A but a library optimization is required before upload the files in github. Thank you again for your patience and keep looking out my post.

Hello, "Long-time listener/first-time caller" here... I just wanted to point out an interesting discussion regarding use of an Arduino-compatible 32-Bit board (the ChipKIT) and a CAN Communication Interface for the Ford Motor Company called OpenXC (http://openxcplatform.com/). The discussion forum can be found at https://groups.google.com/forum/?hl=en&fromgroups#!forum/openxc I have no idea if there's any way these two efforts can be of use to each other, but I figured I'd mention it... Keep up the exciting work!

Hello roundhouselabs and welcome to the forum. Thank you for the information. So far, my Arduino Due can transmit/receive CAN 2.0A messages within the Arduino API. I used an Atmel sample code for the SAM3X series. Right now, I am organizing the library and replacing missing functions presents in Atmel but in the Arduino API and hope to release them with a couple of sample sketches in github in the coming days for revision and comments. As you may have noticed, a CAN shield has been required. Regards!

Here a picture of my Arduino Due CAN shield (prototype) during loop tests. I will mount the resistors in the shield (less power of course!)

I'm excited to see work with CAN on the Arduino Due - I'm one of the developers of the OpenXC platform that roundhouselabs mentioned (openxcplatform.com) and while we started prototyping with the Arduino at Ford, we had to move to the chipKIT to get a little bit more performance and CAN controllers on the MCU. I'd love to get the OpenXC translator working with the Due; all we really need is the library API - I read through this thread but I can't quite tell if there is progress happening somewhere else on the software side.

If there's a work-in-progress repository somewhere, I'd love to help out. Looking for examples of simple CAN APIs that would exist at about the same level of abstraction as the other core Arduino libraries, the one provided by the mbed library may be a good start: http://mbed.org/handbook/CAN

CAN Shield - Due electrical schematic.

|500x283

Arduino Due and CAN shield with termination resistors (120 ohm) mounted. The jumpers are selecting high-speed (0V-black) and disabling low-power (3V3-red) modes in the SN65HVD234 transceivers. The CANH (orange) and CANL (purple) bus terminals hooked for a loop test.

I was able to order a DUE today, so I'll join the ranks soon :)

I really appreciate it, that you use both CAN-Transceivers! This will be great for using it as a Gateway!

I have my Due and now it's time to order the transceivers. I'm going to get both the 234 and 235's. Which ever ones I don't use in the car I'll use on the work bench. Thanks for tackling this.

Great for you keija and that_kid. Do as I did: Request a couple of samples of each transceiver to Atmel. I have some sample sketches running OK on my Due, using a combination of Atmel and Arduino library files. The goal is to occupy as much as Arduino files and as less as Atmel files as possible. I also hope to run my first real test these next days interfacing Due with a battery manager system (with XC167CI - by Infineon and AT91SAM7).

I wanted to share another of the tests I am working now with Arduino Due using the CAN shield. The test consists of making Due read CAN data from a commercial OBD II code reader. This will prepare the ground for more tests like convert Due as a OBD2 simulator system generating some DTC codes to be read by the code reader and finally to make Arduino Due read some real DTC codes from my car (Honda-Oddysey 2002) or any other car under OBD2.

As some of you know, ODB II stands for On Board Diagnostics, level 2. OBD II is a federally mandated engine & emissions management standard for all passenger cars sold in 1996 and beyond. ODB II uses CAN bus Dual Wire like Arduino Due (ISO 11898-1/SAE J2284).

For my first test I used an Actron CP9125 pocket scanner (with a 89C71CC01CA microcontroller and TJA1050 CAN transceiver).

Here a the schematic of interconnection between the code reader and Arduino Due and a picture of both systems. So far, Due can read from the reader ID 0x07DF the following data: 02 01 00 99 99 99 99 99 which is a request data to start reading DTC codes. I am very excited exploring CAN protocol in Arduino Due and OBD2 systems. I'd recommend to get ready if you want to embark on this journey.

Excellent news, I'm just waiting on my parts to arrive from mouser.com I was going to order the engineering samples but I needed some parts so I just went ahead and get it all. Next stop is to see if my local radio shack has the shield that you are using.