IOT123 - CĂRĂCIĂ DE BĂTĂTĂ INIMĂ I2C: 6 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

IOT123 BRICKS sunt unități modulare DIY care pot fi amestecate cu alte IOT123 BRICKS, pentru a adăuga funcționalitate unui nod sau purtabil. Acestea se bazează pe protoboardele cu două fețe pătrate de inch, cu găuri interconectate.

Un număr dintre aceste BRICKS se așteaptă să fie pe mai multe noduri (Master MCU - ESP8266 sau ATTINY84) pe un site. MCU nu are nevoie de cunoștințe prealabile despre scopul senzorilor sau despre nevoile software-ului. Acesta scanează nodurile I2C, apoi solicită o descărcare a proprietății (date senzor) de la fiecare sclav. Aceste cărămizi furnizează 5.0V, 3.3V și o altă linie AUX personalizabilă.

Această cărămidă I2C HEARTBEAT indică dacă sclavul ATTINY este în viață, de asemenea traficul I2C și are o proprietate:

STARE ("VIE")

PB1 (alb) indică sănătatea ATTINY.

PB3 (galben) comută cu solicitările I2C de la master.

PB4 (portocaliu) comută cu primirea I2C de la master.

Găurile de trecere adiacente ATTINY85 au fost lăsate neutilizate, pentru a permite un programator pogo pin în timp ce DIP8 este lipit pe PCB. O altă abstracție, ambalarea BRICKS în cilindri mici care se conectează la un hub D1M WIFI BLOCK, pompând valorile către un server MQTT, este în curs de dezvoltare.

Pasul 1: Materiale și instrumente

Există o listă completă de materiale și aprovizionare.

1. PCB de hârtie (7 x 7 găuri)
2. LED-uri (roșu, verde, albastru)
3. Rezistoare (3 off 1K)
4. ATTINY85 20PU (1)
5. 1 "Protoboard dublu (1)
6. Antet masculin 90º (3P, 3P)
7. Antet masculin (2P, 2P)
8. Jumper Shunt (1)
9. Sârmă de conectare (~ 7)
10. Sudură și fier (1)

Pasul 2: Pregătiți ATTINY85

NOTĂ: Dacă intenționați să aveți integrarea Crouton, vă rugăm să utilizați biblioteca de aici și să folosiți exemplul instalat „attiny_heartbeat”

Este nevoie de AttinyCore de la managerul de borduri. Ardeți încărcătorul de încărcare „EEPROM păstrat”, „8mHZ intern” (toate configurațiile sunt prezentate mai sus).

Depozitul de coduri poate fi găsit aici.

Un ZIP al bibliotecii poate fi găsit aici.

Instrucțiuni pentru „Importarea unei biblioteci ZIP” aici.

Odată ce biblioteca este instalată puteți deschide exemplul „attiny_heartbeat”.

Pentru a încărca firmware-ul pe ATTINY85, puteți găsi mai multe detalii în aceste instrucțiuni:

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

Cel mai bine este să testați prin panou înainte de a continua.

Dacă aveți SENSORI ASSIMILATE, asigurați-vă că adresa slave este diferită pe o combinație SENSOR / MCU Host de ex. toți actorii de releu pot avea aceeași adresă, atâta timp cât aveți un singur actor de releu pe un MCU / nod.

Pasul 3: Asamblarea indicatorilor

Indicatorii sunt meniți să fie complet personalizabili. Semnalele de eveniment din circuitul principal sunt văzute ca Heartbeats. Pentru această construcție vom folosi indicatori LED; construcția dvs. poate utiliza relee (da, VCC este defect) sau un alt indicator vizual / bazat pe semnal. Valorile rezistenței vor depinde de preferința personală de cât de luminoase le doriți.

1. În partea de sus, introduceți un LED albastru în RED1 (+) și BLACK1 (G) și lipiți în partea de jos.
2. În partea de jos, îndoiți cablul de la RED1 astfel încât să atingă placa de cupru de pe SILVER8 și decupați.
3. În partea de jos, tăiați cablul de la BLACK1 deasupra lipirii.
4. În partea de sus, introduceți un LED verde în RED2 (+) și BLACK2 (G) și lipiți în partea de jos.
5. În partea de jos, îndoiți cablul de la RED2 astfel încât să atingă placa de cupru de pe SILVER9 și decupați.
6. În partea de jos, tăiați cablul de la BLACK2 deasupra lipirii.
7. În partea de sus, introduceți un LED roșu în RED3 (+) și BLACK3 (G) și lipiți în partea de jos.
8. În partea de jos, îndoiți cablul de la RED3 astfel încât să atingă placa de cupru de pe SILVER10 și tăiați.
9. În partea de jos, tăiați cablul de la BLACK3 deasupra lipirii.
10. În partea de sus, introduceți un rezistor de 1K în orificiile de trecere SILVER1 și SILVER4.
11. În partea de jos, urmăriți, tăiați și lipiți cablul de la SILVER1 pe BLACK1.
12. În partea de sus, introduceți un rezistor de 1K în orificiile de trecere SILVER2 și SILVER4.
13. În partea de jos, urmăriți, tăiați și lipiți cablul de la SILVER2 pe BLACK2.
14. În partea de sus, introduceți un rezistor de 1K în orificiile de trecere SILVER3 și SILVER4.
15. În partea de jos, urmăriți, tăiați și lipiți plumbul de la SILVER3 pe BLACK3.
16. În partea de jos, firele de lipit pe SILVER4 și tăiate la aproximativ 5 mm extinzându-se.
17. În partea de jos, lipiți un fir negru pe SILVER4.
18. În partea de jos, lipiți un fir alb în SILVER5, asigurând continuitatea conducerii de la RED1.
19. În partea de jos, lipiți un fir galben în SILVER6, asigurând continuitatea conducerii de la RED2.
20. În partea de jos, lipiți un fir portocaliu în SILVER7, asigurând continuitatea conducerii de la RED3.

Pasul 4: Asamblarea circuitului principal

Asamblare:

1. În partea din față, introduceți componentele ATTINY85 (1), anteturi masculine 3P 90deg (2) (3), anteturi masculine 3P (4) (5) și lipiți în spate.
2. În spate, urmăriți un fir galben de la GALBEN1 la GALBEN2 și lipiți.
3. În spate, urmăriți un fir portocaliu de la ORANGE1 la ORANGE2 și lipiți.
4. În spate, urmăriți un fir albastru de la ALBASTRU1 la ALBĂRAT2 și lipiți.
5. În spate, urmăriți un fir verde de la GREEN1 la GREEN2 și lipiți.
6. În partea din spate, urmăriți un fir alb de la WHITE1 la WHITE2 și lipiți.
7. În spate, urmăriți un fir negru de la BLACK1 la BLACK2 și lipiți.
8. În spate, urmăriți un fir negru de la BLACK3 la BLACK4 și lipiți.
9. În spate, urmăriți un fir roșu de la RED1 la RED2 și lipiți.
10. În spate, urmăriți un fir gol de la RED3 la RED4 și lipiți.
11. În spate, urmăriți un fir gol de la SILVER1 la SILVER2 și lipiți.
12. Adăugați un jumper pe linia 5V sau 3V3.

Dacă utilizați indicatorii de mai sus (consultați diagrama pinout):

1. În spate, lipiți firul alb în PB1.
2. În partea din spate, lipiți firul galben în PB3.
3. În spate, lipiți firul portocaliu în PB4.
4. În spate, lipiți firul negru în GND.

Pasul 5: Testare

Un număr dintre aceste BRICKS se așteaptă să fie pe mai multe noduri (MCU - ESP8266 sau ATTINY84) într-un mediu. Acesta este un test de unitate: trimite comenzi I2C de la UNO la ATTINY care comută LED-ul de recepție. LED-ul ATTINY ALIVE rămâne aprins.

Am construit anterior un I2C SHIELD pentru Arduino.

Dacă doriți să o faceți în schimb:

1. Conectați 5.0V pe UNO la un VCC pe BRICK.
2. Conectați GND pe UNO la GND pe BRICK.
3. Conectați A5 pe UNO la SCL pe BRICK.
4. Conectați A4 pe UNO la SDA pe BRICK.
5. Conectați un rezistor de tragere 4K7 de la SDA la VCC.
6. Conectați un rezistor de tragere 4K7 de la SCL la VCC.

Rularea testului

1. Conectați-vă UNO la computerul dvs. Dev cu USB.
2. Încărcați codul la UNO.
3. Deschideți consola Arduino.
4. Alegeți 9600 baud (reporniți UNO și redeschideți consola dacă trebuie).
5. Adresa sclavului va fi tipărită pe consolă.
6. Când, introduceți în caseta de trimitere 2 1 (deci 16 2 1) și LED-ul de primire se aprinde.
7. Când, introduceți în caseta de trimitere 2 0 (deci 16 2 0), iar LED-ul de primire se stinge.

Comenzi adhoc I2C BRICK pentru sclavi de la masterul UNO

#include

octet const _num_chars = 32;

char _received_chars [_num_chars]; // o matrice pentru stocarea datelor primite

boolean _has_new_data = false;

voidsetup () {

Serial.begin (9600);

Serial.println ();

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

Serial.println ("asigurați linia nouă selectată în fereastra consolei");

Serial.println ();

Serial.println ("ADRESA 1 CONFIRMĂ PRIMITE METADATE N / A (PENTRU M2M)");

Serial.println ("ADRESA 2 ACTOR COMANDĂ");

Serial.println ();

Serial.println ("ADRESE PE AUTOBUZ:");

scan_i2c_addresses ();

Serial.println ();

Serial.println ("");

}

voidscan_i2c_addresses () {

int device_count = 0;

for (adresa de octet = 8; adresa <127; adresa ++)

{

Wire.beginTransmission (adresa);

const byte error = Wire.endTransmission ();

if (eroare == 0)

{

Serial.println (adresa);

}

}

}

voidloop () {

recv_with_end_marker ();

send_to_i2c ();

}

voidrecv_with_end_marker () {

octet static ndx = 0;

char end_marker = '\ n';

char rc;

while (Serial.available ()> 0 && _has_new_data == false) {

rc = Serial.read ();

if (rc! = end_marker) {

_received_chars [ndx] = rc;

ndx ++;

if (ndx> = _num_chars) {

ndx = _num_chars - 1;

}

}

altceva {

_received_chars [ndx] = '\ 0'; // terminați șirul

ndx = 0;

_has_new_data = true;

}

}

}

voidsend_to_i2c () {

char param_buf [16];

const String received_string = String (_received_chars);

if (_has_new_data == true) {

int idx1 = a primit_string.indexOf ('');

Adresa șirului = a primit_string.substring (0, idx1);

int address_int = address.toInt ();

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

Serial.println ("ADRESS ADRESS INVALID:");

Serial.println (adresa);

întoarcere;

}

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

Cod șir;

if (idx2 == -1) {

cod = a primit_string.substring (idx1 + 1);

} altceva {

cod = a primit_string.substring (idx1 + 1, idx2 + 1);

}

int code_int = code.toInt ();

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

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

Serial.println (cod);

întoarcere;

}

bool has_parameter = idx2> -1;

Parametru șir;

if (has_parameter) {

parametru = a primit_string.substring (idx2 + 1, idx2 + 17); // 16 caractere max

if (parametru.lungime () <1) {

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

_has_new_data = false;

întoarcere;

}

} altceva {

if (code_int> 1) {

Serial.println ("PARAMETRU NECESAR!");

_has_new_data = false;

întoarcere;

}

}

Serial.println ();

Serial.print ("input orig =");

Serial.println (șir_ primit);

Serial.print ("adresa =");

Serial.println (adresa);

Serial.print ("cod =");

Serial.println (cod);

Serial.print ("parametru =");

Serial.println (parametru);

// TRIMITEȚI VIA I2C

Wire.beginTransmission (address_int);

Wire.write (code_int);

if (has_parameter) {

parametru.trim ();

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 = false;

}

}

vizualizați rawuno_i2c_command_input.ino găzduit cu ❤ de GitHub

Pasul 6: Pașii următori

Urmărirea ASSIMILATE ACTOR: HEARTBEAT care folosește această cărămidă are configurație automată pentru Crouton prin metadatele deja instalate în ATTINY85 aici. Pachetul JSON trimis către Crouton este trimis prin cel mai recent firmware pentru ICOS10. Puteți face o dovadă a conceptului pe un ESP8266 obișnuit, dacă versiunea este prea multă pentru moment.

Schița UNO utilizată în testare are o funcție pentru salvarea unei noi adrese slave în EEPROM pe ATTINY85, dacă aveți o ciocnire pe magistrala I2C țintă.