IOT123 - I2C KY019 BAKSTEEN - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

De IOT123 BRICKS zijn doe-het-zelf modulaire units die kunnen worden gepureerd met andere IOT123 BRICKS, om functionaliteit toe te voegen aan een node of wearable. Ze zijn gebaseerd op de vierkante inch vierkante, dubbelzijdige protoboards met onderling verbonden doorgaande gaten.

Een aantal van deze BRICKS zal naar verwachting op meerdere knooppunten (Master MCU's - ESP8266 of ATTINY84) op een site staan. De MCU heeft geen voorkennis nodig van het doel van de sensoren of softwarebehoeften. Het scant naar I2C-knooppunten en vraagt vervolgens om een eigendomsdump (sensorgegevens) van elke slave. Deze BRICKs leveren 5.0V, 3.3V en een andere AUX-lijn die aanpasbaar is.

Deze I2C KY019 BRICK is de eerste van de ACTOREN en heeft één lees-/schrijfeigenschap:

Wissel (waar/onwaar)

De sensorstenen van het Keyes-type worden eerst geabstraheerd omdat ze worden geleverd met vitamines (extra benodigde componenten) en relatief goedkoop zijn (ik kocht 37 voor 10 AUD). Andere boards/circuits zullen worden geïntroduceerd in de I2C BRICKS.

De doorgaande gaten naast de ATTINY85 zijn ongebruikt gelaten om een pogo-pin-programmeur mogelijk te maken terwijl de DIP8 op de PCB wordt gesoldeerd. Een verdere abstractie, het verpakken van de BRICKS in kleine cilinders die worden aangesloten op een D1M WIFI BLOCK-hub, waarbij de waarden naar een MQTT-server worden gepompt, wordt ontwikkeld.

Stap 1: Materialen en gereedschappen

Er is een volledige lijst van materiaal en sourcing.

1. KY-019 Relais (1)
2. ATTINY85 20PU (1)
3. 1" Dubbelzijdig protoboard (1)
4. Mannelijke kop 90º (3P, 3P)
5. Aansluitdraad (~7)
6. Soldeer en ijzer (1)

Stap 2: Bereid de ATTINY85. voor

OPMERKING: Als u Crouton-integratie wilt hebben, gebruik dan de bibliotheek vanaf hier en gebruik het geïnstalleerde voorbeeld "attiny_ky019".

AttinyCore van de Boards Manager is nodig. Brand bootloader "EEPROM Retained", "8mHZ Internal" (alle hierboven getoonde configuraties).

De coderepository is hier te vinden.

Een ZIP van de bibliotheek vind je hier.

Instructies voor "Een ZIP-bibliotheek importeren" hier.

Zodra de bibliotheek is geïnstalleerd, kunt u het voorbeeld "attiny_ky019" openen.

Om de firmware naar de ATTINY85 te uploaden, vindt u mogelijk meer details in deze instructables:

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…

Best te testen via breadboard alvorens verder te gaan.

Als je bestaande ASSIMILATE SENSORS hebt, zorg er dan voor dat het slave-adres verschillend is op een SENSOR/MCU Host-combinatie, d.w.z. alle relais-actoren kunnen hetzelfde adres hebben, zolang je maar één relais-actor op een MCU/node hebt.

Stap 3: Monteer het circuit

1. Plaats aan de voorkant de componenten ATTINY85 (1), 3P 90deg mannelijke headers (2) (3) en soldeer ze aan de achterkant vast.
2. Trek aan de achterkant een gele draad van GEEL1 naar GEEL2 en soldeer.
3. Trek aan de achterkant een blauwe draad van BLUE1 naar BLUE2 en soldeer.
4. Trek aan de achterkant een groene draad van GROEN1 naar GROEN2 en soldeer.
5. Trek aan de achterkant een zwarte draad van ZWART1 naar ZWART2 en soldeer.
6. Trek aan de achterkant een zwarte draad van BLACK3 naar BLACK4 en soldeer.
7. Trek aan de achterkant een rode draad van RED1 naar RED2 en soldeer.
8. Trek aan de achterkant een rode draad van RED3 naar RED4 en soldeer.

Het relais kan nu rechtstreeks via zijn pinnen op de printplaat worden aangesloten of via draden, op de punten die in het pincontract zijn aangegeven.

Stap 4: Testen

Een aantal van deze BRICKS zal naar verwachting op meerdere nodes (MCU's - ESP8266 of ATTINY84) in een omgeving staan. Dit is een eenheidstest: stuurt I2C-commando's van de UNO naar de ATTINY die het relais opent of sluit.

We hebben eerder een I2C SHIELD voor Arduino gebouwd.

Als je het in plaats daarvan wilt breadboarden:

1. Sluit de 5.0V op UNO aan op een VCC op BRICK.
2. Verbind de GND op UNO met GND op BRICK.
3. Verbind de A5 op UNO met SCL op BRICK.
4. Verbind de A4 op UNO met SDA op BRICK.
5. Sluit een 4K7 pull-up weerstand aan van SDA naar VCC.
6. Sluit een 4K7 pull-up weerstand aan van SCL naar VCC.

De test uitvoeren

1. Verbind uw UNO met uw Dev-pc via USB.
2. Upload de code naar de UNO.
3. Open de Arduino-console. Kies 9600 baud (start de UNO opnieuw en open de console indien nodig).
4. Het adres van de slaaf wordt afgedrukt naar de console.
5. Wanneer, voer in het verzendvak 2 1 (dus 12 2 1) in en het relais wordt ingeschakeld.
6. Wanneer, voer in het verzendveld 2 0 (dus 12 2 0) in en het relais wordt uitgeschakeld.

I2C BRICK adhoc-commando's voor slaves van UNO-master

#erbij betrekken

const byte _num_chars = 32;

char _received_chars [_num_chars]; // een array om de ontvangen gegevens op te slaan

boolean _has_new_data = false;

voidsetup() {

Serieel.begin(9600);

Serieel.println();

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

Serial.println("zorg ervoor dat de nieuwe regel is geselecteerd in het consolevenster");

Serieel.println();

Serial.println("ADRES 1 BEVESTIG METADATA ONTVANGST N.v.t. (VOOR M2M)");

Serial.println ("ADRES 2 ACTORCOMMANDO");

Serieel.println();

Serial.println("ADRESSEN OP BUS:");

scan_i2c_adressen();

Serieel.println();

Serieel.println("");

}

voidscan_i2c_addresses(){

int device_count = 0;

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

{

Wire.beginTransmission (adres);

const byte error = Wire.endTransmission();

als (fout == 0)

{

Serial.println(adres);

}

}

}

voidloop() {

recv_with_end_marker();

send_to_i2c();

}

voidrecv_with_end_marker() {

statische byte ndx = 0;

char end_marker = '\n';

char rc;

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

rc = Serieel.lezen();

if (rc != end_marker) {

_received_chars[ndx] = rc;

ndx++;

if (ndx >= _num_chars) {

ndx = _num_chars - 1;

}

}

anders {

_received_chars[ndx] = '\0'; // beëindig de string

ndx = 0;

_has_new_data = waar;

}

}

}

voidsend_to_i2c() {

char param_buf[16];

const String ontvangen_string = String (_received_chars);

if (_has_new_data == waar) {

int idx1 = Received_string.indexOf('');

Stringadres = ontvangen_string.substring(0, idx1);

int adres_int = adres.toInt();

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

Serial.println("INVALID ADRES INPUT:");

Serial.println(adres);

opbrengst;

}

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

Stringcode;

als (idx2 == -1){

code = ontvangen_string.substring(idx1+1);

}anders{

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

}

int code_int = code.toInt();

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

Serial.println("INVALID CODE INPUT:");

Serieel.println(code);

opbrengst;

}

bool has_parameter = idx2 > -1;

Stringparameter;

if (has_parameter){

parameter = ontvangen_string.substring(idx2 + 1, idx2 + 17); // maximaal 16 tekens

if (parameter.lengte() < 1){

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

_has_new_data = onwaar;

opbrengst;

}

}anders{

if (code_int >1){

Serial.println("PARAMETER VEREIST!");

_has_new_data = onwaar;

opbrengst;

}

}

Serieel.println();

Serial.print("invoer origineel = ");

Serial.println(received_string);

Serial.print("adres = ");

Serial.println(adres);

Serial.print("code = ");

Serieel.println(code);

Serial.print("parameter = ");

Seriële.println (parameter);

// VERZENDEN VIA I2C

Wire.beginTransmission(address_int);

Wire.write(code_int);

if (has_parameter){

parameter.trim();

strcpy(param_buf, parameter.c_str());

Wire.write (param_buf);

}

Wire.endTransmission();

Serieel.println();

Serial.println ("VERZONDEN VIA I2C!");

Serieel.println();

Serieel.println("");

_has_new_data = onwaar;

}

}

bekijk rawuno_i2c_command_input.ino gehost met ❤ door GitHub

Stap 5: Volgende stappen

De follow-up ASSIMILATE ACTOR: KY019 die deze steen gebruikt, heeft automatische configuratie voor Crouton via de metadata die hier al in de ATTINY85 is geïnstalleerd. Het JSON-pakket dat naar Crouton wordt gestuurd, wordt verzonden via de nieuwste firmware voor de ICOS10. Je kunt een Proof-of-concept doen op een gewone ESP8266, als de build voorlopig te veel is.

De UNO-schets die in Testen wordt gebruikt, heeft een functie voor het opslaan van een nieuw slave-adres in EEPROM op de ATTINY85, als u een botsing heeft op uw doel-I2C-bus.

Er zijn een paar schema's toegevoegd, maar er zijn verschillende manieren om het stroomafwaartse circuit te bedraden, afhankelijk van wat je wilt bereiken, dus dat laat ik voor je over:)