IOT123 - I2C HARTKLOPTEEN: 6 stappe

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

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 -HARTKLOOPSTEEN dui aan of die ATTINY -slaaf lewendig is, ook die I2C -verkeer, en het een eienskap:

STATUS ("LEEF")

PB1 (wit) dui op ATTINY gesondheid.

PB3 (geel) wissel met I2C -versoeke van die meester.

PB4 (oranje) wissel met I2C ontvang van die meester.

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. Papier PCB (7 x 7 gate)
2. LED's (rooi, groen, blou)
3. Weerstande (3 van 1K)
4. ATTINY85 20PU (1)
5. 1 "dubbelzijdige protobord (1)
6. Manlike kop 90º (3P, 3P)
7. Manlike kop (2P, 2P)
8. Trui Shunt (1)
9. Aansluitdraad (~ 7)
10. Soldeer en yster (1)

Stap 2: Berei die ATTINY85 voor

LET WEL: As u van plan is om Crouton -integrasie te hê, gebruik die biblioteek hiervandaan en gebruik die voorbeeld geïnstalleer "attiny_heartbeat"

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_heartbeat" oopmaak.

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

www.instructables.com/id/Programming-the-….

www.instructables.com/id/How-to-Program-A…

www.instructables.com/id/Programming-the-…

www.instructables.com/id/How-to-Program-A…

www.instructables.com/id/Programming-the-…

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, bv. al die Relay -akteurs kan dieselfde adres hê solank u slegs een Relay -akteur op 'n MCU/node het.

Stap 3: Monteer die aanwysers

Die aanwysers is bedoel om volledig aanpasbaar te wees. Dit is die gebeurtenisseine van die hoofstroombaan wat as hartklop beskou word. Vir hierdie opset gebruik ons LED -aanwysers; u bou kan relais gebruik (ja, die VCC is uitgebreek) of 'n ander visuele/sein -gebaseerde aanwyser. Die weerstandswaardes hang af van persoonlike voorkeur oor hoe helder u dit wil hê.

1. Plaas 'n blou LED bo -op RED1 (+) en SWART1 (G) en soldeer onderaan.
2. Buig die lood aan die onderkant van RED1 sodat dit die koperblok op SILVER8 raak en snoei.
3. Sny lood van BLACK1 aan die onderkant bo soldeer af.
4. Plaas bo -op 'n groen LED in RED2 (+) en SWART2 (G) en soldeer aan die onderkant.
5. Buig die lood aan die onderkant van RED2 sodat dit die koperblok op SILVER9 raak en snoei.
6. Sny lood van BLACK2 aan die onderkant bo soldeer af.
7. Plaas 'n rooi LED bo -op RED3 (+) en SWART3 (G) en soldeer onderaan.
8. Buig die lood onderaan van RED3 sodat dit die koperblokkie op SILVER10 raak en snoei.
9. Sny lood van BLACK3 aan die onderkant bo soldeer af.
10. Plaas bo-op 'n 1K-weerstand in die deurlopende gate SILVER1 en SILVER4.
11. Onderaan, spoor, sny en soldeer lood van SILVER1 na SWART1.
12. Plaas bo-op 'n 1K-weerstand in die deurlopende gate SILVER2 en SILVER4.
13. Onderaan, spoor, sny en soldeer lood van SILVER2 na BLACK2.
14. Plaas 'n 1K-weerstand aan die bokant in die deurlopende gate SILVER3 en SILVER4.
15. Onderaan, spoor, sny en soldeer lood van SILVER3 na BLACK3.
16. Onderaan, soldeerdrade op SILVER4 en snoei ongeveer 5 mm lank.
17. Soldeer 'n swart draad aan die onderkant op SILVER4.
18. Soldeer 'n wit draad aan die onderkant in SILVER5, wat verseker dat die kontinuïteit van RED1 lei.
19. Soldeer 'n geel draad aan die onderkant in SILVER6, wat verseker dat die kontinuïteit van RED2 lei.
20. Soldeer 'n oranje draad aan die onderkant in SILVER7, wat verseker dat die kontinuïteit van RED3 lei.

Stap 4: Monteer die hoofstroombaan

Vergadering:

1. Plaas die komponente ATTINY85 (1), 3P 90deg male headers (2) (3), 3P male headers (4) (5) en soldeer aan die agterkant.
2. Trek agter 'n geel draad van GEEL1 na GEEL2 en soldeer.
3. Trek agter 'n oranje draad van ORANGE1 na ORANGE2 en soldeer.
4. Trek agter 'n blou draad van BLUE1 na BLUE2 en soldeer.
5. Aan die agterkant spoor 'n groen draad van GREEN1 na GREEN2 en soldeer.
6. Trek agter 'n wit draad van WHITE1 na WHITE2 en soldeer.
7. Trek agter 'n swart draad van BLACK1 na BLACK2 en soldeer.
8. Trek agter 'n swart draad van BLACK3 na BLACK4 en soldeer.
9. Trek agter 'n rooi draad van RED1 na RED2 en soldeer.
10. Aan die agterkant spoor 'n kaal draad van RED3 tot RED4 en soldeer.
11. Trek agter 'n kaal draad van SILVER1 na SILVER2 en soldeer.
12. Voeg 'n trui by die 5V of 3V3 lyn.

As u die bogenoemde aanwysers gebruik (verwys na die pinout -diagram):

1. Soldeer die wit draad aan die agterkant in PB1.
2. Aan die agterkant, soldeer die geel draad in PB3.
3. Aan die agterkant, soldeer die oranje draad in PB4.
4. Aan die agterkant, soldeer die swart draad in GND.

Stap 5: 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 ontvangs -LED skakel. Die ATTINY ALIVE -LED bly aan.

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.
4. Kies 9600 baud (herbegin die UNO en heropen die konsole indien nodig).
5. Die adres van die slaaf sal na die konsole gedruk word.
6. Wanneer, voer die stuurkassie 2 1 (dus 16 2 1) in, en die ontvangs -LED gaan aan.
7. Wanneer, voer die stuurkas 2 0 (dus 16 2 0) in, en die ontvangs -LED gaan uit.

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 6: Volgende stappe

Die opvolg ASSIMILATE ACTOR: HEARTBEAT 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.