IOT123 - I2C BRICK MASTER JIG - Gunook

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

Während der Entwicklung der ASSIMILATE SENSORS und ACTORS halte ich eine UNO bereit, um adhoc I2C-Befehle an die zu entwickelnden Prototypen zu senden. Einer der Vorteile der I2C BRICKS ist die standardisierte Pinbelegung. Anstatt jedes Mal Breadboard-Drähte zu verwenden (siehe die Fritzings), wird ein robuster Lo-Tech-Schild verwendet.

Schritt 1: Materialien und Werkzeuge

1. 4cm x 6cm Universalplatine (1)
2. Anschlusskabel (~6)
3. 4K7 Widerstände (2)6
4. Stiftleiste (12P, 8P)
5. Buchsenleiste (9P oder 3P, 3P)
6. Löten und Eisen (1)

Schritt 2: Montage

Wenn Sie 2 x 3P Buchsenleisten anstelle der 1 x 9P Buchsenleiste verwenden, passen die ASSIMILATE SENSOR/ACTORS auf die JIG, ohne sie zu demontieren.

Bei der Verdrahtung an den Enden bis zu 10 mm abisolieren und ganz an den Enden verzinnen.

1. Auf der Unterseite der Platine die Stiftleiste (1) (2) einstecken und oben ablöten.
2. Auf der Leiterplattenoberseite die Buchsenleiste (3) einstecken und unten ablöten.
3. Auf der Oberseite ein rotes Kabel in RED1 und RED2 durchbohren.
4. Auf der Unterseite Durchgangslochdraht von RED1 in RED3.
5. Auf der Unterseite Durchgangslochdraht von RED2 in RED5 und löten.
6. Auf der Oberseite Durchgangslochdraht von RED3 in RED4 und löten.
7. Auf der Oberseite ein rotes Kabel in RED6 und RED7 bohren.
8. Auf der Unterseite Durchgangslochdraht von RED6 in RED8.
9. Auf der Unterseite Durchgangslochdraht von RED7 in RED10 und löten.
10. Oben, Durchgangslochdraht von RED8 in RED9 und löten.
11. Auf der Oberseite ein schwarzes Kabel in BLACK1 und BLACK2 durchbohren.
12. Auf der Unterseite Durchgangslochdraht von BLACK1 zu BLACK3.
13. Auf der Unterseite Durchgangslochdraht von BLACK2 in BLACK5 und löten.
14. Oben, Durchgangslochdraht von BLACK3 in BLACK4 und löten.
15. Auf der Oberseite ein blaues Kabel in BLUE1 und BLUE2 durchbohren.
16. Auf der Unterseite Durchgangslochdraht von BLUE1 zu BLUE3.
17. Auf der Unterseite, Durchgangslochdraht von BLUE2 in BLUE5, und löten.
18. Oben, Durchgangslochdraht von BLUE3 in BLUE4 und löten.
19. Auf der Oberseite ein grünes Kabel in GREEN1 und GREEN2 durchbohren.
20. Auf der Unterseite Durchgangslochdraht von GREEN1 in GREEN3.
21. Auf der Unterseite den Draht von GREEN2 in GREEN5 durchstecken und verlöten.
22. Auf der Oberseite Durchgangslochdraht von GREEN3 in GREEN4 und löten.
23. Auf der Oberseite einen 4K7-Widerstand in SILVER3 und SILVER4 durchbohren.
24. Auf der Unterseite Durchgangslochdraht von SILVER3 in GREEN5 und Löten.
25. Auf der Unterseite Durchgangslochdraht von SILVER4 in RED10 stecken und löten.
26. Auf der Oberseite einen 4K7-Widerstand in SILVER1 und SILVER2 durchbohren.
27. Auf der Unterseite den Draht von SILVER1 in BLUE5 durchstecken und löten.
28. Auf der Unterseite Durchgangslochdraht von SILVER2 in RED10 stecken und löten.

Schritt 3: Code für die UNO

Die Skizze hier ist rudimentär. Es ermöglicht Ihnen, den Konsoleneingang zu verwenden, damit die UNO I2C-Nachrichten an den I2C ATTINY85 BRICK sendet.

Alle Anweisungen werden mit den unterstützten Optionen auf den Bildschirm gedruckt.

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

Von den vorgestellten Builds gibt es genug bewegliche Teile, damit Sie Ihr eigenes ASSIMILATE IOT NETWORK aufbauen können.

Jede der einzelnen Funktionen der Knoten (Sensoren und Aktoren) ist dezentral steuerbar, unabhängig davon, ob der MCU-Master Kenntnis über die unterstützten Funktionen hat.

Jede App, die sich mit dem MQTT-Broker verbindet, kann jede Funktion des IOT-Knotens steuern/beobachten. Das ist M2M, Webanwendungen, IFTTT und so weiter. Viel einfachere (oder reichere, wenn Sie möchten) Schnittstellen zu Ihrer IOT-Welt.