IOT123 - I2C 2CH RELAY BRICK: 5 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

IOT123 აგური არის წვრილმანი მოდულური ერთეული, რომლის შეზავება შესაძლებელია სხვა IOT123 აგურებთან ერთად, რათა დაამატოთ ფუნქციონირება კვანძზე ან ტარებადი. ისინი დაფუძნებულია დუიმიან კვადრატზე, ორმხრივ პროტო დაფაზე, ერთმანეთთან დაკავშირებული ხვრელებით.

მოსალოდნელია, რომ ამ აგურის რიგი იქნება რამდენიმე კვანძზე (Master MCUs - ESP8266 ან ATTINY84) საიტზე. MCU– ს არ სჭირდება წინასწარი ცოდნა სენსორების დანიშნულების ან პროგრამული უზრუნველყოფის საჭიროებების შესახებ. ის იკვლევს I2C კვანძებს, შემდეგ ითხოვს ქონების ნაგავსაყრელს (სენსორის მონაცემებს) თითოეული მონადან. ეს აგური ამარაგებს 5.0V, 3.3V და სხვა AUX ხაზს, რომლის მორგებაც შესაძლებელია.

ეს I2C 2CH RELAY აგური აფართოებს I2C KY019 აგურის ფუნქციონირებას და აქვს ორი წაკითხვის/ჩაწერის თვისება:

2CH RELAYS [0] (ჭეშმარიტი/მცდარი)

2CH RELAYS [1] (ჭეშმარიტი/მცდარი)

ATTINY85– ის მიმდებარე ხვრელები გამოუყენებელი დარჩა, რათა ჩართოს pogo pin პროგრამისტი, ხოლო DIP8 მიერთებულია PCB– ზე. შემდგომი აბსტრაქცია, აგურის შეფუთვა პატარა ცილინდრებში, რომელიც ჩართულია D1M WIFI BLOCK კვანძში, ამუშავებს მნიშვნელობებს MQTT სერვერზე.

ნაბიჯი 1: მასალები და ინსტრუმენტები

არსებობს მასალებისა და წყაროების სრული სია.

1. 2 არხის სარელეო (1)
2. ATTINY85 20PU (1)
3. 1 "ორმხრივი პროტო დაფა (1)
4. მამაკაცის სათაური 90º (3P, 3P)
5. მამაკაცის სათაური (2P, 2P)
6. მხტუნავები (1)
7. დასაკავშირებელი მავთული (7 ფუნტი)
8. შედუღება და რკინა (1)

ნაბიჯი 2: მოამზადეთ ATTINY85

შენიშვნა: თუ აპირებთ კრუტონის ინტეგრაციას, გთხოვთ გამოიყენოთ ბიბლიოთეკა აქედან და გამოიყენეთ მაგალითი დაინსტალირებული "attiny_2ch_relay".

საჭიროა დაფების მენეჯერის AttinyCore. ჩაწერეთ ჩამტვირთავი "EEPROM შენარჩუნებულია", "8mHZ შიდა" (ყველა კონფიგურაცია ნაჩვენებია ზემოთ).

კოდის საცავი შეგიძლიათ იხილოთ აქ.

ბიბლიოთეკის ZIP შეგიძლიათ იხილოთ აქ.

ინსტრუქცია "ZIP ბიბლიოთეკის იმპორტი" აქ.

ბიბლიოთეკის დაყენების შემდეგ შეგიძლიათ გახსნათ მაგალითი "attiny_2ch_relay".

Firmware 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-…

გაგრძელებამდე უმჯობესია შეამოწმოთ პურის დაფის საშუალებით.

თუ თქვენ გაქვთ ASIMIMATE SENSORS, დარწმუნდით, რომ მონა მისამართი განსხვავებულია 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 ხაზზე.

ახლა სარელეო შეიძლება უშუალოდ დაუკავშირდეს PCB– ს პინებით ან მავთულხლართებით, პინ კონტრაქტში ნაჩვენებ წერტილებს.

ნაბიჯი 4: ტესტირება

ამ აგურის რიგი მოსალოდნელია იყოს მრავალ კვანძზე (MCUs - ESP8266 ან ATTINY84) გარემოში. ეს არის ერთეულის ტესტი: აგზავნის I2C ბრძანებებს UNO– დან ATTINY– ში, რომელიც ხსნის ან ხურავს რელეებს.

ჩვენ ადრე ავაშენეთ I2C SHIELD არდუინოსთვის.

თუ გსურთ ამის ნაცვლად დაფა:

1. შეაერთეთ 5.0V UNO– სთან VCC– ზე BRICK– ზე.
2. შეაერთეთ GND UNO– ს GND– თან აგურზე.
3. შეაერთეთ A5 UNO– ზე SCL– ზე აგურზე.
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 15 0: 0) და CH1 სარელეო გამორთულია.
8. როდესაც, შეიყვანეთ გაგზავნის ყუთი 2 1: 1 (ასე 15 15 1: 1) და CH2 სარელეო ჩართულია.
9. როდესაც, შეიყვანეთ გაგზავნის ყუთი 2 1: 0 (ასე 15 15 0: 0) და CH2 სარელეო გამორთულია.

I2C BRICK adhoc ბრძანებებს მონებისათვის გაეროს ოსტატისგან

#ჩართეთ

კონსტ ბაიტი _num_chars = 32;

char _ მიიღო_ჩარსი [_ რიცხვითი_ჩარხები]; // მასივი მიღებული მონაცემების შესანახად

ლოგიკური _has_new_data = ყალბი;

voidsetup () {

სერიული.დაწყება (9600);

Serial.println ();

Serial.println ("ASIMIMILATE IOT ACTOR/SENSOR EEPROM EDITOR");

Serial.println ("კონსოლის ფანჯარაში არჩეული ახალი ხაზის უზრუნველყოფა");

Serial.println ();

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

Serial.println ("მისამართი 2 მსახიობის ბრძანება");

Serial.println ();

Serial.println ("მისამართები ავტობუსზე:");

scan_i2c_addresses ();

Serial.println ();

Serial.println ("");

}

voidscan_i2c_addresses () {

int device_count = 0;

for (ბაიტის მისამართი = 8; მისამართი <127; მისამართი ++)

{

Wire.begin გადაცემა (მისამართი);

const byte შეცდომა = Wire.endTransmission ();

თუ (შეცდომა == 0)

{

Serial.println (მისამართი);

}

}

}

voidloop () {

recv_w_end_marker ();

send_to_i2c ();

}

voidrecv_w_ მარკერი () {

სტატიკური ბაიტი ndx = 0;

char end_marker = '\ n';

char rc;

ხოლო (Serial.available ()> 0 && _has_new_data == ყალბი) {

rc = Serial.read ();

თუ (rc! = end_marker) {

_მიღებულია_ჩარსი [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 სიმებიანი მიღებული_სტრიქონი = სიმებიანი (_მიღებული_ჩარხები);

თუ (_has_new_data == ჭეშმარიტი) {

int idx1 = მიღებული_სტრიქონი.ინდექსი Of ('');

სიმებიანი მისამართი = მიღებული_სტრიქო. ქვესტრიქონი (0, idx1);

int address_int = address.toInt ();

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

Serial.println ("INVALID ADDRESS INPUT:");

Serial.println (მისამართი);

დაბრუნების;

}

int idx2 = მიღებული_სტრიქონი.ინდექსი Of ('', idx1+1);

სიმებიანი კოდი;

თუ (idx2 == -1) {

კოდი = მიღებული_სტრიქონი. ქვესტრიქონი (idx1+1);

} სხვა {

კოდი = მიღებული_სტრიქონი. ქვესტრიქონი (idx1+1, idx2+1);

}

int code_int = code.toInt ();

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

Serial.println ("INVALID CODE INPUT:");

Serial.println (კოდი);

დაბრუნების;

}

bool has_parameter = idx2> -1;

სიმებიანი პარამეტრი;

თუ (აქვს_პარამეტრი) {

პარამეტრი = მიღებული_სტრიქონი. ქვესტრიქონი (idx2 + 1, idx2 + 17); // მაქსიმუმ 16 სიმბოლო

if (parameter.length () <1) {

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

_has_new_data = ყალბი;

დაბრუნების;

}

} სხვა {

if (code_int> 1) {

Serial.println ("საჭირო პარამეტრი!");

_has_new_data = ყალბი;

დაბრუნების;

}

}

Serial.println ();

Serial.print ("input orig =");

Serial.println (მიღებული_სტრიქონი);

Serial.print ("მისამართი =");

Serial.println (მისამართი);

Serial.print ("კოდი =");

Serial.println (კოდი);

Serial.print ("პარამეტრი =");

Serial.println (პარამეტრი);

// გააგზავნე VIA I2C

Wire.beginTransmission (address_int);

Wire.write (code_int);

თუ (აქვს_პარამეტრი) {

პარამეტრი.ტრიმი ();

strcpy (param_buf, parameter.c_str ());

Wire.write (param_buf);

}

Wire.endTransmission ();

Serial.println ();

Serial.println ("SENT VIA I2C!");

Serial.println ();

Serial.println ("");

_has_new_data = ყალბი;

}

}

rawuno_i2c_command_input.ino- ს ნახვა GitHub– ის მიერ hosted ერთად განთავსებული

ნაბიჯი 5: შემდეგი ნაბიჯები

შემდგომი ASSIMILATE ACTOR: 2CH RELAY, რომელიც იყენებს ამ აგურს, აქვს ავტომატური კონფიგურაცია Crouton– ისთვის მეტადატების საშუალებით, რომლებიც უკვე დაყენებულია აქ ATTINY85– ში. Crouton– ზე გაგზავნილი JSON პაკეტი იგზავნება ICOS10– ის უახლესი პროგრამული უზრუნველყოფის საშუალებით. თქვენ შეგიძლიათ გააკეთოთ კონცეფციის დამტკიცება ჩვეულებრივ ESP8266– ზე, თუ მშენებლობა ჯერჯერობით ზედმეტია.

ტესტირებისას გამოყენებული UNO- ს ესკიზს აქვს ფუნქცია გადაარჩინოს ახალი მონა მისამართი EEPROM– ზე ATTINY85– ზე, თუ თქვენ გაქვთ შეჯახება თქვენს სამიზნე I2C ავტობუსზე. რამოდენიმე სქემა დაემატა, მაგრამ არსებობს სხვადასხვა გზები მავთულხლართების შესაქმნელად, იმისდა მიხედვით თუ რისი მიღწევა გსურთ, ასე რომ მე ამას დაგტოვებთ თქვენთვის:)