- מהו פרוטוקול תקשורת I2C?
- כיצד עובדת תקשורת I2C?
- היכן להשתמש בתקשורת I2C?
- I2C בארדואינו
- רכיבים נדרשים
- תרשים מעגל
- הסבר עבודה
- תכנות I2C בארדואינו
- הסבר לתכנות מאסטר ארדואינו
- הסבר על תכנות עבדים של ארדואינו
במדריך הקודם שלנו למדנו על תקשורת SPI בארדואינו. היום נלמד על פרוטוקול תקשורת סדרתי נוסף: I2C (Inter Integrated Circuits). בהשוואת I2C עם SPI, ל- I2C יש רק שני חוטים בעוד ש- SPI משתמש בארבעה ו- I2C יכול להיות בעל מאסטר ועבד מרובים, בעוד ש- SPI יכול להיות רק מאסטר אחד ועבדים מרובים. אז יש יותר ממיקרו-בקר אחד בפרויקט שצריך להיות אדון ואז משתמשים ב- I2C. תקשורת I2C משמשת בדרך כלל לתקשורת עם גירוסקופ, מד תאוצה, חיישני לחץ ברומטריים, תצוגות LED וכו '.
במדריך זה של Arduino I2C נשתמש בתקשורת I2C בין שני לוחות arduino ונשלח (0 עד 127) ערכים זה לזה באמצעות פוטנציומטר. ערכים יוצגו על גבי LCD 16x2 המחובר לכל אחד מהארדואינו. כאן ארדואינו אחד ישמש כמאסטר ואחד אחר ישמש כעבד. אז נתחיל בהקדמה על תקשורת I2C.
מהו פרוטוקול תקשורת I2C?
המונח IIC מייצג " מעגלים משולבים בין-לאומיים ". בדרך כלל זה מסומן כ- I2C או בריבוע C או אפילו כפרוטוקול ממשק דו-חוטי (TWI) במקומות מסוימים, אך כל זה אומר אותו דבר. I2C הוא פרוטוקול תקשורת סינכרוני שמשמעותו, שני המכשירים שמשתפים את המידע חייבים לשתף אות שעון משותף. יש לו רק שני חוטים לשיתוף מידע שמתוכם אחד משמש לאות הזין והשני משמש לשליחת וקבלת נתונים.
כיצד עובדת תקשורת I2C?
תקשורת I2C הוצגה לראשונה על ידי פיליפס. כאמור קודם יש לו שני חוטים, שני חוטים אלה יחוברו על פני שני מכשירים. כאן מכשיר אחד נקרא מאסטר והמכשיר השני נקרא עבד. תקשורת צריכה ותמיד תתרחש בין שני מאסטר ועבד. היתרון בתקשורת I2C הוא שניתן לחבר יותר מעבד אחד למאסטר.
התקשורת המלאה מתבצעת באמצעות שני החוטים הללו, כלומר שעון סידורי (SCL) ונתונים סידוריים (SDA).
שעון סידורי (SCL): משתף את אות השעון שנוצר על ידי המאסטר עם העבד
נתונים סידוריים (SDA): שולח את הנתונים אל המאסטר והעבד וממנו.
בכל זמן נתון רק המאסטר יוכל ליזום את התקשורת. מכיוון שיש יותר מעבד אחד באוטובוס, המאסטר צריך להתייחס לכל עבד באמצעות כתובת אחרת. כאשר פונים אליו רק העבד עם הכתובת הספציפית ההוא ישיב בחזרה עם המידע בעוד האחרים ימשיכו להפסיק. בדרך זו אנו יכולים להשתמש באותו אוטובוס כדי לתקשר עם מספר מכשירים.
רמות המתח של I2C לא נקבעו מראש. תקשורת I2C גמישה, כלומר המכשיר המופעל באמצעות 5 וולט, יכול להשתמש ב -5 וולט עבור I2C והתקני 3.3 וולט יכולים להשתמש ב -3 וולט לתקשורת I2C. אך מה אם שני מכשירים הפועלים על מתח שונה, צריכים לתקשר באמצעות I2C? 5V I2C אוטובוס לא יכול להיות מחובר עם מכשיר 3.3V. במקרה זה משתמשים בממתחי מתח להתאמת רמות המתח בין שני אוטובוסים I2C.
יש קבוצה מסוימת של תנאים שמסגרים עסקה. אתחול השידור מתחיל בקצה נופל של SDA, שמוגדר כמצב 'START' בתרשים למטה, כאשר המאסטר משאיר את SCL גבוה בזמן שהוא מגדיר את ה- SDA נמוך.
כפי שמוצג בתרשים למעלה, הקצה הנופל של SDA הוא גורם החומרה למצב START. אחרי זה כל המכשירים באותו אוטובוס עוברים למצב האזנה.
באותו אופן, קצה עולה של SDA מפסיק את השידור שמוצג כמצב 'STOP' בתרשים לעיל, שם המאסטר משאיר את SCL גבוה ומשחרר גם את ה- SDA כדי לעבור ל- HIGH. אז קצה עולה של SDA מפסיק את השידור.
סיבית R / W מציינת את כיוון ההעברה של הבתים הבאים, אם זה HIGH פירושו שהעבד ישדר ואם הוא נמוך פירושו שהמאסטר ישדר.
כל סיבית מועברת בכל מחזור שעון, ולכן נדרשים 8 מחזורי שעון להעברת בתים. לאחר כל בית שנשלח או התקבל, מחזור שעון תשיעי מתקיים עבור ACK / NACK (מוכר / לא מאושר). סיבית ACK זו נוצרת על ידי עבד או מאסטר בהתאם למצב. לקבלת ACK נשך, SDA מוגדר נמוך ידי אב או משני ב 9 th מחזור שעון. אז זה נמוך זה נחשב ACK אחרת NACK.
היכן להשתמש בתקשורת I2C?
תקשורת I2C משמשת רק לתקשורת למרחקים קצרים. זה בהחלט אמין במידה שכן יש לו דופק שעון מסונכרן כדי להפוך אותו לחכם. פרוטוקול זה משמש בעיקר לתקשורת עם חיישן או התקנים אחרים אשר צריכים לשלוח מידע למאסטר. זה מאוד שימושי כאשר מיקרו-בקר צריך לתקשר עם מודולי עבדים רבים אחרים באמצעות מינימום חוטים בלבד. אם אתם מחפשים תקשורת לטווח רחוק עליכם לנסות את RS232 ואם אתם מחפשים תקשורת אמינה יותר עליכם לנסות את פרוטוקול SPI.
I2C בארדואינו
התמונה למטה מציגה את סיכות ה- I2C הקיימות ב- Arduino UNO.
| קו I2C | הצמד בארדואינו |
| SDA | A4 |
| SCL | A5 |
לפני שנתחיל לתכנת I2C באמצעות שני ארדואינו. עלינו ללמוד על ספריית Wire המשמשת בארדואינו IDE.
הספרייה
1. Wire.begin (כתובת):
שימוש: ספרייה זו משמשת ליצירת תקשורת עם מכשירי I2C. זה יוזם את ספריית Wire והצטרף לאוטובוס I2C כמאסטר או עבד.
כתובת: כתובת העבדים של 7 סיביות היא אופציונלית ואם הכתובת לא מוגדרת, היא מצטרפת לאוטובוס כמאסטר כזה.
2. Wire.read ():
שימוש: פונקציה זו משמשת לקריאת בתים שהתקבלו ממאסטר או ממכשיר עבדים, או שהועבר ממכשיר עבדים למכשיר מאסטר לאחר קריאה לבקשה מ- () או שהועבר ממאסטר לעבד.
3. Wire.write ():
שימוש: פונקציה זו משמשת לכתיבת נתונים לעבד או למכשיר מאסטר.
עבד למאסטר: עבד כותב נתונים למאסטר כאשר משתמשים ב- Wire.RequestFrom () במאסטר.
מאסטר לעבד: להעברה ממכשיר מאסטר לעבדים Wire.write () משמש שיחות בין לבין ל- Wire.beginTransmission () ו- Wire.endTransmission ().
ניתן לכתוב את Wire.write () כ:
- Wire.write (ערך)
value: ערך שיש לשלוח כבת אחד.
- Wire.write (מחרוזת):
מחרוזת: מחרוזת למשלוח כסדרת בתים.
- Wire.write (נתונים, אורך):
נתונים: מערך נתונים לשליחה כבתים
אורך: מספר הבתים שיש להעביר.
4. Wire.beginTransmission (כתובת):
שימוש: פונקציה זו משמשת להפעלת שידור למכשיר I2C עם כתובת העבדים הנתונה. לאחר מכן, בנה תור של בתים להעברה עם הפונקציה write () ואז העביר אותם על ידי קריאה לפונקציה endTransmission () . כתובת 7 סיביות של המכשיר מועברת.
5. Wire.endTransmission ();
שימוש: פונקציה זו משמשת לסיום שידור למכשיר עבדים שהתחיל על ידי beginTransmission () ומשדר את הבייטים שעומדו בתור על ידי Wire.write ().
6. Wire.onRequest ();
שימוש: פונקציה זו מתקשרת כאשר מאסטר מבקש נתונים באמצעות Wire.requestFrom () ממכשיר העבדים. כאן נוכל לכלול את פונקציית Wire.write () לשליחת נתונים למאסטר.
7. Wire.onReceive ();שימוש: פונקציה זו מתקשרת כאשר מכשיר עבדים מקבל נתונים ממאסטר. כאן אנו יכולים לכלול Wire.read (); פונקציה לקריאת הנתונים שנשלחו מהמאסטר.
8. Wire.requestFrom (כתובת, כמות);
שימוש: פונקציה זו משמשת במאסטר לבקשת בתים ממכשיר עבדים. הפונקציה Wire.read () משמשת לקריאת הנתונים שנשלחו ממכשיר העבדים.
כתובת: כתובת 7 הסיביות של המכשיר שאליו ניתן לבקש בתים
כמות: מספר הבתים שיש לבקש
רכיבים נדרשים
- Arduino Uno (2-Nos)
- מודול תצוגת LCD 16X2
- פוטנציומטר 10K (4-Nos)
- קרש לחם
- חוטי חיבור
תרשים מעגל
הסבר עבודה
כאן לצורך הדגמת תקשורת I2C בארדואינו, אנו משתמשים בשני ארדואינו UNO עם שתי תצוגות LCD 16X2 המחוברות זו לזו ומשתמשות בשני פוטנציומטרים בשני הארדואינו כדי לקבוע את ערכי השליחה (0 עד 127) ממאסטר לעבד ועבד למאסטר על ידי שינוי פוטנציומטר.
אנו לוקחים ערך אנלוגי קלט בסיכת Arduino A0 מ (0 עד 5V) באמצעות פוטנציומטר וממיר אותם לערך אנלוגי לדיגיטלי (0 עד 1023). ואז ערכי ADC אלה מומרים עוד יותר ל (0 עד 127) מכיוון שנוכל לשלוח רק נתונים של 7 סיביות באמצעות תקשורת I2C. התקשורת I2C מתרחשת באמצעות שני חוטים בסיכה A4 ו- A5 של שניהם הארדואינו.
הערכים ב- LCD של Slave Arduino ישתנו על ידי שינוי ה- POT בצד הראשי ולהיפך.
תכנות I2C בארדואינו
במדריך זה שתי תוכניות האחת למאסטר ארדואינו והשנייה לעבד ארדואינו. תוכניות שלמות לשני הצדדים ניתנות בסוף פרויקט זה עם סרטון הדגמה.
הסבר לתכנות מאסטר ארדואינו
1. קודם כל עלינו לכלול את ספריית Wire לשימוש בפונקציות תקשורת I2C וספריית LCD לשימוש בפונקציות LCD. הגדר גם סיכות LCD עבור 16x2 LCD. למידע נוסף על ממשק LCD עם Arduino כאן.
#לִכלוֹל
2. בהגדרת הריק ()
- אנו מתחילים בתקשורת סדרתית בקצב שידור 9600.
Serial.begin (9600);
- בשלב הבא נתחיל את תקשורת I2C בסיכה (A4, A5)
Wire.begin (); // מתחיל תקשורת I2C בסיכה (A4, A5)
- לאחר מכן אנו מאתחלים את מודול תצוגת LCD במצב 16X2 ומציגים את הודעת הברכה ומנקים לאחר חמש שניות.
lcd.begin (16,2); // אתחל את תצוגת LCD lcd.setCursor (0,0); // מגדיר את הסמן בשורה הראשונה בתצוגה lcd.print ("Circuit Digest"); // מדפיס CIRCUIT DIGEST ב- lcd.setCursor LCD (0,1); // מגדיר את הסמן בשורה השנייה של תצוגת lcd.print ("I2C 2 ARDUINO"); // מדפיס I2C ARDUINO בהשהיית LCD (5000); // השהה למשך 5 שניות lcd.clear (); // מנקה תצוגת LCD
3. בלולאה בטלה ()
- ראשית עלינו לקבל נתונים מהעבד ולכן אנו משתמשים ב- requestFrom () עם כתובת העבד 8 ואנו מבקשים בת אחד.
Wire.requestFrom (8,1);
הערך שהתקבל נקרא באמצעות Wire.read ()
בתים MasterReceive = Wire.read ();
- בשלב הבא עלינו לקרוא את הערך האנלוגי ממסדר ה- arduino הראשי המצורף לסיכה A0
int potvalue = analogRead (A0);
אנו ממירים ערך זה במונחים של בת אחד כ- 0 ל- 127.
בתים MasterSend = מפה (פוטו-ערך, 0,1023,0,127);
- בשלב הבא עלינו לשלוח את אותם ערכים שהומרו, כך שנתחיל בהעברה עם עבד ארדואינו עם כתובת 8
Wire.beginTransmission (8); Wire.write (MasterSend); Wire.endTransmission ();
- לאחר מכן אנו מציגים את הערכים שהתקבלו מהעבד ארדואינו בעיכוב של 500 מיקרו שניות ואנו מקבלים ומציגים את הערך ברציפות.
lcd.setCursor (0,0); // מגדיר סמן בשורה אחת של LCD lcd.print (">> מאסטר <<"); // הדפסות >> מאסטר << ב- LCD lcd.setCursor (0,1); // מגדיר את הסמן בשורה השנייה של LCD lcd.print ("SlaveVal:"); // הדפסות SlaveVal: ב- LCD lcd.print (MasterReceive); // מדפיס MasterReceive ב- LCD שהתקבל מ- Slave Serial.println ("מאסטר שהתקבל מהעבד"); // הדפסות בצג סידורי Serial.println (MasterReceive); עיכוב (500); lcd.clear ();
הסבר על תכנות עבדים של ארדואינו
1. זהה למאסטר, קודם כל עלינו לכלול את ספריית החוטים לשימוש בפונקציות תקשורת I2C וספריית LCD לשימוש בפונקציות LCD. הגדר גם סיכות LCD עבור 16x2 LCD.
#לִכלוֹל
2. בהגדרת הריק ()
- אנו מתחילים בתקשורת סדרתית בקצב שידור 9600.
Serial.begin (9600);
- לאחר מכן אנו מתחילים את תקשורת I2C בסיכה (A4, A5) עם כתובת העבדים כ- 8. כאן חשוב לציין את כתובת העבדים.
Wire.begin (8);
בשלב הבא עלינו להתקשר לפונקציה כאשר Slave מקבל ערך ממסטר וכאשר Master מבקש ערך מ- Slave
Wire.onReceive (receivevent); Wire.onRequest (requestEvent);
- לאחר מכן אנו מאתחלים את מודול תצוגת LCD במצב 16X2 ומציגים את הודעת הברכה ומנקים לאחר חמש שניות.
lcd.begin (16,2); // אתחל את תצוגת LCD lcd.setCursor (0,0); // מגדיר את הסמן בשורה הראשונה בתצוגה lcd.print ("Circuit Digest"); // מדפיס CIRCUIT DIGEST ב- lcd.setCursor LCD (0,1); // מגדיר את הסמן בשורה השנייה של תצוגת lcd.print ("I2C 2 ARDUINO"); // מדפיס I2C ARDUINO בהשהיית LCD (5000); // השהה למשך 5 שניות lcd.clear (); // מנקה תצוגת LCD
3. לאחר מכן יש לנו שתי פונקציות אחת לאירוע בקשה ואחת לאירוע קבלה
לבקשה אירוע
כאשר ערך הבקשה הראשי מהעבד תבוצע פונקציה זו. פונקציה זו אכן לוקחת ערך קלט מ- Slave POT וממירה אותו במונחים של 7 סיביות ושולחת ערך זה למאסטר.
בטל requestEvent () { int potvalue = analogRead (A0); בתים SlaveSend = מפה (פוטו-ערך, 0,1023,0,127); Wire.write (SlaveSend); }
לקבלת אירוע
כאשר מאסטר שולח נתונים לעבד עם כתובת עבד (8) פונקציה זו תבוצע. פונקציה זו קוראת את הערך שהתקבל ממאסטר ומאחסן במשתנה מסוג בתים .
void receiveEvent (int howMany { SlaveReceived = Wire.read (); }
4. במעגל ריק ():
אנו מציגים את הערך שהתקבל ממאסטר ברציפות במודול התצוגה LCD.
loop loop (void) { lcd.setCursor (0,0); // מגדיר סמן בשורה אחת של LCD lcd.print (">> עבד <<"); // הדפסים >> עבדים << ב- LCD lcd.setCursor (0,1); // מגדיר את הסמן בשורה השנייה של LCD lcd.print ("MasterVal:"); // הדפסי MasterVal: ב- LCD lcd.print (SlaveReceived); // מדפיס ערך SlaveReceived ב- LCD שהתקבל ממסדרת Serial.println ("עבד שהתקבל ממאסטר:"); // הדפסות בצג סידורי Serial.println (SlaveReceived); עיכוב (500); lcd.clear (); }
על ידי סיבוב פוטנציומטר בצד אחד, תוכלו לראות את הערכים המשתנים על גבי LCD בצד אחר:
אז ככה מתקשרת תקשורת I2C בארדואינו, כאן השתמשנו בשני ארדואינו כדי להדגים לא רק שליחת נתונים אלא גם קבלת הנתונים באמצעות תקשורת I2C. אז עכשיו תוכלו לממשק כל חיישן I2C לארדואינו.
הקידוד השלם עבור מאסטר ועבד ארדואינו ניתן להלן עם סרטון הדגמה