IOT123 - I2C 2CH RELAY BRICK: 5 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:15

Els IOT123 BRICKS són unitats modulars de bricolatge que es poden combinar amb altres IOT123 BRICKS, per afegir funcionalitat a un node o usable. Es basen en protobardes de doble cara quadrades de polzades amb forats interconnectats.

Es preveu que alguns d’aquests BRICKS estiguin en diversos nodes (MCU mestres - ESP8266 o ATTINY84) en un lloc. La MCU no necessita cap coneixement previ del propòsit dels sensors ni de les necessitats del programari. Busca nodes I2C i després sol·licita un buidatge de propietats (dades del sensor) a cada esclau. Aquests BRICKs subministren 5.0V, 3.3V i una altra línia AUX que es pot personalitzar.

Aquest I2C 2CH RELAY BRICK amplia la funcionalitat del I2C KY019 BRICK i té dues propietats de lectura / escriptura:

RELÉS 2CH [0] (veritable / fals)

RELLEUS 2CH [1] (vertader / fals)

Els forats passants adjacents a l'ATTINY85 s'han deixat sense utilitzar, per habilitar un programador de pogo pin mentre el DIP8 està soldat al PCB. S'està desenvolupant una altra abstracció, que empaqueta els BRICKS en petits cilindres que es connecten a un hub D1M WIFI BLOCK, que bombeja els valors a un servidor MQTT.

Pas 1: materials i eines

Hi ha una llista completa de llista de subministraments i material.

1. Relé de 2 canals (1)
2. ATTINY85 20PU (1)
3. 1 "protoborda de doble cara (1)
4. Capçalera masculina 90º (3P, 3P)
5. Capçalera masculina (2P, 2P)
6. Jumper Shunt (1)
7. Cable de connexió (~ 7)
8. Soldadura i ferro (1)

Pas 2: prepareu l'ATTINY85

NOTA: Si teniu intenció d’integrar Crouton, utilitzeu la biblioteca des d’aquí i utilitzeu l’exemple instal·lat "attiny_2ch_relay".

Cal AttinyCore del gestor de juntes. Grava el carregador d'arrencada "EEPROM retingut", "8mHZ Internal" (totes les configuracions es mostren més amunt).

El dipòsit de codis es pot trobar aquí.

Podeu trobar un ZIP de la biblioteca aquí.

Instruccions per a "Importar una biblioteca ZIP" aquí.

Un cop instal·lada la biblioteca, podeu obrir l'exemple "attiny_2ch_relay".

Per carregar el microprogramari a l'ATTINY85, podeu trobar més detalls en aquests instructables:

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

El millor és provar-ho mitjançant taulers abans de continuar.

Si teniu SENSORS ASSIMILATS existents, assegureu-vos que l'adreça esclava sigui diferent en una combinació d'amfitrió SENSOR / MCU, és a dir, tots els actors de retransmissió poden tenir la mateixa adreça sempre que només tingueu un actor de retransmissió en un node / MCU.

Pas 3: Munteu el circuit

1. A la part frontal, inseriu els components ATTINY85 (1), capçaleres masculines 3P 90deg (2) (3), capçaleres masculines 3P (4) (5) i soldeu-les per la part posterior.
2. A la part posterior, traqueu un cable groc de GROC1 a GROC2 i soldeu-lo.
3. A la part posterior, traqueu un fil taronja de TARONJA1 a TARONJA2 i soldeu-lo.
4. A la part posterior, traqueu un fil blau de BLAU 1 a BLAU 2 i soldeu-lo.
5. A la part posterior, traqueu un fil verd de GREEN1 a GREEN2 i soldeu-lo.
6. A la part posterior, traça un fil negre de BLACK1 a BLACK2 i solda.
7. A la part posterior, traça un fil negre de BLACK3 a BLACK4 i solda.
8. A la part posterior, traqueu un cable vermell de RED1 a RED2 i soldeu-lo.
9. A la part posterior, traqueu un fil nu de RED3 a RED4 i soldeu-lo.
10. A la part posterior, traça un fil nu de SILVER1 a SILVER2 i solda.
11. Afegiu un pont a la línia 5V o 3V3.

El relé ara es pot connectar directament a través dels seus pins a la PCB o mitjançant cables, als punts que es mostren al contracte de pins.

Pas 4: proves

S'espera que diversos d'aquests BRICKS estiguin en diversos nodes (MCU - ESP8266 o ATTINY84) en un entorn. Es tracta d’una prova unitària: envia ordres I2C des de l’ONU a l’ATTINY que obre o tanca els relés.

Anteriorment hem construït un I2C SHIELD per a Arduino.

Si el voleu modificar, feu el següent:

1. Connecteu el 5.0V a UNO a un VCC a BRICK.
2. Connecteu el GND a UNO a GND a BRICK.
3. Connecteu l'A5 a UNO a SCL a BRICK.
4. Connecteu l'A4 a UNO a SDA a BRICK.
5. Connecteu una resistència de captació 4K7 des de SDA a VCC.
6. Connecteu una resistència de captació 4K7 de SCL a VCC.

Execució de la prova

1. Connecteu la vostra UNO al vostre PC de desenvolupament amb USB.
2. Pengeu el codi a l’ONU.
3. Obriu la consola Arduino.
4. Trieu 9600 baud (reinicieu UNO i torneu a obrir la consola si cal).
5. L'adreça de l'esclau s'imprimirà a la consola.

6. Quan, introduïu al quadre d’enviament 2 0: 1 (per tant, 15 2 0: 1) i el relé CH1 s’encén.

7. Quan, introduïu al quadre d'enviament 2 0: 0 (per tant, 15 2 0: 0) i el relé CH1 s'apaga.
8. Quan, introduïu a la casella d'enviament 2 1: 1 (per tant, 15 2 1: 1) i el relé CH2 s'encén.
9. Quan, introduïu a la casella d'enviament 2 1: 0 (per tant, 15 2 0: 0) i el relé CH2 s'apaga.

Ordres adhoc I2C BRICK per a esclaus del mestre UNO

#incloure

byte const _num_chars = 32;

char _received_chars [_num_chars]; // una matriu per emmagatzemar les dades rebudes

_ha_new_data booleana = false;

voidsetup () {

Serial.begin (9600);

Serial.println ();

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

Serial.println ("assegureu-vos que hi ha una nova línia seleccionada a la finestra de la consola");

Serial.println ();

Serial.println ("L'ADREÇA 1 CONFIRMA LA RECEPCIÓ DE METADADES N / A (PER A M2M)");

Serial.println ("COMANDA DE L'ACTOR DE L'ADRESSA 2");

Serial.println ();

Serial.println ("ADRESSES AL BUS:");

scan_i2c_addresses ();

Serial.println ();

Serial.println ("");

}

voidscan_i2c_addresses () {

int device_count = 0;

for (adreça de bytes = 8; adreça <127; adreça ++)

{

Wire.beginTransmission (adreça);

error de byte const = Wire.endTransmission ();

if (error == 0)

{

Serial.println (adreça);

}

}

}

voidloop () {

recv_with_end_marker ();

enviar_a_i2c ();

}

voidrecv_with_end_marker () {

byte estàtic 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;

}

}

més {

_received_chars [ndx] = '\ 0'; // finalitzar la cadena

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 = string_cadenada.indexOf ('');

Adreça de la cadena = string_revinguda.substring (0, idx1);

int address_int = address.toInt ();

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

Serial.println ("ENTRADA D'ADREÇA NO VÀLIDA:");

Serial.println (adreça);

tornar;

}

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

Codi de cadena;

if (idx2 == -1) {

codi = cadena_ rebuda.substring (idx1 + 1);

} més {

codi = cadena_receptiva.substring (idx1 + 1, idx2 + 1);

}

int code_int = code.toInt ();

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

Serial.println ("ENTRADA DE CODI NO VÀLID:");

Serial.println (codi);

tornar;

}

bool has_parameter = idx2> -1;

Paràmetre de cadena;

if (has_parameter) {

paràmetre = string_recevada.substring (idx2 + 1, idx2 + 17); // 16 caràcters com a màxim

if (parameter.length () <1) {

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

_has_new_data = false;

tornar;

}

} més {

if (code_int> 1) {

Serial.println ("PARÀMETRE NECESSARI!");

_has_new_data = false;

tornar;

}

}

Serial.println ();

Serial.print ("input orig =");

Serial.println (string_recived);

Serial.print ("adreça =");

Serial.println (adreça);

Serial.print ("codi =");

Serial.println (codi);

Serial.print ("paràmetre =");

Serial.println (paràmetre);

// ENVIAR VIA I2C

Wire.beginTransmission (address_int);

Wire.write (code_int);

if (has_parameter) {

parametre.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;

}

}

veure rawuno_i2c_command_input.ino allotjat amb ❤ per GitHub

Pas 5: passos següents

El seguiment ASSIMILATE ACTOR: 2CH RELAY que utilitza aquest maó té una configuració automàtica per a Crouton a través de les metadades ja instal·lades a l'ATTINY85 aquí. El paquet JSON enviat a Crouton s’envia a través del darrer firmware per a l’ICOS10. Podeu fer una prova de concepte en un ESP8266 normal, si la compilació és massa per ara.

L'esbós UNO utilitzat a les proves té una funció per desar una nova adreça esclava a EEPROM a l'ATINY85, si teniu un xoc al vostre bus I2C objectiu. S'han afegit uns quants esquemes, però hi ha diverses maneres de connectar el circuit avall en funció del que vulgueu aconseguir, així que us ho deixaré:)