IOT123 - לבנה I2C לבבי לב: 6 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:16

ה- IOT123 BRICKS הן יחידות מודולריות מסוג DIY שניתן לערבב אותן עם IOT123 BRICKS אחרות, כדי להוסיף פונקציונליות לצומת או לביש. הם מבוססים על מרובעי הסנטימטרים המרובעים והדו-צדדיים עם חורים המחוברים זה לזה.

מספר בריקים אלה צפויים להיות במספר צמתים (Master MCUs - ESP8266 או ATTINY84) באתר. ה- MCU אינו זקוק לידע מוקדם של מטרת החיישנים או צרכי התוכנה. הוא סורק אחר צמתים I2C ואז מבקש הצלת נכס (נתוני חיישן) מכל עבד. בריקים אלה מספקים 5.0V, 3.3V ועוד קו AUX הניתן להתאמה אישית.

בריק I2C HEARTBEAT BRICK זה מציין אם העבד ATTINY חי, גם תעבורת I2C, ויש לו נכס אחד:

סטטוס ("חי")

PB1 (לבן) מציין בריאות ATTINY.

PB3 (צהוב) מתחלף עם בקשות I2C מהמאסטר.

PB4 (כתום) מתחלף עם קבלת I2C מהמאסטר.

החורים המעוברים הסמוכים ל- ATTINY85 נותרו ללא שימוש, כדי לאפשר מתכנת סיכות פוגו בזמן שה- DIP8 מולחם אל ה- PCB. הפשטה נוספת, אריזת ה- BRICKS בצילינדרים קטנים המתחברים לרכזת D1M WIFI BLOCK, ושואבת את הערכים לשרת MQTT, מפותחת.

שלב 1: חומרים וכלים

יש רשימה מלאה של חומרים ומקורות.

1. PCB נייר (7 x 7 חורים)
2. נוריות LED (אדום, ירוק, כחול)
3. נגדים (3 הנחה על 1K)
4. ATTINY85 20PU (1)
5. 1 "פרוטבורד דו צדדי (1)
6. כותרת זכר 90º (3P, 3P)
7. כותרת זכר (2P, 2P)
8. מגשר Shunt (1)
9. חיבור חיבור (~ 7)
10. הלחמה וברזל (1)

שלב 2: הכינו את ה- ATTINY85

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

יש צורך ב- AttinyCore ממנהל הלוחות. צריבת מטען האתחול "EEPROM שמור", "8mHZ פנימי" (כל התצורות מוצגות למעלה).

ניתן למצוא את מאגר הקוד כאן.

ניתן למצוא כאן ZIP של הספרייה.

הוראות "ייבוא ספריית ZIP" כאן.

לאחר התקנת הספרייה תוכל לפתוח את הדוגמה "attiny_heartbeat".

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

www.instructables.com/id/Programming-the-….

www.instructables.com/id/How-to-Program-A…

www.instructables.com/id/Programming-the-…

www.instructables.com/id/How-to-Program-A…

www.instructables.com/id/Programming-the-…

עדיף לבדוק באמצעות קרש לחם לפני שתמשיך.

אם יש לך חיישני ASSIMILATE קיימים, ודא שכתובת העבד שונה בשילוב מארח SENSOR/MCU למשל. לכל שחקני הממסר יכולה להיות אותה כתובת כל עוד יש לך רק שחקן ממסר אחד ב- MCU/צומת.

שלב 3: הרכבת המדדים

המדדים נועדו להתאמה אישית מלאה. אותות האירוע מהמעגל הראשי נתפסים כפעימות לב. לבנייה זו נשתמש בחיווי LED; המבנה שלך יכול להשתמש בממסרים (כן VCC נשבר) או מחוון אחר מבוסס ויזואלי/אות. ערכי הנגד יהיו תלויים בהעדפה האישית עד כמה אתה רוצה אותם בהירים.

1. בחלק העליון, הכנס נורית כחולה ל- RED1 (+) ו- BLACK1 (G), והלחמה בתחתית.
2. בחלק התחתון, כופפו את העופרת מ- RED1 כך שהיא תיגע ברפידת הנחושת ב- SILVER8 וקיצצו.
3. בתחתית, חיתוך עופרת מ- BLACK1 מעל הלחמה.
4. בחלק העליון, הכנס נורית ירוקה ל- RED2 (+) ו- BLACK2 (G), והלחמה בתחתית.
5. בחלק התחתון, כופפו את העופרת מ- RED2 כך שהיא תיגע ברפידת הנחושת ב- SILVER9 וקיצצו.
6. בתחתית, חיתוך עופרת מ- BLACK2 מעל הלחמה.
7. בחלק העליון, הכנס נורית LED אדומה ל- RED3 (+) ו- BLACK3 (G), והלחמה בתחתית.
8. בחלק התחתון, כופפו את העופרת מ- RED3 כך שהיא תיגע ברפידת הנחושת ב- SILVER10 וקיצצו.
9. בתחתית, חיתוך עופרת מ- BLACK3 מעל הלחמה.
10. בחלקו העליון, הכנס נגד 1K לחורי SILVER1 ו- SILVER4.
11. בתחתית, עקוב, חיתוך והובלת הלחמה מ- SILVER1 אל BLACK1.
12. בחלק העליון, הכנס נגד 1K לחורי SILVER2 ו- SILVER4.
13. בתחתית, עקוב, חיתוך והלחמה מ- SILVER2 אל BLACK2.
14. בחלק העליון, הכנס נגד 1K לחורי SILVER3 ו- SILVER4.
15. בתחתית, עקוב, חיתוך והלחמה מ- SILVER3 אל BLACK3.
16. בתחתית, חוטי הלחמה ב- SILVER4 וקיצוץ באורך של כ -5 מ"מ.
17. בתחתית, הלחם חוט שחור על SILVER4.
18. בתחתית, הלחם חוט לבן לתוך SILVER5, להבטיח המשכיות להוביל מ RED1.
19. בתחתית, הלחם חוט צהוב לתוך SILVER6, להבטיח המשכיות להוביל מ RED2.
20. בתחתית, הלחם חוט כתום לתוך SILVER7, להבטיח המשכיות להוביל מ RED3.

שלב 4: הרכבת המעגל הראשי

הַרכָּבָה:

1. בחזית, הכנס את הרכיבים ATTINY85 (1), כותרות זכר 3P 90deg (2) (3), כותרות זכר 3P (4) (5) והלחם מאחור.
2. מאחור, עקוב אחר חוט צהוב מ- YELLOW1 ל- YELLOW2 והלחמה.
3. מאחור, עקוב אחר חוט כתום מ- ORANGE1 ל- ORANGE2 והלחמה.
4. מאחור, עקוב אחר חוט כחול מ- BLUE1 ל- BLUE2 והלחמה.
5. מאחור, עקוב אחר חוט ירוק מ- GREEN1 ל- GREEN2 והלחמה.
6. מאחור, עקוב אחר חוט לבן מ- WHITE1 ל- WHITE2 והלחמה.
7. מאחור, עקוב אחר חוט שחור מ- BLACK1 ל- BLACK2 והלחמה.
8. מאחור, עקוב אחר חוט שחור מ- BLACK3 ל- BLACK4 והלחמה.
9. מאחור, עקוב אחר חוט אדום מ- RED1 ל- RED2 והלחמה.
10. מאחור, עקוב אחר חוט חשוף מ- RED3 ל- RED4 והלחמה.
11. מאחור, עקוב אחר חוט חשוף מ- SILVER1 ל- SILVER2 והלחמה.
12. הוסף מגשר בקו 5V או 3V3.

אם אתה משתמש במדדים למעלה (עיין בתרשים pinout):

1. מאחור, הלחם את החוט הלבן לתוך PB1.
2. מאחור, הלחם את החוט הצהוב לתוך PB3.
3. מאחור, הלחם את החוט הכתום לתוך PB4.
4. מאחור, הלחם את החוט השחור ל- GND.

שלב 5: בדיקה

מספר בריקים אלה צפויים להיות במספר צמתים (MCUs - ESP8266 או ATTINY84) בסביבה. זוהי בדיקת יחידה: שולחת פקודות I2C מה- UNO ל- ATTINY המחליפה את נורית הקבלה. נורית ה- ATTINY ALIVE נשארת דולקת.

בנינו בעבר I2C SHIELD עבור Arduino.

אם אתה רוצה ללוח אותו במקום:

1. חבר את 5.0V ב- UNO ל- VCC ב- BRICK.
2. חבר את ה- GND ב- UNO ל- GND ב- BRICK.
3. חבר את A5 ב- UNO ל- SCL ב- BRICK.
4. חבר את ה- A4 ב- UNO ל- SDA ב- BRICK.
5. חבר נגד נגד משיכה 4K7 מ- SDA ל- VCC.
6. חבר נגד הנגינה 4K7 מ- SCL ל- VCC.

מבצעים את המבחן

1. חבר את UNO למחשב ה- Dev שלך באמצעות USB.
2. העלה את הקוד ל- UNO.
3. פתח את מסוף Arduino.
4. בחר 9600 baud (הפעל מחדש את UNO ופתח מחדש את הקונסולה אם צריך).
5. כתובת העבד תודפס לקונסולה.
6. כאשר, הזן בתיבת השליחה 2 1 (כך 16 2 1), ונורית הקבלה נדלקת.
7. כאשר, הזן בתיבת השליחה 2 0 (כך 16 2 0), ונורית ה- Receive נכבית.

פקודות adhoc I2C BRICK עבור עבדים מ- UNO master

#לִכלוֹל

const byte _num_chars = 32;

char _received_chars [_num_chars]; // מערך לאחסון הנתונים שהתקבלו

בוליאני _has_new_data = false;

הגדרת voids () {

Serial.begin (9600);

Serial.println ();

Serial.println ("ASSIMILATE IOT ACTOR/SENSOR EEPROM Editor");

Serial.println ("להבטיח שורה חדשה שנבחרה בחלון המסוף");

Serial.println ();

Serial.println ("ADRESS 1 CONFIRM METADATA RECEIPT N/A (FOR M2M)");

Serial.println ("פקודת שחקן ADDRESS 2");

Serial.println ();

Serial.println ("כתובות באוטובוס:");

scan_i2c_addresses ();

Serial.println ();

Serial.println ("");

}

voidscan_i2c_addresses () {

int device_count = 0;

for (כתובת בתים = 8; כתובת <127; כתובת ++)

{

Wire.beginTransmission (כתובת);

שגיאת const byte = Wire.endTransmission ();

אם (שגיאה == 0)

{

Serial.println (כתובת);

}

}

}

voidloop () {

recv_with_end_marker ();

send_to_i2c ();

}

voidrecv_with_end_marker () {

בתים סטטיים ndx = 0;

char end_marker = '\ n';

char rc;

בעוד (Serial.available ()> 0 && _has_new_data == false) {

rc = Serial.read ();

אם (rc! = end_marker) {

_received_chars [ndx] = rc;

ndx ++;

אם (ndx> = _num_chars) {

ndx = _num_chars - 1;

}

}

אחר {

_received_chars [ndx] = '\ 0'; // לסיים את המחרוזת

ndx = 0;

_has_new_data = נכון;

}

}

}

voidsend_to_i2c () {

char param_buf [16];

const String received_string = מחרוזת (_received_chars);

אם (_has_new_data == true) {

int idx1 = received_string.indexOf ('');

כתובת מחרוזת = received_string.substring (0, idx1);

int address_int = address.toInt ();

if (address_int <8 || address_int> 127) {

Serial.println ("קלט כתובת לא חוקי:");

Serial.println (כתובת);

לַחֲזוֹר;

}

int idx2 = received_string.indexOf ('', idx1+1);

קוד מחרוזת;

אם (idx2 == -1) {

code = received_string.substring (idx1+1);

}אַחֵר{

code = received_string.substring (idx1+1, idx2+1);

}

int code_int = code.toInt ();

if (code_int <0 || code_int> 5) {

Serial.println ("קלט קוד לא חוקי:");

Serial.println (קוד);

לַחֲזוֹר;

}

bool has_parameter = idx2> -1;

פרמטר מחרוזת;

if (has_parameter) {

parameter = received_string.substring (idx2 + 1, idx2 + 17); // 16 תווים לכל היותר

if (parameter.length () <1) {

Serial.println ("PARTAMETER MIN. LENGTH 1");

_has_new_data = false;

לַחֲזוֹר;

}

}אַחֵר{

אם (code_int> 1) {

Serial.println ("נדרש פרמטר!");

_has_new_data = false;

לַחֲזוֹר;

}

}

Serial.println ();

Serial.print ("input orig =");

Serial.println (קיבל_מחרוזת);

Serial.print ("כתובת =");

Serial.println (כתובת);

Serial.print ("code =");

Serial.println (קוד);

Serial.print ("parameter =");

Serial.println (פרמטר);

// שלח VIA I2C

שידור Wire.beginTransmission (address_int);

Wire.write (code_int);

if (has_parameter) {

parameter.trim ();

strcpy (param_buf, parameter.c_str ());

Wire.write (param_buf);

}

Wire.endTransmission ();

Serial.println ();

Serial.println ("נשלח באמצעות I2C!");

Serial.println ();

Serial.println ("");

_has_new_data = false;

}

}

הצג rawuno_i2c_command_input.ino המתארח אצל ❤ על ידי GitHub

שלב 6: השלבים הבאים

למעקב ASSIMILATE ACTOR: HEARTBEAT שמשתמש בלבנית זו יש תצורה אוטומטית עבור קרוטון באמצעות המטא נתונים שכבר מותקנים ב- ATTINY85 כאן. מנות JSON שנשלחות לקרואטון נשלחות באמצעות הקושחה העדכנית ביותר עבור ה- ICOS10. אתה יכול לעשות הוכחת קונספט ב- ESP8266 רגיל, אם המבנה הוא יותר מדי לעת עתה.

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