IOT123 - I2C KY019 BRICK: 5 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ă.

Acest I2C KY019 BRICK este primul dintre ACTORI și are o proprietate de citire / scriere:

Comutator (adevărat / fals)

Cărămizile senzorului de tip Keyes vor fi extrase mai întâi deoarece vin cu vitamine (sunt necesare componente suplimentare) incluse și sunt relativ ieftine (am cumpărat 37 pentru 10AUD). Alte plăci / circuite vor fi introduse la I2C BRICKS.

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. Releu KY-019 (1)
2. ATTINY85 20PU (1)
3. 1 "Protoboard dublu (1)
4. Antet masculin 90º (3P, 3P)
5. Sârmă de conectare (~ 7)
6. 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_ky019”.

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_ky019”.

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

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 gazdă SENSOR / MCU, adică 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: Asamblați circuitul

1. În partea din față, introduceți componentele ATTINY85 (1), anteturile masculine 3P 90deg (2) (3) și lipiți-le pe 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 albastru de la ALBASTRU1 la ALBĂRAT2 și lipiți.
4. În spate, urmăriți un fir verde de la GREEN1 la GREEN2 și lipiți.
5. În spate, urmăriți un fir negru de la BLACK1 la BLACK2 și lipiți.
6. În spate, urmăriți un fir negru de la BLACK3 la BLACK4 și lipiți.
7. În spate, urmăriți un fir roșu de la RED1 la RED2 și lipiți.
8. În spate, urmăriți un fir roșu de la RED3 la RED4 și lipiți.

Releul poate fi acum conectat direct prin pinii săi la PCB sau prin fire, la punctele prezentate în contractul pinului.

Pasul 4: Testarea

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 deschide sau închide releul.

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. Alegeți 9600 baud (reporniți UNO și redeschideți consola dacă trebuie).
4. Adresa sclavului va fi tipărită pentru consolă.
5. Când, introduceți în caseta de trimitere 2 1 (deci 12 2 1), iar releul se aprinde.
6. Când, introduceți în caseta de trimitere 2 0 (deci 12 2 0), iar releul se oprește.

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 5: Pașii următori

Urmărirea ASSIMILATE ACTOR: KY019 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ă.

Au fost adăugate câteva scheme, dar există diferite moduri de a conecta circuitul din aval în funcție de ceea ce doriți să realizați, așa că vă voi lăsa asta:)