IOT123 - I2C दिल की धड़कन ईंट: 6 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:22

IOT123 ब्रिक्स DIY मॉड्यूलर इकाइयां हैं जिन्हें नोड या पहनने योग्य में कार्यक्षमता जोड़ने के लिए अन्य IOT123 ब्रिक्स के साथ मैश किया जा सकता है। वे छेद के माध्यम से परस्पर जुड़े हुए इंच वर्ग, दो तरफा प्रोटोबार्ड पर आधारित होते हैं।

इनमें से कई ब्रिक्स एक साइट पर कई नोड्स (मास्टर MCUs - ESP8266 या ATTINY84) पर होने की उम्मीद है। MCU को सेंसर के उद्देश्य या सॉफ़्टवेयर की ज़रूरतों के पूर्व ज्ञान की आवश्यकता नहीं है। यह I2C नोड्स के लिए स्कैन करता है और फिर प्रत्येक दास से एक संपत्ति डंप (सेंसर डेटा) का अनुरोध करता है। ये ब्रिक्स 5.0V, 3.3V और एक अन्य AUX लाइन की आपूर्ति करते हैं जो अनुकूलन योग्य है।

यह I2C HEARTBEAT BRICK इंगित करता है कि क्या ATTINY गुलाम जीवित है, I2C ट्रैफ़िक भी, और उसके पास एक संपत्ति है:

स्थिति ("जीवित")

PB1 (सफ़ेद) ATTINY स्वास्थ्य को इंगित करता है।

PB3 (पीला) मास्टर से I2C अनुरोधों के साथ टॉगल करता है।

PB4 (नारंगी) मास्टर से प्राप्त I2C के साथ टॉगल करता है।

ATTINY85 से सटे थ्रू-होल को एक पोगो पिन प्रोग्रामर को सक्षम करने के लिए अप्रयुक्त छोड़ दिया गया है, जबकि DIP8 को PCB में मिलाया जाता है। एक और अमूर्तता, ब्रिक्स को छोटे सिलेंडरों में पैक करना जो एक डी1एम वाईफ़ाई ब्लॉक हब में प्लग करते हैं, एक एमक्यूटीटी सर्वर पर मूल्यों को पंप करते हैं, विकसित किया जा रहा है।

चरण 1: सामग्री और उपकरण

सामग्री और सोर्सिंग सूची का एक पूर्ण बिल है।

1. पेपर पीसीबी (7 x 7 छेद)
2. एल ई डी (लाल, हरा, नीला)
3. प्रतिरोधों (1K पर 3 बंद)
4. ATTINY85 20PU (1)
5. 1 "दो तरफा प्रोटोबार्ड (1)
6. पुरुष हैडर 90º (3पी, 3पी)
7. पुरुष हैडर (2पी, 2पी)
8. जम्पर शंट (1)
9. हुकअप तार (~ 7)
10. सोल्डर और आयरन (1)

चरण 2: ATTINY85. तैयार करें

नोट: यदि क्राउटन एकीकरण करने का इरादा है, तो कृपया यहां से पुस्तकालय का उपयोग करें, और "attiny_heartbeat" स्थापित उदाहरण का उपयोग करें।

बोर्ड प्रबंधक से AttinyCore की आवश्यकता है। बूटलोडर "EEPROM रिटेन्ड", "8mHZ इंटरनल" (ऊपर दिखाया गया सभी कॉन्फिगरेशन) को बर्न करें।

कोड भंडार यहां पाया जा सकता है।

पुस्तकालय का एक ज़िप यहां पाया जा सकता है।

यहां "एक ज़िप पुस्तकालय आयात करना" के लिए निर्देश।

एक बार पुस्तकालय स्थापित हो जाने के बाद आप "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-…

जारी रखने से पहले ब्रेडबोर्ड के माध्यम से परीक्षण करना सबसे अच्छा है।

यदि आपके पास मौजूदा एसिमिलेट सेंसर हैं, तो सुनिश्चित करें कि सेंसर/एमसीयू होस्ट संयोजन पर गुलाम का पता अलग है। जब तक आपके पास MCU/नोड पर केवल एक रिले अभिनेता है, तब तक सभी रिले अभिनेताओं का एक ही पता हो सकता है।

चरण 3: संकेतकों को इकट्ठा करना

संकेतक पूरी तरह से अनुकूलन योग्य होने के लिए हैं। यह मुख्य सर्किट से घटना के संकेत हैं जिन्हें दिल की धड़कन के रूप में देखा जाता है। इस निर्माण के लिए हम एलईडी संकेतकों का उपयोग करेंगे; आपका निर्माण रिले का उपयोग कर सकता है (हाँ वीसीसी टूट गया है) या कोई अन्य दृश्य/संकेत आधारित संकेतक। रोकनेवाला मान व्यक्तिगत पसंद पर निर्भर करेगा कि आप उन्हें कितना उज्ज्वल चाहते हैं।

1. शीर्ष पर, RED1 (+) और BLACK1 (G) में एक नीली एलईडी डालें, और तल पर मिलाप करें।
2. तल पर, RED1 से लीड को मोड़ें ताकि यह सिल्वर 8 पर कॉपर पैड को छूए और ट्रिम करे।
3. तल पर, मिलाप के ऊपर BLACK1 से सीसा ट्रिम करें।
4. शीर्ष पर, RED2 (+) और BLACK2 (G) में एक हरे रंग की एलईडी डालें, और तल पर मिलाप करें।
5. तल पर, RED2 से लीड को मोड़ें ताकि यह सिल्वर 9 पर कॉपर पैड को छूए और ट्रिम करे।
6. तल पर, मिलाप के ऊपर BLACK2 से सीसा ट्रिम करें।
7. शीर्ष पर, RED3 (+) और BLACK3 (G) में एक लाल एलईडी डालें, और तल पर मिलाप करें।
8. तल पर, RED3 से लीड को मोड़ें ताकि यह सिल्वर 10 पर कॉपर पैड को छूए और ट्रिम करें।
9. तल पर, मिलाप के ऊपर BLACK3 से सीसा ट्रिम करें।
10. शीर्ष पर, एक 1K रोकनेवाला को थ्रू-होल SILVER1 और SILVER4 में डालें।
11. तल पर, सिल्वर1 से 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. तल पर, RED3 से लेड की निरंतरता सुनिश्चित करते हुए, SILVER7 में एक नारंगी तार मिलाप करें।

चरण 4: मुख्य सर्किट को असेंबल करना

सभा:

1. मोर्चे पर, घटक ATTINY85 (1), 3P 90deg पुरुष हेडर (2) (3), 3P पुरुष हेडर (4) (5) डालें और पीछे की तरफ मिलाप करें।
2. पीछे की तरफ, YELLOW1 से YELLOW2 और सोल्डर तक एक पीले रंग के तार को ट्रेस करें।
3. पीछे की तरफ, ऑरेंज 1 से ऑरेंज 2 और सोल्डर तक एक नारंगी तार ट्रेस करें।
4. पीछे की तरफ, नीले रंग के तार को BLUE1 से BLUE2 और सोल्डर तक ट्रेस करें।
5. पीछे की तरफ, हरे रंग के तार को GREEN1 से GREEN2 और सोल्डर तक ट्रेस करें।
6. पीछे की तरफ, WHITE1 से WHITE2 और सोल्डर तक एक सफेद तार ट्रेस करें।
7. पीछे की तरफ, BLACK1 से BLACK2 और सोल्डर तक एक ब्लैक वायर ट्रेस करें।
8. पीछे की तरफ, BLACK3 से BLACK4 और सोल्डर तक एक ब्लैक वायर ट्रेस करें।
9. पीछे की तरफ, RED1 से RED2 और सोल्डर तक एक लाल तार ट्रेस करें।
10. पीछे की तरफ, RED3 से RED4 और सोल्डर तक एक नंगे तार का पता लगाएं।
11. पीछे की तरफ, सिल्वर 1 से सिल्वर 2 और सोल्डर तक एक नंगे तार को ट्रेस करें।
12. 5V या 3V3 लाइन पर एक जम्पर जोड़ें।

यदि उपरोक्त संकेतकों का उपयोग कर रहे हैं (पिनआउट आरेख देखें):

1. पीछे की तरफ, सफेद तार को PB1 में मिलाप करें।
2. पीछे की तरफ, पीले तार को PB3 में मिलाप करें।
3. पीछे की तरफ, नारंगी तार को PB4 में मिलाप करें।
4. पीछे की तरफ, काले तार को GND में मिलाप करें।

चरण 5: परीक्षण

इनमें से कई ब्रिक्स एक वातावरण में कई नोड्स (एमसीयू - ईएसपी 8266 या एटीटीआईएनवाई 84) पर होने की उम्मीद है। यह एक इकाई परीक्षण है: UNO से ATTINY को I2C कमांड भेजता है जो रिसीव एलईडी को टॉगल करता है। ATTINY ALIVE LED चालू रहता है।

हमने पहले Arduino के लिए I2C SHIELD बनाया है।

यदि आप इसके बजाय ब्रेडबोर्ड करना चाहते हैं:

1. UNO पर 5.0V को BRICK पर VCC से कनेक्ट करें।
2. UNO पर GND को BRICK पर GND से कनेक्ट करें।
3. UNO पर A5 को BRICK पर SCL से कनेक्ट करें।
4. UNO पर A4 को BRICK पर SDA से कनेक्ट करें।
5. एक 4K7 पुल-अप रोकनेवाला SDA से VCC से कनेक्ट करें।
6. एक 4K7 पुल-अप रोकनेवाला SCL से VCC से कनेक्ट करें।

परीक्षण चला रहा है।

1. यूएसबी के साथ अपने यूएनओ को अपने देव पीसी से कनेक्ट करें।
2. यूएनओ को कोड अपलोड करें।
3. Arduino कंसोल खोलें।
4. 9600 बॉड चुनें (यूएनओ को पुनरारंभ करें और यदि आपको करना है तो कंसोल को फिर से खोलें)।
5. दास का पता कंसोल पर प्रिंट होगा।
6. कब, भेजें बॉक्स 2 1 (इसलिए 16 2 1) में दर्ज करें, और प्राप्त एलईडी चालू हो जाता है।
7. जब, भेजें बॉक्स 2 0 (इसलिए 16 2 0) में दर्ज करें, और प्राप्त एलईडी बंद हो जाता है।

I2C ब्रिक एडहॉक यूएनओ मास्टर से दासों के लिए आदेश देता है।

#शामिल

कॉन्स्ट बाइट _num_chars = 32;

चार _received_chars[_num_chars]; // प्राप्त डेटा को संग्रहीत करने के लिए एक सरणी

बूलियन _has_new_data = झूठा;

व्यर्थ व्यवस्था() {

सीरियल.बेगिन (९६००);

सीरियल.प्रिंट्लन ();

Serial.println ("IOT अभिनेता / सेंसर EEPROM संपादक को आत्मसात करें");

Serial.println ("कंसोल विंडो में चयनित न्यूलाइन सुनिश्चित करें");

सीरियल.प्रिंट्लन ();

Serial.println ("पता 1 मेटाडेटा रसीद की पुष्टि करें N/A (M2M के लिए)");

Serial.println ("पता 2 अभिनेता कमांड");

सीरियल.प्रिंट्लन ();

Serial.println ("बस में पता:");

स्कैन_i2c_addresses ();

सीरियल.प्रिंट्लन ();

सीरियल.प्रिंट्लन ("");

}

voidscan_i2c_addresses(){

इंट डिवाइस_काउंट = 0;

के लिए (बाइट पता = 8; पता <127; पता ++)

{

Wire.beginTransmission (पता);

कॉन्स्ट बाइट त्रुटि = Wire.endTransmission ();

अगर (त्रुटि == 0)

{

Serial.println (पता);

}

}

}

शून्य लूप () {

recv_with_end_marker ();

send_to_i2c ();

}

voidrecv_with_end_marker() {

स्थिर बाइट एनडीएक्स = 0;

चार एंड_मार्कर = '\ n';

चार आर सी;

जबकि (सीरियल.उपलब्ध ()>0 && _has_new_data == असत्य) {

आरसी = सीरियल.रीड ();

अगर (आरसी! = एंड_मार्कर) {

_received_chars [ndx] = आरसी;

एनडीएक्स++;

अगर (एनडीएक्स>= _num_chars) {

एनडीएक्स = _num_chars - 1;

}

}

अन्यथा {

_received_chars[ndx] = '\0'; // स्ट्रिंग को समाप्त करें

एनडीएक्स = 0;

_has_new_data = सच;

}

}

}

voidsend_to_i2c() {

चार परम_बफ [16];

कॉन्स्ट स्ट्रिंग प्राप्त_स्ट्रिंग = स्ट्रिंग (_received_chars);

अगर (_has_new_data == सच) {

int idx1 = get_string.indexOf ('');

स्ट्रिंग पता = प्राप्त_स्ट्रिंग। सबस्ट्रिंग (0, idx1);

int address_int = address.toInt ();

अगर (address_int <8 || address_int >127){

Serial.println ("अमान्य पता इनपुट:");

Serial.println (पता);

वापसी;

}

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

स्ट्रिंग कोड;

अगर (idx2 == -1) {

कोड = प्राप्त_स्ट्रिंग। सबस्ट्रिंग (idx1 + 1);

}अन्यथा{

कोड = प्राप्त_स्ट्रिंग। सबस्ट्रिंग (idx1+1, idx2+1);

}

int code_int = code.toInt ();

अगर (code_int <0 || code_int >5){

Serial.println ("अमान्य कोड इनपुट:");

Serial.println (कोड);

वापसी;

}

बूल has_parameter = idx2 > -1;

स्ट्रिंग पैरामीटर;

अगर (है_पैरामीटर) {

पैरामीटर = प्राप्त_स्ट्रिंग। सबस्ट्रिंग (idx2 + 1, idx2 + 17); // 16 वर्ण अधिकतम

अगर (पैरामीटर। लंबाई () <1) {

Serial.println ("पार्टमेटर मिन। लंबाई 1");

_has_new_data = झूठा;

वापसी;

}

}अन्यथा{

अगर (कोड_इंट> 1) {

Serial.println ("पैरामीटर आवश्यक!");

_has_new_data = झूठा;

वापसी;

}

}

सीरियल.प्रिंट्लन ();

सीरियल.प्रिंट ("इनपुट मूल =");

Serial.println (प्राप्त_स्ट्रिंग);

सीरियल.प्रिंट ("पता =");

Serial.println (पता);

सीरियल.प्रिंट ("कोड =");

Serial.println (कोड);

सीरियल.प्रिंट ("पैरामीटर =");

Serial.println (पैरामीटर);

// I2C के माध्यम से भेजें

Wire.beginTransmission (address_int);

वायर.राइट (कोड_इंट);

अगर (है_पैरामीटर) {

पैरामीटर। ट्रिम ();

strcpy (param_buf, पैरामीटर.c_str ());

वायर.राइट (param_buf);

}

वायर.एंडट्रांसमिशन ();

सीरियल.प्रिंट्लन ();

Serial.println ("I2C के माध्यम से भेजा गया!");

सीरियल.प्रिंट्लन ();

सीरियल.प्रिंट्लन ("");

_has_new_data = झूठा;

}

}

देखें rawuno_i2c_command_input.ino ❤ के साथ GitHub द्वारा होस्ट किया गया

चरण 6: अगले चरण

अनुवर्ती सहायक अभिनेता: HEARTBEAT जो इस ईंट का उपयोग करता है, यहां ATTINY85 में पहले से स्थापित मेटाडेटा के माध्यम से Crouton के लिए स्वचालित कॉन्फ़िगरेशन है। Crouton को भेजा गया JSON पैकेट ICOS10 के नवीनतम फर्मवेयर के माध्यम से भेजा जाता है। यदि बिल्ड अभी के लिए बहुत अधिक है, तो आप एक साधारण ESP8266 पर प्रूफ-ऑफ-कॉन्सेप्ट कर सकते हैं।

यदि आपके लक्ष्य I2C बस पर टकराव होता है, तो परीक्षण में उपयोग किए गए UNO स्केच में ATTINY85 पर EEPROM को एक नया दास पता सहेजने के लिए एक फ़ंक्शन है।