IOT123 - I2C JIG BAD MASTER: 4 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

În timpul dezvoltării SENZORILOR ȘI ACTORILOR ASIMILAȚI, păstrez un UNO la îndemână pentru trimiterea de comenzi adhoc I2C către prototipurile în curs de dezvoltare. Unul dintre beneficiile modelului I2C BRICKS îl reprezintă pinouturile standardizate. În loc să folosiți de fiecare dată fire de panou (vezi Fritzings), se folosește un scut lo-tech robust.

Pasul 1: Materiale și instrumente

1. PCB uninersal de 4cm x 6cm (1)
2. Sârmă de conectare (~ 6)
3. Rezistoare 4K7 (2)
4. Antet masculin (12P, 8P)
5. Antet feminin (9P, sau 3P, 3P)
6. Sudură și fier (1)

Pasul 2: Asamblare

Dacă utilizați 2 anteturi feminine 3P în loc de 1 antet feminin 9P, ASSIMILATE SENSOR / ACTORS se va potrivi pe JIG fără a le dezasambla.

Cu cablajul, dezbrăcați până la 10 mm pe capete și stanjiți extremitățile.

1. Pe partea de jos a PCB-ului, introduceți antetul tată (1) (2) și lipiți-l în partea de sus.
2. În partea superioară a PCB-ului, introduceți antetul feminin (3) și lipiți-l pe partea inferioară.
3. În partea de sus, găuriți un fir roșu în RED1 și RED2.
4. În partea inferioară, sârmă prin orificiu de la RED1 la RED3.
5. În partea inferioară, sârmă prin orificiu de la RED2 în RED5 și lipire.
6. În partea de sus, sârmă prin orificiu de la RED3 în RED4 și lipire.
7. În partea de sus, găuriți un fir roșu în RED6 și RED7.
8. În partea inferioară, sârmă prin orificiu de la RED6 în RED8.
9. În partea inferioară, sârmă prin orificiul traversant de la RED7 la RED10 și lipire.
10. În partea de sus, sârmă prin orificiu traversant de la RED8 la RED9 și lipit.
11. În partea de sus, găuriți un fir negru în BLACK1 și BLACK2.
12. În partea inferioară, firul orificiului de la BLACK1 în BLACK3.
13. În partea inferioară, sârmă prin orificiul traversant de la BLACK2 în BLACK5 și lipire.
14. În partea de sus, sârmă prin orificiul traversant de la BLACK3 în BLACK4 și lipit.
15. În partea de sus, găuriți un fir albastru în BLUE1 și BLUE2.
16. În partea inferioară, sârmă prin orificiul de trecere de la ALBASTRU1 în ALBASTRU3.
17. În partea inferioară, sârmă prin orificiu de la BLUE2 în BLUE5 și lipire.
18. În partea superioară, sârmă prin orificiu de la BLUE3 în BLUE4 și lipire.
19. În partea de sus, găuriți un fir verde în GREEN1 și GREEN2.
20. În partea inferioară, sârmă prin orificiul traversant de la GREEN1 la GREEN3.
21. În partea inferioară, sârmă prin orificiu traversant de la GREEN2 în GREEN5 și lipită.
22. În partea de sus, sârmă prin orificiu traversant din GREEN3 în GREEN4 și lipit.
23. În partea de sus, găuriți un rezistor 4K7 în SILVER3 și SILVER4.
24. În partea de jos, sârmă prin orificiu de la SILVER3 în GREEN5 și lipit.
25. În partea inferioară, sârmă prin orificiu de la SILVER4 în RED10 și lipire.
26. În partea de sus, găuriți un rezistor 4K7 în SILVER1 și SILVER2.
27. În partea inferioară, sârmă prin orificiu de la SILVER1 în BLUE5 și lipire.
28. În partea inferioară, sârmă prin orificiu de la SILVER2 în RED10 și lipire.

Pasul 3: Cod pentru UNO

Schița de aici este rudimentară. Vă permite să utilizați Consola de intrare, pentru a face UNO să trimită mesaje I2C către I2C ATTINY85 BRICK.

Toate instrucțiunile sunt tipărite pe ecran, cu opțiunile acceptate.

Comenzi adhoc I2C BRICK pentru sclavi de la masterul UNO

#include

octet const _num_chars = 32;

char _received_chars [_num_chars]; // o matrice pentru stocarea datelor primite

boolean _has_new_data = false;

voidsetup () {

Serial.begin (9600);

Serial.println ();

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

Serial.println ("asigurați linia nouă selectată în fereastra consolei");

Serial.println ();

Serial.println ("ADRESA 1 CONFIRMĂ PRIMITE METADATE N / A (PENTRU M2M)");

Serial.println ("ADRESA 2 ACTOR COMANDĂ");

Serial.println ();

Serial.println ("ADRESE PE AUTOBUZ:");

scan_i2c_addresses ();

Serial.println ();

Serial.println ("");

}

voidscan_i2c_addresses () {

int device_count = 0;

for (adresa de octet = 8; adresa <127; adresa ++)

{

Wire.beginTransmission (adresa);

const byte error = Wire.endTransmission ();

if (eroare == 0)

{

Serial.println (adresa);

}

}

}

voidloop () {

recv_with_end_marker ();

send_to_i2c ();

}

voidrecv_with_end_marker () {

octet static ndx = 0;

char end_marker = '\ n';

char rc;

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

rc = Serial.read ();

if (rc! = end_marker) {

_received_chars [ndx] = rc;

ndx ++;

if (ndx> = _num_chars) {

ndx = _num_chars - 1;

}

}

altceva {

_received_chars [ndx] = '\ 0'; // terminați șirul

ndx = 0;

_has_new_data = true;

}

}

}

voidsend_to_i2c () {

char param_buf [16];

const String received_string = String (_received_chars);

if (_has_new_data == true) {

int idx1 = a primit_string.indexOf ('');

Adresa șirului = a primit_string.substring (0, idx1);

int address_int = address.toInt ();

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

Serial.println ("ADRESS ADRESS INVALID:");

Serial.println (adresa);

întoarcere;

}

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

Cod șir;

if (idx2 == -1) {

cod = a primit_string.substring (idx1 + 1);

} altceva {

cod = a primit_string.substring (idx1 + 1, idx2 + 1);

}

int code_int = code.toInt ();

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

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

Serial.println (cod);

întoarcere;

}

bool has_parameter = idx2> -1;

Parametru șir;

if (has_parameter) {

parametru = a primit_string.substring (idx2 + 1, idx2 + 17); // 16 caractere max

if (parametru.lungime () <1) {

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

_has_new_data = false;

întoarcere;

}

} altceva {

if (code_int> 1) {

Serial.println ("PARAMETRU NECESAR!");

_has_new_data = false;

întoarcere;

}

}

Serial.println ();

Serial.print ("input orig =");

Serial.println (șir_ primit);

Serial.print ("adresa =");

Serial.println (adresa);

Serial.print ("cod =");

Serial.println (cod);

Serial.print ("parametru =");

Serial.println (parametru);

// TRIMITEȚI VIA I2C

Wire.beginTransmission (address_int);

Wire.write (code_int);

if (has_parameter) {

parametru.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 = false;

}

}

vizualizați rawuno_i2c_command_input.ino găzduit cu ❤ de GitHub

Pasul 4: Pașii următori

Din versiunile prezentate, există suficiente părți mobile pentru a vă construi propria REȚEAȘĂ ASSIMILATE IOT.

Fiecare dintre funcțiile individuale ale nodurilor (senzori și actori) sunt controlabile într-o manieră descentralizată, nu depinde de masterul MCU pentru a avea cunoștințe despre caracteristicile acceptate.

Orice aplicație care se conectează la brokerul MQTT poate controla / observa fiecare caracteristică a nodului IOT. Asta este M2M, aplicații web, IFTTT și așa mai departe. Interfețe mult mai simple (sau mai bogate dacă doriți) în lumea IOT.