IOT123 - I2C 2CH RELAY BRICK: 5 pași (cu imagini)

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 2CH RELAY BRICK extinde funcționalitatea I2C KY019 BRICK și are două proprietăți de citire / scriere:

RELAJE 2CH [0] (adevărat / fals)

RELAJE 2CH [1] (adevărat / fals)

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 cu 2 canale (1)
2. ATTINY85 20PU (1)
3. 1 "Protoboard dublu (1)
4. Antet masculin 90º (3P, 3P)
5. Antet masculin (2P, 2P)
6. Jumper Shunt (1)
7. Sârmă de conectare (~ 7)
8. 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ă utilizați exemplul instalat „attiny_2ch_relay”.

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

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

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

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), 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 spate, urmăriți un fir negru de la BLACK1 la BLACK2 și lipiți.
7. În spate, urmăriți un fir negru de la BLACK3 la BLACK4 și lipiți.
8. În spate, urmăriți un fir roșu de la RED1 la RED2 și lipiți.
9. În spate, urmăriți un fir gol de la RED3 la RED4 și lipiți.
10. În spate, urmăriți un fir gol de la SILVER1 la SILVER2 și lipiți.
11. Adăugați un jumper pe linia 5V sau 3V3.

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 releele.

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 0: 1 (deci 15 2 0: 1), iar releul CH1 se aprinde.

7. Când, introduceți în caseta de trimitere 2 0: 0 (deci 15 2 0: 0), iar releul CH1 se oprește.
8. Când, introduceți în caseta de trimitere 2 1: 1 (deci 15 2 1: 1), iar releul CH2 se aprinde.
9. Când, introduceți în caseta de trimitere 2 1: 0 (deci 15 2 0: 0), iar releul CH2 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: 2CH RELAY 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:)