Expérience Canbus entre deux Arduino expliquée rapidement

 La ligne Canbus gère la communication série entre deux modules Arduino, elle est constituée des 2 câbles centraux (fil vert, fil bleu) reliés en série aux deux extrémités par deux résistances de 120 𝛀 se trouvant sur les cartes contrôleurs de canbus MCP et activées avec les cavaliers en bas à droite sur la carte.

On utilise les librairies "mcp2515_can.h" et  <SPI.h> pour l’interface du contrôleur MCP2515. 

Le Nano (l’émetteur) lit la donnée du potentiomètre et la transmet par l’intermédiaire de la

ligne Canbus dans une des huit trames de données envoyées périodiquement au moyen de

la ligne de programme (voir dans le sketch)  suivante:

unsigned char canMsg[8] = {cantxValue, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 

Chaque trame de signaux est constituée d’un caractère de 8 bits, transite par les fils vert et

bleu a l’allure suivante à l’oscilloscope: 

La ligne Canbus se compose physiquement d’un fil HIGH à 3,75V (le vert) et d’un fil

LOW à 1,75V (le bleu) qui vont être modulés à 2,50V pour la transmission des trames

de données. La valeur lue du potentiomètre, qui est envoyée par l’Arduino Nano,

est d’abord mise à l’échelle qui doit être comprise entre 0 et 255 pour être contenue

dans les 8 bits de la trame. Le récepteur Arduino Uno attend en permanence de lire

des données du Canbus. Lorsqu’il y en a une il obtient dans la trame les informations

suivantes: nom de l’émetteur et valeur de la donnée. 

CAN.readMsgBuf(&len, buf);// read len:data length, buf: data buf

Le récepteur peut éventuellement filtrer les données en fonction de ce qu’il veut lire

(tel émetteur s’il y en a plusieurs ou telle donnée). 

SKETCH de l’émetteur Nano ⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥

/* Uno_Canbus_Pot_Sender_SL01.ino

 *  utiliser avec  Uno_Canbus_Pot_receive_SL02.ino

 *  slazare 2021 10 06 

 */

#include "mcp2515_can.h"

#include <SPI.h>

mcp2515_can CAN(10); // set CS pin

//Pot for adjusting value

int sensorPin = A0;

int sensorValue = 0;

int cantxValue = 0;

void setup()

{

  Serial.begin(115200);

  // init can bus, baudrate: 100k

  if(CAN.begin(CAN_100KBPS) ==CAN_OK) Serial.print("can init ok!!\r\n");

  else Serial.print("Can init fail!!\r\n");

}

//Some sample CAN messages

unsigned char msg1[8] = {0, 1, 2, 3, 4, 5, 6, 7};

unsigned char msg2[8] = {0xFF, 0x01, 0x10, 0x0A, 0x00, 0x00, 0x00, 0x00};

unsigned char msg3[4] = {0xFF, 0x01, 0x10, 0x0A};

void loop()

{

  //Read the value of the pot

  sensorValue = analogRead(sensorPin);

  //Each CAN bus byte can store a value between 0-255. 

  //Dividing sensorValue by 4 puts us in that range.

  cantxValue = sensorValue / 4;

  Serial.print("cantxValue: ");

  Serial.print(cantxValue);

  Serial.println();

  //Create data packet for CAN message

  unsigned char canMsg[8] = {cantxValue, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

  // send data:  id = 0x123, standard flame, data len = 8, stmp: data buf

  CAN.sendMsgBuf(0x07B, 0, 8, canMsg);  

  delay(100);

}

SKETCH du récepteur Uno ⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥⟥

/*  Uno_Canbus_Pot_receive_LCD_SL01.ino

 *  slazare 2021 10 07 

 * demo: CAN-BUS Shield, receive data with check mode

 * utiliser avec Uno_Canbus_Pot_Sender_SL01.ino

 * loovee, 2014-6-13

 */

#include <SPI.h>

#include "mcp2515_can.h"

// Set SPI CS Pin according to your hardware

// the cs pin of the version after v1.1 is default to D9

// v0.9b and v1.0 is default D10

const int SPI_CS_PIN = 10;

const int CAN_INT_PIN = 2;

#include <Wire.h>           //LCD

#include <LiquidCrystal_I2C.h>    //LCD

LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display

mcp2515_can CAN(SPI_CS_PIN); // Set CS pin

const int LED        = 8;

boolean ledON        = 1;

void setup() {

    SERIAL_PORT_MONITOR.begin(115200);

    pinMode(LED, OUTPUT);

    while (CAN_OK != CAN.begin(CAN_100KBPS)) {             // init can bus : baudrate = 500k

        SERIAL_PORT_MONITOR.println("CAN init fail, retry...");

        delay(100);

    }

    SERIAL_PORT_MONITOR.println("CAN init ok!");

    lcd.init();

    lcd.backlight();

    lcd.setCursor(0,0);

    lcd.print("Hello, world!");

    delay(1500);

}

void loop() {

    unsigned char len = 0;

    unsigned char buf[8];

    if (CAN_MSGAVAIL == CAN.checkReceive()) {         // check if data coming

        CAN.readMsgBuf(&len, buf);    // read data,  len: data length, buf: data buf

        unsigned long canId = CAN.getCanId();

        SERIAL_PORT_MONITOR.println("-----------------------------");

        SERIAL_PORT_MONITOR.print("get data from ID: 0x");

        SERIAL_PORT_MONITOR.println(canId, HEX);

 //       for (int i = 0; i < 1; i++) { // print the data

 //         SERIAL_PORT_MONITOR.print(buf[i]);

            SERIAL_PORT_MONITOR.print(buf[0]);    //c'est la valeur de cantxValue

            SERIAL_PORT_MONITOR.print("\t");

            lcd.clear();

            lcd.setCursor(0,0);

            lcd.print(buf[0]);

            lcd.setCursor(5,0);

            lcd.print(canId, HEX); 

            delay(500);

        SERIAL_PORT_MONITOR.println();

    }

}

Résultat: Donc en tournant le potentiomètre, on fait varier instantanément entre 0 et 255 la valeur affichée sur l'écran LCD, à droite du nombre affiché on voit le nom de l'émetteur. On peut envisager de transmettre les valeurs de plusieurs capteurs qui peuvent être distribués avec plusieurs émetteurs connectés au Canbus. De plus chaque émetteur peut également être configuré en récepteur par le logiciel car le contrôleur MCP2515 le supporte très bien. Cela laisse pas mal de perspectives pour des expériences et montages futurs. Rappelons que le concept Canbus, né dans les années 80 dans les laboratoires Bosch, est universellement utilisé en automobile. Par l'intermédiaire de la prise OBD, il est possible de lire des données transitant sur le réseau de l'auto et éventuellement créer des nouveaux affichages et obtenir des diagnostiques utiles dans les cas de dysfonctionnements.