IOT123 - I2C KY019 BRICK: 5 passos

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

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 KY019 BRICK és el primer dels ACTORS i té una propietat de lectura / escriptura:

Canvia (vertader / fals)

Els maons del sensor del tipus Keyes s’abstraccionaran primer, ja que inclouen vitamines (es necessiten components addicionals) i són relativament econòmics (n’he comprat 37 per 10 AUD). Altres blocs / circuits s’introduiran als I2C BRICKS.

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. Relleu KY-019 (1)
2. ATTINY85 20PU (1)
3. 1 "protoborda de doble cara (1)
4. Capçalera masculina 90º (3P, 3P)
5. Cable de connexió (~ 7)
6. Soldadura i ferro (1)

Pas 2: prepareu l'ATTINY85

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

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

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

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…

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, introduïu els components ATTINY85 (1), capçaleres masculines 3P 90deg (2) (3) 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 blau de BLAU 1 a BLAU 2 i soldeu-lo.
4. A la part posterior, traqueu un fil verd de GREEN1 a GREEN2 i soldeu-lo.
5. A la part posterior, traça un fil negre de BLACK1 a BLACK2 i solda.
6. A la part posterior, traça un fil negre de BLACK3 a BLACK4 i solda.
7. A la part posterior, traqueu un cable vermell de RED1 a RED2 i soldeu-lo.
8. A la part posterior, traqueu un cable vermell de RED3 a RED4 i soldeu-lo.

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 el relé.

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. Trieu 9600 baud (reinicieu UNO i torneu a obrir la consola si cal).
4. L'adreça de l'esclau s'imprimirà a la consola.
5. Quan, introduïu a la casella d’enviament 2 1 (per tant, 12 2 1) i el relé s’encén.
6. Quan, introduïu a la casella d'enviament 2 0 (per tant, 12 2 0) i el relé 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: KY019 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é:)