CAN-Protokoll - Ja, das können wir! - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

Ein weiteres Thema, das kürzlich von den Followern meines YouTube-Kanals vorgeschlagen wurde, war das CAN-Protokoll (Controller Area Network), auf das wir uns heute konzentrieren werden. Es ist wichtig zu erklären, dass CAN ein simultanes serielles Kommunikationsprotokoll ist. Dies bedeutet, dass die Synchronität zwischen den an das Netzwerk angeschlossenen Modulen in Bezug auf den Beginn jeder auf den Bus gesendeten Nachricht erfolgt. Wir beginnen mit einer Einführung in die Grundkonzepte des CAN-Protokolls und führen eine einfache Bestückung mit zwei ESP32 durch.

In unserer Schaltung können die ESPs sowohl als Master als auch als Slave fungieren. Sie können mehrere Mikrocontroller gleichzeitig senden lassen, da der CAN die Kollision von allem automatisch behandelt. Der Quellcode dieses Projekts ist super einfach. Hör zu!

Schritt 1: Verwendete Ressourcen

• Zwei Module ESP WROOM 32 NodeMcu
• Zwei CAN-Transceiver von WaveShare
• Jumper für Anschlüsse
• Logischer Analysator für die Erfassung
• Drei USB-Kabel für ESPs und Analysator
• 10 Meter Twisted Pair als Bus

Schritt 2: CAN (Controller Area Network)

• Es wurde in den 1980er Jahren von der Robert Bosch GmbH für die Automobilindustrie entwickelt.
• Es hat sich im Laufe der Jahre aufgrund seiner Robustheit und Flexibilität in der Implementierung verbreitet. Es wird bei militärischen Geräten, Landmaschinen, Industrie- und Gebäudeautomation, Robotik und medizinischen Geräten eingesetzt.

Schritt 3: CAN - Funktionen

• Serielle Zweidrahtkommunikation
• Maximal 8 Byte nützliche Informationen pro Frame, mit Fragmentierung möglich
• Adresse, die an die Nachricht und nicht an den Knoten gerichtet ist
• Nachrichten Vorrang zuweisen und "gehaltene" Nachrichten weiterleiten
• Effektive Fähigkeit, Fehler zu erkennen und zu signalisieren
• Multi-Master-Fähigkeit (alle Teilnehmer können Buszugriff anfordern)
• Multicast-Fähigkeit (eine Nachricht für mehrere Empfänger gleichzeitig)
• Übertragungsraten von bis zu 1Mbit/s auf einem 40-Meter-Bus (Reduzierung der Rate bei Erhöhung der Schienenlänge)
• Flexibilität bei der Konfiguration und Einführung neuer Knoten (bis zu 120 Knoten pro Bus)
• Standardhardware, geringe Kosten und gute Verfügbarkeit
• Geregeltes Protokoll: ISO 11898

Schritt 4: Schaltung verwendet

Hier habe ich die Transceiver. Auf jeder Seite befindet sich eine, und sie sind durch ein Paar Drähte verbunden. Einer ist für das Senden und der andere für den Empfang von Daten verantwortlich.

Schritt 5: Übertragungsleitungsspannungen (Differenzerkennung)

Bei CAN ist das dominante Bit Null.

Leitungsdifferenzerkennung reduziert die Rauschempfindlichkeit (EFI)

Schritt 6: CAN-Standards und Frames-Format

Standardformat mit 11-Bit-Kennung

Schritt 7: CAN-Standards und Frames-Format

Erweitertes Format mit 29-Bit-Kennung

Schritt 8: CAN-Standards und Frames-Format

Es ist wichtig zu beachten, dass ein Protokoll bereits den CRC berechnet und ACK- und EOF-Signale sendet, was bereits vom CAN-Protokoll erledigt wird. Dies garantiert, dass die gesendete Nachricht nicht falsch ankommt. Dies liegt daran, dass ein Problem in der CRC (Redundant Cyclic Check oder Redundancy Check), die mit einer Informationsprüfziffer identisch ist, durch die CRC identifiziert wird.

Schritt 9: Vier Arten von Frames (Frames)

Es ist wichtig zu beachten, dass ein Protokoll bereits den CRC berechnet und ACK- und EOF-Signale sendet, was bereits vom CAN-Protokoll erledigt wird. Dies garantiert, dass die gesendete Nachricht nicht falsch ankommt. Dies liegt daran, dass ein Problem in der CRC (Redundant Cyclic Check oder Redundancy Check), die mit einer Informationsprüfziffer identisch ist, durch die CRC identifiziert wird.

Vier Arten von Rahmen (Rahmen)

Das Senden und Empfangen von Daten im CAN basiert auf vier Arten von Frames. Die Rahmentypen werden durch Variationen in den Steuerbits oder sogar durch Änderungen in den Rahmenschreibregeln für jeden Fall identifiziert.

• Datenrahmen: Enthält die Senderdaten für den/die Empfänger(e)
• Remote Frame: Dies ist eine Datenanforderung von einem der Knoten
• Error Frame: Dies ist ein Frame, der von einem der Knoten gesendet wird, wenn ein Fehler im Bus erkannt wird und der von allen Knoten erkannt werden kann
• Overload Frame: Dient zur Verzögerung des Datenverkehrs auf dem Bus aufgrund von Datenüberlastung oder Verzögerung auf einem oder mehreren Knoten.

Schritt 10: Schaltung - Details der Verbindungen

Schritt 11: Schaltung - Datenerfassung

Erhaltene Wellenlängen für Standard-CAN mit 11-Bit-ID

Schritt 12: Schaltung - Datenerfassung

Erhaltene Wellenlängen für erweitertes CAN mit 29-Bit-ID

Schritt 13: Schaltung - Datenerfassung

Vom Logikanalysator erhaltene Daten

Schritt 14: Arduino-Bibliothek - CAN

Ich zeige hier die beiden Möglichkeiten, wo Sie die CAN-Treiberbibliothek installieren können

Arduino IDE-Bibliotheksmanager

Schritt 15: Github

github.com/sandeepmistry/arduino-CAN

Schritt 16: Quellcode des Senders

Quellcode: Enthält und Setup ()

Wir binden die CAN-Bibliothek ein, starten die serielle Schnittstelle zum Debuggen und starten den CAN-Bus mit 500 kbps.

#include // Eine Biblioteca einschließen CAN void setup () { Serial.begin (9600); //inicia ein serielles Para-Debug while (!Serial); Serial.println ("Transmissor CAN"); // Inicia oder 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); } }

Schritt 17: Quellcode: Loop (), Senden eines Standard-CAN 2.0-Pakets

Mit dem Standard CAN 2.0 versenden wir ein Paket. Die 11-Bit-ID identifiziert die Nachricht. Der Datenblock muss bis zu 8 Byte lang sein. Es beginnt das Paket mit der ID 18 in hexadezimaler Form. Es packt 5 Bytes und schließt die Funktion.

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 hexadezimal CAN.write('h'); //1º Byte CAN.write('e'); //2º Byte CAN.write('l'); ///3º Byte CAN.write('l'); ///4º Byte CAN.write('o'); ///5º Byte CAN.endPacket(); // Encerra oder Pacote für Envio Serial.println ("Enviado."); Verzögerung (1000);

Schritt 18: Quellcode: Loop (), Senden eines erweiterten CAN 2.0-Pakets

In diesem Schritt hat die ID 29 Bit. Es beginnt mit dem Senden von 24 ID-Bits, packt erneut 5 Bytes und wird beendet.

// 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 Dezimal (abcdef em hexa) = 24 Bit preenchidos até aqui CAN.write('w'); ///1º Byte CAN.write('o'); //° Byte CAN.write('r'); ///3º Byte CAN.write('l'); ///4º Byte CAN.write('d'); ///5º Byte CAN.endPacket(); // Encerra oder Pacote für Envio Serial.println ("Enviado."); Verzögerung (1000); }

Schritt 19: Quellcode des Empfängers

Quellcode: Enthält und Setup ()

Auch hier werden wir die CAN-Bibliothek einschließen, die serielle zum Debuggen starten und den CAN-Bus mit 500 kbps starten. Tritt ein Fehler auf, wird dieser Fehler gedruckt.

#include // Eine Biblioteca einschließen CAN void setup () { Serial.begin (9600); //inicia ein serielles Para-Debug while (!Serial); Serial.println ("Rezeptor-CAN"); // Inicia oder 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); } }

Schritt 20: Quellcode: Loop (), Abrufen des Pakets und Überprüfen des Formats

Wir haben versucht, die Größe des empfangenen Pakets zu überprüfen. Die Methode CAN.parsePacket() zeigt mir die Größe dieses Pakets an. Wenn wir also ein Paket haben, prüfen wir, ob es verlängert wird oder nicht.

Void loop () {// Tenta verificar o tamanho do acote recebido int packetSize = CAN.parsePacket (); if (packetSize) {// Se temos um pacote Serial.println ("Recebido pacote. "); if (CAN.packetExtended ()) {//Verifica se o pacote é stendido Serial.println ("Estendido"); }

Schritt 21: Quelle: Loop (), prüft, ob es sich um ein Remote-Paket handelt

Hier prüfen wir, ob das empfangene Paket eine Datenanforderung ist. In diesem Fall sind keine Daten vorhanden.

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

Schritt 22: Quellcode: Schleife (), angeforderte oder empfangene Datenlänge

Wenn das empfangene Paket eine Anfrage ist, geben wir die angeforderte Länge an. Wir erhalten dann den Data Length Code (DLC), der die Länge der Daten angibt. Schließlich geben wir die erhaltene Länge an.

Serial.print ("Pacote com id 0x"); Serial.print (CAN.packetId(), HEX); if (CAN.packetRtr()) {//se o pacote recebido é de requisição, indicamos o comprimento solicitado Serial.print ("e requsitou o comprimento"); Serial.println (CAN.packetDlc()); // obtem o DLC (Datenlängencode, que indica o comprimento dos dados)} else {Serial.print ("e comprimento"); // Aqui somente indica oder comprimento recebido Serial.println (packetSize);

Schritt 23: Quellcode: Loop (), wenn Daten empfangen werden, wird es dann gedruckt

Wir drucken (auf dem seriellen Monitor) die Daten, aber nur, wenn das empfangene Paket keine Anfrage ist.

// Imprime os dados somente se o pacote recebido não foi de requisição while (CAN.available ()) {Serial.print ((char) CAN.read ()); } Serial.println(); } Serial.println(); } }

Schritt 24: Laden Sie die Dateien herunter

PDF

INO