Sensore di pressione BMP 180 ultimo aggiornamento 6 aprile 2018

Indice

• Descrizione

• Schema elettrico del modulo

• Libreria di gestione del sensore

• Taratura del sensore

• Test base del modulo sensore

  • Schema di collegamento

  • Programma

• Esempio di utilizzo

  • Schema di collegamento

  • Programma

• Realizziamo una Weather Station

  • Schema di collegamento

  • Programma

Descrizione

Il sensore BMP180 prodotto dalla BOSCH, permette di misurare pressioni da 300 a 1100hPa (.da -500m a +9000m relativi al livello del mare), la tensione di alimentazione è compresa tra 1.8-3,6 (VDD) e 1.62-3.6V (VDDIO), il consumo è di soli 5uA con una lettura al secondo.
Il sensore è contenuto in un package tipo LGA con una dimensione di 3,6x3,8 mm.
Oltre al valore di pressione, il sensore fornisce anche la misurazione della temperatura; i dati sono trasmessi tramite un'interfaccia I2C, con un indirizzo fisso 0x77.
La calibrazione è fatta durante la produzione e i valori sono salvati nella memoria del sensore.
Per facilitare l’uso del sensore, questo si trova di solito già montato su una piccola basetta come per esempio la Breakout Board GY-68), dove oltre al sensore, trovano posto i pochi altri componenti necessari al suo funzionamento.
Il modulo dispone anche di un piccolo regolatore di tensione tipo 662K  che fornisce in uscita una tensione di 3,3 V, per alimentare il sensore.

Schema elettrico del modulo

Il circuito è molto semplice in quanto formato principalmente dal sensore BMP180 con le resiste R1 e R2 sulle linee SCL e SDA. L'altro componente presente è un regolatore CMOS a basso dropout tipo 662K che fornisce l'alimentazione a 3.3V, quando il modulo viene alimentato dal pin VCC magari con la tensione 5V fornita da Arduino. Il regolatore può fornire una corrente di uscita di 250 mA e consentire una tensione di ingresso fino a 6,5 V.

BMP180 - Sensore di pressione
Piedinatura	Datasheet	Foto dell'integrato

LM6206N3 (662K) Low Dropout CMOS Voltage Regulators
Piedinatura	Datasheet	Foto dell'integrato

Libreria di gestione del sensore

Per facilitare l’uso del sensore è disponibile un’apposita libreria, questa funzione in unione alla libreria Wire.h è già presente come libreria standard dell’IDE di Arduino che permette l’utilizzo del protocollo I2C.
In rete ve ne sono molte versioni, quella utilizzata per questo test ha vari comandi:

• Initialize() - Inizializza il sensore

• GetUncompensatedTemperature();

• GetUncompensatedPressure();

• Compensate Temperature();

• CompensatePressure();

• SoftReset() - garantisce che quando si è collegato il sensore vi sia un avvio pulito.

• GetTemperature() - acquisisce dal sensore il dato della temperatura.

• GetPressure() - acquisisce dal sensore il dato della pressione in Pascal.

• GetAltitude() - acquisisce dal sensore il dato dell’altitudine in metri, il risultato ottenuto deve essere corretto per la pressione relativa al punto in cui avviene la misurazione, nel programma deve essere inserito il valore locale nella variabile seaLevelPressure, che di default è pari alla pressione a livello del mare pari a 101325 Pa;

• SetResolution();

• IsConnected() – verifica che il sensore sia effettivamente connesso.

• EnsureConnected() - verifica che sia possibile connettersi con il sensore.

• GetErrorText().

Nota: il dato della pressione è fornito in Pascal (Pa) nel Sistema internazionale pari a 1 newton su metro quadrato (1 N/m²). In ambito meteorologico, la pressione atmosferica si misura in centinaia di Pascal (o ettopascal, abbreviato con hPa). Si ha: 1 013,25 millibar = 101 325 Pa = 1 013,25 hPa

Scarica la libreria (modificata per IDE 1.8.5)

Per utilizzare la libreria sarà sufficiente scaricarla e salvarla all’interno della cartella Library dell’IDE di Arduino. Per utilizzarla all’interno del programma si dovranno aggiungere le seguenti righe:

#include <Wire.h>
#include <BMP180.h>

Taratura del sensore

Per ottenere i valori corretti dell’altitudine occorre inserire il valore relativo alla propria posizione nella variabile seaLevelPressure, che di default contiene il valore 101325 (espresso i Pa), per determinare il valore si può utilizzare l’utility trovata in rete
Se non sapete l'altitudine sul livello del mare del vostro comune potete trovarlo in questa pagina.

Il risultato del calcolo del valore di pressione, è solamente una stima in cui si assume un calo esponenziale della pressione considerando una pressione a livello del mare di 1 atm (101325 Pa).
Questo valore potrebbe non essere corretto in quanto la pressione dell'aria dipende non solo dell'altitudine, ma anche da altri fattori quali temperatura, umidità relativa, e le condizioni atmosferiche.
Tuttavia, questa stima può essere utile per applicazioni non critiche.
Nota: Per i calcoli impostare il dato in uscita in Pa

Test base del modulo sensore

Per testare il funzionamento del modulo sensore utilizzeremo lo sketch demo allegato alla libreria. Il materiale occorrente è

• La scheda Arduino UNO R3 smd:

• Sensore di pressione BMP180;

• Cavi di collegamento;

• Breadboard.

Scheda Arduino UNO R3	Sensore BMP180
Breadboard 170 pin	Cavi colorati M/M M/F

Schema di collegamento

I collegamenti sono mostrati nella figura sottostante.

Programma di test

Scarica il programma

#include <Wire.h>
#include <BMP180.h>

// Store an instance of the BMP180 sensor.
BMP180 barometer;
// We are going to use the on board LED for an indicator.
int indicatorLed = 13;

// Store the current sea level pressure at your location in Pascals.
float seaLevelPressure = 101325;

void setup()
{
  // We start the serial library to output our messages.
  Serial.begin(9600);
  // We start the I2C on the Arduino for communication with the BMP180 sensor.
  Wire.begin();
  // Set up the Indicator LED.
  pinMode(indicatorLed, OUTPUT);
  // We create an instance of our BMP180 sensor.
  barometer = BMP180();
  // We check to see if we can connect to the sensor.
  if (barometer.EnsureConnected())
  {
    Serial.println("Connected to BMP180."); // Output we are connected to the computer.
    digitalWrite(indicatorLed, HIGH); // Set our LED.

    // When we have connected, we reset the device to ensure a clean start.
    barometer.SoftReset();
    // Now we initialize the sensor and pull the calibration data.
    barometer.Initialize();
  }
  else
  {
    Serial.println("No sensor found.");
    digitalWrite(indicatorLed, LOW); // Set our LED.
  }
}

void loop()
{
  if (barometer.IsConnected)
  {
    // Retrive the current pressure in Pascals.
    long currentPressure = barometer.GetPressure();

    // Print out the Pressure.
    Serial.print("Pressure: ");
    Serial.print(currentPressure);
    Serial.print(" Pa");

    // Retrive the current altitude (in meters). Current Sea Level Pressure is required for this.
    float altitude = barometer.GetAltitude(seaLevelPressure);

    // Print out the Altitude.
    Serial.print("\tAltitude: ");
    Serial.print(altitude);
    Serial.print(" m");

    // Retrive the current temperature in degrees celcius.
    float currentTemperature = barometer.GetTemperature();

    // Print out the Temperature
    Serial.print("\tTemperature: ");
    Serial.print(currentTemperature);
    Serial.print(" C");
    Serial.println(); // Start a new line.
    delay(1000); // Show new results every second.
  }
}

Una volta caricato lo sketch si dovrà attivare i monitor seiale dell'IDE, a questo punti si dovrebbero leggere i valori letti dal sensore al ritmo di 1 secondo

Nel caso fosse riportato la scritta "No sensor found", controllare che il modulo sia correttamente alimentato, e che non siano invertiti i cavi SDA e SCL.

Esempio di utilizzo

Per testare la scheda, sono necessari i seguenti componenti:

• La scheda Arduino UNO R3 smd:

• Display LCD con I2c

• Sensore di pressione BMP180;

• Cavi di collegamento

• Una batteria 9V per l’alimentazione.

	nella pagina potete scaricare la libreria
Scheda Arduino UNO R3	Display LCD 16x2 con interfaccia I2C
Sensore BMP180	Cavi colorati M/M M/F

Schema di collegamento

Nell’immagine sotto riportata sono visibili i collegamenti da realizzare per l’effettuare il test.

Programma di test

Il programma di test mostrerà sul display dopo una pagina iniziale di presentazione, i valori letti dal sensore BMP180.
Per il funzionamento del programma sono necessarie le librerie Wire.h , LiquidCrystal_I2C.h  e BMP180.h.  Il listato è sufficientemente commentato per comprenderne il funzionamento.
.

Listato del programma per la gestione del sensore

Scarica il programma

 
/*####################################################################
 FILE: test_BMP180_arduino-uno.ino
 VERSION: 1.1
 Descrizione: Programma di test per il sensore di pressione BMP180, i dati letti
 sono motrsti su un diplay LCD collegato tramite I2c 
 Verificata su IDE 1.8.5
 
 Ultima modifica il 29/3/2018
 Applicazione realizzata da Adriano Gandolfo
 Sito http://www.adrirobot.it 
 Blog http://it.emcelettronica.com/author/adrirobot
 
 This example code is in the public domain.
 #################################################################### */

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <BMP180.h>
LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 20 chars and 4 line display
// Store an instance of the BMP180 sensor.
BMP180 barometer;
// We are going to use the on board LED for an indicator.
int indicatorLed = 13; 
// Store the current sea level pressure at your location in Pascals.
float seaLevelPressure = 101325;
void setup()
{
  lcd.begin(); // initialize the lcd 
  // We start the serial library to output our messages.
  Serial.begin(9600);
  // We start the I2C on the Arduino for communication with the BMP180 sensor.
  Wire.begin();
  // Set up the Indicator LED.
  pinMode(indicatorLed, OUTPUT);
  // We create an instance of our BMP180 sensor.
  barometer = BMP180();
  // We check to see if we can connect to the sensor.
  if(barometer.EnsureConnected())
  {
    Serial.println("Connected to BMP180."); // Output we are connected to the computer.
    digitalWrite(indicatorLed, HIGH); // Set our LED.
    // When we have connected, we reset the device to ensure a clean start.
    barometer.SoftReset();
    // Now we initialize the sensor and pull the calibration data.
    barometer.Initialize();
  }
  else
  { 
    Serial.println("No sensor found.");
    digitalWrite(indicatorLed, LOW); // Set our LED.
  }
  lcd.backlight();
  lcd.setCursor(3, 0);
  lcd.print("Test BMP180");
  lcd.setCursor(0, 1);
  lcd.print("www.adrirobot.it");
  delay(5000);
}
void loop()
{
  if(barometer.IsConnected)
  {
    // Retrive the current pressure in Pascals.
    long currentPressure = barometer.GetPressure();
    // Retrive the current altitude (in meters). Current Sea Level Pressure is required for this.
    float altitude = barometer.GetAltitude(seaLevelPressure);
    // Retrive the current temperature in degrees celcius.
    float currentTemperature = barometer.GetTemperature();
    Serial.println(); // Start a new line.
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(currentPressure);
    lcd.print(" Pa");
    lcd.setCursor(0, 1);
    lcd.print (altitude);
    lcd.print (" m");
    lcd.setCursor(9, 1);
    lcd.print (currentTemperature);
    lcd.print (" C");
    delay(1000); // Show new results every second.
  }
}

Realizziamo una Weather Station

In questo nuovo esempio vediamo come  interfacciare il sensore BMP180 con una scheda ARDUINO MICRO per realizzare una Weather station, i dati saranno visualizzati su un  display TFT a colori, sanno visualizzabili  i valori di pressione, temperatura e altitudine sul livello del mare. Questo progetto è stato oggetto di un mio articolo pubblicato nel giugno 2015 sul blog Elettronica Open Source.

Articolo pubblicato il 4 giugno 2015

Per realizzare questo progetto sono necessari i seguenti componenti:

• Una breadboard (tipo Full-Size con 2 linee di alimentazione, 10 colonne e 63 file - per un totale di 830 pin)

• La scheda Arduino Micro

• Display LCD TFT Arduino

• Sensore di pressione BMP180;

• Alimentatore per breadboard

• Cavi di collegamento

• Una fonte di alimentazione.

BreadBoard	Alimentatore per breadboard
Scheda Arduino Micro	Display TFT Arduino
Sensore BMP180	Cavi colorati M/M M/F

Arduino micro

La Arduino Micro è una scheda sviluppata in collaborazione con Adafruit e basata sul microcontrollore ATmega32u4. La scheda è dotata di 20 pin di input/output digitali (7 dei quali possono essere usati come segnali PWM e 12 dei quali possono essere usati come input analogici), un quarzo a 16MHz, una connessione USB-micro, un connettore per la programmazione ICSP ed un piccolo pulsante per il reset della scheda.
La scheda inoltre fornisce tutto ciò che è necessario per supportare il funzionamento del microcontrollore.

Display LCD TFT Arduino.

Il display qui utilizzato è lo stesso presentato nell’articolo Scopriamo la nuova scheda Arduino Esplora.
Si tratta di un display LCD tipo TFT (Thin Film Transistor), retroilluminato che misura 1,77" pari a circa 45 mm di diagonale, con risoluzione di 160 x 128 pixel. Il modulo misura 40x44mm circa e nella parte posteriore è presente uno slot per schede micro-SD, che tra le altre cose, permette di memorizzare le immagini bitmap da visualizzare sullo schermo.  Per la comunicazione, il display utilizza un protocollo SPI, per facilitare la gestione del display. E’ disponibile un’apposita libreria che è inclusa in quelle disponibili per l’IDE 1.0.5 e successive.

Alimentatore per breadboard

Per alimentare i vari componenti utilizzati, si è utilizzato un alimentatore compatto (dimensioni: 55 x 35mm) studiato appositamente per essere impiegato con le breadboard. Al modulo è possibile applicare una tensione compresa tra 6,5 e 12 Vdc, per ottenere in uscita due tensioni distinte a 3,3 V e 5 V con una corrente massima di circa 700 mA. Ha un interruttore on/off, uscita USB 5V (non utilizzata nel nostro caso), LED di alimentazione e jumper di selezione tensione.

Schema di collegamento

Tabella dei collegamenti

Dettaglio alimentatore Dettaglio display TFT Dettaglio sensore BMP180 Dettaglio Arduino Micro Messaggio su display nel caso di mancata lettura sensore Dati mostrati dal sensore

Sketch Stazione Meteo

Scarica il programma

/*####################################################################
 FILE: stazione_meteo_BMP180.ino
 VERSIONE: 1.0
 Descrizione: Il programma, legge i valori forniti dal sensore
 di pressione BMP180 e mostra i risultati su un display Arduino TFT 
 
  Ultima modifica il 5/4/2018

   Applicazione realizzata da Adriano Gandolfo
   Sito http://www.adrirobot.it
   Blog http://it.emcelettronica.com/author/adrirobot
   Pagina Facebook https://www.facebook.com/Adrirobot-318949048122955
   Istagram https://www.instagram.com/adrirobot/
   This example code is in the public domain.
 #################################################################### */

#include <TFT.h>  // Arduino LCD library
#include <SPI.h>
// gestione sensore BMP180
#include <Wire.h>
#include <BMP180.h>

// Definizione dei pin utilizzati
// per il display TFT
#define cs   10
#define dc   9
#define rst  8

#define indicatorLed  13
// array per contenere i dati di pressione
char PressurePrintout[5];  
String Pressure;
// array per contenere i dati di temperatura
char TemperaturePrintout[5];  
String Temperature;
// array per contenere i dati di altitudine
char AltitudePrintout[5];  
String Altitude;

// Crea un'istanza per il senore BMP180.
BMP180 barometer;
// Inserire la pressione a livello del mare della
// vostra posizione a Pascal.
float seaLevelPressure = 101325;

// create an instance of the library
TFT TFTscreen = TFT(cs, dc, rst);

void setup() {
  // Scrittura pagina di presentazione
  TFTscreen.begin();
  TFTscreen.background(0, 0, 0);
  TFTscreen.setTextSize(2);
  TFTscreen.stroke(255,255,0);
  TFTscreen.text(" Test sensore",0,0);
  TFTscreen.text("   BMP180",0,20);
  TFTscreen.text("Arduino Micro",0,40);
  TFTscreen.stroke(0,255,255);
  TFTscreen.text("  adrirobot",0,60);

  // inizalizzazione della libreria I2C per la
  // comunicazione con il sensore BMP180.
  Wire.begin();
  // Impostazione LED indicatore.
  pinMode(indicatorLed, OUTPUT);
  // Creiamo un'istanza del nostro sensore BMP180.
  barometer = BMP180();
  // Si verifica che ci si può collegare al sensore ..
  if(barometer.EnsureConnected())
  {
    TFTscreen.setTextSize(1);
    TFTscreen.stroke(0,255,0);  
    TFTscreen.text("BMP180 collegato",30,100);
    // Accensione led se sensore collegato
    digitalWrite(indicatorLed, HIGH); 

    // Dopo il, collegamento, il sensore viene
    //resettato per garantire un avvio pulito.
    barometer.SoftReset();
    // Ora inizializziamo il sensore.
    barometer.Initialize();
  }
  else
  { 
    TFTscreen.setTextSize(1);
    TFTscreen.stroke(255,0,0);  
    TFTscreen.text("BMP180 non collegato",20,100);
    // Spegnimento led se sensore non collegato
    digitalWrite(indicatorLed, LOW); 
  }  
  // Tempo di visualizzazione schermata iniziale
  delay(2000); 
  TFTscreen.background(0, 0, 0);
}

void loop() {
  if(barometer.IsConnected)
  {
    //Lettura e visualizzazione pressione in Pascal.
    TFTscreen.stroke(255,0,0);
    TFTscreen.setTextSize(2);
    TFTscreen.text("Pressione:",0,0);
    TFTscreen.setTextSize(3);
    Pressure = String (barometer.GetPressure());
    Pressure.toCharArray(PressurePrintout, 6); 
    TFTscreen.text(PressurePrintout, 0, 18);
    TFTscreen.text("Pa",115,18);

    // Lettura e visualizzazione temperatura in gradi Celsius.
    TFTscreen.stroke(0,255,0);
    TFTscreen.setTextSize(2);
    TFTscreen.text("Temperatura:",0,45);
    TFTscreen.setTextSize(3);
    TFTscreen.stroke(0,255,0);
    Temperature = String (barometer.GetTemperature());
    Temperature.toCharArray(TemperaturePrintout, 6); 
    TFTscreen.text(TemperaturePrintout, 0, 63);
    TFTscreen.circle(110, 65, 2);
    TFTscreen.text("C",115,63);

    //Lettura e visualizzazione quota attuale in metri.
    TFTscreen.stroke(255,255,0);
    TFTscreen.setTextSize(2);
    TFTscreen.text("Altitudine:",0,90);
    TFTscreen.setTextSize(3);
    Altitude = String (barometer.GetAltitude(seaLevelPressure));
    Altitude.toCharArray(AltitudePrintout, 6);
    TFTscreen.text(AltitudePrintout, 0, 108);
    TFTscreen.text("m",115,108);

    // Attesa tra le misure
    delay(1000); 

    // Cancellazione dati per nuova misura
    TFTscreen.stroke(0,0,0);
    TFTscreen.text(PressurePrintout, 0, 18);
    TFTscreen.text(TemperaturePrintout, 0, 63);
    TFTscreen.text(AltitudePrintout, 0, 108);
  }
}