Protocole CAN - Oui, nous pouvons ! : 24 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Un autre sujet récemment suggéré par les abonnés de ma chaîne YouTube était le protocole CAN (Controller Area Network), sur lequel nous allons nous concentrer aujourd'hui. Il est important d'expliquer que CAN est un protocole de communication série simultanée. Cela signifie que le synchronisme entre les modules connectés au réseau s'effectue par rapport au début de chaque message envoyé sur le bus. Nous allons commencer par présenter les concepts de base du protocole CAN et effectuer un assemblage simple avec deux ESP32.

Dans notre circuit, les ESP peuvent agir à la fois comme maître et esclave. Vous pouvez avoir plusieurs microcontrôleurs transmettant simultanément, car le CAN gère automatiquement la collision de tout. Le code source de ce projet est super simple. Vérifiez-le!

Étape 1: Ressources utilisées

• Deux modules d'ESP WROOM 32 NodeMcu
• Deux émetteurs-récepteurs CAN de WaveShare
• Cavaliers pour les connexions
• Analyseur logique pour la capture
• Trois câbles USB pour ESP et analyseur
• 10 mètres de paire torsadée pour servir de bus

Étape 2: CAN (Controller Area Network)

• Il a été développé par Robert Bosch GmbH dans les années 1980 pour servir l'industrie automobile.
• Il s'est généralisé au fil des années en raison de sa robustesse et de sa souplesse de mise en œuvre. Il est utilisé avec des équipements militaires, des machines agricoles, l'automatisation industrielle et des bâtiments, la robotique et l'équipement médical.

Étape 3: CAN - Caractéristiques

• Communication série à deux fils
• Maximum de 8 octets d'informations utiles par trame, avec fragmentation possible
• Adresse dirigée vers le message et non vers le nœud
• Attribution de priorité aux messages et relayage des messages « en attente »
• Capacité efficace de détecter et de signaler les erreurs
• Capacité multi-maître (tous les nœuds peuvent demander un accès au bus)
• Capacité de multidiffusion (un message pour plusieurs récepteurs en même temps)
• Débits de transfert jusqu'à 1Mbit/s sur un bus de 40 mètres (diminution du débit avec augmentation de la longueur du jeu de barres)
• Flexibilité de configuration et introduction de nouveaux nœuds (jusqu'à 120 nœuds par bus)
• Matériel standard, faible coût et bonne disponibilité
• Protocole réglementé: ISO 11898

Étape 4: Circuit utilisé

Ici, j'ai les émetteurs-récepteurs. Il y en a un de chaque côté et ils sont reliés par une paire de fils. L'un est responsable de l'envoi et l'autre de la réception des données.

Étape 5: Tensions de ligne de transmission (détection différentielle)

Dans CAN, le bit dominant est zéro.

La détection différentielle de ligne réduit la sensibilité au bruit (EFI)

Étape 6: Format des normes et des trames CAN

Format standard avec identifiant 11 bits

Étape 7: Normes CAN et format des trames

Format étendu avec identifiant 29 bits

Étape 8: Format des normes et des trames CAN

Il est important de noter qu'un protocole calcule déjà le CRC et envoie des signaux ACK et EOF, ce qui est déjà fait par le protocole CAN. Cela garantit que le message envoyé n'arrivera pas dans le mauvais sens. En effet, s'il génère un problème dans le CRC (Redundant Cyclic Check ou Redundancy Check), qui est le même qu'un chiffre de contrôle d'information, il sera identifié par le CRC.

Étape 9: Quatre types de cadres (cadres)

Il est important de noter qu'un protocole calcule déjà le CRC et envoie des signaux ACK et EOF, ce qui est déjà fait par le protocole CAN. Cela garantit que le message envoyé n'arrivera pas dans le mauvais sens. En effet, s'il génère un problème dans le CRC (Redundant Cyclic Check ou Redundancy Check), qui est le même qu'un chiffre de contrôle d'information, il sera identifié par le CRC.

Quatre types de cadres (cadres)

La transmission et la réception des données dans le CAN reposent sur quatre types de trames. Les types de trames seront identifiés par des variations dans les bits de contrôle ou même par des changements dans les règles d'écriture de trame pour chaque cas.

• Trame de données: contient les données de l'émetteur pour le(s) récepteur(s)
• Trame distante: il s'agit d'une demande de données de l'un des nœuds
• Trame d'erreur: il s'agit d'une trame envoyée par l'un des nœuds lors de l'identification d'une erreur dans le bus et peut être détectée par tous les nœuds
• Overload Frame: Sert à retarder le trafic sur le bus en raison d'une surcharge de données ou d'un retard sur un ou plusieurs nœuds.

Étape 10: Circuit - Détails des connexions

Étape 11: Circuit - Capture de données

Longueurs d'onde obtenues pour CAN standard avec ID 11 bits

Étape 12: Circuit - Capture de données

Longueurs d'onde obtenues pour CAN étendu avec ID 29 bits

Étape 13: Circuit - Capture de données

Données obtenues par l'analyseur logique

Étape 14: Bibliothèque Arduino - CAN

Je montre ici les deux options où vous pouvez installer la bibliothèque de pilotes CAN

Gestionnaire de bibliothèque IDE Arduino

Étape 15: Github

github.com/sandeepmistry/arduino-CAN

Étape 16: Code source de l'émetteur

Code source: Inclut et configuration ()

Nous allons inclure la bibliothèque CAN, démarrer la série pour le débogage et démarrer le bus CAN à 500 kbps.

#include //Inclui a biblioteca CAN void setup() { Serial.begin(9600); //inicia un débogage en série pendant (!Serial); Serial.println("Transmissor CAN"); // Inicia o barramento CAN a 500 kbps if (!CAN.begin(500E3)) { Serial.println("Falha ao iniciar o controlador CAN"); //caso não seja possível iniciar o controlador while (1); } }

Étape 17: Code source: boucle (), Envoi d'un paquet CAN 2.0 standard

En utilisant la norme CAN 2.0, nous envoyons un colis. L'ID 11 bits identifie le message. Le bloc de données doit avoir jusqu'à 8 octets. Il commence le paquet avec l'ID 18 en hexadécimal. Il emballe 5 octets et ferme la fonction.

void loop() { // Usando o CAN 2.0 padrão //Envia um pacote: o id tem 11 bits e identifica a mensagem (prioridade, evento) //o bloco de dados deve possuir até 8 bytes Serial.println("Enviando pacote …"); CAN.beginPacket (0x12); //id 18 em hexadécimal CAN.write('h'); //1º octet CAN.write('e'); //2º octet CAN.write('l'); //3º octet CAN.write('l'); //4º octet CAN.write('o'); ///5º octet CAN.endPacket(); //encerra o pacote para envio Serial.println("Enviado."); retard(1000);

Étape 18: Code source: boucle (), Envoi d'un package CAN 2.0 étendu

Dans cette étape, l'ID a 29 bits. Il commence à envoyer 24 bits d'ID et, une fois de plus, emballe 5 octets et s'arrête.

//Usando CAN 2.0 Estendido //Envia um pacote: o id tem 29 bits e identifica a mensagem (prioridade, evento) //o bloco de dados deve possuir at 8 bytes Serial.println("Enviando pacote estendido…"); CAN.beginExtendedPacket(0xabcdef); //id 11259375 décimal (abcdef em hexa) = 24 bits preenchidos até aqui CAN.write('w'); //1º octet CAN.write('o'); ///2º octet CAN.write('r'); //3º octet CAN.write('l'); //4º octet CAN.write('d'); ///5º octet CAN.endPacket(); //encerra o pacote para envio Serial.println("Enviado."); retard(1000); }

Étape 19: Code source du récepteur

Code source: Inclut et configuration ()

Encore une fois, nous allons inclure la bibliothèque CAN, démarrer la série à déboguer et démarrer le bus CAN à 500 kbps. Si une erreur se produit, cette erreur sera imprimée.

#include //Inclui a biblioteca CAN void setup() { Serial.begin(9600); //inicia un débogage en série pendant (!Serial); Serial.println("Récepteur CAN"); // Inicia o barramento CAN a 500 kbps if (!CAN.begin(500E3)) { Serial.println("Falha ao iniciar o controlador CAN"); //caso não seja possível iniciar o controlador while (1); } }

Étape 20: Code source: boucle (), obtenir le package et vérifier le format

Nous avons essayé de vérifier la taille du paquet reçu. La méthode CAN.parsePacket() me montre la taille de ce package. Donc, si nous avons un package, nous vérifierons s'il est prolongé ou non.

void loop() { // Tenta verificar o tamanho do acote recebido int packetSize = CAN.parsePacket(); if (packetSize) { // Voir les temos um pacote Serial.println("Recebido pacote. "); if (CAN.packetExtended()) { //verifica se o pacote é estendido Serial.println("Estendido"); }

Étape 21: Source: Loop (), vérifie s'il s'agit d'un package distant

Ici, nous vérifions si le paquet reçu est une demande de données. Dans ce cas, il n'y a pas de données.

if (CAN.packetRtr()) { //Verifica se o pacote é um pacote remoto (Requisição de dados), neste caso não há dados Serial.print("RTR "); }

Étape 22: Code source: boucle (), longueur de données demandée ou reçue

Si le paquet reçu est une requête, nous indiquons la longueur demandée. On obtient alors le Data Length Code (DLC) qui indique la longueur des données. Enfin, nous indiquons la longueur reçue.

Serial.print("Pacote com id 0x"); Serial.print(CAN.packetId(), HEX); if (CAN.packetRtr()) { //se o pacote recebido é de réquisition, indicamos o comprimento sollicitado Serial.print(" e requsitou o comprimento "); Serial.println(CAN.packetDlc()); //obtem o DLC (Data Length Code, que indica o comprimento dos dados) } else { Serial.print(" e comprimento "); // aqui somente indica ou comprimento recebido Serial.println(packetSize);

Étape 23: Code source: boucle (), si des données sont reçues, elles s'impriment ensuite

Nous imprimons (sur le moniteur série) les données, mais seulement si le paquet reçu n'est pas une requête.

//Imprimer sur certaines données afin de recevoir la demande de confirmation pendant que (CAN.available()) { Serial.print((char)CAN.read()); } Serial.println(); } Serial.println(); } }

Étape 24: Téléchargez les fichiers

PDF

INO