IOT123 - I2C HEARTBEAT BRICK: 6 საფეხური

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

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

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

ეს I2C HEARTBEAT აგური მიუთითებს ცოცხალია თუ არა ATTINY მონა, ასევე I2C ტრაფიკი და აქვს ერთი თვისება:

სტატუსი ("ცოცხალი")

PB1 (თეთრი) მიუთითებს ATTINY ჯანმრთელობაზე.

PB3 (ყვითელი) გადადის სამაგისტრო I2C მოთხოვნებით.

PB4 (ნარინჯისფერი) გადადის I2C მასტერისგან.

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

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

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

1. ქაღალდის PCB (7 x 7 ხვრელი)
2. LEDS (წითელი, მწვანე, ლურჯი)
3. რეზისტორები (3 off 1K)
4. ATTINY85 20PU (1)
5. 1 "ორმხრივი პროტო დაფა (1)
6. მამაკაცის სათაური 90º (3P, 3P)
7. მამაკაცის სათაური (2P, 2P)
8. მხტუნავები (1)
9. დასაკავშირებელი მავთული (7 ფუნტი)
10. შედუღება და რკინა (1)

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

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

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

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

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

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

ბიბლიოთეკის დაყენების შემდეგ შეგიძლიათ გახსნათ მაგალითი "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-…

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

თუ თქვენ გაქვთ არსებული ASSIMILATE SENSORS, დარწმუნდით, რომ მონა მისამართი განსხვავებულია SENSOR/MCU მასპინძლის კომბინაციაში მაგ. სარელეო ყველა მსახიობს შეიძლება ჰქონდეს იგივე მისამართი, თუ თქვენ გაქვთ მხოლოდ ერთი სარელეო მსახიობი MCU/კვანძზე.

ნაბიჯი 3: ინდიკატორების შეკრება

ინდიკატორები უნდა იყოს სრულად კონფიგურირებადი. ეს არის მოვლენის სიგნალები ძირითადი წრიდან, რომლებიც განიხილება როგორც გულისცემა. ამ მშენებლობისთვის ჩვენ გამოვიყენებთ LED ინდიკატორებს; თქვენს აშენებას შეუძლია გამოიყენოს რელეები (დიახ VCC გატეხილია) ან ვიზუალურ/სიგნალზე დაფუძნებული სხვა ინდიკატორი. რეზისტორის ღირებულებები დამოკიდებული იქნება პირად უპირატესობაზე იმაზე, თუ რამდენად ნათელი გსურთ ისინი.

1. ზემოდან ჩადეთ ლურჯი LED RED1 (+) და BLACK1 (G) და შედგით ბოლოში.
2. ქვედა, წარმართონ ტყვიის საწყისი RED1 ასე რომ ეხება სპილენძის pad SILVER8 და მორთვა.
3. ბოლოში, მორთეთ ტყვია BLACK1– ისგან შედუღების ზემოთ.
4. თავზე, ჩადეთ მწვანე LED RED2 (+) და BLACK2 (G) და შედგით ბოლოში.
5. ქვედა, წარმართონ ტყვიის საწყისი RED2 ასე რომ ეხება სპილენძის pad on SILVER9 და მორთვა.
6. ბოლოში, მორთეთ ტყვია BLACK2– დან, გამაგრების ზემოთ.
7. თავზე, ჩადეთ წითელი LED RED3 (+) და BLACK3 (G) და შედგით ბოლოში.
8. ქვედა, წარმართონ ტყვიის საწყისი RED3 ასე რომ ეხება სპილენძის pad on SILVER10 და მორთვა.
9. ბოლოში, მორთეთ ტყვია BLACK3– დან ზემოთ.
10. თავზე, ჩადეთ 1K რეზისტორი ხვრელებში SILVER1 და SILVER4.
11. ბოლოში, მიაკვლიეთ, მორთეთ და შეაერთეთ ტყვია SILVER1– დან 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. ბოლოში, შეაერთეთ ნარინჯისფერი მავთული SILVER7– ში, რაც უზრუნველყოფს RED3– დან ტყვიის უწყვეტობას.

ნაბიჯი 4: ძირითადი სქემის შეკრება

შეკრება:

1. წინა მხარეს ჩადეთ კომპონენტები ATTINY85 (1), 3P 90deg მამრობითი სათაურები (2) (3), 3P მამრობითი სათაურები (4) (5) და შედგით უკანა ნაწილზე.
2. უკანა მხარეს, მიჰყევით ყვითელ მავთულს YELLOW1– დან YELLOW2– მდე და შედუღეთ.
3. უკანა მხარეს მიაკვლიეთ ფორთოხლის მავთულს ORANGE1– დან ORANGE2– მდე და შეაერთეთ.
4. უკანა მხარეს, მიჰყევით ლურჯ მავთულს BLUE1– დან BLUE2– მდე და შეაერთეთ.
5. უკანა მხარეს მიაკვლიეთ მწვანე მავთულს GREEN1– დან GREEN2– მდე და შეაერთეთ.
6. უკანა მხარეს, მიჰყევით თეთრ მავთულს WHITE1– დან WHITE2– მდე და შედუღეთ.
7. უკანა მხარეს, მიჰყევით შავ მავთულს BLACK1– დან BLACK2– მდე და შედუღეთ.
8. უკანა მხარეს, მიჰყევით შავ მავთულს BLACK3- დან BLACK4- მდე და შედუღეთ.
9. უკანა მხარეს მიაკვლიეთ წითელ მავთულს RED1– დან RED2– მდე და შეაერთეთ.
10. უკანა მხარეს მიაკვლიეთ შიშველ მავთულს RED3- დან RED4- მდე და შეაერთეთ.
11. უკანა მხარეს მიაკვლიეთ შიშველ მავთულს SILVER1– დან SILVER2– მდე და შეაერთეთ.
12. დაამატეთ მხტუნავი 5V ან 3V3 ხაზზე.

თუ იყენებთ ზემოთ მითითებულ ინდიკატორებს (იხილეთ pinout დიაგრამა):

1. უკანა მხარეს შეაერთეთ თეთრი მავთული PB1- ში.
2. უკანა მხარეს შეაერთეთ ყვითელი მავთული PB3- ში.
3. უკანა მხარეს შეაერთეთ ფორთოხლის მავთული PB4- ში.
4. უკანა მხარეს შეაერთეთ შავი მავთული GND– ში.

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

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

ჩვენ ადრე ავაშენეთ 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 1 (ასე რომ 16 2 1) და Receive LED ჩართულია.
7. როდესაც, შეიყვანეთ გაგზავნის ყუთი 2 0 (ასე რომ 16 2 0) და Receive LED გამორთულია.

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 ერთად განთავსებული

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

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

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