IOT123 - I2C 2CH रिले ईंट: 5 कदम (चित्रों के साथ)

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

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

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

यह I2C 2CH RELAY BRICK I2C KY019 BRICK की कार्यक्षमता का विस्तार करता है, और इसमें दो पढ़ने/लिखने के गुण हैं:

2CH रिले [0] (सच/गलत)।

2CH रिले [1] (सच/गलत)।

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

रिले को अब सीधे अपने पिन के माध्यम से पीसीबी या तारों के माध्यम से पिन अनुबंध में दिखाए गए बिंदुओं से जोड़ा जा सकता है।

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

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

हमने पहले 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 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 रिले बंद हो जाता है।

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 द्वारा होस्ट किया गया

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

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

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