Comment construire un bus CAN avec une planche à pain et Arduino

Le bus CAN (Controller Area Network) est un protocole de communication robuste et fiable largement utilisé dans diverses applications industrielles, automobiles et aérospatiales. Il est conçu pour la transmission de données entre des microcontrôleurs et des appareils sur un réseau de bus CAN. Vous ne le savez peut-être pas encore, mais c’est ce qui se cache derrière les modélisations délirantes du tableau de bord des voitures que vous voyez sur les réseaux sociaux.

Nous allons vous expliquer comment construire un bus CAN avec le module CAN MCP2515 en utilisant un Arduino et une planche à pain. Nous verrons également la bibliothèque CAN d’Arduino et démontrerons comment envoyer et recevoir des données sur le bus CAN.

Qu’est-ce qu’un bus CAN ?

Le bus CAN est un protocole de communication série développé par Bosch dans les années 1980. Il est largement utilisé dans diverses applications en raison de sa grande fiabilité et de sa robustesse. Il permet la transmission de données entre des dispositifs à des vitesses élevées avec une latence minimale sur seulement deux lignes : CAN High et CAN Low.

En 1994, le bus CAN est devenu une norme internationale (ISO 11898) conçue spécifiquement pour l’échange rapide de données en série entre les contrôleurs électroniques dans les applications automobiles. Pour plus de détails, consultez notre guide complet sur ce qu’est un bus CAN et sur son rôle dans les systèmes automobiles.

L’une des raisons pour lesquelles le bus CAN est si populaire est sa capacité à détecter et à corriger les erreurs. Le protocole peut détecter et corriger les erreurs dans la transmission des données. Il est donc idéal pour les applications où l’intégrité des données est essentielle, comme dans l’automatisation industrielle.

Connaître le module CAN MCP2515

Le module MCP2515 CAN Bus Controller est un dispositif qui offre un support exceptionnel pour le protocole CAN version 2.0B largement utilisé. Ce module est idéal pour la communication à des débits de données élevés allant jusqu’à 1 Mbps.

Le CI MCP2515 est un contrôleur CAN indépendant avec une interface SPI qui permet la communication avec une large gamme de microcontrôleurs. Le circuit intégré TJA1050, quant à lui, sert d’interface entre le contrôleur CAN MCP2515 et le bus CAN physique.

Pour plus de commodité, un cavalier vous permet d’attacher une terminaison de 120 ohms, ce qui rend encore plus facile la connexion de vos fils au bus CAN. CAN_H &amp ; CAN_L vis pour la communication avec d’autres modules CAN.

Vous pouvez obtenir des informations supplémentaires sur la fiche technique du MCP2515 au cas où vous auriez besoin de ce module pour un projet plus avancé.

Structure des messages CAN

La structure du message CAN se compose de plusieurs segments, mais les segments les plus importants pour ce projet sont l’identifiant et les données. L’identifiant, également appelé CAN ID ou Parameter Group Number (PGN), identifie les dispositifs sur le réseau CAN. La longueur de l’identifiant peut être de 11 ou 29 bits, selon le type de protocole CAN utilisé.

Pendant ce temps, les données représentent les données réelles du capteur/de la commande qui sont transmises. Les données peuvent avoir une longueur comprise entre 0 et 8 octets, et le code de longueur de données (DLC) indique le nombre d’octets de données présents.

La bibliothèque Arduino MCP2515 CAN Bus

Cette bibliothèque implémente le bus CAN Protocole CAN V2.0Bqui peut fonctionner à des vitesses allant jusqu’à 1Mbps. Il fournit une interface SPI qui peut fonctionner à des vitesses allant jusqu’à 10 MHz tout en prenant en charge les données standard (11 bits) et étendues (29 bits). De plus, il est équipé de deux tampons de réception, qui permettent de stocker les messages par ordre de priorité.

Initialisation du bus CAN

Voici le code d’installation dont vous aurez besoin pour initialiser le bus CAN :

 #include <SPI.h>
#include <mcp2515.h>

MCP2515 mcp2515(10); // Set CS pin

void setup() {
  while (!Serial);
  Serial.begin(9600);
  SPI.begin(); //Begins SPI communication

  mcp2515.reset();
  mcp2515.setBitrate(CAN_500KBPS, MCP_8MHZ);
  mcp2515.setNormalMode();
} 

Ceci initialise le MCP2515 avec un débit binaire CAN de 500Kbps et une fréquence d’oscillateur de 8MHz.

Modes opérationnels CAN du MCP2515

Il existe trois modes opérationnels utilisés avec le contrôleur de bus CAN MCP2515 :

• setNormalMode(): permet au contrôleur d’envoyer et de recevoir des messages.
• setLoopbackMode()setLoopbackMode() : permet au contrôleur d’envoyer et de recevoir des messages, mais les messages qu’il envoie seront également reçus par lui-même.
• setListenOnlyMode(): configure le contrôleur pour qu’il ne reçoive que des messages.

Il s’agit d’appels de fonction utilisés pour définir le mode opérationnel du contrôleur de bus CAN MCP2515.

mcp2515.setNormalMode();

mcp2515.setLoopbackMode() ;

mcp2515.setListenOnlyMode() ;

Envoi de données sur le bus CAN

Pour envoyer un message sur le bus CAN, utilisez la fonction sendMsgBuf() méthode :

 unsigned char data[] = {0x01, 0x02, 0x03, 0x04};
CAN.sendMsgBuf(0x01, 0, 4, data); 

Cette méthode envoie un message avec l’ID 0x01 et une charge utile de données de {0x01, 0x02, 0x03, 0x04}. Le premier paramètre est l’ID CAN, le deuxième est la priorité du message, le troisième est la longueur de la charge utile de données et le quatrième est la charge utile de données elle-même.

Le sendMsgBuf() renvoie une valeur indiquant si le message a été envoyé avec succès ou non. Vous pouvez vérifier cette valeur en appelant la méthode checkError() méthode :

 if (CAN.checkError()) {
  Serial.println("Error sending message.");
} 

Cette méthode vérifie si une erreur s’est produite lors de la transmission du message et imprime un message d’erreur si nécessaire.

Réception de données du bus CAN

Pour recevoir un message sur le bus CAN, vous pouvez utiliser la fonction readMsgBuf() méthode :

 unsigned char len = 0;
unsigned char buf[8];
unsigned char canID = 0;

if (CAN.checkReceive()) {
  CAN.readMsgBuf(&len, buf);
  canID = CAN.getCanId();
} 

Cette méthode vérifie si un message est disponible sur le bus CAN et lit ensuite le message dans le fichier buf array. La longueur du message est stockée dans le tableau len et l’ID du message est stocké dans la variable canID variable.

Une fois que vous avez reçu un message, vous pouvez traiter les données utiles comme vous le souhaitez. Par exemple, vous pouvez imprimer les données sur le moniteur série :

 Serial.print("Received message with ID ");
Serial.print(canID, HEX);
Serial.print(" and data: ");

for (int i = 0; i < len; i++) {
  Serial.print(buf[i], HEX);
  Serial.print(" ");
}

Serial.println(); 

Ceci imprime l’ID du message reçu et les données utiles sur le moniteur série.

Comment connecter un émetteur-récepteur de bus CAN à une planche à pain ?

Pour construire un bus CAN afin de connecter deux appareils dans cet exemple de projet, vous aurez besoin de :

• Deux microcontrôleurs (deux cartes Arduino Nano pour cet exemple)
• Deux modules CAN MCP2515
• Une planche à pain
• Fils de connexion
• Un module d’écran LCD I2C 16×2
• Capteur ultrasonique HC-SR04

Pour cet exemple de projet, quatre bibliothèques sont utilisées dans le sketch Arduino. Il y a la bibliothèque NewPing, qui fournit une interface facile à utiliser pour le capteur à ultrasons, ainsi que la bibliothèque SPI, qui facilite la communication entre la carte Arduino et le contrôleur de bus CAN MCP2515. La bibliothèque LiquidCrystal_I2C est utilisée pour le module d’affichage.

Enfin, la bibliothèque mcp2515 sert d’interface avec la puce MCP2515, ce qui nous permet de transmettre facilement des données sur le réseau de bus CAN.

Configuration matérielle (exemple HC-SR04)

Dans ce projet utilisant un capteur HC-SR04 et un écran LCD, une carte Arduino Nano agira en tant que récepteur, tandis que l’autre Arduino agira en tant qu’émetteur. Connectez les composants de l’émetteur selon le schéma de câblage ci-dessous :

Voici le schéma du circuit récepteur :

Enfin, connectez les deux nœuds ensemble à l’aide de la fonction CAN_H et CAN_L comme indiqué :

Lors du branchement des modules, il est important de s’assurer que la tension d’alimentation se situe dans la plage spécifiée et que le câble d’alimentation est bien en place. CAN H et CAN L sont correctement connectées au bus.

Programmation du module de bus CAN MCP2515

Lors de la programmation du module MCP2515, il est important d’utiliser le débit binaire correct pour assurer une communication réussie avec les autres dispositifs CAN du réseau.

Code expéditeur :

 #include <MCP2515.h>
#include <SPI.h>
#include <NewPing.h>

MCP2515 mcp2515(10);
const byte trigPin = 3;
const byte echoPin = 4;
NewPing sonar(trigPin, echoPin, 200);

struct can_frame canMsg;

void setup() {
  Serial.begin(9600);
  mcp2515.reset();
  mcp2515.setBitrate(CAN_500KBPS, MCP_8MHZ);
  mcp2515.setNormalMode();
}

void loop() {
  unsigned int distance = sonar.ping_cm();
  canMsg.can_id = 0x036; //CAN id as 0x036
  canMsg.can_dlc = 8; //CAN data length as 8
  canMsg.data[0] = distance; //Update humidity value in [0]
  canMsg.data[1] = 0x00; //Rest all with 0 
  canMsg.data[2] = 0x00;
  canMsg.data[3] = 0x00;
  canMsg.data[4] = 0x00;
  canMsg.data[5] = 0x00;
  canMsg.data[6] = 0x00;
  canMsg.data[7] = 0x00;

  mcp2515.sendMessage(&canMsg);//Sends the CAN message
  delay(100);
} 

Code récepteur :

 #include <mcp2515.h>
#include <SPI.h>
#include <LiquidCrystal_I2C.h>

MCP2515 mcp2515(10);
LiquidCrystal_I2C lcd(0x27,16,2);
struct can_frame canMsg;

void setup() {
  Serial.begin(9600);

  mcp2515.reset();
  mcp2515.setBitrate(CAN_500KBPS, MCP_8MHZ);
  mcp2515.setNormalMode();
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("MUO CAN TUTORIAL");
  delay(3000);
  lcd.clear();
}

void loop() {
  if (mcp2515.readMessage(&canMsg) == MCP2515::ERROR_OK) // To receive data
   {
     int distance = canMsg.data[0];
     lcd.setCursor(0,0);
     lcd.print("Distance: ");
     lcd.print(distance);
     lcd.print("cm ");
   }
} 

Faites passer vos projets Arduino au niveau supérieur

La combinaison du bus CAN et d’Arduino fournit une plateforme puissante pour construire ou apprendre des réseaux de communication sophistiqués utilisés dans diverses applications. Bien que la courbe d’apprentissage puisse sembler abrupte, le fait d’avoir sa propre configuration sur une planche à pain est un moyen très pratique d’apprendre les ficelles de l’utilisation d’un réseau de bus CAN dans des projets de bricolage complexes.