IOT123 - לבני ממסר I2C 2CH: 5 שלבים (עם תמונות)

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 2CH RELAY BRICK זה מרחיב את הפונקציונליות של I2C KY019 BRICK, ויש לו שני מאפייני קריאה/כתיבה:

2CH RELAYS [0] (נכון/לא נכון)

ממסרים 2CH [1] (נכון/לא נכון)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

שלב 4: בדיקה

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

בנינו בעבר 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 0: 1 (כך 15 2 0: 1), וממסר CH1 נדלק.

7. כאשר, הזן בתיבת השליחה 2 0: 0 (כך 15 2 0: 0), וממסר CH1 נכבה.
8. כאשר, הזן בתיבת השליחה 2 1: 1 (כך 15 2 1: 1), וממסר CH2 נדלק.
9. כאשר, הזן בתיבת השליחה 2 1: 0 (כך 15 2 0: 0), וממסר CH2 נכבה.

פקודות 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

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

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

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