Hoe een CAN-bus te bouwen met een breadboard en Arduino

De CAN-bus (Controller Area Network) is een robuust en betrouwbaar communicatieprotocol dat veel wordt gebruikt in verschillende industriële, automobiel- en ruimtevaarttoepassingen. Het is ontworpen voor de overdracht van gegevens tussen microcontrollers en apparaten via een CAN-busnetwerk. Je weet dit misschien nog niet, maar het is het ding achter die gekke autodashboard-mods die je op sociale media ziet.

We laten u zien hoe u een CAN-bus bouwt met de MCP2515 CAN-module met behulp van een Arduino en breadboard. We zullen ook de Arduino CAN-bibliotheek doornemen en demonstreren hoe gegevens via de CAN-bus kunnen worden verzonden en ontvangen.

Wat is een CAN-bus?

De CAN-bus is een serieel communicatieprotocol dat in de jaren tachtig door Bosch is ontwikkeld. Het wordt veel gebruikt in verschillende toepassingen vanwege de hoge betrouwbaarheid en robuustheid. Het zorgt voor de overdracht van gegevens tussen apparaten met hoge snelheden met minimale latentie over slechts twee lijnen: CAN High en CAN Low.

In 1994 werd de CAN-bus een internationale standaard (ISO 11898) die speciaal was ontworpen voor snelle seriële gegevensuitwisseling tussen elektronische controllers in automobieltoepassingen. Bekijk onze uitgebreide gids op wat een CAN-bus is en welke rol deze speelt in autosystemen voor meer informatie.

Een van de redenen waarom de CAN-bus zo populair is, is vanwege de foutdetectie- en correctiefuncties. Het protocol kan fouten in de overdracht van gegevens detecteren en corrigeren. Dit maakt het ideaal voor toepassingen waarbij gegevensintegriteit van cruciaal belang is, zoals in industriële automatisering.

De MCP2515 CAN-module kennen

De MCP2515 CAN Bus Controller-module is een apparaat dat uitzonderlijke ondersteuning biedt voor het veelgebruikte CAN-protocol versie 2.0B. Deze module is ideaal voor communicatie met hoge datasnelheden tot 1 Mbps.

De MCP2515 IC is een onafhankelijke CAN-controller met een SPI-interface die communicatie met een breed scala aan microcontrollers mogelijk maakt. De TJA1050 IC daarentegen functioneert als een interface tussen de MCP2515 CAN-controller-IC en de fysieke CAN-bus.

Voor extra gemak is er een jumper waarmee u een 120 ohm afsluiting kunt aansluiten, waardoor het nog eenvoudiger wordt om uw draden aan te sluiten op de KAN_H & KAN IK schroeven voor communicatie met andere CAN-modules.

Aanvullende informatie kunt u krijgen bij de MCP2515-gegevensblad voor het geval u deze module nodig heeft voor een meer geavanceerd project.

CAN-berichtenstructuur

De CAN-berichtenstructuur bestaat uit meerdere segmenten, maar de meest kritische segmenten voor dit project zijn de identifier en data. De identifier, ook wel CAN ID of Parameter Group Number (PGN) genoemd, identificeert de apparaten op de CAN netwerk, en de lengte van de identifier kan 11 of 29 bits zijn, afhankelijk van het type CAN-protocol gebruikt.

Ondertussen vertegenwoordigen de gegevens de daadwerkelijke sensor-/besturingsgegevens die worden verzonden. De gegevens kunnen 0 tot 8 bytes lang zijn en de Data Length Code (DLC) geeft het aantal aanwezige databytes aan.

De Arduino MCP2515 CAN-busbibliotheek

Deze bibliotheek implementeert de CAN V2.0B-protocol, die kan werken met snelheden tot 1 Mbps. Het biedt een SPI-interface die kan werken met snelheden tot 10 MHz en ondersteunt zowel standaard (11-bits) als uitgebreide (29-bits) gegevens. Bovendien wordt het geleverd met twee ontvangstbuffers, waardoor berichten met prioriteit kunnen worden opgeslagen.

Initialisatie van de CAN-bus

Hier is de setup-code die je nodig hebt om de CAN-bus te initialiseren:

#erbij betrekken
#erbij betrekken
MCP2515 mcp2515(10); // CS-pin instellen
leegteopgericht(){
terwijl (!Serieel);
Serieel.beginnen(9600);
SPI.beginnen(); // Begint SPI-communicatie
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormaleModus();
}

Dit initialiseert de MCP2515 met een CAN-bitsnelheid van 500 Kbps en een oscillatorfrequentie van 8 MHz.

MCP2515 CAN-bedrijfsmodi

Er worden drie bedrijfsmodi gebruikt met de MCP2515 CAN-buscontroller:

• setNormaleModus(): stelt de controller in om berichten te verzenden en te ontvangen.
• setLoopbackMode(): stelt de controller in om berichten te verzenden en te ontvangen, maar de verzonden berichten worden ook zelf ontvangen.
• setListenOnlyMode(): stelt de controller in om alleen berichten te ontvangen.

Dit zijn functieaanroepen die worden gebruikt om de operationele modus van de MCP2515 CAN-buscontroller in te stellen.

mcp2515.setNormaleModus();

mcp2515.setLoopbackMode();

mcp2515.setListenOnlyMode();

Gegevens verzenden via de CAN-bus

Gebruik de om een ​​bericht over de CAN-bus te verzenden stuurMsgBuf() methode:

ongetekendchar gegevens[] = {0x01, 0x02, 0x03, 0x04};
KAN.sendMsgBuf(0x01, 0, 4, gegevens);

Deze stuurt een bericht met de ID 0x01 en een datalading van {0x01, 0x02, 0x03, 0x04}. De eerste parameter is de CAN-ID, de tweede is de berichtprioriteit, de derde is de lengte van de gegevenslading en de vierde is de gegevenslading zelf.

De stuurMsgBuf() methode retourneert een waarde die aangeeft of het bericht met succes is verzonden of niet. U kunt deze waarde controleren door te bellen naar de checkFout() methode:

als (CAN.checkError()) {
Serieel.println("Fout bij verzenden van bericht.");
}

Dit controleert of er een fout is opgetreden tijdens de verzending van het bericht en drukt indien nodig een foutbericht af.

Gegevens ontvangen van de CAN-bus

Om een ​​bericht over de CAN-bus te ontvangen, kunt u de leesMsgBuf() methode:

ongetekendchar len = 0;
ongetekendchar buf[8];
ongetekendchar canID = 0;
als (CAN.checkOntvangen()) {
 CAN.readMsgBuf(&len, buf);
 canID = CAN.getCanId();
}

Deze controleert of er een bericht beschikbaar is op de CAN-bus en leest het bericht vervolgens in de buf reeks. De lengte van het bericht wordt opgeslagen in het lenen variabele en de ID van het bericht wordt opgeslagen in de canID variabel.

Zodra u een bericht heeft ontvangen, kunt u de gegevenslading naar behoefte verwerken. U kunt bijvoorbeeld de datalading naar de seriële monitor afdrukken:

Serieel.afdrukken("Ontvangen bericht met ID ");
Serieel.afdrukken(canID, HEX);
Serieel.afdrukken(" en gegevens: ");
voor (int ik = 0; ik < len; ik++) {
Serieel.afdrukken(buf[i], HEX);
Serieel.afdrukken(" ");
}
Serieel.println();

Dit drukt de ID van het ontvangen bericht en de gegevenslading af naar de seriële monitor.

Een CAN-bus-transceiver aansluiten op een breadboard

Om een ​​CAN-bus te bouwen om twee apparaten in dit voorbeeldproject met elkaar te verbinden, hebt u het volgende nodig:

• Twee microcontrollers (twee Arduino Nano-kaarten voor dit voorbeeld)
• Twee MCP2515 CAN-modules
• Een broodplank
• Jumper draden
• Een I2C 16x2 LCD-schermmodule
• HC-SR04 ultrasone sensor

Voor dit projectvoorbeeld worden vier bibliotheken gebruikt in de Arduino-schets. Daar is de NieuwePing bibliotheek, die een gebruiksvriendelijke interface biedt voor de ultrasone sensor, evenals de SPI-bibliotheek, wat de communicatie tussen het Arduino-bord en de MCP2515 CAN-buscontroller vergemakkelijkt. De LiquidCrystal_I2C bibliotheek wordt gebruikt voor de weergavemodule.

Ten slotte is er de mcp2515 bibliotheek om te communiceren met de MCP2515-chip, waardoor we gemakkelijk gegevens over het CAN-busnetwerk kunnen verzenden.

Hardware-installatie (HC-SR04-voorbeeld)

In dit project met een HC-SR04-sensor en LCD, zal één Arduino Nano-bord fungeren als ontvanger, terwijl de andere Arduino als zender zal fungeren. Sluit uw zendercomponenten aan volgens onderstaand bedradingsschema:

Hier is het diagram voor het ontvangercircuit:

Verbind ten slotte de twee knooppunten met elkaar met behulp van de KAN_H En KAN IK lijnen zoals getoond:

Bij het aansluiten van de modules is het belangrijk om ervoor te zorgen dat de voedingsspanning binnen het gespecificeerde bereik ligt en dat de KAN H En KAN IK pinnen zijn goed aangesloten op de bus.

Programmeren van de MCP2515 CAN-busmodule

Merk op dat het bij het programmeren van de MCP2515-module belangrijk is om de juiste bitsnelheid te gebruiken om succesvolle communicatie met andere CAN-apparaten op het netwerk te garanderen.

Afzendercode:

#erbij betrekken
#erbij betrekken
#erbij betrekken
MCP2515 mcp2515(10);
constbyte trigPin = 3;
constbyte echoPin = 4;
NieuwePing sonar(trigPin, echoPin, 200);
structuurkan_framekanMsg;
leegteopgericht(){
Serieel.beginnen(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormaleModus();
}
leegtelus(){
ongetekendint afstand = sonar.ping_cm();
 canMsg.can_id = 0x036; //CAN-ID als 0x036
 canMsg.can_dlc = 8; // CAN-gegevenslengte als 8
 canMsg.data[0] = afstand; //Vochtigheidswaarde bijwerken in [0]
 canMsg.data[1] = 0x00; // Laat alles rusten met 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);// Verzendt het CAN-bericht
vertraging(100);
}

Ontvangercode:

#erbij betrekken
#erbij betrekken
#erbij betrekken
MCP2515 mcp2515(10);
LiquidCrystal_I2C lcd(0x27,16,2);
structuurkan_framekanMsg;
leegteopgericht(){
Serieel.beginnen(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormaleModus();
 lcd.init();
 lcd.achtergrondverlichting();
 lcd.setCursor(0, 0);
 lcd.afdrukken("MUO KAN TUTORIAL");
vertraging(3000);
 lcd.duidelijk();
}
leegtelus(){
als (mcp2515.Lees bericht(&canMsg) == MCP2515::ERROR_OK) // Om gegevens te ontvangen
 {
int afstand = canMsg.data[0];
 lcd.setCursor(0,0);
 lcd.afdrukken("Afstand: ");
 lcd.afdrukken(afstand);
 lcd.afdrukken("cm ");
 }
}

Breng uw Arduino-projecten naar een hoger niveau

De combinatie van de CAN-bus en Arduino biedt een krachtig platform voor het bouwen of leren van geavanceerde communicatienetwerken die in verschillende toepassingen worden gebruikt. Hoewel het misschien een steile leercurve lijkt, is het hebben van je eigen setup op een breadboard een behoorlijk handige manier om de fijne kneepjes van het gebruik van een CAN-busnetwerk in complexe doe-het-zelfprojecten te leren.