IOT123 - MATTONE RELÈ I2C 2CH: 5 passaggi (con immagini)

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 BRICK RELAY I2C 2CH estende le funzionalità del BRICK I2C KY019 e ha due proprietà di lettura/scrittura:

RELÈ 2CH[0] (vero/falso)

RELÈ 2CH[1] (vero/falso)

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. Relè a 2 canali (1)
2. ATTINY85 20PU (1)
3. Scheda prototipi bifacciale da 1" (1)
4. Testata maschio 90º (3P, 3P)
5. Intestazione maschio (2P, 2P)
6. Ponticello di derivazione (1)
7. Cavo di collegamento (~7)
8. 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_2ch_relay".

È 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_2ch_relay".

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

www.instructables.com/id/How-to-Program-A…

www.instructables.com/id/Programming-the-…

www.instructables.com/id/Programming-the-…

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, ovvero tutti gli attori Relay possono avere lo stesso indirizzo purché tu abbia solo un attore Relay su un MCU/nodo.

Passaggio 3: assemblare il circuito

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 nero da BLACK1 a BLACK2 e salda.
7. Sul retro, traccia un filo nero da BLACK3 a BLACK4 e salda.
8. Sul retro, traccia un filo rosso da RED1 a RED2 e salda.
9. Sul retro, traccia un filo nudo da RED3 a RED4 e salda.
10. Sul retro, traccia un filo nudo da SILVER1 a SILVER2 e salda.
11. Aggiungere un ponticello sulla linea 5V o 3V3.

Il relè può ora essere collegato direttamente tramite i suoi pin al PCB o tramite fili, ai punti indicati nel contratto dei pin.

Passaggio 4: test

Si prevede che alcuni di questi BRICK si trovino su più nodi (MCU - ESP8266 o ATTINY84) in un ambiente. Questo è un test unitario: invia i comandi I2C dall'UNO all'ATTINY che apre o chiude i relè.

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, inserisci nella casella di invio 2 0:1 (quindi 15 2 0:1) e il relè CH1 si accende.

7. Quando, inserisci nella casella di invio 2 0:0 (quindi 15 2 0:0) e il relè CH1 si spegne.
8. Quando, inserisci nella casella di invio 2 1:1 (quindi 15 2 1:1) e il relè CH2 si accende.
9. Quando, inserisci nella casella di invio 2 1:0 (quindi 15 2 0:0) e il relè CH2 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 5: passaggi successivi

Il follow-up ASSIMILA ACTOR: 2CH RELAY 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. Sono stati aggiunti alcuni schemi, ma ci sono vari modi per cablare il circuito a valle a seconda di ciò che si desidera ottenere, quindi lo lascerò per te:)