CAN-protocol - Ja, we kunnen!: 24 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

Een ander onderwerp dat onlangs door de volgers van mijn YouTube-kanaal werd gesuggereerd, was het CAN-protocol (Controller Area Network), waar we ons vandaag op zullen concentreren. Het is belangrijk om uit te leggen dat CAN een gelijktijdig serieel communicatieprotocol is. Dit betekent dat de synchronisatie tussen de op het netwerk aangesloten modules wordt uitgevoerd in relatie tot het begin van elk bericht dat naar de bus wordt verzonden. We beginnen met het introduceren van de basisconcepten van het CAN-protocol en voeren een eenvoudige montage uit met twee ESP32's.

In ons circuit kunnen de ESP's zowel als master als als slave fungeren. Je kunt meerdere microcontrollers tegelijk laten zenden, omdat de CAN de botsing van alles automatisch afhandelt. De broncode van dit project is supereenvoudig. Bekijken!

Stap 1: Gebruikte bronnen

• Twee modules van ESP WROOM 32 NodeMcu
• Twee CAN-transceivers van WaveShare
• Jumpers voor verbindingen
• Logische analysator voor vastleggen
• Drie USB-kabels voor ESP's en analysator
• 10 meter getwist paar om als bus te dienen

Stap 2: CAN (Controller Area Network)

• Het werd in de jaren 80 ontwikkeld door Robert Bosch GmbH om de auto-industrie te bedienen.
• Het is in de loop der jaren wijdverbreid geworden vanwege de robuustheid en flexibiliteit van de implementatie. Het wordt gebruikt met militaire uitrusting, landbouwmachines, industriële en gebouwautomatisering, robotica en medische apparatuur.

Stap 3: CAN - Functies

• Tweedraads seriële communicatie
• Maximaal 8 bytes aan nuttige informatie per frame, fragmentatie mogelijk
• Adres gericht naar het bericht en niet naar het knooppunt
• Prioriteit toekennen aan berichten en doorsturen van "in de wacht" berichten
• Effectief vermogen om fouten te detecteren en te signaleren
• Mogelijkheid tot meerdere masters (alle nodes kunnen bustoegang aanvragen)
• Multicast-mogelijkheid (één bericht voor meerdere ontvangers tegelijk)
• Overdrachtssnelheden tot 1Mbit/s op een bus van 40 meter (verlaging van de snelheid bij toename van de raillengte)
• Flexibiliteit van configuratie en introductie van nieuwe nodes (tot 120 nodes per bus)
• Standaard hardware, lage kosten en goede beschikbaarheid
• Gereguleerd protocol: ISO 11898

Stap 4: Circuit gebruikt

Hier heb ik de zendontvangers. Er is er een aan elke kant en ze zijn verbonden door een paar draden. De ene is verantwoordelijk voor het verzenden en de andere voor het ontvangen van gegevens.

Stap 5: Transmissielijnspanningen (differentiële detectie)

In CAN is het dominante bit nul.

Lijndifferentiële detectie vermindert de ruisgevoeligheid (EFI)

Stap 6: CAN-standaarden en frames-indeling

Standaardformaat met 11-bits identifier

Stap 7: CAN-standaarden en frames-indeling

Uitgebreid formaat met 29-bits identifier

Stap 8: CAN-standaarden en frames-indeling

Het is belangrijk op te merken dat een protocol de CRC al berekent en ACK- en EOF-signalen verzendt, wat al door het CAN-protocol wordt gedaan. Dit garandeert dat het verzonden bericht niet op de verkeerde manier aankomt. Dit komt omdat als het een probleem geeft in de CRC (Redundant Cyclic Check of Redundancy Check), wat hetzelfde is als een informatiecontrolecijfer, het wordt geïdentificeerd door de CRC.

Stap 9: Vier soorten frames (frames)

Het is belangrijk op te merken dat een protocol de CRC al berekent en ACK- en EOF-signalen verzendt, wat al door het CAN-protocol wordt gedaan. Dit garandeert dat het verzonden bericht niet op de verkeerde manier aankomt. Dit komt omdat als het een probleem geeft in de CRC (Redundant Cyclic Check of Redundancy Check), wat hetzelfde is als een informatiecontrolecijfer, het wordt geïdentificeerd door de CRC.

Vier soorten frames (frames)

Het verzenden en ontvangen van gegevens in de CAN is gebaseerd op vier soorten frames. De frametypes zullen worden geïdentificeerd door variaties in de besturingsbits of zelfs door veranderingen in de frameschrijfregels voor elk geval.

• Data Frame: Bevat de zendergegevens voor de ontvanger(s)
• Remote Frame: dit is een verzoek om gegevens van een van de knooppunten
• Error Frame: het is een frame dat door een van de knooppunten wordt verzonden bij het identificeren van een fout in de bus en dat door alle knooppunten kan worden gedetecteerd
• Overbelastingsframe: dient om het verkeer op de bus te vertragen vanwege gegevensoverbelasting of vertraging op een of meer knooppunten.

Stap 10: Circuit - Details van verbindingen

Stap 11: Circuit - Gegevens vastleggen

Golflengten verkregen voor standaard CAN met 11-bits ID

Stap 12: Circuit - Gegevens vastleggen

Golflengten verkregen voor uitgebreide CAN met 29-bits ID

Stap 13: Circuit - Gegevens vastleggen

Gegevens verkregen door de logische analysator

Stap 14: Arduino-bibliotheek - CAN

Ik laat hier de twee opties zien waar je de CAN Driver Library kunt installeren

Arduino IDE Bibliotheek Manager

Stap 15: Github

github.com/sandeepmistry/arduino-CAN

Stap 16: Zenderbroncode

Broncode: Inclusief en Setup ()

We nemen de CAN-bibliotheek op, starten de serie voor debugging en starten de CAN-bus op 500 kbps.

#include //Inclusief een biblioteca CAN void setup() {Serial.begin(9600); //inicia een seriële para debug while (!Serial); Serial.println ("Transmissor CAN"); // Inicia o barramento KAN een 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); } }

Stap 17: Broncode: lus (), een standaard CAN 2.0-pakket verzenden

Met behulp van de standaard CAN 2.0 versturen wij een pakket. De 11-bits ID identificeert het bericht. Het datablok mag maximaal 8 bytes bevatten. Het begint het pakket met ID 18 in hexadecimaal. Het packs 5 bytes en sluit de functie.

void loop() {// Gebruik van CAN 2.0 padrão //Envia um pacote: o id tem 11 bits e identifica a mensagem (prioridade, eventto) //o bloco de dados deve possuir até 8 bytes Serial.println("Enviando pacote …"); KAN.beginPacket (0x12); //id 18 em hexadecimaal 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 o pacote para envio Serial.println ("Enviado."); vertraging (1000);

Stap 18: Broncode: Loop (), Een uitgebreid CAN 2.0-pakket verzenden

In deze stap heeft de ID 29 bits. Het begint met het verzenden van 24 bits ID en, nogmaals, verpakt 5 bytes en stopt.

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

Stap 19: Broncode ontvanger

Broncode: Inclusief en Setup ()

Nogmaals, we zullen de CAN-bibliotheek opnemen, de serieel starten om te debuggen en de CAN-bus starten op 500 kbps. Als er een fout optreedt, wordt deze fout afgedrukt.

#include //Inclusief een biblioteca CAN void setup() {Serial.begin(9600); //inicia een seriële para debug while (!Serial); Serial.println ("Receptor KAN"); // Inicia o barramento KAN een 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); } }

Stap 20: Broncode: Loop (), het pakket ophalen en het formaat controleren

We hebben geprobeerd de grootte van het ontvangen pakket te controleren. De methode CAN.parsePacket () laat me de grootte van dit pakket zien. Dus als we een pakket hebben, kijken we of het verlengd is of niet.

void loop () {// Tenta verificar of 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 é estendido Serial.println("Estendido"); }

Stap 21: Bron: Loop (), controleert of het een extern pakket is

Hier controleren we of het ontvangen pakket een gegevensverzoek is. In dit geval zijn er geen gegevens.

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

Stap 22: Broncode: lus (), gegevenslengte gevraagd of ontvangen

Als het ontvangen pakket een verzoek is, geven we de gevraagde lengte aan. We verkrijgen dan de Data Length Code (DLC), die de lengte van de gegevens aangeeft. Ten slotte geven we de ontvangen lengte aan.

Serial.print("Pacote com id 0x"); Serial.print(CAN.packetId(), HEX); if (CAN.packetRtr()) {//se o pacote recebido é de requisição, indicamos o comprimento verzoeken 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 of comprimento recebido Serial.println (packetSize);

Stap 23: Broncode: lus (), als gegevens worden ontvangen, wordt deze afgedrukt

We printen (op de seriële monitor) de gegevens, maar alleen als het ontvangen pakket geen verzoek is.

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

Stap 24: Download de bestanden

PDF

INO