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 via un réseau de bus CAN. Vous ne le savez peut-être pas encore, mais c'est ce qui se cache derrière ces mods de tableau de bord de voiture fous que vous voyez sur les réseaux sociaux.

Nous vous expliquerons comment construire un bus CAN avec le module CAN MCP2515 à l'aide d'un Arduino et d'une maquette. Nous allons également passer en revue la bibliothèque Arduino CAN et montrer comment envoyer et recevoir des données via 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 appareils à haut débit 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) spécialement conçue pour l'échange rapide de données en série entre les contrôleurs électroniques dans les applications automobiles. Consultez notre guide complet sur qu'est-ce qu'un bus CAN et quel rôle il joue dans les systèmes automobiles pour plus de détails.

L'une des raisons pour lesquelles le bus CAN est si populaire est ses fonctions de détection et de correction des erreurs. Le protocole peut détecter et corriger les erreurs dans la transmission des données. Cela le rend idéal pour les applications où l'intégrité des données est critique, comme dans l'automatisation industrielle.

Connaître le module CAN MCP2515

Le module de contrôleur de bus CAN MCP2515 est un appareil qui offre une prise en charge exceptionnelle de la version 2.0B du protocole CAN largement utilisée. Ce module est idéal pour la communication à des débits de données élevés allant jusqu'à 1 Mbps.

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

Pour plus de commodité, il y a un cavalier qui vous permet de fixer une terminaison de 120 ohms, ce qui facilite encore plus la connexion de vos fils au CAN_H & PUIS-JE vis pour la communication avec d'autres modules CAN.

Vous pouvez obtenir des informations complémentaires auprès du Fiche technique 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 critiques pour ce projet sont l'identifiant et les données. L'identifiant, également connu sous le nom d'ID CAN ou numéro de groupe de paramètres (PGN), identifie les appareils sur le CAN réseau, et 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/contrôle 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 de bus CAN Arduino MCP2515

Cette bibliothèque implémente Protocole CAN V2.0B, qui peut fonctionner à des vitesses allant jusqu'à 1 Mbps. 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 livré avec deux tampons de réception, qui permettent un stockage prioritaire des messages.

Initialisation du bus CAN

Voici le code de configuration dont vous aurez besoin pour initialiser le bus CAN :

#inclure
#inclure
MCP2515 mcp2515(10); // Définir la broche CS
annulerinstallation(){
alors que (!En série);
En série.commencer(9600);
IPS.commencer(); // Commence la communication SPI
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
}

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

Modes de fonctionnement CAN MCP2515

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

• setNormalMode(): définit le contrôleur pour envoyer et recevoir des messages.
• setLoopbackMode(): définit le contrôleur pour envoyer et 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.

Ce sont des appels de fonction utilisés pour définir le mode de fonctionnement 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 le sendMsgBuf() méthode:

non signécarboniser données[] = {0x01, 0x02, 0x03, 0x04};
CAN.sendMsgBuf(0x01, 0, 4, données);

Cela 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 second 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() La méthode renvoie une valeur indiquant si le message a été envoyé avec succès ou non. Vous pouvez vérifier cette valeur en appelant le vérifierErreur() méthode:

si (CAN.checkError()) {
En série.println("Erreur lors de l'envoi du message.");
}

Celui-ci 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 le readMsgBuf() méthode:

non signécarboniser len = 0;
non signécarboniser bouf[8];
non signécarboniser canID = 0;
si (CAN.checkReceive()) {
 CAN.readMsgBuf(&len, buf);
 canID = CAN.getCanId();
}

Cela vérifie si un message est disponible sur le bus CAN, puis lit le message dans le buf déployer. La longueur du message est enregistrée dans le len variable, et l'ID du message est stocké dans la canID variable.

Une fois que vous avez reçu un message, vous pouvez traiter la charge utile de données selon vos besoins. Par exemple, vous pouvez imprimer la charge utile des données sur le moniteur série :

En série.imprimer("Message reçu avec ID");
En série.imprimer(canID, HEX);
En série.imprimer(" et données: ");
pour (entier je = 0; je < len; je++) {
En série.imprimer(buf[i], HEX);
En série.imprimer(" ");
}
En série.println();

Cela imprime l'ID du message reçu et la charge utile des données sur le moniteur série.

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

Pour construire un bus CAN pour 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 liaison
• Un module écran LCD I2C 16x2
• Capteur à ultrasons HC-SR04

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

Enfin, il y a le bibliothèque mcp2515 pour s'interfacer avec la puce MCP2515, nous permettant 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 comme un récepteur, tandis que l'autre Arduino agira comme un émetteur. Connectez vos composants émetteurs 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 CAN_H et PUIS-JE lignes comme indiqué :

Lors du raccordement des modules, il est important de s'assurer que la tension d'alimentation se situe dans la plage spécifiée et que le PEUT H et PUIS-JE les broches sont correctement connectées au bus.

Programmation du module de bus CAN MCP2515

Notez que lors de la programmation du module MCP2515, il est important d'utiliser le débit binaire correct pour assurer une communication réussie avec d'autres appareils CAN sur le réseau.

Code expéditeur :

#inclure
#inclure
#inclure
MCP2515 mcp2515(10);
constanteoctet trigPin = 3;
constanteoctet echoPin = 4;
NouveauPing sonar(trigPin, echoPin, 200);
structurecan_framecanMsg;
annulerinstallation(){
En série.commencer(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
}
annulerboucle(){
non signéentier distance = sonar.ping_cm();
 canMsg.can_id = 0x036; // ID CAN en tant que 0x036
 canMsg.can_dlc = 8; // Longueur des données CAN égale à 8
 canMsg.data[0] = distance; // Mettre à jour la valeur d'humidité dans [0]
 canMsg.data[1] = 0x00; // Reste tout avec 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);// Envoie le message CAN
retard(100);
}

Code récepteur :

#inclure
#inclure
#inclure
MCP2515 mcp2515(10);
LiquidCrystal_I2C lcd(0x27,16,2);
structurecan_framecanMsg;
annulerinstallation(){
En série.commencer(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
 lcd.init();
 LCD rétro-éclairage();
 lcd.setCursor(0, 0);
 lcd.imprimer("TUTORIEL MUO CAN");
retard(3000);
 lcd.clair();
}
annulerboucle(){
si (mcp2515.lire le message(&canMsg) == MCP2515::ERROR_OK) // Pour recevoir des données
 {
entier distance = canMsg.data[0];
 lcd.setCursor(0,0);
 lcd.imprimer("Distance: ");
 lcd.imprimer(distance);
 lcd.imprimer("cm ");
 }
}

Faites passer vos projets Arduino au niveau supérieur

La combinaison du bus CAN et d'Arduino fournit une plate-forme puissante pour la construction ou l'apprentissage de réseaux de communication sophistiqués utilisés dans diverses applications. Bien que cela puisse sembler être une courbe d'apprentissage abrupte, avoir votre propre configuration sur une planche à pain est un moyen assez pratique d'apprendre les ficelles de l'utilisation d'un réseau de bus CAN dans des projets de bricolage complexes.