IOT123 - I2C HEARTBEAT BRICK - Gunook

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

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 HEARTBEAT BRICK zeigt an, ob der ATTINY-Slave aktiv ist, auch den I2C-Verkehr und hat eine Eigenschaft:

ZUSTAND ("LEBEND")

PB1 (weiß) zeigt die Gesundheit von ATTINY an.

PB3 (gelb) toggelt mit I2C-Anfragen vom Master.

PB4 (orange) schaltet mit I2C-Empfang vom Master um.

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. Papierplatine (7 x 7 Löcher)
2. LEDs (Rot, Grün, Blau)
3. Widerstände (3 von 1K)
4. ATTINY85 20PU (1)
5. 1" Doppelseitiges Protoboard (1)
6. Stiftleiste 90º (3P, 3P)
7. Stiftleiste (2P, 2P)
8. Jumper-Shunt (1)
9. Anschlusskabel (~7)
10. 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_heartbeat".

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_heartbeat" öffnen.

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

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-…

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, z. alle Relais-Aktoren können dieselbe Adresse haben, solange Sie nur einen Relais-Akteur auf einer MCU/einem Knoten haben.

Schritt 3: Zusammenbau der Indikatoren

Die Indikatoren sollen vollständig anpassbar sein. Es sind die Ereignissignale des Hauptstromkreises, die als Heartbeats angesehen werden. Für diesen Build verwenden wir LED-Anzeigen; Ihr Build kann Relais (ja, der VCC ist ausgebrochen) oder einen anderen visuellen / signalbasierten Indikator verwenden. Die Widerstandswerte hängen von den persönlichen Vorlieben ab, wie hell Sie sie haben möchten.

1. Oben eine blaue LED in RED1 (+) und BLACK1 (G) stecken und unten anlöten.
2. Biegen Sie unten das Kabel von RED1 so, dass es das Kupferpad von SILVER8 berührt und trimmen Sie es.
3. Auf der Unterseite das Kabel von BLACK1 über dem Lötzinn abschneiden.
4. Oben eine grüne LED in RED2 (+) und BLACK2 (G) einstecken und unten anlöten.
5. Biegen Sie unten das Kabel von RED2 so, dass es das Kupferpad von SILVER9 berührt und trimmen Sie es.
6. Auf der Unterseite das Kabel von BLACK2 über dem Lötzinn abschneiden.
7. Oben eine rote LED in RED3 (+) und BLACK3 (G) stecken und unten anlöten.
8. Biegen Sie unten das Kabel von RED3 so, dass es das Kupferpad von SILVER10 berührt und trimmen Sie es.
9. Auf der Unterseite das Kabel von BLACK3 über dem Lötzinn abschneiden.
10. Setzen Sie oben einen 1K-Widerstand in die Durchgangslöcher SILVER1 und SILVER4 ein.
11. Auf der Unterseite das Kabel von SILVER1 auf BLACK1 verfolgen, trimmen und löten.
12. Setzen Sie oben einen 1K-Widerstand in die Durchgangslöcher SILVER2 und SILVER4 ein.
13. Auf der Unterseite das Kabel von SILVER2 auf BLACK2 verfolgen, trimmen und verlöten.
14. Setzen Sie oben einen 1K-Widerstand in die Durchgangslöcher SILVER3 und SILVER4 ein.
15. Auf der Unterseite das Kabel von SILVER3 auf BLACK3 verfolgen, trimmen und verlöten.
16. Auf der Unterseite Drähte an SILVER4 anlöten und auf ca. 5mm verlängern.
17. Auf der Unterseite ein schwarzes Kabel auf SILVER4 löten.
18. Löten Sie auf der Unterseite ein weißes Kabel in SILVER5, um sicherzustellen, dass die Kontinuität von RED1 geführt wird.
19. Löten Sie auf der Unterseite einen gelben Draht in SILVER6, um sicherzustellen, dass die Kontinuität von RED2 führt.
20. Löten Sie auf der Unterseite einen orangefarbenen Draht in SILVER7, um sicherzustellen, dass die Kontinuität von RED3 geführt wird.

Schritt 4: Zusammenbau des Hauptstromkreises

Montage:

1. Auf der Vorderseite die Komponenten ATTINY85 (1), 3P 90deg Stiftleisten (2)(3), 3P Stiftleisten (4)(5) 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 einen orangefarbenen Draht von ORANGE1 zu ORANGE2 verfolgen und verlöten.
4. Auf der Rückseite ein blaues Kabel von BLUE1 zu BLUE2 verfolgen und verlöten.
5. Auf der Rückseite einen grünen Draht von GREEN1 zu GREEN2 verfolgen und löten.
6. Auf der Rückseite ein weißes Kabel von WEISS1 zu WEISS2 verfolgen und verlöten.
7. Auf der Rückseite ein schwarzes Kabel von BLACK1 zu BLACK2 verfolgen und verlöten.
8. Auf der Rückseite ein schwarzes Kabel von BLACK3 zu BLACK4 verfolgen und verlöten.
9. Auf der Rückseite einen roten Draht von RED1 zu RED2 verfolgen und löten.
10. Auf der Rückseite einen blanken Draht von RED3 zu RED4 verfolgen und löten.
11. Auf der Rückseite einen blanken Draht von SILVER1 zu SILVER2 verfolgen und verlöten.
12. Fügen Sie einen Jumper auf der 5V- oder 3V3-Leitung hinzu.

Bei Verwendung der obigen Indikatoren (siehe Pinbelegungsdiagramm):

1. Auf der Rückseite das weiße Kabel in PB1 einlöten.
2. Auf der Rückseite das gelbe Kabel in PB3 einlöten.
3. Löten Sie auf der Rückseite das orangefarbene Kabel in PB4.
4. Auf der Rückseite das schwarze Kabel an GND anlöten.

Schritt 5: 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 die Empfangs-LED umschaltet. Die ATTINY ALIVE-LED bleibt an.

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-Konsole.
4. Wählen Sie 9600 Baud (starten Sie die UNO neu und öffnen Sie die Konsole, falls erforderlich).
5. Die Adresse des Slaves wird an die Konsole ausgegeben.
6. Wenn Sie in das Sendefeld 2 1 eingeben (also 16 2 1), leuchtet die Empfangs-LED auf.
7. Wenn geben Sie in das Sendefeld 2 0 (also 16 2 0) ein, und die Empfangs-LED erlischt.

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 6: Nächste Schritte

Der Nachfolger ASSIMILATE ACTOR: HEARTBEAT, 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.