Dans le domaine des applications automobiles et industriels, une communication fiable entre plusieurs microcontrôleurs est primordiale. Le protocole BUS (CAN) Network (CAN) est devenu une solution robuste pour de tels besoins. Ce billet de blog se plonge dans les principes fondamentaux du protocole de bus Can et montre comment intégrer le contrôleur CAN MCP2515 avec un Arduino, permettant une communication transparente dans vos projets.
Qu'est-ce que le protocole de bus?
Le Bus Network (CAN) Network (CAN) est une norme de bus de véhicules robuste conçue pour permettre aux microcontrôleurs et appareils de communiquer entre eux sans ordinateur hôte. Développé par Bosch dans les années 1980, le bus CAN est devenu une norme dans les systèmes automobiles, mais est également largement utilisé dans l'automatisation industrielle et d'autres systèmes embarqués.
Les caractéristiques clés du protocole de bus CAN comprennent:
- Configuration multi-maître: Plusieurs nœuds peuvent communiquer sur le même bus sans contrôleur central.
- Priorité des messages: Les messages sont prioritaires en fonction de leur identifiant, garantissant que les données critiques sont transmises en premier.
- Détection d'erreur: Des mécanismes de détection d'erreur robustes, y compris les contrôles CRC et les bits de reconnaissance, améliorent la fiabilité.
- Communication à grande vitesse: Prend en charge les débits de données jusqu'à 1 Mbps, adaptés aux applications en temps réel.
Ces fonctionnalités rendent le BUS CAN idéal pour les scénarios où plusieurs appareils doivent communiquer efficacement et de manière fiable, comme dans les systèmes de gestion des moteurs de véhicules, l'automatisation industrielle et la robotique.
Présentation du contrôleur MCP2515
Le MCP2515 est un contrôleur de réseau de zone de contrôleur autonome (CAN) qui interface avec les microcontrôleurs via l'interface périphérique série (SPI). Il gère le protocole complexe de Can, permettant aux développeurs de se concentrer sur la logique d'application de niveau supérieur. Les caractéristiques clés du MCP2515 incluent:
- Prise en charge des cadres de canettes standard et étendus.
- Mécanismes de gestion des erreurs et de filtrage intégrés.
- Compatibilité avec divers microcontrôleurs, y compris Arduino.
- Faible consommation d'énergie, ce qui le rend adapté aux systèmes intégrés.
En intégrant le MCP2515 avec un Arduino, vous pouvez ajouter des capacités de bus CAN à vos projets, en permettant une communication avec d'autres appareils ou réseaux compatibles.
Configuration du MCP2515 avec Arduino
Pour commencer, vous aurez besoin des composants suivants:
- Board Arduino (par exemple, Arduino Uno)
- MCP2515 peut module (souvent livré avec un émetteur-récepteur TJA1050)
- Fils de cavalier
- Planche à pain (en option)
Voici un guide étape par étape pour configurer le MCP2515 avec votre Arduino:
1. Câblage du MCP2515 à Arduino
Connectez le module MCP2515 à l'Arduino comme suit:
- VCC à 5V sur Arduino
- GND à GND sur Arduino
- CS à PIN 10 sur Arduino
- SCK à PIN 13 sur Arduino
- SI (Mosi) à PIN 11 sur Arduino
- DONC (Miso) à Broche 12 sur Arduino
- Int à PIN 2 sur Arduino
Arduino MCP2515
------- -------
5V ------> VCC
GND ------> GND
Pin 10 ------> CS
Pin 13 ------> SCK
Pin 11 ------> SI (MOSI)
Pin 12 ------> SO (MISO)
Pin 2 ------> INT
2. Installation des bibliothèques requises
Pour communiquer avec le MCP2515, vous aurez besoin du MCP_CAN bibliothèque. Installez-le via le gestionnaire de bibliothèque Arduino:
- Ouvrez l'ide Arduino.
- Se diriger vers Sketch> Inclure la bibliothèque> Gérer les bibliothèques ...
- Rechercher MCP_CAN et installer le MCP_CAN Bibliothèque par Cory J. Fowler.
3. Téléchargement de l'exemple de code
Voici un exemple de base à envoyer et à recevoir des messages CAN en utilisant le MCP2515 et Arduino:
Envoi d'un message CAN
// Include the necessary libraries
#include
#include "mcp_can.h"
// Define the CS pin
#define CAN0_CS 10
// Initialize the CAN controller
MCP_CAN CAN0(CAN0_CS);
void setup() {
Serial.begin(115200);
while (CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_8MHZ) != CAN_OK) {
Serial.println("CAN BUS Shield init fail");
Serial.println(" Init CAN BUS Shield again");
delay(100);
}
Serial.println("CAN BUS Shield init ok!");
CAN0.setMode(MCP_NORMAL);
}
void loop() {
byte data[] = {0x00, 0xFF, 0xAA, 0x55, 0x33, 0x66, 0x99, 0xCC};
// Send data: CAN ID = 0x100, data length = 8
if (CAN0.sendMsgBuf(0x100, 0, 8, data) == CAN_OK) {
Serial.println("Message Sent Successfully!");
} else {
Serial.println("Error Sending Message...");
}
delay(1000);
}
Recevoir un message CAN
// Include the necessary libraries
#include
#include "mcp_can.h"
// Define the CS pin
#define CAN0_CS 10
// Initialize the CAN controller
MCP_CAN CAN0(CAN0_CS);
void setup() {
Serial.begin(115200);
while (CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_8MHZ) != CAN_OK) {
Serial.println("CAN BUS Shield init fail");
Serial.println(" Init CAN BUS Shield again");
delay(100);
}
Serial.println("CAN BUS Shield init ok!");
CAN0.setMode(MCP_NORMAL);
}
void loop() {
unsigned long canId;
byte len = 0;
byte buf[8];
// Check if data has been received
if (CAN0.checkReceive() == CAN_MSGAVAIL) {
CAN0.readMsgBuf(&canId, &len, buf);
Serial.print("CAN ID: 0x");
Serial.println(canId, HEX);
Serial.print("Data: ");
for (int i = 0; i < len; i++) {
Serial.print(buf[i], HEX);
Serial.print(" ");
}
Serial.println();
}
}
Dans l'esquisse d'envoi, l'Arduino transmet un message CAN avec ID 0x100 chaque seconde. Le croquis de réception écoute les messages et les données de la monnaie entrante et imprime l'ID et les données au moniteur série.
Applications du bus can avec arduino
L'intégration du bus CAN avec Arduino ouvre une multitude d'applications au-delà des systèmes automobiles. Certains cas d'utilisation populaires comprennent:
- Robotique: Activer la communication entre plusieurs contrôleurs de moteur et capteurs.
- Automatisation industrielle: Faciliter l'échange de données entre les différentes machines et les unités de contrôle.
- Home-Automation: Connectez divers appareils intelligents dans un réseau unifié.
- Systèmes d'acquisition de données: Collectez et traitez efficacement les données de plusieurs capteurs.
Conclusion
Le protocole BUB Bus, avec sa fiabilité et son efficacité, sert de squelette à la communication dans de nombreux systèmes embarqués. En utilisant le contrôleur MCP2515 CAN avec un Arduino, les développeurs peuvent intégrer sans effort les capacités de Bus dans leurs projets. Que vous travailliez sur les systèmes automobiles, l'automatisation industrielle ou la robotique complexe, la compréhension et le moteur de levier BUS peuvent améliorer considérablement le cadre de communication de votre système.
Avec les guides et exemples complets fournis, vous êtes bien équipé pour intégrer l'intégration de BUS CAN dans votre prochain projet Arduino. Codage heureux!
