Misura la pressione con il tuo Micro:bit: 5 passaggi (con immagini)

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

La seguente istruzione descrive un dispositivo facile da costruire ed economico per eseguire misurazioni di pressione e dimostrare la legge di Boyle, utilizzando il micro:bit in combinazione con il sensore di pressione/temperatura BMP280.

Mentre questa combinazione siringa/sensore di pressione è già stata descritta in una delle mie precedenti istruzioni, la combinazione con il micro: bit offre nuove opportunità, ad es. per progetti in classe.

Inoltre, il numero di descrizioni delle applicazioni in cui il micro:bit viene utilizzato in combinazione con un sensore guidato da I2C è finora piuttosto limitato. Spero che questo tutorial possa essere un punto di partenza per altri progetti.

Il dispositivo consente di eseguire misurazioni quantitative della pressione dell'aria e di visualizzare i risultati sull'array di LED micro:bit o su un computer collegato, per poi utilizzare le funzioni di monitor seriale o plotter seriale dell'IDE Arduino. Inoltre hai un feedback tattile, poiché spingerai o tirerai da solo lo stantuffo della siringa, e in questo modo sentirai la potenza richiesta.

Per impostazione predefinita, il display consente di stimare la pressione tramite l'indicatore di livello mostrato sulla matrice di LED. Il plotter seriale dell'IDE Arduino permette di fare lo stesso, ma con una risoluzione molto migliore (vedi video). Sono disponibili anche soluzioni più elaborate, ad es. nella lingua di elaborazione. È anche possibile visualizzare i valori precisi misurati di pressione e temperatura sulla matrice LED dopo aver premuto rispettivamente i pulsanti A o B, ma il monitor seriale dell'IDE Arduino è molto più veloce, consentendo di visualizzare i valori quasi in tempo reale.

I costi totali e le competenze tecniche necessarie per costruire il dispositivo sono piuttosto bassi, quindi potrebbe essere un bel progetto in classe sotto la supervisione di un insegnante. Inoltre il dispositivo potrebbe essere uno strumento per progetti STEM incentrati sulla fisica o utilizzato in altri progetti in cui una forza o un peso devono essere trasformati in un valore digitale.

Il principio è stato utilizzato per costruire un micro:bit dive-o-meter molto semplice, un dispositivo per misurare la profondità di immersione.

Addendum 27 maggio 2018:

Poiché Pimoroni ha sviluppato una libreria MakeCode per il sensore BMP280, questo mi ha dato l'opportunità di sviluppare uno script da utilizzare per il dispositivo qui descritto. Lo script e il file HEX corrispondente possono essere trovati nell'ultimo passaggio di questa istruzione. Per usarlo, basta caricare il file HEX sul tuo micro:bit. Non è necessario un software speciale e puoi utilizzare l'editor MakeCode online per modificare lo script.

Passaggio 1: materiali usati

• Un micro:bit, ho preso il mio da Pimoroni - 13.50 GBP
• Kitronic Edge Connector per micro:bit - via Pimoroni - 5 GBP, Nota: Pimorini ora offre un connettore edge compatibile con breadboard chiamato pin:bit con pin sulle porte I2C.
• Strisce di intestazione 2 x 2 pin
• Batteria o LiPo per il micro:bit (non necessario, ma utile), cavo batteria con interruttore (dito) - Pimoroni
• cavi jumper per il collegamento dei sensori al connettore Edge
• cavi jumper lunghi (!) per il sensore, lunghi almeno quanto la siringa,, f/f o f/m
• Sensore di pressione e temperatura BMP280 - Banggood - 5 US$ per tre unità L'intervallo di misurazione per questo sensore è compreso tra 550 e 1537 hPa.
• Siringa per catetere in plastica da 150 ml con guarnizione in gomma - Amazon o negozi di ferramenta e giardinaggio - circa 2 - 3 US$
• colla a caldo/pistola per colla a caldo
• saldatore
• un computer con l'IDE Arduino installato

Passaggio 2: istruzioni di montaggio

Saldare le intestazioni al breakout del sensore BMP280.

Saldare le due intestazioni a 2 pin ai connettori pin 19 e pin 20 del connettore Edge (vedi immagine).

Collega il micro:bit al connettore Edge e al tuo computer.

Preparare il software e il micro:bit come descritto nelle istruzioni micro:bit di Adafruit. Leggili bene.

Installa le librerie richieste nell'IDE di Arduino.

Aprire lo script BMP280 allegato in un passaggio successivo.

Collegare il sensore al connettore Edge. GND su 0V, VCC su 3V, SCL su pin 19, SDA su pin 20.

Carica lo script nel micro:bit.

Verificare che il sensore fornisca dati ragionevoli, i valori di pressione dovrebbero essere intorno a 1020 hPa, visualizzati sul monitor seriale. Nel caso, controllare prima i cavi e le connessioni, quindi l'installazione del software e correggere.

Spegni il micro:bit, rimuovi il sensore.

Far passare i cavi lunghi attraverso l'uscita della siringa. Nel caso in cui potrebbe essere necessario allargare l'apertura. Fare attenzione a non danneggiare i cavi.

Collegare il sensore ai cavi jumper. Verificare che i collegamenti siano corretti e buoni. Connettiti al micro:bit.

Verificare che il sensore funzioni correttamente. Tirando con cautela i cavi, spostare il sensore sulla parte superiore della siringa.

Inserire lo stantuffo e spostarlo leggermente oltre la posizione di riposo desiderata (100 ml).

Aggiungi la colla a caldo all'estremità dell'uscita della siringa e sposta leggermente indietro lo stantuffo. Controlla se la siringa è chiusa ermeticamente, altrimenti aggiungi altra colla a caldo. Lascia raffreddare la colla a caldo.

Controlla di nuovo che il sensore funzioni. Se si sposta lo stantuffo, i numeri nel monitor seriale e nel display del micro:bit dovrebbero cambiare.

Se necessario, è possibile regolare il volume nella siringa premendola vicino alla guarnizione e spostando lo stantuffo.

Passaggio 3: un po' di teoria e alcune misurazioni pratiche

Con il dispositivo qui descritto, puoi dimostrare la correlazione tra compressione e pressione in semplici esperimenti di fisica. Poiché la siringa è dotata di una scala "ml", anche gli esperimenti quantitativi sono facili da eseguire.

La teoria alla base: secondo la legge di Boyle, [Volume * Pressure] è un valore costante per un gas a una data temperatura.

Ciò significa che se si comprime un dato volume di gas N volte, cioè il volume finale è 1/N volte dell'originale, la sua pressione aumenterà di N volte, come: P0*V0=P1*V1= cons t. Per maggiori dettagli, dai un'occhiata all'articolo di Wikipedia sulle leggi sul gas. A livello del mare, la pressione barometrica è solitamente nell'intervallo di 1010 hPa (hecto Pascal).

Quindi, partendo da punti di riposo, ad es. V0=100 ml e P0=1000 hPa, una compressione dell'aria a circa 66 ml (cioè V1 = 2/3 * V0) risulterà in una pressione di circa 1500 hPa (P1= 3/2 di P0). Tirando lo stantuffo a 125 ml (5/4 di volume) si ottiene una pressione di circa 800 hPa (4/5 di pressione). Le misurazioni sono sorprendentemente precise per un dispositivo così semplice.

Il dispositivo consente di avere un'impressione tattile diretta di quanta forza è necessaria per comprimere o espandere la quantità relativamente piccola di aria nella siringa.

Ma possiamo anche eseguire alcuni calcoli e verificarli sperimentalmente. Supponiamo di comprimere l'aria a 1500 hPa, ad una pressione barometrica basale di 1000 hPa. Quindi la differenza di pressione è 500 hPa, o 50.000 Pa. Per la mia siringa, il diametro (d) del pistone è di circa 4 cm o 0,04 metri.

Ora puoi calcolare la forza necessaria per mantenere il pistone in quella posizione. Dato P = F/A (la pressione è la forza divisa per l'area), o trasformata F = P*A. L'unità SI per la forza è "Newton" N, per la lunghezza "Metro" me 1 Pa è 1N per metro quadrato. Per un pistone tondo, l'area può essere calcolata usando A = ((d/2)^2)*pi, che dà 0,00125 metri quadrati per la mia siringa. Così

50.000 Pa * 0,00125 m^2 = 63 N.

Sulla Terra, 1 N è correlato a un peso di 100 gr, quindi 63 N equivalgono a sostenere un peso di 6,3 kg.

Questo può essere facilmente verificato utilizzando una scala. Spingere la siringa con lo stantuffo sulla bilancia, fino a raggiungere una pressione di circa 1500 hPa, quindi leggere la scala. Oppure premere fino a quando la bilancia non mostra circa 6-7 kg, quindi premere il pulsante "A" e leggere il valore visualizzato sulla matrice LED del micro:bit. Come si è scoperto, la stima basata sui calcoli di cui sopra non era male. Una pressione leggermente superiore a 1500 hPa era correlata ad un "peso" visualizzato di circa 7 kg su una bilancia pesapersone (vedi immagini). Potresti anche capovolgere questo concetto e utilizzare il dispositivo per costruire una semplice bilancia digitale basata sulle misurazioni della pressione.

Tenere presente che il limite superiore per il sensore è di circa 1540 hPa, quindi qualsiasi pressione al di sopra di questo non può essere misurata e potrebbe danneggiare il sensore.

Oltre a scopi didattici, si può anche utilizzare il sistema per alcune applicazioni del mondo reale, poiché consente di misurare quantitativamente le forze che stanno cercando di spostare lo stantuffo in un modo o nell'altro. Quindi potresti misurare un peso posizionato sullo stantuffo o una forza d'impatto che colpisce lo stantuffo. Oppure costruisci un interruttore che attivi una luce o un cicalino o emetta un suono dopo che è stato raggiunto un determinato valore di soglia. Oppure potresti costruire uno strumento musicale che cambia la frequenza a seconda della forza della forza applicata allo stantuffo. Oppure usalo come controller di gioco. Usa la tua immaginazione e gioca!

Passaggio 4: lo script MicroPython

In allegato trovate il mio script BMP280 per il micro:bit. È un derivato di uno script BMP/BME280 che ho trovato da qualche parte sul sito web di Banggood, combinato con la libreria Microbit di Adafruit. Il primo permette di utilizzare il sensore Banggood, il secondo semplifica la gestione del display LED 5x5. I miei ringraziamenti vanno agli sviluppatori di entrambi.

Per impostazione predefinita, lo script visualizza i risultati delle misurazioni della pressione in 5 passaggi sul display LED 5x5 del micro:bit, consentendo di vedere i cambiamenti con poco ritardo. I valori precisi possono essere visualizzati in parallelo sul monitor seriale Arduino IDE, oppure un grafico più dettagliato può essere visualizzato sul plotter serale dell'IDE Arduino.

Se si preme il pulsante A, i valori di pressione misurati vengono visualizzati sull'array LED 5x5 del micro:bit. Premendo il tasto B vengono visualizzati i valori di temperatura. Mentre questo permette di leggere i dati precisi, rallenta notevolmente i cicli di misura.

Sono sicuro che ci sono modi molto più eleganti per programmare le attività e migliorare lo script. Qualsiasi aiuto è benvenuto.

#include xxx

#include Adafruit_Microbit_Matrix microbit; #define BME280_ADDRESS 0x76 unsigned long int hum_raw, temp_raw, pres_raw; firmato long int t_fine; uint16_t dig_T1; int16_t dig_T2; int16_t dig_T3; uint16_t dig_P1; int16_t dig_P2; int16_t dig_P3; int16_t dig_P4; int16_t dig_P5; int16_t dig_P6; int16_t dig_P7; int16_t dig_P8; int16_t dig_P9; int8_t dig_H1; int16_t dig_H2; int8_t dig_H3; int16_t dig_H4; int16_t dig_H5; int8_t dig_H6; // contenitori per valori misurati int value0; int valore1; valore int2; valore int3; valore int4; //------------------------------------------------ --------------------------------------------------- ------------------ void setup() { uint8_t osrs_t = 1; //Sovracampionamento della temperatura x 1 uint8_t osrs_p = 1; //Sovracampionamento della pressione x 1 uint8_t osrs_h = 1; //Sovracampionamento dell'umidità x 1 uint8_t mode = 3; //Modalità normale uint8_t t_sb = 5; //Tstandby 1000ms uint8_t filter = 0; //Filtra uint8_t spi3w_en = 0; // Disabilita SPI a 3 fili uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | modalità; uint8_t config_reg = (t_sb << 5) | (filtro << 2) | spi3w_it; uint8_t ctrl_hum_reg = osrs_h; pinMode(PIN_BUTTON_A, INPUT); pinMode(PIN_BUTTON_B, INPUT); Serial.begin(9600); // Serial.println("Temperatura [gradi C]"); // Serial.print("\t"); Serial.print("Pressione [hPa] "); // header Wire.begin(); writeReg(0xF2, ctrl_hum_reg); writeReg(0xF4, ctrl_meas_reg); writeReg(0xF5, config_reg); leggiTrim(); // microbit.begin(); // microbit.print("x"); ritardo (1000); } //------------------- --------------------------------------------------- -------- void loop() { double temp_act = 0.0, press_act = 0.0, hum_act=0.0; firmato long int temp_cal; unsigned long int press_cal, hum_cal; int N; // imposta i valori di soglia per il display a matrice di LED, in hPa double max_0 = 1100; doppio max_1 = 1230; doppio max_2 = 1360; doppio max_3 = 1490; readData(); temp_cal = calibrazione_T(temp_raw); press_cal = calibrazione_P(pres_raw); hum_cal = calibrazione_H(hum_raw); temp_act = (doppio)temp_cal / 100.0; press_act = (doppio)press_cal / 100.0; hum_act = (doppio)hum_cal / 1024.0; microbit.clear(); //reset matrice LED /* Serial.print ("PRESS: "); Serial.println(press_act); Serial.print(" hPa "); Serial.print("TEMP: "); Serial.print("\t"); Serial.println(temp_act); */ if (! digitalRead(PIN_BUTTON_B)) { // la visualizzazione dei valori in numeri ritarda la misurazione dei cerchi microbit.print("T: "); microbit.print(temp_act, 1); microbit.print(" 'C"); // Serial.println(""); }else if (! digitalRead(PIN_BUTTON_A)) { microbit.print("P: "); microbit.print(press_act, 0); microbit.print("hPa"); }else{ // visualizza i valori di pressione come pixel o linee in un certo livello // 5 step: 1490 hPa // soglie definite dai valori max_n if (press_act > max_3){ (N=0); // riga superiore } else if (press_act > max_2){ (N=1); } else if (press_act > max_1){ (N=2); } else if (press_act > max_0){ (N=3); } altrimenti { (N=4); // riga base } // Serial.println(N); // per scopi di sviluppo // microbit.print(N); // as Line // microbit.drawLine(N, 0, 0, 4, LED_ON); // sposta i valori alla riga successiva value4 = value3; valore3 = valore2; valore2 = valore1; valore1 = valore0; valore0 = N; // disegna l'immagine, colonna per colonna microbit.drawPixel(0, value0, LED_ON); // come Pixel: colonna, riga. 0, 0 in alto a sinistra microbit.drawPixel(1, value1, LED_ON); microbit.drawPixel(2, valore2, LED_ON); microbit.drawPixel(3, valore3, LED_ON); microbit.drawPixel(4, valore4, LED_ON); } // invia i dati al monitor seriale e al plotter seriale // Serial.println(press_act); // invia i valori alla porta seriale per la visualizzazione numerica, opzionale

Serial.print(press_act); // invia il valore alla porta seriale per il plotter

// disegna linee indicatrici e corregge l'intervallo visualizzato Serial.print("\t"); Serial.print(600); Serial.print("\t"); Serial.print(1100), Serial.print("\t"); Serial.println(1600); ritardo(200); // Misura tre volte al secondo } //------------------------------------------------------- --------------------------------------------------- --------------------------------------------------- -- // quanto segue è richiesto per il sensore bmp/bme280, tienilo così com'è void readTrim() { uint8_t data[32], i=0; // Correzione 2014/Wire.beginTransmission(BME280_ADDRESS); Wire.write(0x88); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 24); // Correzione 2014/while(Wire.available()){ data = Wire.read(); io++; } Wire.beginTransmission(BME280_ADDRESS); // Aggiungi 2014/Wire.write(0xA1); // Aggiungi 2014/Wire.endTransmission(); // Aggiungi 2014/Wire.requestFrom(BME280_ADDRESS, 1); // Aggiungi 2014/data = Wire.read(); // Aggiungi 2014/i++; // Aggiungi 2014/Wire.beginTransmission(BME280_ADDRESS); Wire.write(0xE1); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 7); // Correzione 2014/while(Wire.available()){ data = Wire.read(); io++; } dig_T1 = (data[1] << 8) | dati[0]; dig_P1 = (data[7] << 8) | dati[6]; dig_P2 = (data[9] << 8) | dati[8]; dig_P3 = (data[11]<< 8) | dati[10]; dig_P4 = (data[13]<< 8) | dati[12]; dig_P5 = (data[15]<< 8) | dati[14]; dig_P6 = (data[17]<< 8) | dati[16]; dig_P7 = (data[19]<< 8) | dati[18]; dig_T2 = (data[3] << 8) | dati[2]; dig_T3 = (data[5] << 8) | dati[4]; dig_P8 = (data[21]<< 8) | dati[20]; dig_P9 = (data[23]<< 8) | dati[22]; dig_H1 = dati[24]; dig_H2 = (data[26]<< 8) | dati[25]; dig_H3 = dati[27]; dig_H4 = (data[28]<< 4) | (0x0F & dati[29]); dig_H5 = (data[30] 4) & 0x0F); // Fix 2014/dig_H6 = data[31]; // Fix 2014/} void writeReg(uint8_t reg_address, uint8_t data) { Wire.beginTransmission(BME280_ADDRESS); Wire.write(reg_address); Wire.write(dati); Wire.endTransmission(); }

void readData()

{ int io = 0; uint32_t dati[8]; Wire.beginTransmission(BME280_ADDRESS); Wire.write(0xF7); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 8); while(Wire.available()){ data = Wire.read(); io++; } pres_raw = (data[0] << 12) | (dati[1] 4); temp_raw = (data[3] << 12) | (dati[4] 4); hum_raw = (data[6] << 8) | dati[7]; }

firmato long int calibrazione_T(signed long int adc_T)

{ con segno lungo int var1, var2, T; var1 = ((((adc_T >> 3) - ((signed long int)dig_T1 11; var2 = ((((adc_T >> 4) - ((signed long int)dig_T1)) * ((adc_T>>4) - ((signed long int)dig_T1))) >> 12) * ((signed long int)dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; return T; } unsigned long int calibrazione_P(signed long int adc_P) { firmato long int var1, var2; unsigned long int P; var1 = (((signed long int)t_fine)>>1) - (signed long int)64000; var2 = (((var1>>2) * (var1>>2)) >> 11) * ((signed long int)dig_P6); var2 = var2 + ((var1*((signed long int)dig_P5))2) +(((signed long int)dig_P4)2)*(var1>>2)) >> 13)) >>3) + ((((signed long int)dig_P2) * var1)>>1))>> 18; var1 = ((((32768+var1))*((signed long int)dig_P1))>>15); if (var1 == 0) { return 0; } P = (((unsigned long int)(((signed long int)1048576)-adc_P)-(var2>>12)))*3125; if(P<0x80000000) { P = (P <<1) / ((unsigned long int) var1); } else { P = (P / (unsigned long int)var1) * 2; } var1 = (((signed long int)dig_P9) * ((signed long int)(((P>>3) * (P>>3))>>13)))>>12; var2 = (((signed long int)(P>>2)) * ((signed long int)dig_P8))>>13; P = (unsigned long int)((signed long int)P + ((var1 + var2 + dig_P7) >> 4)); ritorno P; } unsigned long int calibrazione_H(signed long int adc_H) { firmato long int v_x1; v_x1 = (t_fine - ((signed long int)76800)); v_x1 = (((((adc_H << 14) -(((signed long int)dig_H4) 15)) * ((((((v_x1 * ((signed long int)dig_H6))) >> 10) * (((v_x1 * ((signed long int)dig_H3)) >> 11) + ((signed long int) 32768))) >> 10) + ((signed long int)2097152)) * ((signed long int) dig_H2) + 8192) >> 14)); v_x1 = (v_x1 - ((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((signed long int)dig_H1)) >> 4)); v_x1 = (v_x1 419430400 ? 419430400: v_x1); return (unsigned long int)(v_x1 >> 12); }

Passaggio 5: script MakeCode/JavaScript

Pimoroni ha recentemente rilasciato l'enviro:bit, che viene fornito con un sensore di pressione BMP280, un sensore di luce/colore e un microfono MEMS. Offrono anche una libreria MicroPython e MakeCode/JavaScript.

Ho usato il successivo per scrivere uno script MakeCode per il sensore di pressione. Il file esadecimale corrispondente può essere copiato direttamente sul tuo micro:bit. Il codice viene visualizzato di seguito e può essere modificato utilizzando l'editor MakeCode online.

È una variazione dello script per il micro:bit dive-o-meter. Per impostazione predefinita, visualizza la differenza di pressione sotto forma di grafico a barre. Premendo il pulsante A si imposta la pressione di riferimento, premendo il pulsante B viene visualizzata la differenza tra la pressione effettiva e quella di riferimento in hPa.

Oltre alla versione base del codice a barre trovi anche una versione "X", mirino e una versione "L", pensata per facilitare la lettura.

let Colonna = 0

let stay = 0 let Row = 0 let Meter = 0 let Delta = 0 let Ref = 0 let Is = 0 Is = 1012 basic.showLeds(` # # # # # #… # #. #. # #.. # # # # # # `) Ref = 1180 basic.clearScreen() basic.forever(() => { basic.clearScreen() if (input.buttonIsPressed(Button. A)) { Ref = envirobit.getPressure() basic.showLeds(` #. #. #. #. #. # # # # #. #. #. #. #. # `) basic.pause(1000) } else if (input.buttonIsPressed(Button. B)) { basic.showString("" + Delta + " hPa") basic.pause(200) basic.clearScreen() } else { Is = envirobit.getPressure() Delta = Is - Ref Meter = Math.abs(Delta) if (Metro >= 400) { Riga = 4 } else if (Metro >= 300) { Riga = 3 } else if (Metro >= 200) { Riga = 2 } else if (Metro >= 100) { Riga = 1 } else { Riga = 0 } stay = Metro - Riga * 100 if (rimane >= 80) { Colonna = 4 } else if (rimane >= 60) { Colonna = 3 } else if (rimane >= 40) { Colonna = 2 } else if (rimane >= 20) { Colonna = 1 } else { Colonna = 0 } for (let ColA = 0; ColA <= Colonna; ColA++) { led.plot(ColA, Row) } basic.pause(500) } })