Bmp180 se conectează la arduino. Conectarea senzorului BMP180 la Arduino

#include #include // Declarați o variabilă pentru a accesa SFE_BMP180: SFE_BMP180 presiune; #define ALTITUDE 1655.0 // înălțimea deasupra nivelului mării la trucul în metri void setup () (Serial.begin (9600); Serial.println ("REBOOT"); // inițializare dacă (pressure.begin ()) Serial. println ("BMP180 init ok"); else (// Dacă ceva nu a crescut împreună aici. De regulă, jamburile cu conexiunea Serial.println ("BMP180 init fail \ n \ n"); while (1); / / hang) ) void loop () (starea char; dublu T, P, p0, a; // Dacă doriți să aflați presiunea aerului corectată la nivelul mării, care este de obicei folosită în prognozele meteo // Trebuie să cunoașteți marea nivelul din zona dvs. unde se măsoară // Trebuie specificat în constanta ALTITUDINE la începutul codului Serial.println (); Serial.print ("Nivelul mării:"); Serial.print (ALTITUDINE, 0); Serial. print ("metri,"); Serial .print (ALTITUDINE * 3.28084,0); Serial.println ("picioare"); // Dacă doriți să aflați altitudinea deasupra nivelului mării, dar știți presiunea // de care aveți nevoie pentru a indica presiunea atmosferică actuală. Cum se face acest lucru este scris la sfârșitul codului ... // Deoarece presiunea depinde oarecum lateral de temperatură, mai întâi trebuie să aflați temperatura // BMP180 are un termometru încorporat. Este nevoie de ceva timp pentru a măsura temperatura. // Dacă totul este neted, pressure.startTemperature va returna în stare numărul de milisecunde // pe care trebuie să le așteptați pentru a măsura temperatura // Dacă există niște stâlpi cu fire, va returna 0 status = pressure.startTemperature () ; dacă (starea! = 0) (// așteptați: întârziere (starea); // Obțineți temperatura, puneți-o în variabila T: // Funcția va returna 1 dacă totul este OK, 0 dacă nu este OK starea = presiune. getTemperature (T); if (status! = 0) (// scrie temperatura: Serial.print ("temperatura:"); Serial.print (T, 2); Serial.print ("grade C,"); / / în Celsius Serial.print ((9,0 / 5,0) * T + 32,0,2); Serial.println ("grade F"); // în Fahrenheit // Determinați presiunea atm.: // Parametrul indică rezoluția, de la 0 la 3 (cu cât rezoluția este mai mare, cu atât acuratețea este mai mare, cu atât așteptarea este mai lungă). // Dacă totul este neted, pressure.startPressure va returna în stare numărul de milisecunde // pe care trebuie să le așteptați pentru a măsura atm .pressure // Dacă există vreo problemă, va returna 0 status = pressure.startPressure ( 3); if (status! = 0) (// așteptați sfârșitul măsurării: întârziere (stare); // Acum aveți poate introduce presiunea în variabila P. // Funcția va returna 1 dacă totul este OK, 0 dacă nu este OK.status = presiune getPressure (P, T); dacă (status! = 0) (// imprimă totul: Seri al.print („presiune absolută:”); Serial.print (P, 2); Serial.print ("milibar,"); Serial.print (P * 0. 0295333727,2); Serial.println ("inci de mercur"); // senzorul returnează atm. presiune care se modifică în funcție de înălțimea senzorului. // Dacă vrem ca în prognoza meteo, atunci trebuie să facem calcule dubioase // Parametri: P = presiunea de la senzor în milibari, ALTITUDINE = înălțimea deasupra nivelului mării în metri. // Rezultat: p0 = presiune corectată la nivelul mării p0 = presiune.nivel etanș (P, ALTITUDINE); Serial.print ("Presiunea la nivelul mării:"); Serial.print (p0,2); Serial.print ("milibar,"); Serial.print (p0 * 0,0295333727,2); Serial.println ("inci de mercur"); // Sau dacă doriți să faceți invers și să determinați altitudinea din presiunea cunoscută, // Parametri: P = presiunea de la traductor în milibari, p0 = presiunea corectată pentru nivelul mării. // Rezultat: a = înălțimea deasupra nivelului mării în metri. a = presiune.altitudine (P, p0); Serial.print ("înălțimea calculată deasupra nivelului mării:"); Serial.print (a, 0); Serial.print ("contoare,"); Serial.print (a * 3.28084,0); Serial.println ("picioare"); ) else Serial.println ("eroare la obținerea presiunii \ n"); ) else Serial.println („eroare de a începe să obțină presiune \ n”); ) else Serial.println ("eroare la obținerea temperaturii \ n"); ) else Serial.println („eroare la începutul obținerii temperaturii \ n”); întârziere (5000); // face o pauză de 5 secunde. )

Program Arduino cu comentarii:

/ * Exemplu de schiță de bibliotecă SFE_BMP180

Această schiță arată cum să utilizați biblioteca SFE_BMP180 pentru a citi
Senzor de presiune barometrică Bosch BMP180.
https://www.sparkfun.com/products/11824
La fel ca majoritatea senzorilor de presiune, BMP180 măsoară presiunea absolută.
Aceasta este presiunea ambientală reală văzută de dispozitiv, care va
variază atât în ​​funcție de altitudine, cât și de vreme.
Înainte de a face o citire a presiunii, trebuie să faceți o citire a temperaturii.
Acest lucru se face cu startTemperature () și getTemperature ().
Rezultatul este în grade C.
Odată ce aveți o citire a temperaturii, puteți face o citire a presiunii.
Acest lucru se face cu startPressure () și getPressure ().
Rezultatul este în milibari (mb) alias hectopascali (hPa).
Dacă „veți monitoriza tiparele vremii, probabil că veți dori
elimina efectele altitudinii. Acest lucru va produce citiri care pot
fi comparat cu citirile de presiune publicate din alte locații.
Pentru a face acest lucru, utilizați funcția sealevel (). Va trebui să oferiți
altitudinea cunoscută la care a fost măsurată presiunea.
Dacă doriți să măsurați altitudinea, va trebui să cunoașteți presiunea
la o altitudine de bază. Aceasta poate fi presiunea medie la nivel de mare sau
o citire anterioară a presiunii la altitudinea dvs., caz în care
citirile ulterioare de altitudine vor fi + sau - linia de bază inițială.
Acest lucru se face cu funcția de altitudine ().

Conexiuni hardware:
- (GND) la GND
+ (Vin) la 5V
De asemenea, va trebui să conectați pinii I2C (SCL și SDA) la dvs
Arduino. Pinii sunt diferiți pe diferite Arduinos:
Orice pin Arduino etichetat: SDA SCL
Uno, Redboard, Pro: A4 A5
Mega2560, scadent: 20 21
Leonardo: 2 3

Biblioteca SFE_BMP180 utilizează ecuații în virgulă mobilă dezvoltate de
Proiect Data Logger al stației meteo: http://wmrx00.sourceforge.net/

V10 Mike Grusin, SparkFun Electronics 24.10.2013
Actualizări V1.1.2 pentru Arduino 1.6.4 5/2015
*/

// Schița dvs. trebuie să #includă această bibliotecă și biblioteca Wire.
// (Wire este o bibliotecă standard inclusă cu Arduino.):

#include
#include
#include

const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd (rs, en, d4, d5, d6, d7);

// Va trebui să creați un obiect SFE_BMP180, numit aici „presiune”:
SFE_BMP180 presiune;

anulează configurarea ()
{
lcd.begin (16, 2);
// Inițializați senzorul (este important să obțineți valorile de calibrare stocate pe dispozitiv).
presiune.începe ();
}

buclă goală ()
{
starea caracterului;
dublu T, P, p0 = 1013,0, a; // 1013,0 - presiunea în hPa la nivelul mării

// Mai întâi trebuie să obțineți o măsurare a temperaturii pentru a efectua o citire a presiunii.
// Începe o măsurătoare de temperatură:

status = pressure.startTemperature ();
dacă (starea! = 0)
{
întârziere (stare);

// Preluați măsurarea temperaturii finalizată:
// Rețineți că măsurarea este stocată în variabila T.

status = pressure.getTemperature (T);
dacă (starea! = 0)
{
lcd.setCursor (0, 0);
lcd.print ("Temp =");
imprimare lcd (T, 2);
lcd.print ("C");
// Începe o măsurătoare de presiune:
// Parametrul este setarea de supraeșantionare, de la 0 la 3 (cel mai mare rezoluție, cea mai lungă așteptare).
// Dacă cererea are succes, este returnat numărul de ms de așteptat.
// Dacă cererea nu reușește, se returnează 0.

status = pressure.startPressure (3);
dacă (starea! = 0)
{
// Așteptați finalizarea măsurătorii:
întârziere (stare);

// Preluați măsurarea presiunii finalizată:
// Rețineți că măsurarea este stocată în variabila P.
// De asemenea, rețineți că funcția necesită măsurarea anterioară a temperaturii (T).
// (Dacă temperatura este stabilă, puteți face o măsurătoare de temperatură pentru un număr de măsurători de presiune.)
// Funcția returnează 1 dacă are succes, 0 dacă eșuează.

status = pressure.getPressure (P, T);
dacă (starea! = 0)
{
// Imprimați măsurarea:
lcd.setCursor (0, 1);
lcd.print ("P =");
lcd.print (P / 1.333,0); // coeff. 1,333 - conversia hPa în mm Hg

// Dacă doriți să vă determinați altitudinea din citirea presiunii,
// folosiți funcția de altitudine împreună cu o presiune de bază (nivelul mării sau altele).
// Parametri: P = presiune absolută în mb, p0 = 1013 presiune de bază în mb.
// Rezultat: a = altitudinea în m.

a = presiune.altitudine (P, p0);
lcd.print ("H =");
lcd.print (a, 2);
lcd.print ("m");
}
else lcd.print („eroare”);
}
else lcd.print („eroare”);
}
else lcd.print („eroare”);
}
else lcd.print („eroare”);
întârziere (5000); // Faceți o pauză de 5 secunde.

O zi bună tuturor, ei bine... doar începeți!!! Acest articol este despre conectarea unui senzor de presiune barometrică BMP180 la un singur computer de bord Arduino Uno, dar nu atât de simplu pe cât ne-am dori la prima vedere. Vom afișa valorile de temperatură măsurate și convertite pe un afișaj cu 7 segmente în funcție de șofer MAX7219... Și acestea vor fi afișate ca o linie târâtoare din două unități de măsură convertite - acestea sunt grade Celsius și grade Fahrenheit.

Senzor BMP180 nu este doar un senzor de presiune barometrică, ci și un senzor de temperatură de înaltă precizie. Acesta este un dispozitiv foarte sensibil, la finalul articolului va fi afișat un videoclip de prezentare generală, prin vizionarea căruia poți fi sigur cât de sensibil este. Ei bine, mai departe, puteți da caracteristicile senzorului BMP180 :

• Tensiune de alimentare 3,3 volți
• Consum de curent 5 mKA la o rată de eșantionare de 1 Hz
• Interfață de conectare - I2C
• Răspândirea preciziei în presiunea măsurată + -0,12 hPa (+ -1 metru înălțime)
• Interval de măsurare a temperaturii de la -40 * C până la + 85 * C
• Interval de măsurare a presiunii: de la 300 la 1100 hPa

Este timpul să conectați senzorul la placă Arduino Uno, dar deoarece valorile noastre măsurate și convertite vor fi afișate pe un afișaj cu 7 segmente, în următoarea diagramă vom arăta conexiunea completă a tuturor dispozitivelor, precum și pinout-ul senzorului BMP180 :

În general, nu este nimic complicat în diagrama de conectare, totul este vizibil și de înțeles, următorul pas este să treci la scrierea unei schițe. Câteva puncte importante în implementarea vizualizării valorilor măsurate și convertite:

• Afișați numai valorile de temperatură convertite (vezi mai jos de ce)
• Valorile temperaturii trebuie implementate în zecimi de grad (așa cum se vede în imaginea de previzualizare)
• Implementați redarea târâtoare
• Prezența mesajelor de diagnosticare despre starea senzorului în timpul pornirii și inițializării este obligatorie
• Folosim biblioteca pentru a lucra cu senzorul

De ce este încă posibil să se afișeze doar valorile de temperatură... Desigur, aș dori să acopăr pe deplin toate capacitățile senzorului BMP180, dar pentru vizualizarea pe un display cu 7 segmente va fi necesar să se utilizeze simboluri mai complexe pentru afișarea „liniilor târâtoare” în mesaje decât cele care pot fi create efectiv folosind module de vizualizare de acest tip. Prin urmare, s-a decis să se afișeze doar valorile de temperatură convertite, dar, în general, în general, de obicei, rar cineva se uită la citirile presiunii atmosferice atunci când, de exemplu, merge la plimbare. Și totuși - dacă cineva dorește să studieze mai în detaliu cum să lucreze cu senzorul BMP180, atunci există două exemple în biblioteca de plug-in care pot explica mai detaliat cum să obțineți și să convertiți presiunea și temperatura folosind acest senzor.

Ca urmare, a fost creată următoarea schiță, cu comentariile dezvoltatorului:

#include "SFE_BMP180.h" #include "Wire.h" #include "LedControl.h" // Prototipul funcției de defilare a mesajului msgScrolling () void msgScrolling (byte msg, int msgSize, int dScroll); // Prototipul funcției de procesare a datelor de temperatură // și pregătirea unui mesaj void TmsgPreparation (valoare dublă, grad bool); // Creați un obiect LC din clasa LedControl pentru a lucra cu afișajul LedControl LC = LedControl (12, 11, 10, 8); // Creați un obiect BMP180Sensor din clasa SFE_BMP180 pentru a lucra cu SFE_BMP180 BMP180Sensor; // Întârziere pentru desenarea caracterelor la derulare const int delayScrolling = 300; // Mesaj „Inițializarea senzorului cu succes” octet msgInitSuccess = (91, 79, 21, 91, 29, 5, 16, 21, 16, 15, 0, 91, 28, 13, 13, 79, 91, 91); // Mesajul „Inițializarea senzorului nu a reușit” octet msgInitFail = (91, 79, 21, 91, 29, 5, 16, 21, 16, 15, 0, 71, 119, 48, 14); // Matrice de caractere numerice fără un octet punct Cifră = (126, 48, 109, 121, 51, 91, 95, 112, 127, 123); // Matrice de caractere numerice cu un octet punct pDigit = (254, 176, 237, 249, 179, 219, 223, 240, 255, 251); // Simboluri octet deg = 99; // Simbol pentru octetul „grad” C = 78; // Simbol „C” - octet Celsius F = 71; // Simbol „F” - octet Fahrenheit S = 1; // Simbolul „-” este un semn minus (dacă valoarea măsurată este sub zero) void setup () (// Scoatem dispozitivul (afișaj cu 7 segmente) din modul de repaus LC.shutdown (0, fals); // Setați luminozitatea afișajului la 8 // Totalul modurilor de luminozitate posibile de la 0 la 15 LC.setIntensity (0, 8); // Ștergeți afișajul LC.clearDisplay (0); // Inițializarea senzorului pe magistrala I2C dacă ( BMP180Sensor.begin ()) (// Mesaj pentru defilare - inițializarea senzorului a fost reușită msgScrolling (msgInitSuccess, sizeof (msgInitSuccess), delayScrolling);) else (while (true) (// Mesaj pentru derulare - inițializarea senzorului eșuată (msgScrollingFacilm, msgScrollingFax) sizeof (msgInitFail), delayScrolling);))) void loop () (starea caracterului; dublu T, tCelsius, tFahrenheit; // Începe măsurarea temperaturii // funcția startTemperature () returnează numărul de milisecunde // de la începutul măsurării proces, dacă procesul de măsurare a fost corect, // salvează această valoare în variabila de stare // Dacă funcția returnează 0, atunci procesul de măsurare este pr stare greșită = BMP180Sensor.startTemperature (); if (stare! = 0) (// Așteptați același număr de milisecunde întârziere (stare); // Obțineți valoarea temperaturii măsurată și procesată // în grade Celsius și stocați-o în variabila T // funcția getTemperature () returnează 1 dacă apelarea acesteia // a trecut cu succes și 0 dacă funcția nu a putut inițializa // variabila T cu starea valorii măsurate = BMP180Sensor.getTemperature (T); dacă (status! = 0) (// Atribuirea unei valori variabilelor // și procesarea gradațiilor pentru scara Fahrenheit tCelsius = T; tFahrenheit = (9.0 / 5.0) * T + 32.0;)) // Prelucrarea valorii și // pregătirea mesajului - temperatura TmsgPreparation (tCelsius, false); TmsgPreparation (tFahrenheit, adevărat); ) // Iată funcția actuală pentru derularea mesajelor gata // de la dreapta la stânga / * * Parametri: * byte msg - pointer către o matrice de date caracter * int msgSize - dimensiunea matricei de date caracter * int dScroll - delay derulare (deplasarea mesajului la stânga) * în milisecunde * / void msgScrolling (byte msg, int msgSize, int dScroll) (pentru (int i = 0; i< 8 + msgSize; i ++) { for(int n = i, j = 0; n >= 0, j< msgSize; n --, j ++) { LC.setRow(0, n, msg[j]); LC.setRow(0, n - 1, B00000000); } delay(dScroll); } } /* * Здесь функция подготовки сообщения, прежде чем оно будет выведено * для прокрутки на дисплее. Параметры: * double value - значение температуры двойной степени точности * bool degree - флаг для определения шкалы градуирования * если false - значит градусы Цельсия * если true - значит градусы Фаренгейта */ void TmsgPreparation(double value, bool degree) { //Приводим к абсолютному значению и сохраняем в переменной T //Это унифицирует значение и сократит код функции вдвое double T = abs(value); //Здесь значение фильтруется, если есть отклонение на пол градуса //от нуля то всё равно формировать сообщение что температура равна 0 //Итак, если замеренная температура меньше 0.5 то ставим 0 if(T < 0.5) { //Резервируем символьный массив на три символа byte preMsg; //Первый символ - это естественно 0 preMsg = Digit; //Второй символ - это сгенерированный символ "градус" preMsg = deg; //Проверка флага градуировки if(degree) { //Если true - то это градусы Фаренгейта //и третий символ в массиве будет содержать //сгенерированный символ F(код 71) preMsg = F; } else { //Иначе, если true - то это градусы Цельсия //и третий символ в массиве будет содержать //сгенерированный символ С(код 78) preMsg = C; } //Отправляем указатель на проинициализированный символьный массив preMsg //в качестве первого параметра функции для прокрутки сообщений //второй параметр - это размер символьного массива preMsg //третий параметр - задержка сдвига(прокрутки влево) в миллисекундах msgScrolling(preMsg, sizeof(preMsg), delayScrolling); //После прокрутки сообщения покинуть тело функции return; } //Если больше 0.5 но меньше 1 if(T < 1) { byte preMsg; preMsg = pDigit; preMsg = Digit; preMsg = deg; if(degree) { preMsg = F; } else { preMsg = C; } //Здесь нужно знать показания температуры //Отрицательные или положительные, //если отрицательные - добавить отрисовку знака минус if(value < 0) { byte rdyMsg; //В первый байт массива символов сообщения //записываем знак rdyMsg = S; //Далее - слияние массивов в готовое сообщение for(int i = 1; i < sizeof(rdyMsg); i ++) { // rdyMsg[i] = preMsg; } msgScrolling(rdyMsg, sizeof(rdyMsg), delayScrolling); return; } else { msgScrolling(preMsg, sizeof(preMsg), delayScrolling); return; } } //Если больше 1 но меньше 10 if(T < 10) { byte preMsg; preMsg = pDigit; preMsg = Digit; preMsg = deg; if(degree) { preMsg = F; } else { preMsg = C; } if(value < 0) { byte rdyMsg; //В первый байт массива символов сообщения //записываем знак rdyMsg = S; //Далее - слияние массивов в готовое сообщение for(int i = 1; i < sizeof(rdyMsg); i ++) { // rdyMsg[i] = preMsg; } msgScrolling(rdyMsg, sizeof(rdyMsg), delayScrolling); return; } else { msgScrolling(preMsg, sizeof(preMsg), delayScrolling); return; } } //Если больше 10 но меньше 100 if(T < 100) { byte preMsg; preMsg = Digit; preMsg = pDigit; preMsg = Digit; preMsg = deg; if(degree) { preMsg = F; } else { preMsg = C; } if(value < 0) { byte rdyMsg; //В первый байт массива символов сообщения //записываем знак rdyMsg = S; //Далее - слияние массивов в готовое сообщение for(int i = 1; i < sizeof(rdyMsg); i ++) { // rdyMsg[i] = preMsg; } msgScrolling(rdyMsg, sizeof(rdyMsg), delayScrolling); return; } else { msgScrolling(preMsg, sizeof(preMsg), delayScrolling); return; } } //Если больше 100 но меньше 1000 if(T < 1000) { byte preMsg; preMsg = Digit; preMsg = Digit; preMsg = pDigit; preMsg = Digit; preMsg = deg; if(degree) { preMsg = F; } else { preMsg = C; } if(value < 0) { byte rdyMsg; //В первый байт массива символов сообщения //записываем знак rdyMsg = S; //Далее - слияние массивов в готовое сообщение for(int i = 1; i < sizeof(rdyMsg); i ++) { // rdyMsg[i] = preMsg; } msgScrolling(rdyMsg, sizeof(rdyMsg), delayScrolling); return; } else { msgScrolling(preMsg, sizeof(preMsg), delayScrolling); return; } } }

As vrea sa mai spun ca nu s-au gasit functii de defilare in biblioteca standard LedControl, poate vom fi noi cei care adaugam aceasta biblioteca? Ei bine, totul depinde de dorințele vizitatorilor noștri, comentați, încercați, puneți întrebări... Așteptăm feedback-ul dumneavoastră. La acest articol este atașat și un videoclip al schiței, să vedem rezultatele schiței:

Vă rugăm să activați javascript pentru ca comentariile să funcționeze.

BMP085 este un senzor pentru monitorizarea presiunii barometrice (in plus, monitorizeaza si temperatura).

Senzorul este folosit în multe proiecte, inclusiv în cele care folosesc Arduino, deoarece practic nu are analogi. În plus, este și ieftin. Prima întrebare care apare este: de ce ar măsura cineva presiunea atmosferică? Există două motive pentru aceasta. Primul este controlul altitudinii. Odată cu creșterea altitudinii, presiunea scade. Este foarte convenabil pentru drumeții, ca alternativă la navigatoarele GPS. În plus, indicatorul presiunii atmosferice este folosit pentru a prezice vremea.

BMP085 a fost înlocuit la un moment dat de senzorul BMP180, care se conectează la Arduino și la alte microcontrolere în același mod ca predecesorul său, dar în același timp este mai puțin și costă mai puțin.

Specificații BMP085

• Interval de sensibilitate: 300-1100 hPa (9000 m - 500 m deasupra nivelului mării);
• Rezolutie: 0,03 hPa / 0,25 m;
• Temperatura de lucru -40 până la + 85 ° C, precizie de măsurare a temperaturii + -2 ° C;
• conexiune I2c;
• V1 de pe modul folosește putere de 3,3 V și putere logică;
• V2 de pe modul folosește 3,3-5 V putere și putere logică;

După repornirea IDE-ului Arduino, puteți rula primul exemplu de schiță, al cărui cod este dat mai jos:

#include & ltWire.h & gt

#include & ltAdafruit_Sensor.h & gt

#include & ltAdafruit_BMP085_U.h & gt

Adafruit_BMP085_Unified bmp = Adafruit_BMP085_Unified (10085);

void setup (void)

Serial.begin (9600);

Serial.println ("Test senzor de presiune"); Serial.println ("");

/ * Inițializați senzorul * /

dacă (! bmp.begin ())

/ * Dacă a apărut o inscripție: „A existat o problemă la detectarea BMP085...”,

Verificați dacă senzorul este conectat corect * /

Serial.print ("Hopa, nu a fost detectat niciun BMP085... Verificați cablarea sau ADDR-ul I2C!");

senzori_event_t eveniment;

bmp.getEvent (& eveniment);

/ * afișați rezultatele (presiunea barometrică este măsurată în hPa) * /

dacă (eveniment.presiune)

/ * Afișează presiunea atmosferică în hPa * /

Serial.print ("Presiune:"); Serial.print (presiune.eveniment); Serial.println ("hPa");

Deschideți fereastra monitorului serial (rată de transmisie - 9600). Schița noastră ar trebui să scoată date de presiune în hPa (hectopascali). Puteți testa funcționalitatea senzorului apăsând degetul pe senzor. Figura arată valorile presiunii după apăsarea cu degetul.

Măsurarea înălțimii deasupra nivelului mării

Probabil știi că presiunea scade odată cu creșterea altitudinii. Adică putem calcula altitudinea cunoscând presiunea și temperatura. Din nou, vom lăsa matematica în culise. Dacă sunteți interesat de calcule, vă puteți familiariza cu ele pe această pagină Wikipedia.

Exemplul de mai jos va folosi biblioteca suplimentară Arduino. Pentru a calcula altitudinea folosind senzorul BMP085, actualizați funcția „buclă de gol ()”. Modificările necesare ale schiței sunt prezentate în schița de mai jos. Acest lucru vă va oferi o citire a temperaturii pe baza nivelului de presiune și a temperaturii.

/ * creează un nou eveniment pentru senzor * /

senzori_event_t eveniment;

bmp.getEvent (& eveniment);

/ * afișează rezultatele (presiunea barometrică în hPa) * /

dacă (eveniment.presiune)

/ * afișează presiunea atmosferică în hPa * /

Serial.print ("Presiune:");

Serial.print (presiune.eveniment);

Serial.println ("hPa");

/ * pentru a calcula înălțimea cu o anumită precizie, trebuie să știți *

* presiunea medie si temperatura mediului ambiant

* în grade Celsius în momentul efectuării citirilor *

* dacă nu aveți aceste date, puteți utiliza „valoarea implicită”,

* care este egal cu 1013,25 hPa (această valoare este definită ca

* SENSORS_PRESSURE_SEALEVELHPA *

* în fișierul senzori.h). Dar rezultatele nu vor fi exacte *

* valorile cerute pot fi găsite pe site-urile cu prognoze de temperatură *

* sau pe resursele centrelor de informare din aeroporturile mari *

* de exemplu, pentru Paris, Franța, poate fi găsită presiunea medie actuală *

* pe site: http://bit.ly/16Au8ol * /

/ * obțineți valoarea actuală a temperaturii de la senzorul BMP085 * /

temperatura de plutire;

bmp.getTemperature (& temperatura);

Serial.print ("Temperatura:");

Serial.print (temperatura);

Serial.println ("C");

/ * convertiți datele primite la înălțime * /

/ * actualizați următoarea linie pentru a reflecta valorile curente * /

float seaLevelPressure = SENSORS_PRESSURE_SEALEVELHPA;

Serial.print ("Altitudine:");

Serial.print (bmp.pressureToAltitude (seaLevelPressure,

Serial.println ("m");

Serial.println ("");

Serial.println („Eroare senzor”);

Lansăm schița și vedem înălțimea calculată deasupra nivelului mării.

Precizia citirilor BMP085 poate fi crescută semnificativ prin ajustarea valorii medii a presiunii, care variază în funcție de vreme. Fiecare 1 hPa de presiune pe care nu l-am luat în calcul duce la o eroare de 8,5 metri!

Figura de mai jos prezintă valorile presiunii de la una dintre resursele de informații ale aeroportului european. Valoarea presiunii este evidențiată cu galben, pe care o putem folosi pentru a rafina rezultatele.

Să schimbăm următoarea linie din schița noastră, notând valoarea reală (1009 hPa) în ea:

float seaLevelPressure = 1009;

Ca rezultat, vom obține rezultate ușor diferite:

Sugestie: când specificați presiunea, asigurați-vă că convertiți datele utilizate în hPa.

Utilizarea BMP085 (API v1)

Să repetăm ​​încă o dată: pentru a afla presiunea și altitudinea deasupra nivelului mării, trebuie să faci niște calcule. Dar toate sunt deja incluse în Biblioteca Arduino Adafruit_BMP085 (API v1), pe care o puteți descărca din link.

După instalarea bibliotecilor, trebuie să reporniți IDE-ul Arduino

După repornire, puteți rula primul exemplu de schiță:

#include & ltWire.h & gt

Adafruit_BMP085 bmp;

Serial.begin (9600);

Serial.println ("* C");

Serial.print ("Presiune =");

Serial.println ("Pa");

Serial.println ();

După ce ați intermit Arduino, deschideți monitorul serial. Setați viteza de transmisie la 9600. Schița va afișa temperatura în grade Celsius și presiunea în pascali. Dacă puneți degetul pe elementul senzor al senzorului, temperatura și presiunea vor crește:

Măsurarea altitudinii (API v1)

Pentru a controla altitudinea, rulați schița de mai jos:

#include & ltWire.h & gt

#include & ltAdafruit_BMP085.h & gt

Adafruit_BMP085 bmp;

Serial.begin (9600);

Serial.print ("Temperatura =");

Serial.print (bmp.readTemperature ());

Serial.println ("* C");

Serial.print ("Presiune =");

Serial.print (bmp.readPressure ());

Serial.println ("Pa");

// calculează altitudinea pe baza valorilor

// Presiunea barometrică „standard” egală cu 1013,25 milibari = 101325 Pascal

Serial.print ("Altitudine =");

Serial.print (bmp.readAltitude ());

Serial.println („metri”);

Serial.println ();

Rulați schița pentru a afișa rezultatele:

Pe baza citirilor de mai sus, ne aflăm la -21,5 metri deasupra nivelului mării. Dar știm că suntem deasupra mării! Amintiți-vă de aceeași problemă ca atunci când utilizați API V2. Trebuie să ținem cont de vreme! O.K. Să presupunem că am găsit un site meteorologic bun și presiunea este de 101,964 Pa. Deschideți exemplul Exemple-> BMP085test în Arduino IDE și editați linia care este evidențiată în figura de mai jos:

În această linie trebuie să introduceți datele presiunii curente. După o nouă lansare, veți constata că datele s-au schimbat dramatic și am ajuns la 29,58 de metri cu un semn plus, ceea ce seamănă mult mai mult cu adevărul.

Lasă-ți comentariile, întrebările și împărtășește-ți experiența personală mai jos. În discuție se nasc adesea idei și proiecte noi!

BMP180 este un senzor de presiune absolută piezoresistiv cu zgomot redus și liniaritate ridicată, precum și viteza mare stabilirea citirilor. Matrița găzduiește un senzor MEMS sub forma unei membrane flexibile de silicon care acoperă camera cu presiune standard. Există tensiometre pe membrană, care sunt conectate conform schemei punții și își schimbă rezistența atunci când membrana este îndoită. Îndoirea diafragmei depinde de diferența dintre presiunea ambiantă și presiunea din cameră, iar ieșirea de la puntea de extensometru depinde de presiunea ambientală. Deoarece parametrii membranei și ai rezistențelor depind de temperatură, pe cristal este amplasat un termometru digital, ale cărui citiri sunt folosite pentru a compensa datele barometrului, dar pot fi utilizate și independent. Nu se recomandă utilizarea datelor de temperatură de la alți senzori pentru a compensa datele barometrului. Termometrul din BMP180 este situat pe cristalul de măsurare în sine, măsoară temperatura elementului senzor - prin urmare citirile sale sunt cele mai apropiate de temperatura barometrului și sunt precise. Barometrul poate funcționa cu o precizie maximă de 2 Pa (dacă este utilizat ca altimetru barometric, aceasta corespunde unei erori de măsurare a altitudinii de 17 cm).

Specificații:

Tensiune de alimentare 1.62V - 3.6V.

Interfață de conectare I2C.

Precizie de până la 0,02 hPa (17 cm).

Interval: 300hPa până la 1100hPa (+9000m până la -500m).

Date de ieșire: presiune și temperatură de 16 biți

rezoluție presiune 0,01 hPa

rezoluție de temperatură 0,1 о С

Cod exemplu Arduino

#include
#include

/***************************************************
Acesta este un exemplu pentru senzorul de temperatură și presiune barometrică BMP085
Proiectat special pentru a funcționa cu Adafruit BMP085 Breakout
----> https://www.adafruit.com/products/391
Aceste afișaje folosesc I2C pentru a comunica, pentru care sunt necesari 2 pini
interfata
Adafruit investește timp și resurse furnizând acest cod open source,
vă rugăm să susțineți Adafruit și hardware-ul open-source prin achiziționare
produse de la Adafruit!
Scris de Limor Fried / Ladyada pentru Adafruit Industries.
Licență BSD, tot textul de mai sus trebuie inclus în orice redistribuire
****************************************************/

// Conectați VCC al senzorului BMP085 la 3,3 V (NU 5,0 V!)
// Conectați GND la masă
// Conectați SCL la ceasul i2c - pe "168 /" 328 Arduino Uno / Duemilanove / etc, asta este Analog 5
// Conectați SDA la datele i2c - pe "168 /" 328 Arduino Uno / Duemilanove / etc, asta este Analog 4
// EOC nu este folosit, înseamnă sfârșitul conversiei
// XCLR este un pin de resetare, de asemenea, nu este folosit aici

Adafruit_BMP085 bmp;

Void setup () (
Serial.begin (9600);
dacă (! bmp.begin ()) (
Serial.println ("Nu s-a putut găsi un senzor BMP085 valid, verificați cablarea!");
în timp ce (1) ()
}
}

Buclă goală () (
Serial.print ("Temperatura =");
Serial.print (bmp.readTemperature ());
Serial.println ("* C");

Serial.print ("Presiune =");
Serial.print (bmp.readPressure ());
Serial.println ("Pa");

// Calculați altitudinea presupunând barometrie „standard”.
// presiunea de 1013,25 milibari = 101325 Pascal
Serial.print ("Altitudine =");
Serial.print (bmp.readAltitude ());
Serial.println („metri”);

Serial.print ("Presiune la nivelul marinului (calculat) =");
Serial.print (bmp.readSealevelPressure ());
Serial.println ("Pa");

// puteți obține o măsurare mai precisă a altitudinii
// dacă știți presiunea curentă la nivelul mării care va
// variază în funcție de vreme și așa ceva. Dacă este de 1015 milibari
// care este egal cu 101500 Pascals.
Serial.print ("Altitudine reală =");
Serial.print (bmp.readAltitude ( 101500 ));
Serial.println („metri”);

Serial.println ();
întârziere (500);
}

Această schiță iese

• Temperatura = xx.xx * C - Temperatura în grade Celsius
• Presiune = xx Pa - Presiunea atmosferică în Pascali
• Altitudine = xx.xx metri - Înălțimea în metri
• Presiunea la nivelul mării (calculată) = xx Pa - Presiunea atmosferică în pascali (relativ la nivelul mării (calculat))
• Altitudine reală = хх.хх metri - Înălțime reală (calculată)

Pentru a afișa presiunea atmosferică în mmHg, trebuie schimbate mai multe linii

Serial.print ("Presiune =");

Serial.print (bmp.readPressure () / 133.322); // Valoarea rezultată în Pa este împărțită la 133,322 și obținem mm Hg.

Serial.println ("mm"); // și schimbați „Pa” în „mm” în consecință

Serial.print ("Presiune la nivelul marinului (calculat) =");

Serial.print (bmp.readSealevelPressure () / 133.322);

Serial.println ("mm");

Configurarea senzorului BMP180

Presiunea atmosferică depinde de locul de măsurare, de temperatura aerului și de vreme. La nivelul mării, presiunea atmosferică medie anuală este p n = 1013,25 mbar = 101,325 kPa (presiune normală) la o temperatură medie anuală de 15 ° C. Și când crește la fiecare 8 m, presiunea atmosferică scade cu 100 Pa = 1 mbar.

Se poate obține o măsurare mai precisă a înălțimii. Dacă știm presiunea actuală deasupra nivelului mării pentru coordonatele noastre. Pentru a face acest lucru, trebuie să aflați înălțimea noastră reală deasupra nivelului mării folosind hărțile de la Google, la care mergem legătură... În fereastra cu o hartă de la Google, găsim locația noastră și facem clic pe butonul stâng al mouse-ului pentru a plasa un marcaj pe hartă și obținem date despre înălțimea deasupra nivelului mării pentru punctul nostru. De asemenea, nu uitați să țineți cont de ce etaj ne aflăm și să adăugați înălțimea etajelor la datele noastre.

Presiunea atmosferică normală la nivelul mării este de aproximativ 101,3 kPa sau 101.325 Pa. Este mai ușor să obțineți valoarea dorită folosind calculatorul online - Calculul presiunii atmosferice la diferite înălțimi și pentru traducere din (mmHg.) v (Pa) există o formulă simplă Pa = mmHg Artă. * 133,322 ... Pentru a calibra înălțimea, trebuie să facem modificări la linie

Serial. imprimare (bmp. readAltitude (101500));

unde în loc de valoarea 101500 introducem valoarea noastră calculată.

Lucruri la care să fii atent

Dă-i aer: Amintiți-vă că BMP180 are nevoie de aer ambiental pentru a-și măsura presiunea, așa că nu trebuie plasat într-o carcasă etanșă.

Dar nu prea mult aer: Pe de altă parte, expunerea la curenți de aer în mișcare rapidă sau vânt poate provoca fluctuații de presiune pe termen scurt, care vă vor afecta citirea. Protejați dispozitivul de curenții puternici de aer.

Interval de temperatură: Deoarece este necesară o citire precisă a temperaturii pentru măsurarea presiunii, aveți grijă să nu supuneți dispozitivul la schimbări bruște de temperatură și țineți-l departe de părțile fierbinți și de alte surse de căldură.

Umiditate: BMP180 este sensibil la umiditate și nu trebuie să intre în contact cu apa.

Ușoară:În mod surprinzător, senzorul BMP180 este sensibil la lumina care poate pătrunde în dispozitiv prin orificiul din partea de sus a cipului. Pentru o precizie maximă, protejați cipul de lumina ambientală.