Meça a pressão com seu micro: bit: 5 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

O seguinte instrutível descreve um dispositivo fácil de construir e barato para realizar medições de pressão e demonstrar a lei de Boyle, usando o micro: bit em combinação com o sensor de pressão / temperatura BMP280.

Considerando que esta combinação seringa / sensor de pressão já foi descrita em um de meus instrutíveis anteriores, a combinação com o micro: bit está oferecendo novas oportunidades, por exemplo, para projetos de sala de aula.

Além disso, o número de descrições de aplicações nas quais o micro: bit é usado em combinação com um sensor acionado por I2C é bastante limitado até agora. Espero que este instrutível possa ser um ponto de partida para outros projetos.

O dispositivo permite realizar medições quantitativas de pressão atmosférica e exibir os resultados no array micro: bit LED ou em um computador conectado, para o posterior usando as funções de monitor serial ou plotter serial do IDE Arduino. Além disso, você tem um feedback tátil, pois vai empurrar ou puxar o êmbolo da seringa e, assim, sentir a potência necessária.

Por padrão, o display permite estimar a pressão pelo indicador de nível mostrado na matriz de LED. A plotadora serial do IDE do Arduino permite fazer o mesmo, mas com resolução muito melhor (veja o vídeo). Soluções mais elaboradas também estão disponíveis, por ex. na linguagem de processamento. Você também pode exibir os valores medidos precisos de pressão e temperatura na matriz de LED após pressionar os botões A ou B respectivamente, mas o monitor serial do IDE do Arduino é muito mais rápido, permitindo exibir os valores quase em tempo real.

Os custos totais e as habilidades técnicas necessárias para construir o dispositivo são bastante baixos, então poderia ser um bom projeto de sala de aula sob a supervisão de um professor. Além disso, o dispositivo pode ser uma ferramenta para projetos STEM com foco em física ou usado em outros projetos onde uma força ou peso deve ser transformado em um valor digital.

O princípio foi usado para construir um micro muito simples: bit dive-o-meter, um dispositivo para medir a profundidade do mergulho.

Adendo 27 de maio de 2018:

Como Pimoroni desenvolveu uma biblioteca MakeCode para o sensor BMP280, isso me deu a oportunidade de desenvolver um script a ser usado para o dispositivo descrito aqui. O script e o arquivo HEX correspondente podem ser encontrados na última etapa deste instrutível. Para usá-lo, basta carregar o arquivo HEX no seu micro: bit. Não há necessidade de software especial e você pode usar o editor MakeCode online para editar o script.

Etapa 1: Materiais Usados

• Um micro: bit, peguei o meu de Pimoroni - 13,50 libras esterlinas
• Conector Kitronic Edge para micro: bit - via Pimoroni - 5 GBP, Observação: Pimorini agora oferece um conector de borda amigável para placa de ensaio chamado pin: bit com pinos nas portas I2C.
• 2 x 2 tiras de cabeçalho de pino
• Bateria ou LiPo para o micro: bit (não necessário, mas útil), cabo da bateria com interruptor (aqui) - Pimoroni
• cabos jumper para conexão de sensores ao conector Edge
• cabos de jumper longos (!) para o sensor, pelo menos tão longos quanto a seringa,, f / f ou f / m
• Sensor de pressão e temperatura BMP280 - Banggood - 5 US $ por três unidades A faixa de medição para este sensor está entre 550 e 1537 hPa.
• Seringa cateter de plástico de 150 ml com gaxeta de borracha - Amazon ou lojas de ferragens e jardinagem - cerca de 2 - 3 US $
• cola quente / pistola de cola quente
• ferro de solda
• um computador com o Arduino IDE instalado

Etapa 2: Instruções de montagem

Soldar cabeçotes para a quebra do sensor BMP280.

Solde os dois cabeçotes de 2 pinos nos conectores do pino 19 e do pino 20 do conector Edge (veja a imagem).

Conecte o micro: bit ao conector Edge e ao seu computador.

Prepare o software e o micro: bit conforme descrito nas instruções do Adafruit micro: bit. Leia-os completamente.

Instale as bibliotecas necessárias para o Arduino IDE.

Abra o script BMP280 anexado em uma etapa posterior.

Conecte o sensor ao conector Edge. GND para 0V, VCC para 3V, SCL para pino 19, SDA para pino 20.

Faça upload do script para o micro: bit.

Verifique se o sensor fornece dados razoáveis, os valores de pressão devem ser em torno de 1020 hPa, exibidos no monitor serial. Nesse caso, verifique primeiro os cabos e as conexões, depois a instalação do software e corrija.

Desligue o micro: broca, remova o sensor.

Passe os cabos longos de ligação pela saída da seringa. No caso, você pode ter que alargar a abertura. Tenha cuidado para omitir que os cabos estão sendo danificados.

Conecte o sensor aos cabos jumper. Verifique se as conexões estão corretas e boas. Conecte ao micro: bit.

Verifique se o sensor está funcionando corretamente. Puxando os cabos com cuidado, mova o sensor para o topo da seringa.

Insira o êmbolo e mova-o um pouco além da posição de repouso desejada (100 ml).

Adicione cola quente na extremidade da saída da seringa e mova o êmbolo um pouco para trás. Verifique se a seringa está fechada hermeticamente, caso contrário, adicione mais cola quente. Deixe esfriar a cola quente.

Verifique novamente se o sensor está funcionando. Se você mover o êmbolo, os números no monitor serial e na exibição do micro: bit devem mudar.

Se necessário, você pode ajustar o volume da seringa apertando-a perto da gaxeta e movendo o êmbolo.

Etapa 3: um pouco de teoria e algumas medidas práticas

Com o dispositivo descrito aqui, você pode demonstrar a correlação de compressão e pressão em experimentos de física simples. Como a seringa vem com uma escala de "ml", até mesmo experimentos quantitativos são fáceis de realizar.

A teoria por trás disso: de acordo com a lei de Boyle, [Volume * Pressão] é um valor constante para um gás em uma determinada temperatura.

Isso significa que se você comprimir um determinado volume de gás N-vezes, ou seja, o volume final é 1 / N vezes do original, sua pressão aumentará N-vezes, como: P0 * V0 = P1 * V1 = cons t. Para mais detalhes, dê uma olhada no artigo da Wikipedia sobre leis de gás. Ao nível do mar, a pressão barométrica está geralmente na faixa de 1010 hPa (hecto Pascal).

Portanto, começando em pontos de repouso de, por exemplo, V0 = 100 ml e P0 = 1000 hPa, uma compressão do ar para cerca de 66 ml (ou seja, V1 = 2/3 * V0) resultará em uma pressão de cerca de 1500 hPa (P1 = 3/2 de P0). Puxar o êmbolo para 125 ml (5/4 vezes o volume) resulta em uma pressão de cerca de 800 hPa (4/5 de pressão). As medições são surpreendentemente precisas para um dispositivo tão simples.

O dispositivo permite que você tenha uma impressão háptica direta de quanta força é necessária para comprimir ou expandir a quantidade relativamente pequena de ar na seringa.

Mas também podemos realizar alguns cálculos e verificá-los experimentalmente. Suponha que comprimimos o ar a 1500 hPa, a uma pressão barométrica basal de 1000 hPa. Portanto, a diferença de pressão é 500 hPa, ou 50.000 Pa. Para minha seringa, o diâmetro (d) do pistão é cerca de 4 cm ou 0,04 metro.

Agora você pode calcular a força necessária para manter o pistão nessa posição. Dado P = F / A (pressão é força dividida pela área), ou transformado F = P * A. A unidade SI para força é "Newton" N, para comprimento "Metro" m, e 1 Pa é 1N por metro quadrado. Para um pistão redondo, a área pode ser calculada usando A = ((d / 2) ^ 2) * pi, o que dá 0,00125 metros quadrados para minha seringa. Então

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

Na Terra, 1 N se correlaciona com um peso de 100 gr, então 63 N são iguais a sustentar um peso de 6,3 kg.

Isso pode ser verificado facilmente usando uma escala. Empurre a seringa com o êmbolo na escala, até que uma pressão de cerca de 1500 hPa seja atingida, então leia a escala. Ou pressione até que a balança mostre cerca de 6-7 kg e, em seguida, pressione o botão "A" e leia o valor exibido na matriz de LED micro: bit. No final das contas, a estimativa com base nos cálculos acima não era ruim. Uma pressão ligeiramente acima de 1500 hPa correlacionada a um "peso" exibido de cerca de 7 kg em uma balança corporal (ver imagens). Você também pode inverter esse conceito e usar o dispositivo para construir uma escala digital simples com base em medições de pressão.

Esteja ciente de que o limite superior do sensor é de cerca de 1540 hPa, portanto, qualquer pressão acima disso não pode ser medida e pode danificar o sensor.

Além de propósitos educacionais, pode-se também usar o sistema para algumas aplicações do mundo real, pois permite medir quantitativamente as forças que estão tentando mover o êmbolo para um lado ou para o outro. Portanto, você pode medir um peso colocado no êmbolo ou uma força de impacto que atinge o êmbolo. Ou construa um interruptor que ative uma luz ou campainha ou toque um som depois que um determinado valor limite for atingido. Ou você pode construir um instrumento musical que muda a frequência dependendo da força da força aplicada ao êmbolo. Ou use-o como um controlador de jogo. Use sua imaginação e jogue!

Etapa 4: o script MicroPython

Em anexo você encontra meu script BMP280 para o micro: bit. É um derivado de um script BMP / BME280 que encontrei em algum lugar do site Banggood, combinado com a biblioteca Microbit de Adafruit. O primeiro permite que você use o sensor Banggood, o segundo simplifica o manuseio do display LED 5x5. Meus agradecimentos aos desenvolvedores de ambos.

Por padrão, o script exibe os resultados das medições de pressão em 5 etapas no display de LED 5x5 do micro: bit, permitindo ver as alterações com pouco atraso. Os valores precisos podem ser exibidos em paralelo no monitor serial do IDE do Arduino, ou um gráfico mais detalhado pode ser exibido no plotter seral do IDE do Arduino.

Se você pressionar o botão A, os valores de pressão medidos são exibidos no arranjo de LEDs 5x5 do micro: bit. Se você pressionar o botão B, os valores de temperatura serão exibidos. Embora isso permita a leitura de dados precisos, diminui significativamente os ciclos de medição.

Tenho certeza de que existem maneiras muito mais elegantes de programar as tarefas e melhorar o script. Qualquer ajuda é bem vinda.

#include xxx

#include Adafruit_Microbit_Matrix microbit; #define BME280_ADDRESS 0x76 unsigned long int hum_raw, temp_raw, pres_raw; assinado longo 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; // recipientes para valores medidos int value0; int value1; int value2; int value3; int value4; // ------------------------------------------------ -------------------------------------------------- ------------------ void setup () {uint8_t osrs_t = 1; // Sobreamostragem de temperatura x 1 uint8_t osrs_p = 1; // Sobreamostragem de pressão x 1 uint8_t osrs_h = 1; // Sobreamostragem de umidade x 1 uint8_t mode = 3; // Modo normal uint8_t t_sb = 5; // Tstandby 1000ms uint8_t filter = 0; // Filtrar uint8_t spi3w_en = 0; // Desativar SPI de 3 fios uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | modo; uint8_t config_reg = (t_sb << 5) | (filtro << 2) | spi3w_en; uint8_t ctrl_hum_reg = osrs_h; pinMode (PIN_BUTTON_A, INPUT); pinMode (PIN_BUTTON_B, INPUT); Serial.begin (9600); // Serial.println ("Temperatura [deg C]"); // Serial.print ("\ t"); Serial.print ("Pressão [hPa]"); // cabeçalho Wire.begin (); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); readTrim (); // microbit.begin (); // microbit.print ("x"); atraso (1000); } // ----------------------------------------------- -------------------------------------------------- -------- void loop () {double temp_act = 0,0, press_act = 0,0, hum_act = 0,0; assinado longo int temp_cal; sem sinal longo int press_cal, hum_cal; int N; // definir valores de limite para exibição de matriz de LED, em hPa double max_0 = 1100; duplo max_1 = 1230; máximo duplo_2 = 1360; duplo max_3 = 1490; readData (); temp_cal = calibração_T (temp_raw); press_cal = calibração_P (pres_raw); hum_cal = calibração_H (hum_raw); temp_act = (duplo) temp_cal / 100,0; press_act = (duplo) press_cal / 100.0; hum_act = (duplo) hum_cal / 1024.0; microbit.clear (); // redefine a matriz de 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)) {// exibir valores em números atrasa a medição de círculos 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 {// exibindo os valores de pressão como pixels ou linhas em um determinado nível // 5 etapas: 1490 hPa // limites definidos pelos valores max_n if (press_act> max_3) {(N = 0); // linha superior} else if (press_act> max_2) {(N = 1); } else if (press_act> max_1) {(N = 2); } else if (press_act> max_0) {(N = 3); } else {(N = 4); // linha de base} // Serial.println (N); // para fins de desenvolvimento // microbit.print (N); // como linha // microbit.drawLine (N, 0, 0, 4, LED_ON); // muda os valores para a próxima linha value4 = value3; valor3 = valor2; valor2 = valor1; valor1 = valor0; valor0 = N; // desenhar imagem, coluna por coluna microbit.drawPixel (0, valor0, LED_ON); // como Pixel: coluna, linha. 0, 0 canto superior esquerdo microbit.drawPixel (1, valor1, LED_ON); microbit.drawPixel (2, valor2, LED_ON); microbit.drawPixel (3, valor3, LED_ON); microbit.drawPixel (4, valor4, LED_ON); } // enviar dados para monitor serial e plotter serial // Serial.println (press_act); // envia valor (es) para a porta serial para exibição numérica, opcional

Serial.print (press_act); // envia o valor para a porta serial do plotter

// desenha as linhas do indicador e fixa o intervalo exibido Serial.print ("\ t"); Serial.print (600); Serial.print ("\ t"); Serial.print (1100), Serial.print ("\ t"); Serial.println (1600); atraso (200); // Meça três vezes por segundo} // ---------------------------------------- -------------------------------------------------- -------------------------------------------------- - // o seguinte é necessário para o sensor bmp / bme280, mantenha como é void readTrim () {uint8_t data [32], i = 0; // Fix 2014 / Wire.beginTransmission (BME280_ADDRESS); Wire.write (0x88); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 24); // Correção de 2014 / while (Wire.available ()) {data = Wire.read (); i ++; } Wire.beginTransmission (BME280_ADDRESS); // Adicionar 2014 / Wire.write (0xA1); // Adicionar 2014 / Wire.endTransmission (); // Adicionar 2014 / Wire.requestFrom (BME280_ADDRESS, 1); // Adicionar 2014 / data = Wire.read (); // Adicionar 2014 / i ++; // Adicionar 2014 / Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xE1); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 7); // Correção de 2014 / while (Wire.available ()) {data = Wire.read (); i ++; } dig_T1 = (dados [1] << 8) | dados [0]; dig_P1 = (dados [7] << 8) | dados [6]; dig_P2 = (dados [9] << 8) | dados [8]; dig_P3 = (dados [11] << 8) | dados [10]; dig_P4 = (dados [13] << 8) | dados [12]; dig_P5 = (dados [15] << 8) | dados [14]; dig_P6 = (dados [17] << 8) | dados [16]; dig_P7 = (dados [19] << 8) | dados [18]; dig_T2 = (dados [3] << 8) | dados [2]; dig_T3 = (dados [5] << 8) | dados [4]; dig_P8 = (dados [21] << 8) | dados [20]; dig_P9 = (dados [23] << 8) | dados [22]; dig_H1 = dados [24]; dig_H2 = (dados [26] << 8) | dados [25]; dig_H3 = dados [27]; dig_H4 = (dados [28] << 4) | (0x0F e dados [29]); dig_H5 = (dados [30] 4) & 0x0F); // Fix 2014 / dig_H6 = data [31]; // Corrige 2014 /} void writeReg (uint8_t reg_address, uint8_t data) {Wire.beginTransmission (BME280_ADDRESS); Wire.write (reg_address); Wire.write (dados); Wire.endTransmission (); }

void readData ()

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

calibração int longo com sinal_T (adc_T int longo assinado)

{int longo assinado var1, var2, T; var1 = ((((adc_T >> 3) - ((int longo assinado) dig_T1 11; var2 = (((((adc_T >> 4) - ((int longo assinado) dig_T1)) * ((adc_T >> 4) - ((int longo assinado) dig_T1))) >> 12) * ((int longo assinado) dig_T3)) >> 14; t_fino = var1 + var2; T = (t_fino * 5 + 128) >> 8; retornar T;} calibração int longo sem sinal_P (int longo assinado_p_P) {int longo assinado var1, var2; int longo não assinado P; var1 = (((int longo assinado) t_fino) >> 1) - (int longo assinado) 64000; var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((int longo assinado) dig_P6); var2 = var2 + ((var1 * ((int longo assinado) dig_P5)) 2) + (((int longo assinado) dig_P4) 2) * (var1 >> 2)) >> 13)) >> 3) + ((((int longo assinado) dig_P2) * var1) >> 1)) >> 18; var1 = ((((32768 + var1)) * ((int longo assinado) dig_P1)) >> 15); if (var1 == 0) {return 0; } P = (((int longo sem sinal) (((int longo assinado) 1048576) -adc_P) - (var2 >> 12))) * 3125; if (P <0x80000000) {P = (P << 1) / ((int longo sem sinal) var1); } else {P = (P / (int longo sem sinal) var1) * 2; } var1 = (((int longo com sinal) dig_P9) * ((int longo com sinal) (((P >> 3) * (P >> 3)) >> 13))) >> 12; var2 = (((int longo assinado) (P >> 2)) * ((int longo assinado) dig_P8)) >> 13; P = (int longo sem sinal) ((int longo assinado) P + ((var1 + var2 + dig_P7) >> 4)); return P; } sem sinal longo int calibração_H (assinado longo int adc_H) {assinado longo int v_x1; v_x1 = (t_fine - ((int longo assinado) 76800)); v_x1 = (((((adc_H << 14) - ((((int longo assinado) dig_H4) 15) * ((((((((v_x1) * ((int longo assinado) dig_H6)) >> 10) * (((v_x1 * ((int longo assinado) dig_H3)) >> 11) + ((int longo assinado) 32768))) >> 10) + ((int longo assinado) 2097152)) * ((int longo assinado) dig_H2) + 8192) >> 14)); v_x1 = (v_x1 - (((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((int longo assinado) dig_H1)) >> 4)); v_x1 = (v_x1 419430400? 419430400: v_x1); return (int longo sem sinal) (v_x1 >> 12);}

Etapa 5: Scripts MakeCode / JavaScript

A Pimoroni lançou recentemente o enviro: bit, que vem com um sensor de pressão BMP280, um sensor de luz / cor e um microfone MEMS. Eles também oferecem uma biblioteca MicroPython e uma biblioteca MakeCode / JavaScript.

Usei o último para escrever um script MakeCode para o sensor de pressão. O arquivo hexadecimal correspondente pode ser copiado diretamente para o seu micro: bit. O código é exibido abaixo e pode ser modificado usando o editor MakeCode online.

É uma variação do script do micro: bit dive-o-meter. Por padrão, ele exibe a diferença de pressão como um gráfico de barras. Pressionar o botão A define a pressão de referência, pressionar o botão B exibe a diferença entre a pressão real e a pressão de referência em hPa.

Além da versão básica do código de barras, você também encontra uma versão em "X", versão em cruz e uma versão em "L", para facilitar a leitura.

deixe Coluna = 0

deixe permanecer = 0 deixe Row = 0 deixe Meter = 0 deixe Delta = 0 deixe Ref = 0 deixe 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) se (Medidor> = 400) {Linha = 4} else if (Medidor> = 300) {Linha = 3} else if (Medidor> = 200) {Linha = 2} else if (Medidor> = 100) {Linha = 1} senão {Linha = 0} permanece = Medidor - Linha * 100 se (permanecer> = 80) {Coluna = 4} senão se (permanecer> = 60) {Coluna = 3} senão se (permanecer> = 40) {Coluna = 2 } else if (permanecer> = 20) {Coluna = 1} else {Coluna = 0} para (deixe ColA = 0; ColA <= Coluna; ColA ++) {led.plot (ColA, Linha)} basic.pause (500)}})