Enregistreur de données altimétrique : ESP32 avec BMP388

Enregistreur de données altimétrique : ESP32 avec BMP388

Dans ce projet, nous allons construire un enregistreur de données altimétrique avec l’ESP32 et le capteur BMP388. Le BMP388 est un capteur de pression précis qui nous permet d’estimer l’altitude avec une grande précision. Dans ce projet, la pression et l’altitude sont enregistrées dans un fichier sur une microSD. Nous avons également ajouté un écran OLED à ce projet afin que vous puissiez vérifier l’altitude actuelle en appuyant sur un bouton-poussoir.

Enregistreur de données altimétrique ESP32 avec stockage sur carte MicroSD BMP388 et écran OLED

Pour un guide de démarrage du BMP388, consultez le didacticiel suivant : ESP32 avec capteur barométrique/altimètre BMP388 (Arduino IDE)

Table des matières:

Aperçu du projet

Avant d’aller directement au projet, regardons les principales caractéristiques de ce projet.

Aperçu du projet de centrale de mesure ESP32 BMP388
  • L’ESP32 définit un point d’accès (1) auquel vous pouvez vous connecter à l’aide de votre smartphone. Une fois connecté, vous pouvez accéder à une page Web avec un champ de saisie, où vous pouvez entrer la pression actuelle au niveau de la mer à votre emplacement. Vous devez saisir cette valeur lorsque le projet démarre. L’altitude est calculée en comparant la pression du capteur avec la pression actuelle au niveau de la mer, c’est pourquoi cette étape est importante pour des résultats précis. Vous pouvez vérifier le courant pression au niveau de la mer.
Formulaire HTML ESP32 Insérer la pression au niveau de la mer
  • L’ESP32 est connecté à un capteur de pression BMP388, un module de carte microSD, un écran OLED et un bouton poussoir.
  • Chaque minute (ou toute autre période que vous définissez dans le code), l’ESP32 enregistre les nouvelles lectures du capteur dans un fichier sur la carte microSD (2). Il enregistre la pression actuelle au niveau du joint, la pression actuelle à l’emplacement du capteur, la température et l’estimation de l’altitude.
  • Lorsque vous appuyez sur le bouton-poussoir, l’écran OLED s’allume et affiche l’altitude et la température actuelles (3). Après 5 secondes, il s’éteint (pour économiser de l’énergie).

Pour mieux comprendre le fonctionnement de ce projet, il peut être utile de jeter un œil aux tutoriels suivants :

Pièces requises

Pour construire ce projet, vous avez besoin des pièces suivantes :

ESP32 BMP388 Capteur Altitude Pression Température Arduino Oled SSD1306 Démonstration de la carte MicroSD

Conditions préalables

Avant de continuer, assurez-vous de vérifier les conditions préalables suivantes.

1. Installez la carte ESP32 dans Arduino IDE

Nous allons programmer l’ESP32 en utilisant Arduino IDE. Vous devez donc avoir installé le module complémentaire ESP32. Suivez le tutoriel suivant si vous ne l’avez pas déjà fait :

Si vous souhaitez utiliser VS Code avec l’extension PlatformIO, suivez plutôt le tutoriel suivant pour apprendre à programmer l’ESP32 :

2. Installation des bibliothèques

Pour construire ce projet, vous devez installer les bibliothèques suivantes :

Vous pouvez installer les quatre premières bibliothèques à l’aide du gestionnaire de bibliothèques Arduino. Aller à Esquisser > Inclure la bibliothèque > Gérer les bibliothèques et recherchez le nom de la bibliothèque.

Les bibliothèques ESPAsyncWebServer et AsynTCP ne peuvent pas être installées via Arduino Library Manager, vous devez donc copier les fichiers de bibliothèque dans le dossier Arduino Installation Libraries. Alternativement, dans votre IDE Arduino, vous pouvez aller à Esquisser > Inclure la bibliothèque > Ajouter une bibliothèque .zip et sélectionnez les bibliothèques que vous venez de télécharger.

Installation de bibliothèques (Code VS + PlatformIO)

Si vous programmez l’ESP32 à l’aide de PlatformIO, vous devez ajouter les lignes suivantes au platformio.ini fichier pour inclure les bibliothèques (changez également la vitesse du moniteur série en 115200) :

monitor_speed = 115200
lib_deps = ESP Async WebServer
	adafruit/Adafruit [email protected]^2.4.6
	adafruit/Adafruit GFX [email protected]^1.10.10
	adafruit/Adafruit BMP3XX [email protected]^2.1.0

3. Formatage de la carte MicroSD

Avant de poursuivre le didacticiel, assurez-vous que vous formatez votre carte microSD en FAT32. Suivez les instructions suivantes pour formater votre carte microSD ou utilisez un outil logiciel comme Formateur de carte SD (compatible avec Windows et Mac OS).

1. Insérez la carte microSD dans votre ordinateur. Aller à Mon ordinateur et faites un clic droit sur la carte SD. Sélectionner Format comme le montre la figure ci-dessous.

Carte SD au format du module de carte MicroSD

2. Une nouvelle fenêtre apparaît. Sélectionner FAT32, presse Démarrer pour initialiser le processus de formatage et suivez les instructions à l’écran.

Carte SD au format du module de carte MicroSD

Diagramme schématique

Connectez tous les composants comme indiqué dans le schéma suivant.

Schéma de câblage du bouton-poussoir OLED de l'enregistreur de données ESP32 BMP388

Vous pouvez également vérifier le câblage dans le tableau suivant :

Composant Affectation des broches ESP32
BMP388 GPIO 21 (SDA), GPIO 22 (SCL)
Affichage OLED GPIO 21 (SDA), GPIO 22 (SCL)
Module de carte MicroSD GPIO 5 (CS), GPIO 23 (MOSI), GPIO 18 (CLK), GPIO 19 (MISO)
Bouton GPIO 4

Code

Copiez le code suivant sur votre carte ESP32 et le projet fonctionnera immédiatement.

/*
  Rui Santos
  Complete project details at https://Raspberryme.com/altimeter-datalogger-esp32-bmp388/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BMP3XX.h"
#include <WiFi.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>

//Libraries for microSD card
#include "FS.h"
#include "SD.h"
#include "SPI.h"

AsyncWebServer server(80);

// Replace with your network credentials
const char* ssid     = "ESP32";
const char* password = NULL;

//OLED Display
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

// Variables for BMP388
float seaLevelPressure = 1013.25;
Adafruit_BMP3XX bmp;
float alt;
float temp;
float pres;
String dataMessage;

//Pushbutton
const int buttonPin = 4; 
int buttonState;              
int lastButtonState = LOW;    
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;    // the debounce time; increase if the output flickers   

//Timers for datalogging
unsigned long lastTimer = 0;
unsigned long timerDelay = 18000;

const char* PARAM_INPUT_1 = "seaLevelPressure";

// HTML web page to handle 1 input field
const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html><head>
  <title>Sea Level Pressure</title>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  </head><body>
  <form action="/get">
    Sea Level Pressure: <input type="float" name="seaLevelPressure">
    <input type="submit" value="Submit">
  </form>
</body></html>)rawliteral";

void initBMP(){
  if (!bmp.begin_I2C()) {   // hardware I2C mode, can pass in address & alt Wire
  //if (! bmp.begin_SPI(BMP_CS)) {  // hardware SPI mode  
  //if (! bmp.begin_SPI(BMP_CS, BMP_SCK, BMP_MISO, BMP_MOSI)) {  // software SPI mode
    Serial.println("Could not find a valid BMP3 sensor, check wiring!");
    while (1);
  }

  // Set up oversampling and filter initialization
  bmp.setTemperatureOversampling(BMP3_OVERSAMPLING_8X);
  bmp.setPressureOversampling(BMP3_OVERSAMPLING_4X);
  bmp.setIIRFilterCoeff(BMP3_IIR_FILTER_COEFF_3);
  bmp.setOutputDataRate(BMP3_ODR_50_HZ);
}

void getReadings(){
  if (! bmp.performReading()) {
    Serial.println("Failed to perform reading :(");
    return;
  }
  temp = bmp.temperature;
  pres = bmp.pressure / 100.0;
  alt = bmp.readAltitude(seaLevelPressure);
}

void initDisplay(){
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  }
  delay(500);
  display.clearDisplay();
  display.setTextColor(WHITE); 
}

void displayReadings(){
  display.clearDisplay();
  // display temperature
  display.setTextSize(1);
  display.setCursor(0,0);
  display.print("Temperature: ");
  display.setTextSize(2);
  display.setCursor(0,10);
  display.print(String(temp));
  display.print(" ");
  display.setTextSize(1);
  display.cp437(true);
  display.write(167);
  display.setTextSize(2);
  display.print("C");
  // display altitude
  display.setTextSize(1);
  display.setCursor(0, 35);
  display.print("Altitude: ");
  display.setTextSize(2);
  display.setCursor(0, 45);
  display.print(String(alt));
  display.print(" m"); 
  display.display();
}

// Initialize SD card
void initSDCard(){
   if (!SD.begin()) {
    Serial.println("Card Mount Failed");
    return;
  }
}

// Write to the SD card
void writeFile(fs::FS &fs, const char * path, const char * message) {
  Serial.printf("Writing file: %sn", path);

  File file = fs.open(path, FILE_WRITE);
  if(!file) {
    Serial.println("Failed to open file for writing");
    return;
  }
  if(file.print(message)) {
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  file.close();
}

// Append data to the SD card
void appendFile(fs::FS &fs, const char * path, const char * message) {
  Serial.printf("Appending to file: %sn", path);

  File file = fs.open(path, FILE_APPEND);
  if(!file) {
    Serial.println("Failed to open file for appending");
    return;
  }
  if(file.print(message)) {
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

// Initialize WiFi
void initWiFi() {
  WiFi.softAP(ssid, password);
  IPAddress IP = WiFi.softAPIP();
  Serial.print("AP IP address: ");
  Serial.println(IP);
}

void setup() {
  Serial.begin(115200);
  initBMP();
  initDisplay();
  initSDCard();
  initWiFi();
  pinMode(buttonPin, INPUT);

  File file = SD.open("/data.txt");
  if(!file) {
    Serial.println("File doesn't exist");
    Serial.println("Creating file...");
    writeFile(SD, "/data.txt", "Pressure, Altitude, Temperature rn");
  }
  else {
    Serial.println("File already exists");  
  }
  file.close();

  // Send web page with input fields to client
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/html", index_html);
  });

  // Send a GET request to <ESP_IP>/get?input1=<inputMessage>
  server.on("/get", HTTP_GET, [] (AsyncWebServerRequest *request) {
    String inputMessage;
    // GET input1 value on <ESP_IP>/get?input1=<inputMessage>
    if (request->hasParam(PARAM_INPUT_1)) {
      inputMessage = request->getParam(PARAM_INPUT_1)->value();
      seaLevelPressure = inputMessage.toFloat();
    }
    else {
      inputMessage = "No message sent";
    }
    Serial.println(inputMessage);
    request->send(200, "text/html", "HTTP GET request sent to your ESP on input field with value: " + inputMessage +
                                     "<br><a href="/">Return to Home Page</a>");
  });
  server.begin();

}
void loop() {
  int reading = digitalRead(buttonPin);
  display.clearDisplay();

  // Light up when the pushbutton is pressed
  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != buttonState) {
      buttonState = reading;
      if (buttonState == HIGH) {
        getReadings();
        displayReadings();
        delay(5000);
        display.clearDisplay();
        display.display();
        lastDebounceTime = millis();
      }
    }
  }
  lastButtonState = reading;

  // Log data every timerDelay seconds
  if ((millis() - lastTimer) > timerDelay) {
    //Concatenate all info separated by commas
    getReadings();
    dataMessage = String(pres) + "," + String(alt) + "," + String(temp)+ "," + String(seaLevelPressure) + "rn";
    Serial.print(dataMessage);
    //Append the data to file
    appendFile(SD, "/data.txt", dataMessage.c_str());
    lastTimer = millis();
  }
}

Afficher le code brut

Comment fonctionne le code

Continuez à lire pour savoir comment fonctionne le code, ou passez à la section de démonstration.

Commencez par inclure toutes les bibliothèques nécessaires :

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BMP3XX.h"
#include <WiFi.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>
//Libraries for microSD card
#include "FS.h"
#include "SD.h"
#include "SPI.h"

Les lignes suivantes définissent le nom et le mot de passe du point d’accès. Dans ce cas, nous définissons le mot de passe sur NUL— cela crée un point d’accès ouvert. Vous pouvez ajouter un mot de passe pour le point d’accès si vous le souhaitez.

// Replace with your network credentials
const char* ssid     = "ESP32";
const char* password = NULL;

Définissez la taille d’affichage OLED et instanciez une instance sur les broches I2C par défaut.

// OLED Display
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

Nous avons défini la pression au niveau de la mer par défaut à 1013,25 hPa. Cependant, vous devez vous connecter au point d’accès pour modifier cette valeur afin d’obtenir des résultats plus précis.

float seaLevelPressure = 1013.25;

Créez une instance pour le capteur BMP388 appelée bmp– cela utilise automatiquement les broches I2C par défaut.

Adafruit_BMP3XX bmp;

Les variables suivantes seront utilisées pour enregistrer les données du capteur.

float alt;
float temp;
float pres;
String dataMessage;

Le bouton poussoir est connecté au GPIO 4.

const int buttonPin = 4;

le boutonÉtat et lastButtonState Les variables enregistrent l’état actuel du bouton et le dernier état du bouton.

int buttonState;              
int lastButtonState = LOW;

Les variables suivantes sont utilisées pour anti-rebond du bouton-poussoir.

unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;    // the debounce time; increase if the output flickers

Les lectures BMP388 sont enregistrées chaque minute. Vous pouvez changer cela dans le temporisateur variable (en millisecondes).

//Timers for datalogging
unsigned long lastTimer = 0;
unsigned long timerDelay = 60000;

le PARAM_INPUT_1 sera utilisée pour rechercher la valeur d’entrée sur le formulaire HTML. Pour en savoir plus sur les formulaires HTML avec l’ESP32, nous vous recommandons ce tutoriel.

const char* PARAM_INPUT_1 = "seaLevelPressure";

le index_html La variable enregistre une simple page HTML qui affiche un champ de saisie pour saisir la pression actuelle au niveau de la mer.

// HTML web page to handle 1 input field
const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html><head>
  <title>Sea Level Pressure</title>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  </head><body>
  <form action="/get">
    Sea Level Pressure: <input type="float" name="seaLevelPressure">
    <input type="submit" value="Submit">
  </form>
</body></html>)rawliteral";

Lorsque vous soumettez une nouvelle valeur de pression, l’ESP32 reçoit une requête sur l’URL suivante (par exemple, pression = 1022) :

/get?seaLevelPressure=1022

Initialiser BMP388

le initBMP() La fonction initialise le capteur BMP388. Lisez l’ESP32 avec le tutoriel BMP388 pour en savoir plus.

void initBMP(){
  if (!bmp.begin_I2C()) {   // hardware I2C mode, can pass in address & alt Wire
  //if (! bmp.begin_SPI(BMP_CS)) {  // hardware SPI mode  
  //if (! bmp.begin_SPI(BMP_CS, BMP_SCK, BMP_MISO, BMP_MOSI)) {  // software SPI mode
    Serial.println("Could not find a valid BMP3 sensor, check wiring!");
    while (1);
  }

  // Set up oversampling and filter initialization
  bmp.setTemperatureOversampling(BMP3_OVERSAMPLING_8X);
  bmp.setPressureOversampling(BMP3_OVERSAMPLING_4X);
  bmp.setIIRFilterCoeff(BMP3_IIR_FILTER_COEFF_3);
  bmp.setOutputDataRate(BMP3_ODR_50_HZ);
}

Obtenez des lectures BMP388

le getReadings() la fonction obtient de nouvelles lectures: température, pression et altitude et les enregistre sur le température, presse, et alt variables.

void getReadings(){
  if (! bmp.performReading()) {
    Serial.println("Failed to perform reading :(");
    return;
  }
  temp = bmp.temperature;
  pres = bmp.pressure / 100.0;
  alt = bmp.readAltitude(seaLevelPressure);
}

Initialiser l’affichage OLED

le initAffichage() La fonction initialise l’affichage OLED.

void initDisplay(){
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  }
  delay(500);
  display.clearDisplay();
  display.setTextColor(WHITE); 
}

Pour en savoir plus sur l’écran OLED avec l’ESP32, lisez ESP32 OLED Display with Arduino IDE.

Afficher les lectures BMP388

le displayReadings() La fonction affiche la température et l’altitude sur l’écran.

void displayReadings(){
  display.clearDisplay();
  // display temperature
  display.setTextSize(1);
  display.setCursor(0,0);
  display.print("Temperature: ");
  display.setTextSize(2);
  display.setCursor(0,10);
  display.print(String(temp));
  display.print(" ");
  display.setTextSize(1);
  display.cp437(true);
  display.write(167);
  display.setTextSize(2);
  display.print("C");
  // display altitude
  display.setTextSize(1);
  display.setCursor(0, 35);
  display.print("Altitude: ");
  display.setTextSize(2);
  display.setCursor(0, 45);
  display.print(String(alt));
  display.print(" m"); 
  display.display();
}

Initialiser la carte microSD

le initSDCard() La fonction initialise la carte microSD sur les broches SPI par défaut.

// Initialize SD card
void initSDCard(){
   if (!SD.begin()) {
    Serial.println("Card Mount Failed");
    return;
  }
}

Si vous souhaitez utiliser d’autres broches, lisez cet article pour savoir comment définir des broches SPI personnalisées.

Écrire sur la carte microSD

le écrireFichier() et ajouterFichier() Les fonctions écrivent et ajoutent un message à un fichier sur la carte microSD.

// Write to the SD card
void writeFile(fs::FS &fs, const char * path, const char * message) {
  Serial.printf("Writing file: %sn", path);

  File file = fs.open(path, FILE_WRITE);
  if(!file) {
    Serial.println("Failed to open file for writing");
    return;
  }
  if(file.print(message)) {
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  file.close();
}

// Append data to the SD card
void appendFile(fs::FS &fs, const char * path, const char * message) {
  Serial.printf("Appending to file: %sn", path);

  File file = fs.open(path, FILE_APPEND);
  if(!file) {
    Serial.println("Failed to open file for appending");
    return;
  }
  if(file.print(message)) {
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

Pour en savoir plus sur les fonctions de la carte microSD, lisez ESP32: Guide for MicroSD Card Module using Arduino IDE.

Définir le point d’accès

Initialisez le Wi-Fi en définissant l’ESP32 comme point d’accès.

// Initialize WiFi
void initWiFi() {
  WiFi.softAP(ssid, password);
  IPAddress IP = WiFi.softAPIP();
  Serial.print("AP IP address: ");
  Serial.println(IP);
}

mettre en place()

Dans le mettre en place(), initialisez le Serial Monitor, le capteur BMP388, l’écran OLED, la carte microSD, démarrez le point d’accès et définissez le bouton poussoir comme un SAISIR.

Serial.begin(115200);
initBMP();
initDisplay();
initSDCard();
initWiFi();
pinMode(buttonPin, INPUT);

Créez un nouveau fichier sur la carte microSD appelé données.txt s’il n’existe pas déjà.

File file = SD.open("/data.txt");
if(!file) {
  Serial.println("File doesn't exist");
  Serial.println("Creating file...");
  writeFile(SD, "/data.txt", "Pressure, Altitude, Temperature rn");
}
else {
  Serial.println("File already exists");  
}
file.close();

Lorsque vous accédez au point d’accès à la root (/) URL, le serveur (ESP32) envoie la page HTML (index_html variable) avec le formulaire.

// Send web page with input fields to client
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/html", index_html);
});

La partie suivante récupère le champ de saisie que vous avez inséré dans le formulaire et l’enregistre dans le merNiveauPression variable.

// Send web page with input fields to client
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
  request->send_P(200, "text/html", index_html);
});

// Send a GET request to <ESP_IP>/get?input1=<inputMessage>
server.on("/get", HTTP_GET, [] (AsyncWebServerRequest *request) {
  String inputMessage;
  // GET input1 value on <ESP_IP>/get?input1=<inputMessage>
  if (request->hasParam(PARAM_INPUT_1)) {
    inputMessage = request->getParam(PARAM_INPUT_1)->value();
    seaLevelPressure = inputMessage.toFloat();
  }
  else {
    inputMessage = "No message sent";
  }
  Serial.println(inputMessage);
  request->send(200, "text/html", "HTTP GET request sent to your ESP on input field with value: " + inputMessage +
                                     "<br><a href="/">Return to Home Page</a>");
});

Pour en savoir plus sur la façon dont cela fonctionne, lisez : Données d’entrée sur le formulaire HTML ESP32/ESP8266 Web Server à l’aide d’Arduino IDE.

boucler()

Dans le boucler() c’est là que l’on vérifie l’état du bouton poussoir. S’il est enfoncé, nous éclairons l’écran OLED avec les lectures de température et d’altitude actuelles.

int reading = digitalRead(buttonPin);
display.clearDisplay();

// Light up when the pushbutton is pressed
if (reading != lastButtonState) {
  lastDebounceTime = millis();
}
if ((millis() - lastDebounceTime) > debounceDelay) {
  if (reading != buttonState) {
    buttonState = reading;
    if (buttonState == HIGH) {
      getReadings();
      displayReadings();
      delay(5000);
      display.clearDisplay();
      display.display();
      lastDebounceTime = millis();
    }
  }
}
lastButtonState = reading;

Nous sauvegardons également de nouvelles lectures toutes les 60 secondes (temporisateur) variables.

if ((millis() - lastTimer) > timerDelay) {
  //Concatenate all info separated by commas
  getReadings();
  dataMessage = String(pres) + "," + String(alt) + "," + String(temp)+ "," + String(seaLevelPressure) + "rn";
  Serial.print(dataMessage);
  //Append the data to file
  appendFile(SD, "/data.txt", dataMessage.c_str());
  lastTimer = millis();
}

Manifestation

Téléchargez le code sur votre tableau. N’oubliez pas de sélectionner la bonne carte (ESP32) et le bon port COM.

Après le téléchargement, vous devriez obtenir les messages suivants sur le moniteur série*.

Démonstration du moniteur série de l'enregistreur de données de l'altimètre ESP32 BMP388

*Dans mon cas, il affiche « Le fichier existe déjà ». Mais, lorsque vous l’exécutez pour la première fois, il devrait afficher « Le fichier n’existe pas », « Création du fichier… ».

Après quelques secondes, il affichera les premières lectures.

Après cela, si vous souhaitez obtenir des relevés d’altitude plus précis, sur votre ordinateur ou votre smartphone, connectez-vous au point d’accès ESP32. Ouvrez un navigateur et accédez à l’adresse IP 192.168.4.1 et insérez la pression actuelle au niveau de la mer à votre emplacement.

Formulaire HTML ESP32 Insérer la pression au niveau de la mer

Après avoir cliqué sur le bouton d’envoi, vous verrez la valeur insérée sur le moniteur série.

ESP32 BMP388 Altimètre Datalogger Serial Monitor Demonstration Nouvelle valeur pour la pression au niveau de la mer

Si vous cliquez sur le bouton-poussoir, vous pouvez vérifier la température et l’altitude actuelles sur l’écran OLED.

ESP32 BMP388 Capteur Altitude Pression Température Arduino Oled SSD1306 Carte MicroSD Pièces Requises

Si vous souhaitez vérifier toutes les lectures, il vous suffit de connecter la carte microSD à votre ordinateur, et vous pouvez accéder au données.txt fichier avec tous les enregistrements. Pour analyser vos données, vous pouvez utiliser Google Sheets, Excel ou d’autres logiciels.

Conclusion

Ce projet vous a montré comment enregistrer des données sur une carte microSD à l’aide de l’ESP32 et comment obtenir l’altitude à l’aide du capteur de pression BMP388. Vous avez également appris à créer un point d’accès où vous pouvez entrer des données que l’ESP32 utilisera, comme la pression au niveau de la mer.

Nous avons un projet similaire utilisant un capteur de température (il se connecte à un serveur NTP pour horodater les lectures, donc l’ESP32 doit avoir accès à Internet) :

En savoir plus sur l’ESP32 avec nos ressources :

Pourquoi avons-nous créé ce projet ?

Quelques curiosités sur ce projet pour ceux d’entre vous qui aimeraient en savoir un peu plus sur nous. Il y a quelques semaines, nous avons visité l’île de Pico, une île portugaise de l’archipel des Açores. Le paysage comprend un volcan, Ponta do Pico, la plus haute montagne du Portugal, et la plus haute altitude de la dorsale médio-atlantique avec 2351 mètres.

L’un des points forts de la visite de l’île de Pico est l’escalade / la randonnée de la montagne jusqu’au point le plus élevé. Nous avons décidé que ce voyage serait une bonne occasion de tester le capteur BMP388 à différentes altitudes. Nous avons donc créé ce projet d’enregistrement de données.

Au sommet, le capteur marquait environ 2 260 mètres, soit environ 90 mètres de la valeur réelle (2351 mètres). Je ne pense pas qu’une différence de 90 mètres soit pertinente à une telle altitude. Qu’en penses-tu? La température marquait 13 ºC (55 ºF), ce qui était la même température prédite dans les prévisions.

Nous avons essayé de prendre des photos de l’écran OLED montrant les résultats à l’aide de notre smartphone. Malheureusement, en raison de la fréquence d’images de l’écran OLED, les chiffres ne sont pas visibles.

Enregistreur de données BMP388 ESP32

Avez-vous visité l’île de Pico ou les Açores ? Faites-nous savoir dans les commentaires ci-dessous.

Merci d’avoir lu.