Hvordan bygge en CAN-buss med et breadboard og Arduino

Controller Area Network (CAN)-bussen er en robust og pålitelig kommunikasjonsprotokoll som er mye brukt i ulike industri-, bil- og romfartsapplikasjoner. Den er designet for overføring av data mellom mikrokontrollere og enheter over et CAN-bussnettverk. Du vet kanskje ikke dette ennå, men det er tingen bak de sprø bil dashbord mods du ser på sosiale medier.

Vi vil lede deg gjennom hvordan du bygger en CAN-buss med MCP2515 CAN-modulen ved å bruke en Arduino og breadboard. Vi vil også gå gjennom Arduino CAN-biblioteket og demonstrere hvordan du sender og mottar data over CAN-bussen.

Hva er en CAN-buss?

CAN-bussen er en seriell kommunikasjonsprotokoll som ble utviklet av Bosch på 1980-tallet. Den er mye brukt i ulike applikasjoner på grunn av sin høye pålitelighet og robusthet. Den tillater overføring av data mellom enheter ved høye hastigheter med minimal latens over bare to linjer: CAN High og CAN Low.

I 1994 ble CAN-bussen en internasjonal standard (ISO 11898) som ble designet spesielt for rask seriell datautveksling mellom elektroniske kontrollere i bilapplikasjoner. Sjekk ut vår omfattende guide på hva en CAN-buss er og hvilken rolle den spiller i bilsystemer for flere detaljer.

En av grunnene til at CAN-bussen er så populær er på grunn av dens feildeteksjons- og korrigeringsfunksjoner. Protokollen kan oppdage og korrigere feil i overføringen av data. Dette gjør den ideell for applikasjoner der dataintegritet er kritisk, for eksempel innen industriell automatisering.

Kjenne til MCP2515 CAN-modulen

MCP2515 CAN Bus Controller-modulen er en enhet som gir eksepsjonell støtte for den mye brukte CAN Protocol versjon 2.0B. Denne modulen er ideell for kommunikasjon med høye datahastigheter på opptil 1 Mbps.

MCP2515 IC er en uavhengig CAN-kontroller med et SPI-grensesnitt som muliggjør kommunikasjon med et bredt spekter av mikrokontrollere. TJA1050 IC, derimot, fungerer som et grensesnitt mellom MCP2515 CAN-kontroller IC og den fysiske CAN-bussen.

For ekstra bekvemmelighet er det en jumper som lar deg koble til 120 ohm terminering, noe som gjør det enda enklere å koble ledningene til CAN_H & KAN JEG skruer for kommunikasjon med andre CAN-moduler.

Du kan få ytterligere informasjon fra MCP2515 datablad i tilfelle du trenger denne modulen for et mer avansert prosjekt.

CAN-meldingsstruktur

CAN-meldingsstrukturen består av flere segmenter, men de mest kritiske segmentene for dette prosjektet er identifikatoren og dataene. Identifikatoren, også kjent som CAN ID eller Parameter Group Number (PGN), identifiserer enhetene på CAN-en nettverk, og lengden på identifikatoren kan være enten 11 eller 29 biter, avhengig av typen CAN-protokoll brukt.

I mellomtiden representerer dataene de faktiske sensor-/kontrolldataene som overføres. Dataene kan være alt fra 0 til 8 byte lange, og Data Length Code (DLC) indikerer antall databyte som er tilstede.

Arduino MCP2515 CAN Bus Library

Dette biblioteket implementerer CAN V2.0B-protokoll, som kan operere med hastigheter på opptil 1 Mbps. Den gir et SPI-grensesnitt som kan operere med hastigheter på opptil 10MHz samtidig som den støtter både standard (11-bit) og utvidet (29-bit) data. Dessuten kommer den med to mottaksbuffere, som gir mulighet for prioritert meldingslagring.

Initialisering av CAN-bussen

Her er oppsettkoden du trenger for å initialisere CAN-bussen:

#inkludere
#inkludere
MCP2515 mcp2515(10); // Sett CS pin
tomromoppsett(){
samtidig som (!Seriell);
Seriell.begynne(9600);
SPI.begynne(); //Begynner SPI-kommunikasjon
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
}

Dette initialiserer MCP2515 med en CAN-bithastighet på 500Kbps og en oscillatorfrekvens på 8MHz.

MCP2515 CAN driftsmoduser

Det er tre driftsmoduser som brukes med MCP2515 CAN bus-kontrolleren:

• setNormalMode(): setter kontrolleren til å sende og motta meldinger.
• setLoopbackMode(): setter kontrolleren til å sende og motta meldinger, men meldingene den sender vil også mottas av seg selv.
• setListenOnlyMode(): setter kontrolleren til kun å motta meldinger.

Dette er funksjonskall som brukes til å angi driftsmodusen til MCP2515 CAN-busskontrolleren.

mcp2515.setNormalMode();

mcp2515.setLoopbackMode();

mcp2515.setListenOnlyMode();

Sende data over CAN-bussen

For å sende en melding over CAN-bussen, bruk sendMsgBuf() metode:

usignertrøye data[] = {0x01, 0x02, 0x03, 0x04};
CAN.sendMsgBuf(0x01, 0, 4, data);

Dette sender en melding med ID 0x01 og en datanyttelast på {0x01, 0x02, 0x03, 0x04}. Den første parameteren er CAN ID, den andre er meldingsprioriteten, den tredje er lengden på datanyttelasten, og den fjerde er selve datanyttelasten.

De sendMsgBuf() metoden returnerer en verdi som indikerer om meldingen ble sendt eller ikke. Du kan sjekke denne verdien ved å ringe checkError() metode:

hvis (CAN.checkError()) {
Seriell.println("Feil ved sending av melding.");
}

Denne sjekker om det oppstod en feil under overføringen av meldingen og skriver ut en feilmelding om nødvendig.

Motta data fra CAN-bussen

For å motta en melding over CAN-bussen kan du bruke readMsgBuf() metode:

usignertrøye len = 0;
usignertrøye buff[8];
usignertrøye canID = 0;
hvis (CAN.checkReceive()) {
 CAN.readMsgBuf(&len, buf);
 canID = CAN.getCanId();
}

Dette sjekker om en melding er tilgjengelig på CAN-bussen og leser deretter meldingen inn i buff array. Lengden på meldingen lagres i len variabel, og meldingens ID er lagret i canID variabel.

Når du har mottatt en melding, kan du behandle datanyttelasten etter behov. Du kan for eksempel skrive ut nyttelasten til den serielle monitoren:

Seriell.skrive ut("Mottatt melding med ID");
Seriell.skrive ut(canID, HEX);
Seriell.skrive ut(" og data: ");
til (int jeg = 0; i < len; i++) {
Seriell.skrive ut(buff[i], HEX);
Seriell.skrive ut(" ");
}
Seriell.println();

Dette skriver ut IDen til den mottatte meldingen og datanyttelasten til den serielle monitoren.

Slik kobler du en CAN Bus-sender/mottaker til et brødbrett

For å bygge en CAN-buss for å koble til to enheter i dette eksempelprosjektet, trenger du:

• To mikrokontrollere (to Arduino Nano-kort for dette eksemplet)
• To MCP2515 CAN-moduler
• Et brødbrett
• Jumper ledninger
• En I2C 16x2 LCD-skjermmodul
• HC-SR04 ultralydsensor

For dette prosjekteksemplet brukes fire biblioteker i Arduino-skissen. Det er NewPing bibliotek, som gir et brukervennlig grensesnitt for ultralydsensoren, så vel som SPI bibliotek, som letter kommunikasjonen mellom Arduino-kortet og MCP2515 CAN-busskontrolleren. De LiquidCrystal_I2C biblioteket brukes for visningsmodulen.

Til slutt er det mcp2515 bibliotek til grensesnitt med MCP2515-brikken, slik at vi enkelt kan overføre data over CAN-bussnettverket.

Maskinvareoppsett (HC-SR04 eksempel)

I dette prosjektet som bruker en HC-SR04-sensor og LCD, vil det ene Arduino Nano-kortet fungere som en mottaker, mens det andre Arduinoet vil fungere som en avsender. Koble til senderkomponentene i henhold til koblingsskjemaet nedenfor:

Her er diagrammet for mottakerkretsen:

Koble til slutt de to nodene sammen ved hjelp av CAN_H og KAN JEG linjer som vist:

Når du kobler til modulene, er det viktig å sikre at strømforsyningsspenningen er innenfor det spesifiserte området og at KAN H og KAN JEG pinnene er riktig koblet til bussen.

Programmering av MCP2515 CAN Bus Module

Merk at når du programmerer MCP2515-modulen, er det viktig å bruke riktig bithastighet for å sikre vellykket kommunikasjon med andre CAN-enheter på nettverket.

Avsenderkode:

#inkludere
#inkludere
#inkludere
MCP2515 mcp2515(10);
konstbyte trigPin = 3;
konstbyte echoPin = 4;
NewPing ekkolodd(trigPin, echoPin, 200);
strukturkan_rammecanMsg;
tomromoppsett(){
Seriell.begynne(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
}
tomromLøkke(){
usignertint avstand = sonar.ping_cm();
 canMsg.can_id = 0x036; //CAN id som 0x036
 canMsg.can_dlc = 8; //CAN-datalengde som 8
 canMsg.data[0] = avstand; //Oppdater fuktighetsverdien i [0]
 canMsg.data[1] = 0x00; //Hvil alle med 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);//Sender CAN-meldingen
forsinkelse(100);
}

Mottakerkode:

#inkludere
#inkludere
#inkludere
MCP2515 mcp2515(10);
LiquidCrystal_I2C lcd(0x27,16,2);
strukturkan_rammecanMsg;
tomromoppsett(){
Seriell.begynne(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
 lcd.init();
 lcd.baklys();
 lcd.setMarkør(0, 0);
 lcd.skrive ut("MUO CAN TUTORIAL");
forsinkelse(3000);
 lcd.klar();
}
tomromLøkke(){
hvis (mcp2515.readMessage(&canMsg) == MCP2515::ERROR_OK) // For å motta data
 {
int avstand = canMsg.data[0];
 lcd.setMarkør(0,0);
 lcd.skrive ut("Avstand:");
 lcd.skrive ut(avstand);
 lcd.skrive ut("cm");
 }
}

Ta Arduino-prosjektene dine til neste nivå

Kombinasjonen av CAN-bussen og Arduino gir en kraftig plattform for å bygge eller lære sofistikerte kommunikasjonsnettverk som brukes i ulike applikasjoner. Selv om det kan virke som en bratt læringskurve, er det å ha ditt eget oppsett på et brødbrett en ganske hendig måte å lære seg å bruke et CAN-bussnettverk i komplekse DIY-prosjekter.