IOT123 - DIMA I2C BRICK MASTER: 4 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

Durante lo sviluppo di ASSIMILATE SENSORS e ACTORS, tengo a portata di mano un UNO per inviare comandi I2C ad hoc ai prototipi in fase di sviluppo. Uno dei vantaggi di I2C BRICKS è la piedinatura standardizzata. Piuttosto che usare ogni volta i fili della breadboard (vedi i Fritzings), viene utilizzato un robusto scudo lo-tech.

Passaggio 1: materiali e strumenti

1. PCB inerziale 4 cm x 6 cm (1)
2. Cavo di collegamento (~6)
3. Resistori 4K7 (2)6
4. Testata maschio (12P, 8P)
5. Intestazione femmina (9P, o 3P, 3P)
6. Saldare e Ferro (1)

Passaggio 2: assemblaggio

Se si utilizzano 2 connettori femmina 3P invece di 1 connettore femmina 9P, ASSIMILATE SENSOR/ACTORS si adatterà al JIG senza smontarli.

Con il cablaggio, spelare fino a 10 mm alle estremità e stagnare le estremità.

1. Nella parte inferiore del PCB, inserire l'intestazione maschio (1)(2) e saldare sopra.
2. Sulla parte superiore del PCB, inserire l'intestazione femmina (3) e saldare sul fondo.
3. Sulla parte superiore, forare un filo rosso in RED1 e RED2.
4. In basso, cavo passante da RED1 a RED3.
5. In basso, filo passante da RED2 a RED5 e saldare.
6. Sulla parte superiore, filo passante da RED3 a RED4 e saldare.
7. Sulla parte superiore, forare un filo rosso in RED6 e RED7.
8. In basso, cavo passante da RED6 a RED8.
9. In basso, filo passante da RED7 a RED10 e saldare.
10. Sulla parte superiore, filo passante da RED8 a RED9 e saldatura.
11. In alto, forare un filo nero in BLACK1 e BLACK2.
12. In basso, cavo passante da NERO1 a NERO3.
13. In basso, filo passante da BLACK2 a BLACK5 e saldatura.
14. Sulla parte superiore, filo passante da BLACK3 a BLACK4 e saldatura.
15. Sulla parte superiore, forare un filo blu in BLUE1 e BLUE2.
16. In basso, cavo passante da BLU1 a BLU3.
17. In basso, filo passante da BLUE2 a BLUE5 e saldare.
18. Sulla parte superiore, filo passante da BLUE3 a BLUE4 e saldare.
19. Sulla parte superiore, forare un filo verde in VERDE1 e VERDE2.
20. In basso, cavo passante da VERDE1 a VERDE3.
21. In basso, filo passante da GREEN2 a GREEN5, e saldare.
22. Sulla parte superiore, filo passante da GREEN3 a GREEN4 e saldare.
23. Sulla parte superiore, foro passante un resistore 4K7 in SILVER3 e SILVER4.
24. In basso, filo passante da SILVER3 a GREEN5 e saldare.
25. In basso, filo passante da SILVER4 a RED10 e saldare.
26. Sulla parte superiore, foro passante un resistore 4K7 in SILVER1 e SILVER2.
27. Sul fondo, filo passante da SILVER1 a BLUE5 e saldare.
28. In basso, filo passante da SILVER2 a RED10 e saldare.

Passaggio 3: codice per l'ONU

Lo schizzo qui è rudimentale. Consente di utilizzare l'ingresso della console, per fare in modo che l'UNO invii messaggi I2C all'I2C ATTINY85 BRICK.

Tutte le istruzioni vengono stampate sullo schermo, con le opzioni supportate.

I2C BRICK comandi ad hoc per gli slave dal master UNO

#includere

const byte _num_chars = 32;

char _caratteri_ricevuti[_num_caratteri]; // un array per memorizzare i dati ricevuti

booleano _has_new_data = falso;

voidsetup() {

Serial.begin(9600);

Serial.println();

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

Serial.println("assicura che la nuova riga sia selezionata nella finestra della console");

Serial.println();

Serial.println("INDIRIZZO 1 CONFERMA RICEVUTA METADATI N/A (PER M2M)");

Serial.println("COMANDO ATTORE INDIRIZZO 2");

Serial.println();

Serial.println("INDIRIZZI SUL BUS:");

scan_i2c_addresses();

Serial.println();

Serial.println("");

}

voidscan_i2c_addresses(){

int device_count = 0;

for (indirizzo byte = 8; indirizzo < 127; indirizzo++)

{

Wire.beginTransmission(indirizzo);

const byte errore = Wire.endTransmission();

se (errore == 0)

{

Serial.println(indirizzo);

}

}

}

voidloop() {

recv_with_end_marker();

send_to_i2c();

}

voidrecv_with_end_marker() {

byte statico 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;

}

}

altro {

_received_chars[ndx] = '\0'; // termina la stringa

ndx = 0;

_has_new_data = vero;

}

}

}

voidsend_to_i2c() {

char param_buf[16];

const String stringa_ricevuta = String(_caratteri_ricevuti);

if (_has_new_data == true) {

int idx1 = stringa_ricevuta.indexOf('');

Indirizzo stringa = stringa_ricevuta.substring(0, idx1);

int address_int = address.toInt();

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

Serial.println("INSERIMENTO INDIRIZZO NON VALIDO:");

Serial.println(indirizzo);

Restituzione;

}

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

Codice stringa;

if (idx2 == -1){

codice = stringa_ricevuta.sottostringa(idx1+1);

}altro{

codice = stringa_ricevuta.sottostringa(idx1+1, idx2+1);

}

int code_int = code.toInt();

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

Serial.println("INSERIMENTO CODICE NON VALIDO:");

Serial.println(codice);

Restituzione;

}

bool has_parameter = idx2 > -1;

Parametro stringa;

if (ha_parametro){

parametro = stringa_ricevuta.sottostringa(idx2 + 1, idx2 + 17); // 16 caratteri max

if (parametro.lunghezza() < 1){

Serial.println("PARTAMETRO MIN. LUNGHEZZA 1");

_has_new_data = falso;

Restituzione;

}

}altro{

if (code_int >1){

Serial.println("PARAMETRO RICHIESTO!");

_has_new_data = falso;

Restituzione;

}

}

Serial.println();

Serial.print("input orig = ");

Serial.println(received_string);

Serial.print("indirizzo = ");

Serial.println(indirizzo);

Serial.print("codice = ");

Serial.println(codice);

Serial.print("parametro = ");

Serial.println(parametro);

// INVIA TRAMITE I2C

Wire.beginTransmission(address_int);

Wire.write(code_int);

if (ha_parametro){

parametro.trim();

strcpy(param_buf, parametro.c_str());

Wire.write(param_buf);

}

Wire.endTransmission();

Serial.println();

Serial.println("INVIATO TRAMITE I2C!");

Serial.println();

Serial.println("");

_has_new_data = falso;

}

}

visualizza rawuno_i2c_command_input.ino ospitato con ❤ da GitHub

Passaggio 4: passaggi successivi

Dalle build presentate, ci sono abbastanza parti mobili per costruire la tua RETE IOT ASSIMILATA.

Ognuna delle singole funzioni dei nodi (sensori e attori) è controllabile in maniera decentralizzata, non dipendendo dal master dell'MCU per avere alcuna conoscenza delle funzionalità supportate.

Qualsiasi app che si connette al broker MQTT può controllare/osservare ogni funzionalità del nodo IOT. Quello è M2M, applicazioni web, IFTTT e così via. Interfacce molto più semplici (o più ricche se vuoi) al tuo mondo IOT.