IOT123 - MATTONE HEARTBEAT I2C: 6 passaggi

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

I BRICK IOT123 sono unità modulari fai da te che possono essere combinate con altri BRICK IOT123, per aggiungere funzionalità a un nodo o indossabili. Si basano su schede prototipi a doppia faccia quadrate in pollici con fori passanti interconnessi.

Si prevede che alcuni di questi BRICK si trovino su più nodi (Master MCU - ESP8266 o ATTINY84) in un sito. L'MCU non necessita di alcuna conoscenza preliminare dello scopo dei sensori o delle esigenze del software. Esegue la scansione dei nodi I2C, quindi richiede un dump delle proprietà (dati del sensore) da ogni slave. Questi BRICK forniscono 5,0 V, 3,3 V e un'altra linea AUX che è personalizzabile.

Questo I2C HEARTBEAT BRICK indica se lo slave ATTINY è vivo, anche il traffico I2C, e ha una proprietà:

STATO ("VIVO")

PB1 (bianco) indica la salute di ATTINY.

PB3 (giallo) si alterna con le richieste I2C dal master.

PB4 (arancione) si alterna con la ricezione I2C dal master.

I fori passanti adiacenti all'ATTINY85 sono stati lasciati inutilizzati, per abilitare un programmatore di pin pogo mentre il DIP8 è saldato al PCB. È in fase di sviluppo un'ulteriore astrazione, il confezionamento dei BRICKS in piccoli cilindri che si collegano a un hub D1M WIFI BLOCK, pompando i valori su un server MQTT.

Passaggio 1: materiali e strumenti

C'è una distinta base completa e un elenco di approvvigionamento.

1. PCB in carta (7 x 7 fori)
2. LED (rosso, verde, blu)
3. Resistori (3 su 1K)
4. ATTINY85 20PU (1)
5. Scheda prototipi bifacciale da 1" (1)
6. Testata maschio 90º (3P, 3P)
7. Intestazione maschio (2P, 2P)
8. Ponticello di derivazione (1)
9. Cavo di collegamento (~7)
10. Saldare e Ferro (1)

Passaggio 2: preparare l'ATTINY85

NOTA: se si intende integrare Crouton, utilizzare la libreria da qui e utilizzare l'esempio installato "attiny_heartbeat"

È necessario AttinyCore del Board Manager. Masterizza il bootloader "EEPROM mantenuto", "8 mHZ interno" (tutte le configurazioni mostrate sopra).

Il repository del codice può essere trovato qui.

Uno ZIP della biblioteca può essere trovato qui.

Istruzioni per "Importare una libreria ZIP" qui.

Una volta installata la libreria, puoi aprire l'esempio "attiny_heartbeat".

Per caricare il firmware su ATTINY85, puoi trovare maggiori dettagli in queste istruzioni:

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

Meglio testare tramite breadboard prima di continuare.

Se disponi di SENSORI ASSIMILA esistenti, assicurati che l'indirizzo slave sia diverso su una combinazione SENSOR/MCU Host, ad es. tutti gli attori Relay possono avere lo stesso indirizzo purché si disponga di un solo attore Relay su un MCU/nodo.

Passaggio 3: assemblaggio degli indicatori

Gli indicatori sono pensati per essere completamente personalizzabili. Sono i segnali degli eventi dal circuito principale che vengono visti come Heartbeats. Per questa build utilizzeremo indicatori LED; la tua build può utilizzare relè (sì, il VCC è rotto) o un altro indicatore basato su segnale / visivo. I valori dei resistori dipenderanno dalle preferenze personali su quanto luminosi li vuoi.

1. In alto, inserire un LED blu in RED1 (+) e BLACK1 (G), e saldare in basso.
2. In basso, piega il cavo di RED1 in modo che tocchi il pad di rame su SILVER8 e taglia.
3. In basso, tagliare il cavo da BLACK1 sopra la saldatura.
4. In alto, inserire un LED verde in RED2 (+) e BLACK2 (G), e saldare in basso.
5. In basso, piega il cavo di RED2 in modo che tocchi il pad di rame su SILVER9 e taglia.
6. In basso, tagliare il cavo da BLACK2 sopra la saldatura.
7. In alto, inserire un LED rosso in RED3 (+) e BLACK3 (G), e saldare in basso.
8. In basso, piega il cavo di RED3 in modo che tocchi il pad di rame su SILVER10 e taglia.
9. In basso, tagliare il cavo da BLACK3 sopra la saldatura.
10. In alto, inserire una resistenza da 1K nei fori passanti SILVER1 e SILVER4.
11. Sul fondo, traccia, taglia e salda il cavo da SILVER1 a BLACK1.
12. In alto, inserire una resistenza da 1K nei fori passanti SILVER2 e SILVER4.
13. Sul fondo, traccia, taglia e salda il cavo da SILVER2 a BLACK2.
14. In alto, inserire una resistenza da 1K nei fori passanti SILVER3 e SILVER4.
15. Sul fondo, traccia, taglia e salda il cavo da SILVER3 a BLACK3.
16. Nella parte inferiore, saldare i fili su SILVER4 e tagliare a circa 5 mm di estensione.
17. In basso, saldare un filo nero su SILVER4.
18. Sul fondo, saldare un filo bianco in SILVER5, garantendo continuità al conduttore da RED1.
19. Sul fondo, saldare un filo giallo in SILVER6, assicurando continuità al conduttore da RED2.
20. Sul fondo, saldare un filo arancione in SILVER7, garantendo continuità al cavo da RED3.

Passaggio 4: assemblaggio del circuito principale

Assemblea:

1. Sulla parte anteriore, inserire i componenti ATTINY85 (1), connettori maschio 3P 90deg (2)(3), connettori maschio 3P (4)(5) e saldare sul retro.
2. Sul retro, traccia un filo giallo da GIALLO1 a GIALLO2 e salda.
3. Sul retro, traccia un filo arancione da ORANGE1 a ORANGE2 e salda.
4. Sul retro, traccia un filo blu da BLUE1 a BLUE2 e salda.
5. Sul retro, traccia un filo verde da GREEN1 a GREEN2 e salda.
6. Sul retro, traccia un filo bianco da WHITE1 a WHITE2 e salda.
7. Sul retro, traccia un filo nero da BLACK1 a BLACK2 e salda.
8. Sul retro, traccia un filo nero da BLACK3 a BLACK4 e salda.
9. Sul retro, traccia un filo rosso da RED1 a RED2 e salda.
10. Sul retro, traccia un filo nudo da RED3 a RED4 e salda.
11. Sul retro, traccia un filo nudo da SILVER1 a SILVER2 e salda.
12. Aggiungere un ponticello sulla linea 5V o 3V3.

Se si utilizzano gli indicatori sopra (fare riferimento al diagramma dei piedini):

1. Sul retro, saldare il filo bianco in PB1.
2. Sul retro, saldare il filo giallo in PB3.
3. Sul retro, saldare il filo arancione in PB4.
4. Sul retro, saldare il filo nero a GND.

Passaggio 5: test

Si prevede che alcuni di questi BRICK si trovino su più nodi (MCU - ESP8266 o ATTINY84) in un ambiente. Questo è un test dell'unità: invia i comandi I2C dall'UNO all'ATTINY che attiva il LED di ricezione. Il LED ATTINY ALIVE rimane acceso.

Abbiamo precedentemente costruito uno SHIELD I2C per Arduino.

Se invece vuoi eseguire il breadboard:

1. Collega il 5.0V su UNO a un VCC su BRICK.
2. Collega GND su UNO a GND su BRICK.
3. Collega A5 su UNO a SCL su BRICK.
4. Collega l'A4 su UNO a SDA su BRICK.
5. Collegare un resistore di pull-up 4K7 da SDA a VCC.
6. Collegare un resistore di pull-up 4K7 da SCL a VCC.

Esecuzione del test

1. Collega il tuo UNO al tuo Dev PC con USB.
2. Carica il codice all'ONU.
3. Apri la console Arduino.
4. Scegli 9600 baud (riavvia l'UNO e riapri la console se necessario).
5. L'indirizzo dello slave verrà stampato sulla console.
6. Quando, entra nella casella di invio 2 1 (quindi 16 2 1), e il LED di ricezione si accende.
7. Quando, inserisci nella casella di invio 2 0 (quindi 16 2 0), e il LED di ricezione si spegne.

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 6: passaggi successivi

Il follow-up ASSIMILA ATTORE: HEARTBEAT che utilizza questo mattone ha una configurazione automatica per Crostino tramite i metadati già installati nell'ATTINY85 qui. Il pacchetto JSON inviato a Crouton viene inviato tramite l'ultimo firmware per ICOS10. Puoi fare un Proof-of-concept su un normale ESP8266, se la build è troppo per ora.

Lo sketch UNO utilizzato in Test ha una funzione per salvare un nuovo indirizzo slave in EEPROM sull'ATTINY85, se si verifica un conflitto sul bus I2C di destinazione.