IOT123 - MATTONE I2C MQ2: 5 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,0V, 3,3V e un'altra linea AUX personalizzabile.

Questo I2C MQ2 BRICK scarica 3 proprietà:

GPL (parti per milione), CO (PPM), FUMO (PPM)

Questo sensore ha fornito uno scenario interessante: ha bisogno di almeno 2 minuti (fino a 5 minuti) per riscaldarsi, quindi deve essere calibrato per 20 secondi prima dell'uso. Poiché l'MCU host è coinvolto solo nell'ottenere coppie nome/valore (e un messaggio di continuazione), abbiamo introdotto una proprietà "PREPARE". Poiché il messaggio di continuazione è "1" (altri in arrivo), l'MCU Host continuerà a interrogare il BRICK finché non sarà pronto. Inoltre si consiglia di "bruciare" l'MQ2 prima dell'uso, ad esempio lasciarlo collegato al circuito a 5 V per 24 ore.

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: materiale e strumenti

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

1. Mattone sensore MQ2 (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

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

Usa la fonte inclusa; compilare e programmare su ATtiny85.

Il GIST è qui:

gist.github.com/IOT-123/4c501046d365d01a60…

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 i sensori di temperatura possono avere lo stesso indirizzo purché tu abbia un solo sensore di temperatura su un MCU/nodo.

Passaggio 3: assemblare il circuito

1. Sulla parte anteriore, inserire i componenti ATTINY85 (1), connettori maschio 3P 90 gradi (2)(3), connettori maschio 2P (4)(5) e saldare sul retro.
2. Sul retro, traccia un filo arancione da ORANGE1 a ORANGE2 e salda.
3. Sul retro, traccia un filo blu da BLUE1 a BLUE2 e salda.
4. Sul retro, traccia un filo verde da GREEN1 a GREEN2 e salda.
5. Sul retro, traccia un filo nudo da SILVER1 a SILVER2 e salda.
6. Sul retro, traccia un filo nudo da SILVER3 a SILVER4 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 rosso da RED3 a RED4 e salda.
11. Sul retro, traccia un filo giallo da GIALLO1 a GIALLO2 e salda.

Il sensore 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: controlla le richieste/risposte UNO fino a quando tutti i dati sono stati scaricati, quindi trascura lo slave I2C.

1. Carica il codice UNO sul tuo test harness UNO. Assicurati che ADDRESS_SLAVE corrisponda all'indirizzo I2C del BRICK.
2. Collega il 5.0V su UNO a un VCC su BRICK.
3. Assicurati che il ponticello per quel pin sia acceso.
4. Collega GND su UNO a GND su BRICK.
5. Collega A5 su UNO a SCL su BRICK.
6. Collega l'A4 su UNO a SDA su BRICK.
7. Collegare un resistore di pull-up 4K7 da SDA a VCC.
8. Collegare un resistore di pull-up 4K7 da SCL a VCC.
9. Collega il tuo UNO al tuo Dev PC con USB.
10. Apri la console Arduino. Scegli 9600 baud (riavvia UNO e riapri la console se necessario).
11. I nomi e i valori delle proprietà devono essere stampati sulla console una volta che viene ripetuta la parola sleep.

Se vedi "setup", quindi 3 righe di immondizia ripetute, potresti avere le tue linee SDA e SCL in primo piano.

I2C Master logging da I2C slave con supporto plotter/metadati

#includere

#defineADDRESS_SLAVE10

bool _outputPlotterOnly = false;

bool _confirmedMetadata = false;

int _packetSegment = 0;

bool _i2cNodeProcessed = false;

char _property[2][24] = {"nome", "valore"};

voidsetup() {

Wire.begin(); // entra nel bus i2c (indirizzo opzionale per il master)

Serial.begin(9600); // avvia seriale per l'output

ritardo(1000);

if (!_outputPlotterOnly){

Serial.println("configurazione");

Serial.println();

}

}

voidloop() {

if (_i2cNodeProcessed){

if (!_confirmedMetadata){// comunica allo slave di iniziare a inviare i dati del sensore

ritardo(1);

Wire.beginTransmission(ADDRESS_SLAVE);

Wire.write(1);

Wire.endTransmission();

ritardo(100);

_confirmedMetadata = vero;

}

_i2cNodeProcessed = false;

if (!_outputPlotterOnly){

Serial.println();

}

Restituzione;

}

Wire.requestFrom(ADDRESS_SLAVE, 16);

_packetSegment++;

pacchetto di caratteri[16];

indice = 0;

bool isContinueSegment = false;// continueSegment (il 3°) 1=altro, 0=ultimo

while (Wire.available()) { // lo slave può inviare meno di quanto richiesto

char c = Wire.read();

pacchetto[indice] = int(c) > -1 ? c: '';// sostituisce i caratteri non validi con spazi

if (_packetSegment == 3){

_packetSegment = 0;

isContinueSegment = true;

//Serial.println("-------------");

//Serial.println(int(c));

//Serial.println("-------------");

if (int(c) == 48 || int(c) == 86){// 0 sull'ultima proprietà

_i2cNodeProcessed = vero;

// invia valori a MQTT

rottura;

}

}

indice++;

}

if (!isContinueSegment){

if (!_outputPlotterOnly){

Serial.println(pacchetto);

}

strcpy(_property[_packetSegment - 1], packet);// imposta var locale con nome/valore

}altro{

if (_outputPlotterOnly && _confirmedMetadata){

if (_i2cNodeProcessed){

Serial.println(_property[1]);

}altro{

Serial.print(_property[1]);

Serial.print("");

}

}

}

}

visualizza rawuno_i2c_generic_sensor_test_w_plotter_v2.ino ospitato con ❤ da GitHub

Passaggio 5: passaggi successivi

Il layout di base del circuito e il livello I2C del software sono correlati a molti sensori diversi. La cosa principale da cui iniziare è il contratto a pacchetto tra master e slave.

Ho programmato/avviato una rete di sensori confezionati (stampati in 3D) che utilizzano questo framework e si collegheranno ad esso man mano che le parti verranno pubblicate.

Questo BLOCCO è utilizzato dal SENSORE ASSIMILA MQ2.