IOT123 - I2C KY019 בריק: 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 KY019 זה הוא הראשון מבין השחקנים, ויש לו מאפיין קריאה/כתיבה אחד:

מתג (נכון/לא נכון)

לבני החיישן מסוג Keyes יופשטו תחילה מכיוון שהן מגיעות עם ויטמינים (יש צורך ברכיבים נוספים) והם יחסית זולים (קניתי 37 תמורת 10AUD). לוחות/מעגלים אחרים יוצגו ל- I2C BRICKS.

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

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

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

1. ממסר KY-019 (1)
2. ATTINY85 20PU (1)
3. 1 "פרוטבורד דו צדדי (1)
4. כותרת זכר 90º (3P, 3P)
5. חיבור חיבור (~ 7)
6. הלחמה וברזל (1)

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

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

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

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

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

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

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

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

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

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

www.instructables.com/id/How-to-program-th…

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

www.instructables.com/id/Programming-an-At…

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

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

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

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

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

שלב 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. בחר 9600 baud (הפעל מחדש את UNO ופתח מחדש את הקונסולה אם עליך).
4. כתובת העבד תודפס למסוף.
5. כאשר, הזן בתיבת השליחה 2 1 (כך 12 2 1), והממסר נדלק.
6. כאשר, הזן בתיבת השליחה 2 0 (כך 12 2 0), והממסר נכבה.

פקודות 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: KY019 שמשתמש בלבנית זו יש תצורה אוטומטית עבור Crouton באמצעות המטא נתונים שכבר מותקנים ב- ATTINY85 כאן. מנות JSON שנשלחות לקרואטון נשלחות באמצעות הקושחה העדכנית ביותר עבור ה- ICOS10. אתה יכול לעשות הוכחת קונספט ב- ESP8266 רגיל, אם המבנה הוא יותר מדי לעת עתה.

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

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