IOT123 - I2C KY019 BRICK - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:19

Die IOT123 BRICKS sind modulare DIY-Einheiten, die mit anderen IOT123 BRICKS kombiniert werden können, um einem Knoten oder Wearable Funktionalität hinzuzufügen. Sie basieren auf den quadratischen, doppelseitigen Protoboards mit miteinander verbundenen Durchgangslöchern.

Es wird erwartet, dass sich eine Reihe dieser BRICKS auf mehreren Knoten (Master-MCUs – ESP8266 oder ATTINY84) an einem Standort befinden. Die MCU benötigt keine Vorkenntnisse über den Sensorzweck oder die Softwareanforderungen. Es sucht nach I2C-Knoten und fordert dann von jedem Slave einen Property-Dump (Sensordaten) an. Diese BRICKs liefern 5,0 V, 3,3 V und eine weitere AUX-Leitung, die anpassbar ist.

Dieser I2C KY019 BRICK ist der erste der ACTORS und hat eine Lese-/Schreibeigenschaft:

Wechseln (wahr/falsch)

Die Sensorbausteine vom Typ Keyes werden zuerst abstrahiert, da sie mit Vitaminen (zusätzliche Komponenten benötigt) geliefert werden und relativ günstig sind (ich habe 37 für 10 AUD gekauft). Andere Boards/Schaltungen werden in die I2C BRICKS eingeführt.

Die Durchgangslöcher neben dem ATTINY85 wurden ungenutzt gelassen, um einen Pogo-Pin-Programmierer zu ermöglichen, während der DIP8 an die Leiterplatte gelötet wird. Eine weitere Abstraktion, bei der die BRICKS in kleine Zylinder verpackt werden, die an einen D1M WIFI BLOCK-Hub angeschlossen werden und die Werte an einen MQTT-Server pumpen, wird entwickelt.

Schritt 1: Materialien und Werkzeuge

Es gibt eine vollständige Stücklisten- und Beschaffungsliste.

1. KY-019 Relais (1)
2. ATTINY85 20PU (1)
3. 1" Doppelseitiges Protoboard (1)
4. Stiftleiste 90º (3P, 3P)
5. Anschlusskabel (~7)
6. Löten und Eisen (1)

Schritt 2: Bereiten Sie das ATTINY85. vor

HINWEIS: Wenn Sie eine Crouton-Integration beabsichtigen, verwenden Sie bitte die Bibliothek von hier und verwenden Sie das installierte Beispiel "attiny_ky019".

AttinyCore vom Boards Manager wird benötigt. Brennen Sie den Bootloader "EEPROM Retained", "8mHZ Internal" (alle Konfiguration oben gezeigt).

Das Code-Repository finden Sie hier.

Eine ZIP der Bibliothek finden Sie hier.

Anleitung zum "Importieren einer ZIP-Bibliothek" hier.

Sobald die Bibliothek installiert ist, können Sie das Beispiel "attiny_ky019" öffnen.

Um die Firmware auf den ATTINY85 hochzuladen, finden Sie weitere Details in diesen Anleitungen:

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…

Testen Sie am besten über ein Steckbrett, bevor Sie fortfahren.

Wenn Sie über ASSIMILATE SENSORS verfügen, stellen Sie sicher, dass die Slave-Adresse bei einer SENSOR/MCU-Host-Kombination unterschiedlich ist, d. h. alle Relais-Aktoren können dieselbe Adresse haben, solange Sie nur einen Relais-Aktor auf einer MCU/Knoten haben.

Schritt 3: Bauen Sie die Schaltung zusammen

1. Auf der Vorderseite die Komponenten ATTINY85 (1), 3P 90deg Stiftleisten (2) (3) einsetzen und auf der Rückseite ablöten.
2. Auf der Rückseite ein gelbes Kabel von GELB1 zu GELB2 verfolgen und löten.
3. Auf der Rückseite ein blaues Kabel von BLUE1 zu BLUE2 verfolgen und verlöten.
4. Auf der Rückseite einen grünen Draht von GREEN1 zu GREEN2 verfolgen und löten.
5. Auf der Rückseite ein schwarzes Kabel von BLACK1 zu BLACK2 verfolgen und verlöten.
6. Auf der Rückseite ein schwarzes Kabel von BLACK3 zu BLACK4 verfolgen und verlöten.
7. Auf der Rückseite einen roten Draht von RED1 zu RED2 verfolgen und löten.
8. Auf der Rückseite einen roten Draht von RED3 zu RED4 verfolgen und löten.

Das Relais kann nun direkt über seine Pins mit der Platine oder über Drähte an den im Pinvertrag angegebenen Punkten verbunden werden.

Schritt 4: Testen

Es wird erwartet, dass sich eine Reihe dieser BRICKS auf mehreren Knoten (MCUs – ESP8266 oder ATTINY84) in einer Umgebung befinden. Dies ist ein Komponententest: sendet I2C-Befehle von der UNO an die ATTINY, die das Relais öffnet oder schließt.

Wir haben zuvor ein I2C SHIELD für Arduino gebaut.

Wenn Sie stattdessen ein Steckbrett verwenden möchten:

1. Verbinden Sie die 5.0V von UNO mit einem VCC auf BRICK.
2. Verbinden Sie GND von UNO mit GND von BRICK.
3. Verbinden Sie A5 auf UNO mit SCL auf BRICK.
4. Verbinden Sie die A4 auf UNO mit SDA auf BRICK.
5. Schließen Sie einen 4K7-Pull-up-Widerstand von SDA an VCC an.
6. Schließen Sie einen 4K7-Pull-up-Widerstand von SCL an VCC an.

Ausführen des Tests

1. Verbinden Sie Ihr UNO über USB mit Ihrem Dev-PC.
2. Laden Sie den Code in die UNO hoch.
3. Öffnen Sie die Arduino Console. Choose 9600 Baud (starten Sie die UNO neu und öffnen Sie die Konsole erneut, wenn Sie müssen).
4. Die Adresse des Slaves wird an die Konsole ausgegeben.
5. Wenn Sie in das Sendefeld 2 1 eingeben (also 12 2 1), schaltet sich das Relais ein.
6. Wenn Sie in das Sendefeld 2 0 (also 12 2 0) eingeben, schaltet sich das Relais aus.

I2C BRICK Adhoc-Befehle für Slaves vom UNO-Master

#enthalten

konstantes Byte _num_chars = 32;

char _received_chars[_num_chars]; // ein Array zum Speichern der empfangenen Daten

boolesch _has_new_data = false;

voidsetup() {

Serial.begin (9600);

Serial.println();

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

Serial.println ("Stellen Sie sicher, dass der Zeilenumbruch im Konsolenfenster ausgewählt ist");

Serial.println();

Serial.println("ADRESSE 1 METADATENEMPFANG BESTÄTIGEN N/A (FÜR M2M)");

Serial.println ("ADRESSE 2 SCHAUSPIELERBEFEHL");

Serial.println();

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

scan_i2c_adressen();

Serial.println();

Serial.println("");

}

voidscan_i2c_addresses(){

int device_count = 0;

für (Byte-Adresse = 8; Adresse < 127; Adresse++)

{

Wire.beginTransmission(Adresse);

const-Byte-Fehler = Wire.endTransmission();

wenn (Fehler == 0)

{

Serial.println (Adresse);

}

}

}

Leerschleife () {

recv_with_end_marker();

send_to_i2c();

}

voidrecv_with_end_marker() {

statisches Byte ndx = 0;

char end_marker = '\n';

char rc;

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

rc = Serial.read();

if (rc != end_marker) {

_empfangene_chars[ndx] = rc;

ndx++;

if (ndx >= _num_chars) {

ndx = _num_chars - 1;

}

}

anders {

_received_chars[ndx] = '\0'; // den String beenden

ndx = 0;

_has_new_data = wahr;

}

}

}

voidsend_to_i2c() {

char param_buf[16];

const String Received_string = String(_received_chars);

if (_has_new_data == true) {

int idx1 = Received_string.indexOf('');

String-Adresse = Received_string.substring(0, idx1);

int address_int = address.toInt();

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

Serial.println ("Ungültige Adresseingabe:");

Serial.println (Adresse);

Rückkehr;

}

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

Zeichenfolgencode;

wenn (idx2 == -1){

Code = Received_string.substring(idx1+1);

}anders{

Code = Received_string.substring(idx1+1, idx2+1);

}

int code_int = code.toInt();

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

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

Serial.println (Code);

Rückkehr;

}

bool has_parameter = idx2 > -1;

Zeichenfolgenparameter;

if (has_parameter){

Parameter = Received_string.substring(idx2 + 1, idx2 + 17); // max. 16 Zeichen

wenn (parameter.länge() < 1){

Serial.println ("PARTAMETER MIN. LÄNGE 1");

_has_new_data = false;

Rückkehr;

}

}anders{

if (code_int >1){

Serial.println ("PARAMETER ERFORDERLICH!");

_has_new_data = false;

Rückkehr;

}

}

Serial.println();

Serial.print ("Eingabe orig = ");

Serial.println (received_string);

Serial.print ("Adresse = ");

Serial.println (Adresse);

Serial.print ("code = ");

Serial.println (Code);

Serial.print ("parameter = ");

Serial.println (Parameter);

// SENDEN ÜBER 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();

Serial.println();

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

Serial.println();

Serial.println("");

_has_new_data = false;

}

}

rawuno_i2c_command_input.ino anzeigen, gehostet mit ❤ von GitHub

Schritt 5: Nächste Schritte

Der Nachfolger ASSIMILATE ACTOR: KY019, der diesen Brick verwendet, hat eine automatische Konfiguration für Crouton über die hier bereits im ATTINY85 installierten Metadaten. Das an Crouton gesendete JSON-Paket wird über die neueste Firmware für den ICOS10 gesendet. Sie können einen Proof-of-Concept auf einem normalen ESP8266 machen, wenn der Build im Moment zu viel ist.

Der beim Testen verwendete UNO-Sketch hat eine Funktion zum Speichern einer neuen Slave-Adresse im EEPROM auf dem ATTINY85, wenn Sie einen Konflikt auf Ihrem Ziel-I2C-Bus haben.

Ein paar Schaltpläne wurden hinzugefügt, aber es gibt verschiedene Möglichkeiten, die nachgeschaltete Schaltung zu verdrahten, je nachdem, was Sie erreichen möchten, also überlasse ich das für Sie:)