IOT123 - I2C KY019 BRICK: 5 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:26

Die IOT123 BRICKS is DIY -modulêre eenhede wat met ander IOT123 BRICKS gekombineer kan word om funksionaliteit by 'n knoop of draagbare te voeg. Hulle is gebaseer op die duim vierkantige, dubbelzijdige protoborde met onderling verbind gate.

Na verwagting sal 'n aantal van hierdie BRICKS op 'n webwerf op verskeie nodes (Master MCU's - ESP8266 of ATTINY84) wees. Die MCU benodig geen voorafgaande kennis van die sensor se doel of sagtewarebehoeftes nie. Dit soek na I2C -nodusse en versoek dan 'n eiendomsstorting (sensordata) van elke slaaf. Hierdie BRICK's bied 5.0V, 3.3V en nog 'n AUX -lyn wat aanpasbaar is.

Hierdie I2C KY019 BRICK is die eerste van die Akteurs en het een lees/skryf eienskap:

Skakelaar (waar/onwaar)

Die sensorstene van die Keyes -tipe word eers onttrek, aangesien dit vitamiene bevat (benodig ekstra komponente) en relatief goedkoop is (ek het 37 vir 10AUD gekoop). Ander planke/stroombane sal bekendgestel word aan die I2C BRICKS.

Die deurgate langs die ATTINY85 is ongebruik gelaat om 'n pogo-penprogrammeerder moontlik te maak terwyl die DIP8 aan die PCB gesoldeer is. 'N Verdere abstraksie, wat die BRICKS verpak in klein silinders wat by 'n D1M WIFI BLOCK -hub aansluit, wat die waardes na 'n MQTT -bediener pomp, word ontwikkel.

Stap 1: materiaal en gereedskap

Daar is 'n volledige lys van materiaal en verkrygings.

1. KY-019 Relay (1)
2. ATTINY85 20PU (1)
3. 1 "dubbelzijdige protobord (1)
4. Manlike kop 90º (3P, 3P)
5. Aansluitdraad (~ 7)
6. Soldeer en yster (1)

Stap 2: Berei die ATTINY85 voor

OPMERKING: As u van plan is om Crouton -integrasie te hê, gebruik die biblioteek van hier af en gebruik die voorbeeld geïnstalleer "attiny_ky019".

AttinyCore van die direksiebestuurder is nodig. Brand selflaaiprogram "EEPROM behou", "8mHZ intern" (al die konfigurasies word hierbo getoon).

Die kodebewaarplek kan hier gevind word.

'N Poskode van die biblioteek kan hier gevind word.

Instruksies vir die invoer van 'n zip -biblioteek hier.

Sodra die biblioteek geïnstalleer is, kan u die voorbeeld "attiny_ky019" oopmaak.

Om die firmware na die ATTINY85 op te laai, vind u meer inligting in hierdie instruksies:

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…

Dit is die beste om dit op 'n broodbord te toets voordat u verder gaan.

As u bestaande ASSIMILATE SENSORS het, maak seker dat die slaafadres anders is op 'n SENSOR/MCU Host -kombinasie, dit wil sê dat alle Relay -akteurs dieselfde adres kan hê, solank u slegs een Relay -akteur op 'n MCU/node het.

Stap 3: Monteer die stroombaan

1. Plaas die komponente ATTINY85 (1), 3P 90deg manlike kopstukke (2) (3) aan die voorkant en soldeer aan die agterkant af.
2. Trek agter 'n geel draad van GEEL1 na GEEL2 en soldeer.
3. Trek agter 'n blou draad van BLUE1 na BLUE2 en soldeer.
4. Aan die agterkant spoor 'n groen draad van GREEN1 na GREEN2 en soldeer.
5. Trek agter 'n swart draad van BLACK1 na BLACK2 en soldeer.
6. Trek agter 'n swart draad van BLACK3 na BLACK4 en soldeer.
7. Trek agter 'n rooi draad van RED1 na RED2 en soldeer.
8. Aan die agterkant, spoor 'n rooi draad van RED3 tot RED4 en soldeer.

Die aflos kan nou direk via sy penne aan die printplaat of via drade gekoppel word aan die punte wat in die penkontrak aangedui word.

Stap 4: Toets

'N Aantal van hierdie BRICKS sal na verwagting op verskeie knope (MCU's - ESP8266 of ATTINY84) in 'n omgewing wees. Dit is 'n eenheidstoets: stuur I2C -opdragte van die UNO na die ATTINY wat die aflos oopmaak of sluit.

Ons het voorheen 'n I2C SHIELD vir Arduino gebou.

As jy dit eerder wil broodplank:

1. Koppel die 5.0V op UNO aan 'n VCC op BRICK.
2. Koppel die GND op UNO aan GND op BRICK.
3. Koppel die A5 op UNO aan SCL op BRICK.
4. Koppel die A4 op UNO aan SDA op BRICK.
5. Koppel 'n 4K7-optrekweerstand van SDA na VCC.
6. Koppel 'n optrekweerstand van 4K7 van SCL na VCC.

Doen die toets

1. Koppel u UNO aan u Dev PC met USB.
2. Laai die kode op na die UNO.
3. Maak die Arduino -konsole oop. Kies 9600 baud (herbegin die UNO en heropen die konsole indien nodig).
4. Die adres van die slaaf sal na die konsole gedruk word.
5. Wanneer, voer die stuurkassie 2 1 (dus 12 2 1) in, en die aflos skakel aan.
6. Wanneer, voer die stuurkas 2 0 (dus 12 2 0) in, en die aflos skakel af.

I2C BRICK adhoc -opdragte vir slawe van UNO -meester

#insluit

const byte _num_chars = 32;

char _received_chars [_num_chars]; // 'n skikking om die ontvangde data te stoor

boolean _has_new_data = vals;

voidsetup () {

Serial.begin (9600);

Serial.println ();

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

Serial.println ("verseker dat nuwe lyn in die konsole -venster gekies is");

Serial.println ();

Serial.println ("ADRES 1 BEVESTIG METADATA -ONTVANGS Nvt (VIR M2M)");

Serial.println ("ADRES 2 Akteur OPDRAG");

Serial.println ();

Serial.println ("ADRES OP DIE BUS:");

scan_i2c_addresses ();

Serial.println ();

Serial.println ("");

}

voidscan_i2c_addresses () {

int device_count = 0;

vir (byte adres = 8; adres <127; adres ++)

{

Wire.beginTransmission (adres);

const byte fout = Wire.endTransmission ();

as (fout == 0)

{

Serial.println (adres);

}

}

}

voidloop () {

recv_with_end_marker ();

send_to_i2c ();

}

voidrecv_with_end_marker () {

statiese greep ndx = 0;

char end_marker = '\ n';

char rc;

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

rc = Serial.read ();

as (rc! = end_marker) {

_ontvang_tekens [ndx] = rc;

ndx ++;

as (ndx> = _num_chars) {

ndx = _num_chars - 1;

}

}

anders {

_received_chars [ndx] = '\ 0'; // eindig die string

ndx = 0;

_has_new_data = waar;

}

}

}

voidsend_to_i2c () {

char param_buf [16];

const String received_string = String (_received_chars);

as (_has_new_data == waar) {

int idx1 = ontvangen_string.indexOf ('');

Stringadres = received_string.substring (0, idx1);

int address_int = address.toInt ();

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

Serial.println ("Ongeldige adresinvoer:");

Serial.println (adres);

terugkeer;

}

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

String kode;

as (idx2 == -1) {

kode = ontvangen_string.substring (idx1+1);

} anders {

kode = ontvangen_string.substring (idx1+1, idx2+1);

}

int code_int = code.toInt ();

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

Serial.println ("INGELDIGE KODE -INVOER:");

Serial.println (kode);

terugkeer;

}

bool has_parameter = idx2> -1;

String parameter;

as (has_parameter) {

parameter = ontvangen_string.substring (idx2 + 1, idx2 + 17); // 16 karakters maks

as (parameter.length () <1) {

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

_has_new_data = vals;

terugkeer;

}

} anders {

as (code_int> 1) {

Serial.println ("PARAMETER VEREIS!");

_has_new_data = vals;

terugkeer;

}

}

Serial.println ();

Serial.print ("input orig =");

Serial.println (ontvangen_reeks);

Serial.print ("adres =");

Serial.println (adres);

Serial.print ("kode =");

Serial.println (kode);

Serial.print ("parameter =");

Serial.println (parameter);

// STUUR VIA I2C

Wire.beginTransmission (address_int);

Wire.write (code_int);

as (has_parameter) {

parameter.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 = vals;

}

}

sien rawuno_i2c_command_input.ino aangebied deur ❤ deur GitHub

Stap 5: Volgende stappe

Die opvolg ASSIMILATE ACTOR: KY019 wat hierdie baksteen gebruik, het outomatiese konfigurasie vir Crouton via die metadata wat reeds in die ATTINY85 hier geïnstalleer is. Die JSON -pakkie wat na Crouton gestuur word, word gestuur via die nuutste firmware vir die ICOS10. U kan 'n bewys van konsep op 'n gewone ESP8266 doen, as die bou vir eers te veel is.

Die UNO -skets wat in toetsing gebruik word, het 'n funksie om 'n nuwe slawe -adres in EEPROM op die ATTINY85 op te slaan, as u 'n botsing op u doel I2C -bus het.

Daar is 'n paar skemas bygevoeg, maar daar is verskillende maniere om die stroomafwaartse stroombaan te bedraad, afhangende van wat u wil bereik, so ek laat dit aan u oor:)