Sommario:
- Passaggio 1: materiali e strumenti
- Passaggio 2: preparare l'ATTINY85
- Passaggio 3: assemblare il circuito
- Passaggio 4: test
- Passaggio 5: passaggi successivi
Video: IOT123 - MATTONE I2C KY019: 5 passaggi
2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03
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 KY019 BRICK è il primo degli ATTORI e ha una proprietà di lettura/scrittura:
Cambio (vero/falso)
I mattoncini sensore di tipo Keyes verranno estratti per primi in quanto vengono forniti con vitamine (componenti extra necessari) inclusi e sono relativamente economici (ho comprato 37 per 10 AUD). Altre schede/circuiti verranno introdotte negli I2C BRICKS.
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.
- KY-019 Relè (1)
- ATTINY85 20PU (1)
- Scheda prototipi bifacciale da 1" (1)
- Testata maschio 90º (3P, 3P)
- Cavo di collegamento (~7)
- 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_ky019".
È 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_ky019".
Per caricare il firmware su ATTINY85, puoi trovare maggiori dettagli in queste istruzioni:
www.instructables.com/id/Programming-the-A…
www.instructables.com/id/How-to-Program-AT…
www.instructables.com/id/How-to-program-th…
www.instructables.com/id/Programming-the-A…
www.instructables.com/id/Programming-an-At…
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
- Sulla parte anteriore, inserire i componenti ATTINY85 (1), connettori maschio 3P 90deg (2) (3) e saldare sul retro.
- Sul retro, traccia un filo giallo da GIALLO1 a GIALLO2 e salda.
- Sul retro, traccia un filo blu da BLUE1 a BLUE2 e salda.
- Sul retro, traccia un filo verde da GREEN1 a GREEN2 e salda.
- Sul retro, traccia un filo nero da BLACK1 a BLACK2 e salda.
- Sul retro, traccia un filo nero da BLACK3 a BLACK4 e salda.
- Sul retro, traccia un filo rosso da RED1 a RED2 e salda.
- Sul retro, traccia un filo rosso da RED3 a RED4 e salda.
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 il relè.
Abbiamo precedentemente costruito uno SHIELD I2C per Arduino.
Se invece vuoi eseguire il breadboard:
- Collega il 5.0V su UNO a un VCC su BRICK.
- Collega GND su UNO a GND su BRICK.
- Collega A5 su UNO a SCL su BRICK.
- Collega l'A4 su UNO a SDA su BRICK.
- Collegare un resistore di pull-up 4K7 da SDA a VCC.
- Collegare un resistore di pull-up 4K7 da SCL a VCC.
Esecuzione del test
- Collega il tuo UNO al tuo Dev PC con USB.
- Carica il codice all'ONU.
- Apri la console Arduino. Scegli 9600 baud (riavvia UNO e riapri la console se necessario).
- L'indirizzo dello slave verrà stampato sulla console.
- Quando, inserisci nella casella di invio 2 1 (quindi 12 2 1) e il relè si attiva.
- Quando, inserisci nella casella di invio 2 0 (quindi 12 2 0) e il relè 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 ATTORE: KY019 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:)
Consigliato:
Display LCD I2C / IIC - Utilizzare un display LCD SPI sul display LCD I2C utilizzando il modulo SPI su IIC con Arduino: 5 passaggi
Display LCD I2C / IIC | Utilizzare un display LCD SPI per il display LCD I2C utilizzando il modulo da SPI a IIC con Arduino: Ciao ragazzi poiché un normale LCD 1602 SPI ha troppi fili da collegare, quindi è molto difficile interfacciarlo con arduino ma c'è un modulo disponibile sul mercato che può convertire il display SPI in display IIC, quindi è necessario collegare solo 4 fili
Display LCD I2C / IIC - Converti un LCD SPI nel display LCD I2C: 5 passaggi
Display LCD I2C / IIC | Convertire un display LCD SPI in display LCD I2C: l'utilizzo del display lcd spi richiede troppe connessioni, il che è davvero difficile da fare, quindi ho trovato un modulo che può convertire l'affissione a cristalli liquidi i2c all'affissione a cristalli liquidi spi quindi iniziamo
IOT123 - ATTORE ASSIMILA: KY019: 4 Passi
IOT123 - ATTORE ASSIMILA: KY019: è con segnale di controllo TIL 5V che può controllare il segnale DC / AC. Questa build si basa sul BRICK I2C KY019. Se hai bisogno di 2 canali, ti consiglio di sostituire questo attore con il 2CH RELAY BRICK. ATTORI/SENSORI ASSIMILATI sono attori/sensori ambientali
IOT123 - SLITTE PCB I2C: 5 passaggi
IOT123 - I2C PCB RAILS: dove non sono necessari involucri durevoli, ASSIMILATE IOT NETWORK SENSORS e ACTORS possono impilarsi in modo più efficiente e con meno risorse e sforzi, direttamente su binari minimalisti. I cilindri di alloggiamento possono essere utilizzati (come mostrato in questa build) o l'und
IOT123 - DIMA I2C BRICK MASTER: 4 passaggi
IOT123 - I2C BRICK MASTER JIG: Durante lo sviluppo dei SENSORI ASSIMILATI e degli ATTORI, 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 i fili della breadboard ogni volta