Hogyan készítsünk CAN-buszt kenyértáblával és Arduino-val

A Controller Area Network (CAN) busz egy robusztus és megbízható kommunikációs protokoll, amelyet széles körben használnak különféle ipari, autóipari és repülőgépipari alkalmazásokban. Mikrokontrollerek és eszközök közötti adatátvitelre tervezték CAN-busz hálózaton keresztül. Lehet, hogy ezt még nem tudod, de ez áll a közösségi médiában látható őrült autós műszerfali modok mögött.

Végigvezetjük Önt, hogyan építhet CAN-buszt az MCP2515 CAN-modullal Arduino és kenyérlap segítségével. Áttekintjük az Arduino CAN könyvtárat is, és bemutatjuk, hogyan küldhetünk és fogadhatunk adatokat a CAN buszon keresztül.

Mi az a CAN busz?

A CAN busz egy soros kommunikációs protokoll, amelyet a Bosch fejlesztett ki az 1980-as években. Nagy megbízhatósága és robusztussága miatt széles körben használják különféle alkalmazásokban. Lehetővé teszi az adatok átvitelét az eszközök között nagy sebességgel minimális késleltetéssel mindössze két vonalon keresztül: CAN High és CAN Low.

1994-ben a CAN busz nemzetközi szabvány lett (ISO 11898), amelyet kifejezetten az autóipari alkalmazások elektronikus vezérlői közötti gyors soros adatcserére terveztek. Tekintse meg átfogó útmutatónkat mi a CAN busz és milyen szerepet játszik az autóipari rendszerekben további részletekért.

Az egyik ok, amiért a CAN busz olyan népszerű, a hibaészlelési és -javító funkciói miatt van. A protokoll képes észlelni és kijavítani az adatátvitel során fellépő hibákat. Ez ideálissá teszi olyan alkalmazásokhoz, ahol kritikus az adatok integritása, például az ipari automatizálásban.

Az MCP2515 CAN modul ismerete

Az MCP2515 CAN Bus Controller modul egy olyan eszköz, amely kivételes támogatást nyújt a széles körben használt CAN Protocol 2.0B verziójához. Ez a modul ideális nagy, akár 1 Mbps adatátviteli sebességű kommunikációhoz.

Az MCP2515 IC egy független CAN vezérlő SPI interfésszel, amely lehetővé teszi a kommunikációt a mikrokontrollerek széles skálájával. A TJA1050 IC ezzel szemben interfészként működik az MCP2515 CAN vezérlő IC és a fizikai CAN busz között.

A nagyobb kényelem érdekében van egy jumper, amely lehetővé teszi a 120 ohmos lezárást, így még könnyebben csatlakoztathatja a vezetékeket a CAN_H & LEHET csavarok a többi CAN-modullal való kommunikációhoz.

További információkat a MCP2515 adatlap ha szüksége van erre a modulra egy fejlettebb projekthez.

CAN üzenetstruktúra

A CAN üzenetstruktúra több szegmensből áll, de a projekt szempontjából a legkritikusabb szegmensek az azonosító és az adatok. Az azonosító, más néven CAN ID vagy Parameter Group Number (PGN), azonosítja a CAN-on lévő eszközöket. hálózat, és az azonosító hossza 11 vagy 29 bit lehet, a CAN protokoll típusától függően használt.

Eközben az adatok a ténylegesen továbbított érzékelő/vezérlő adatokat jelentik. Az adatok bárhol 0 és 8 bájt közöttiek lehetnek, és a Data Length Code (DLC) jelzi a jelenlévő adatbájtok számát.

Az Arduino MCP2515 CAN buszkönyvtár

Ez a könyvtár valósítja meg a CAN V2.0B protokoll, amely akár 1 Mbps sebességgel is működhet. SPI interfészt biztosít, amely akár 10 MHz-es sebességgel is működhet, miközben támogatja a szabványos (11 bites) és a kiterjesztett (29 bites) adatokat is. Sőt, két fogadópufferrel is rendelkezik, amelyek lehetővé teszik az üzenetek fontosabb tárolását.

A CAN busz inicializálása

Íme a CAN-busz inicializálásához szükséges beállítási kód:

#tartalmazza
#tartalmazza
MCP2515 mcp2515(10); // CS pin beállítása
üresbeállít(){
míg (!Sorozatszám);
Sorozatszám.kezdődik(9600);
SPI.kezdődik(); //Megkezdődik az SPI-kommunikáció
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
}

Ez inicializálja az MCP2515-öt 500 Kbps CAN bitsebességgel és 8 MHz oszcillátorfrekvenciával.

MCP2515 CAN működési módok

Az MCP2515 CAN buszvezérlővel három üzemmód használható:

• setNormalMode(): beállítja a vezérlőt üzenetek küldésére és fogadására.
• setLoopbackMode(): beállítja a vezérlőt üzenetek küldésére és fogadására, de az általa küldött üzeneteket is magától fogadja.
• setListenOnlyMode(): beállítja, hogy a vezérlő csak üzeneteket fogadjon.

Ezek olyan funkcióhívások, amelyek az MCP2515 CAN buszvezérlő működési módjának beállítására szolgálnak.

mcp2515.setNormalMode();

mcp2515.setLoopbackMode();

mcp2515.setListenOnlyMode();

Adatok küldése CAN buszon keresztül

Üzenet küldéséhez a CAN buszon használja a sendMsgBuf() módszer:

aláírás nélkülichar adat[] = {0x01, 0x02, 0x03, 0x04};
CAN.sendMsgBuf(0x01, 0, 4, adatok);

Ez üzenetet küld az azonosítóval 0x01 és a hasznos adatmennyiség 0x01, 0x02, 0x03, 0x04}. Az első paraméter a CAN ID, a második az üzenet prioritása, a harmadik az adathordozó hossza, a negyedik pedig maga az adatterhelés.

A sendMsgBuf() metódus egy értéket ad vissza, amely jelzi, hogy az üzenet sikeresen el lett-e küldve vagy sem. Ezt az értéket a telefonszámon ellenőrizheti checkError() módszer:

ha (CAN.checkError()) {
Sorozatszám.println("Hiba az üzenet küldésekor.");
}

Ez ellenőrzi, hogy történt-e hiba az üzenet továbbítása során, és szükség esetén hibaüzenetet nyomtat.

Adatok fogadása a CAN buszról

Ha üzenetet szeretne fogadni a CAN buszon keresztül, használja a readMsgBuf() módszer:

aláírás nélkülichar len = 0;
aláírás nélkülichar buf[8];
aláírás nélkülichar canID = 0;
ha (CAN.checkReceive()) {
 CAN.readMsgBuf(&len, buf);
 canID = CAN.getCanId();
}

Ez ellenőrzi, hogy elérhető-e üzenet a CAN buszon, majd beolvassa az üzenetet buf sor. Az üzenet hossza a len változó, és az üzenet azonosítója a canID változó.

Miután megkapta az üzenetet, szükség szerint feldolgozhatja az adathordozót. Például kinyomtathatja az adathordozót a soros monitorra:

Sorozatszám.nyomtatás("Üzenet érkezett azonosítóval");
Sorozatszám.nyomtatás(canID, HEX);
Sorozatszám.nyomtatás(" és adatok: ");
számára (int i = 0; i < len; i++) {
Sorozatszám.nyomtatás(buf[i], HEX);
Sorozatszám.nyomtatás(" ");
}
Sorozatszám.println();

Ez kinyomtatja a fogadott üzenet azonosítóját és az adathordozót a soros monitorra.

Hogyan csatlakoztassunk egy CAN-busz adó-vevőt a kenyértáblához

Ebben a példaprojektben két eszköz csatlakoztatására szolgáló CAN-busz építéséhez a következőkre lesz szüksége:

• Két mikrokontroller (ebben a példában két Arduino Nano kártya)
• Két MCP2515 CAN modul
• Kenyérdeszka
• Jumper vezetékek
• Egy I2C 16x2 LCD képernyős modul
• HC-SR04 ultrahangos érzékelő

Ebben a projektpéldában négy könyvtárat használunk az Arduino vázlatban. Ott van a NewPing könyvtár, amely könnyen kezelhető felületet biztosít az Ultrahangos érzékelőhöz, valamint a SPI könyvtár, amely megkönnyíti a kommunikációt az Arduino kártya és az MCP2515 CAN buszvezérlő között. A LiquidCrystal_I2C könyvtárat használják a megjelenítő modulhoz.

Végül ott van a mcp2515 könyvtár az MCP2515 chippel való interfészhez, lehetővé téve az adatok egyszerű továbbítását a CAN-busz hálózaton keresztül.

Hardverbeállítás (HC-SR04 példa)

Ebben a HC-SR04 érzékelőt és LCD-t használó projektben az egyik Arduino Nano kártya vevőként, míg a másik Arduino küldőként fog működni. Csatlakoztassa a küldő alkatrészeit az alábbi kapcsolási rajz szerint:

Íme a vevő áramkör diagramja:

Végül kösse össze a két csomópontot a CAN_H és LEHET vonalak az ábrán látható módon:

A modulok csatlakoztatásakor ügyelni kell arra, hogy a tápfeszültség a megadott tartományon belül legyen, és a CAN H és LEHET a tűk megfelelően csatlakoznak a buszhoz.

Az MCP2515 CAN busz modul programozása

Ne feledje, hogy az MCP2515 modul programozásakor fontos a megfelelő bitsebesség használata a hálózat más CAN-eszközeivel való sikeres kommunikáció érdekében.

Feladó kódja:

#tartalmazza
#tartalmazza
#tartalmazza
MCP2515 mcp2515(10);
constbyte trigPin = 3;
constbyte echoPin = 4;
NewPing hanglokátor(trigPin, echoPin, 200);
structcan_framecanMsg;
üresbeállít(){
Sorozatszám.kezdődik(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
}
üreshurok(){
aláírás nélküliint távolság = szonár.ping_cm();
 canMsg.can_id = 0x036; //CAN azonosító: 0x036
 canMsg.can_dlc = 8; //CAN adathossz 8
 canMsg.data[0] = távolság; //A páratartalom frissítése itt: [0]
 canMsg.data[1] = 0x00; //Tudjon mindent 0-val 
 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);//Elküldi a CAN üzenetet
késleltetés(100);
}

Vevő kódja:

#tartalmazza
#tartalmazza
#tartalmazza
MCP2515 mcp2515(10);
LiquidCrystal_I2C lcd(0x27,16,2);
structcan_framecanMsg;
üresbeállít(){
Sorozatszám.kezdődik(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
 lcd.init();
 lcd.backlight();
 lcd.setCursor(0, 0);
 lcd.nyomtatás("MUO CAN TUTORIAL");
késleltetés(3000);
 lcd.egyértelmű();
}
üreshurok(){
ha (mcp2515.Üzenet olvasása(&canMsg) == MCP2515::ERROR_OK) // Adatok fogadásához
 {
int távolság = canMsg.data[0];
 lcd.setCursor(0,0);
 lcd.nyomtatás("Távolság:");
 lcd.nyomtatás(távolság);
 lcd.nyomtatás("cm");
 }
}

Emelje Arduino projektjeit a következő szintre

A CAN-busz és az Arduino kombinációja hatékony platformot biztosít a különféle alkalmazásokban használt kifinomult kommunikációs hálózatok kiépítéséhez vagy tanulásához. Bár meredek tanulási görbének tűnhet, a saját beállítás a kenyérsütőtáblán nagyon praktikus módja annak, hogy megtanuljuk a CAN-busz-hálózat használatát komplex barkácsprojektekben.