איך לבנות אוטובוס CAN עם לוח לחם וארדואינו

האוטובוס של Controller Area Network (CAN) הוא פרוטוקול תקשורת חזק ואמין שנמצא בשימוש נרחב ביישומי תעשייה, רכב וחלל שונים. הוא מיועד להעברת נתונים בין מיקרו-בקרים והתקנים דרך רשת CAN bus. אולי אתה עדיין לא יודע את זה, אבל זה הדבר מאחורי האופנים המטורפים של לוח המחוונים לרכב שאתה רואה במדיה החברתית.

אנו נדריך אותך כיצד לבנות אוטובוס CAN עם מודול CAN MCP2515 באמצעות ארדואינו ולוח לחם. נעבור גם על ספריית ה-CAN של Arduino ונדגים כיצד לשלוח ולקבל נתונים דרך אפיק ה-CAN.

מהו אוטובוס CAN?

ה-CAN bus הוא פרוטוקול תקשורת טורית שפותח על ידי Bosch בשנות השמונים. הוא נמצא בשימוש נרחב ביישומים שונים בגלל האמינות והחוסן הגבוהים שלו. הוא מאפשר העברת נתונים בין מכשירים במהירויות גבוהות עם חביון מינימלי על פני שני קווים בלבד: CAN High ו-CAN Low.

בשנת 1994, אפיק ה-CAN הפך לתקן בינלאומי (ISO 11898) שתוכנן במיוחד לחילופי נתונים טוריים מהירים בין בקרים אלקטרוניים ביישומי רכב. עיין במדריך המקיף שלנו בנושא מהו אוטובוס CAN ואיזה תפקיד הוא ממלא במערכות רכב לפרטים נוספים.

אחת הסיבות לכך שהאוטובוס CAN כל כך פופולרי היא בגלל תכונות זיהוי ותיקון השגיאות שלו. הפרוטוקול יכול לזהות ולתקן שגיאות בהעברת הנתונים. זה הופך אותו לאידיאלי עבור יישומים שבהם שלמות הנתונים היא קריטית, כגון באוטומציה תעשייתית.

הכרת מודול CAN MCP2515

מודול MCP2515 CAN Bus Controller הוא התקן המספק תמיכה יוצאת דופן עבור פרוטוקול CAN בשימוש נרחב גרסה 2.0B. מודול זה אידיאלי לתקשורת בקצבי נתונים גבוהים של עד 1Mbps.

ה-MCP2515 IC הוא בקר CAN עצמאי עם ממשק SPI המאפשר תקשורת עם מגוון רחב של מיקרו-בקרים. ה-TJA1050 IC, לעומת זאת, מתפקד כממשק בין IC בקר CAN MCP2515 לבין אפיק ה-CAN הפיזי.

לנוחות נוספת, ישנו מגשר המאפשר לך לחבר סיומת של 120 אוהם, מה שמקל עוד יותר על חיבור החוטים שלך CAN_H & אני יכול ברגים לתקשורת עם מודולי CAN אחרים.

אתה יכול לקבל מידע נוסף מ- גיליון נתונים MCP2515 למקרה שאתה צריך את המודול הזה לפרויקט מתקדם יותר.

מבנה הודעות CAN

מבנה הודעות ה-CAN מורכב ממקטעים מרובים, אך המקטעים הקריטיים ביותר עבור פרויקט זה הם המזהה והנתונים. המזהה, הידוע גם כ-CAN ID או Parameter Group Number (PGN), מזהה את ההתקנים ב-CAN רשת, ואורך המזהה יכול להיות 11 או 29 סיביות, תלוי בסוג פרוטוקול ה-CAN בשימוש.

בינתיים, הנתונים מייצגים את נתוני החיישן/בקרה המועברים בפועל. אורך הנתונים יכול להיות בין 0 ל-8 בתים, וקוד אורך הנתונים (DLC) מציין את מספר בתי הנתונים הקיימים.

ספריית האוטובוסים של Arduino MCP2515 CAN

ספריה זו מיישמת את ה פרוטוקול CAN V2.0B, שיכול לפעול במהירויות של עד 1Mbps. הוא מספק ממשק SPI שיכול לפעול במהירויות של עד 10 מגה-הרץ תוך תמיכה הן בנתונים סטנדרטיים (11 סיביות) והן בנתונים מורחבים (29 סיביות). יתרה מכך, הוא מגיע עם שני מאגרי קליטה, המאפשרים אחסון הודעות עדיפות.

אתחול ה-CAN Bus

להלן קוד ההגדרה שתצטרך לאתחל את אפיק ה-CAN:

#לִכלוֹל
#לִכלוֹל
MCP2515 mcp2515(10); // הגדר פין CS
בָּטֵללהכין(){
בזמן (!סידורי);
סידורי.התחל(9600);
SPI.התחל(); //מתחיל תקשורת SPI
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
}

זה מאתחל את ה-MCP2515 עם קצב סיביות CAN של 500Kbps ותדר מתנד של 8MHz.

מצבי תפעול MCP2515 CAN

ישנם שלושה מצבי תפעול בשימוש עם בקר MCP2515 CAN bus:

• setNormalMode(): מגדיר את הבקר לשלוח ולקבל הודעות.
• setLoopbackMode(): מגדיר את הבקר לשלוח ולקבל הודעות, אך גם ההודעות שהוא שולח יתקבלו מעצמו.
• setListenOnlyMode(): מגדיר את הבקר לקבל הודעות בלבד.

אלו הן קריאות פונקציה המשמשות להגדרת מצב הפעולה של בקר ה-CAN bus MCP2515.

mcp2515.setNormalMode();

mcp2515.setLoopbackMode();

mcp2515.setListenOnlyMode();

שליחת נתונים דרך ה-CAN Bus

כדי לשלוח הודעה דרך אפיק ה-CAN, השתמש ב- sendMsgBuf() שיטה:

לא חתוםלְהַשְׁחִיר נתונים[] = {0x01, 0x02, 0x03, 0x04};
CAN.sendMsgBuf(0x01, 0, 4, נתונים);

זה שולח הודעה עם תעודת הזהות 0x01 ומטען נתונים של {0x01, 0x02, 0x03, 0x04}. הפרמטר הראשון הוא מזהה ה-CAN, השני הוא עדיפות ההודעה, השלישי הוא אורך מטען הנתונים, והרביעי הוא מטען הנתונים עצמו.

ה sendMsgBuf() השיטה מחזירה ערך המציין אם ההודעה נשלחה בהצלחה או לא. אתה יכול לבדוק ערך זה על ידי קריאה ל- checkError() שיטה:

אם (CAN.checkError()) {
סידורי.println("שגיאה בשליחת הודעה.");
}

זה בודק אם אירעה שגיאה במהלך שידור ההודעה ומדפיס הודעת שגיאה במידת הצורך.

קבלת נתונים מ-CAN Bus

כדי לקבל הודעה דרך אפיק ה-CAN, תוכל להשתמש ב- readMsgBuf() שיטה:

לא חתוםלְהַשְׁחִיר לן = 0;
לא חתוםלְהַשְׁחִיר buff[8];
לא חתוםלְהַשְׁחִיר canID = 0;
אם (CAN.checkReceive()) {
 CAN.readMsgBuf(&len, buf);
 canID = CAN.getCanId();
}

זה בודק אם הודעה זמינה באפיק ה-CAN ולאחר מכן קורא את ההודעה לתוך buff מַעֲרָך. אורך ההודעה מאוחסן ב- לן משתנה, והמזהה של ההודעה מאוחסן ב- canID מִשְׁתַנֶה.

לאחר שקיבלת הודעה, תוכל לעבד את מטען הנתונים לפי הצורך. לדוגמה, תוכל להדפיס את מטען הנתונים לצג הטורי:

סידורי.הדפס("התקבלה הודעה עם תעודת זהות");
סידורי.הדפס(canID, HEX);
סידורי.הדפס(" ונתונים: ");
ל (int אני = 0; i < len; i++) {
סידורי.הדפס(buff[i], HEX);
סידורי.הדפס(" ");
}
סידורי.println();

זה מדפיס את המזהה של ההודעה שהתקבלה ואת מטען הנתונים לצג הטורי.

כיצד לחבר משדר CAN Bus ללוח לחם

כדי לבנות אפיק CAN לחיבור שני מכשירים בפרויקט לדוגמה זה, תצטרך:

• שני מיקרו-בקרים (שני לוחות Arduino Nano לדוגמא זו)
• שני מודולי CAN MCP2515
• קרש לחם
• חוטי מגשר
• מודול מסך LCD I2C 16x2
• חיישן קולי HC-SR04

עבור דוגמה לפרויקט זה, נעשה שימוש בארבע ספריות בסקיצה של Arduino. יש את ה NewPing ספרייה, המספקת ממשק קל לשימוש עבור החיישן האולטראסוני, כמו גם את ספריית SPI, מה שמקל על התקשורת בין לוח Arduino לבקר MCP2515 CAN bus. ה LiquidCrystal_I2C הספרייה משמשת עבור מודול התצוגה.

לבסוף, יש את ספריית mcp2515 להתממשק עם שבב MCP2515, מה שמאפשר לנו להעביר נתונים בקלות דרך רשת ה-CAN bus.

הגדרת חומרה (דוגמה HC-SR04)

בפרויקט זה באמצעות חיישן HC-SR04 ו-LCD, לוח Arduino Nano אחד ישמש כמקלט, ואילו Arduino השני ישמש כשלוח. חבר את רכיבי השולח שלך בהתאם לתרשים החיווט שלהלן:

להלן הדיאגרמה עבור מעגל המקלט:

לבסוף, חבר את שני הצמתים יחד באמצעות CAN_H ו אני יכול קווים כפי שמוצג:

בעת חיבור המודולים, חשוב לוודא שמתח אספקת החשמל נמצא בטווח שצוין ושה יכול H ו אני יכול פינים מחוברים כראוי לאוטובוס.

תכנות את מודול ה-CAN Bus MCP2515

שימו לב שכאשר מתכנתים את מודול MCP2515, חשוב להשתמש בקצב הסיביות הנכון כדי להבטיח תקשורת מוצלחת עם התקני CAN אחרים ברשת.

קוד השולח:

#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
MCP2515 mcp2515(10);
constבייט trigPin = 3;
constבייט echoPin = 4;
NewPing סוֹנָר(trigPin, echoPin, 200);
structcan_framecanMsg;
בָּטֵללהכין(){
סידורי.התחל(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
}
בָּטֵללוּלָאָה(){
לא חתוםint distance = sonar.ping_cm();
 canMsg.can_id = 0x036; //מזהה CAN כ-0x036
 canMsg.can_dlc = 8; //אורך נתוני CAN כ-8
 canMsg.data[0] = מרחק; //עדכן את ערך הלחות ב-[0]
 canMsg.data[1] = 0x00; //השאר הכל עם 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);//שולח את הודעת ה-CAN
לְעַכֵּב(100);
}

קוד מקלט:

#לִכלוֹל
#לִכלוֹל
#לִכלוֹל
MCP2515 mcp2515(10);
LiquidCrystal_I2C lcd(0x27,16,2);
structcan_framecanMsg;
בָּטֵללהכין(){
סידורי.התחל(9600);
 mcp2515.reset();
 mcp2515.setBitrate (CAN_500KBPS, MCP_8MHZ);
 mcp2515.setNormalMode();
 lcd.init();
 lcd.backlight();
 lcd.setCursor(0, 0);
 lcd.הדפס("MUO CAN TUTORIAL");
לְעַכֵּב(3000);
 lcd.ברור();
}
בָּטֵללוּלָאָה(){
אם (mcp2515.קרא הודעה(&canMsg) == MCP2515::ERROR_OK) // כדי לקבל נתונים
 {
int distance = canMsg.data[0];
 lcd.setCursor(0,0);
 lcd.הדפס("מרחק:");
 lcd.הדפס(מֶרְחָק);
 lcd.הדפס("ס"מ ");
 }
}

קח את פרויקטי הארדואינו שלך לשלב הבא

השילוב של CAN bus ו- Arduino מספק פלטפורמה רבת עוצמה לבנייה או למידה של רשתות תקשורת מתוחכמות המשמשות ביישומים שונים. למרות שזה עשוי להיראות כעקומת למידה תלולה, הגדרה משלך על לוח לחם היא דרך שימושית למדי ללמוד את החבלים של שימוש ברשת אוטובוס CAN בפרויקטים מורכבים של עשה זאת בעצמך.