IOT123 - I2C KY019 აგური: 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 KY019 აგური არის პირველი მსახიობიდან და აქვს ერთი წაკითხვის/ჩაწერის თვისება:

გადართვა (ჭეშმარიტი/მცდარი)

კეისის ტიპის სენსორული აგური პირველად იქნება ამოღებული, რადგან მათ აქვთ ვიტამინები (დამატებითი კომპონენტებია საჭირო) და შედარებით იაფია (37 ვიყიდე 10 AUD– ში). სხვა დაფები/სქემები გაეცნობა I2C აგურს.

ATTINY85– ის მიმდებარე ხვრელები გამოუყენებელი დარჩა, რათა ჩართოს pogo pin პროგრამისტი, ხოლო DIP8 მიერთებულია PCB– ზე. შემდგომი აბსტრაქცია, აგურის შეფუთვა პატარა ცილინდრებში, რომელიც ჩართულია 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…

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

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

ახლა სარელეო შეიძლება უშუალოდ დაუკავშირდეს 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 კონსოლი. შეარჩიეთ 9600 baud (გადატვირთეთ UNO და გახსენით კონსოლი, თუ მოგიწევთ).
4. მონას მისამართი იბეჭდება კონსოლზე.
5. როდესაც, შეიყვანეთ გაგზავნის ყუთი 2 1 (ასე 12 12 1) და რელე ჩართულია.
6. როდესაც, შეიყვანეთ გაგზავნის ყუთი 2 0 (ასე 12 12 0) და რელე გამორთულია.

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: KY019, რომელიც იყენებს ამ აგურს, აქვს ავტომატური კონფიგურაცია Crouton– ისთვის აქ უკვე ATTINY85– ში დაინსტალირებული მეტამონაცემების საშუალებით. Crouton– ზე გაგზავნილი JSON პაკეტი იგზავნება ICOS10– ის უახლესი პროგრამული უზრუნველყოფის საშუალებით. თქვენ შეგიძლიათ გააკეთოთ კონცეფციის დამტკიცება ჩვეულებრივ ESP8266– ზე, თუ მშენებლობა ჯერჯერობით ზედმეტია.

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

რამოდენიმე სქემა დაემატა, მაგრამ არსებობს სხვადასხვა გზები მავთულხლართების შესაქმნელად, იმისდა მიხედვით თუ რისი მიღწევა გსურთ, ასე რომ მე ამას დაგტოვებთ თქვენთვის:)