• ESP32 com BMP280, MPU6050 e Cartão SD

    Aprenda a utilizar o sensor BMP280, MPU6050 e o Cartão SD junto ao microcontrolador ESP32  

Introdução

Dentro do subsistema de eletrônica da GDAe, fizemos uma escolha estratégica ao utilizar a placa ESP32 como nosso microcontrolador principal. A ESP32 oferece uma ampla gama de recursos que atendem às nossas necessidades, desde a coleta de dados de sensores até o armazenamento de informações e a futura comunicação.

Um dos sensores fundamentais em nosso kit é o MPU6050, que nos permite coletar dados precisos de movimento e orientação. Combinando a ESP32 e o MPU6050, conseguimos explorar todo o potencial do projeto, mantendo um desempenho robusto sem comprometer recursos.

Além do MPU6050, também utilizamos o sensor BMP280 para medir pressão atmosférica, temperatura e umidade. Esses dados são essenciais para algumas de nossas aplicações, especialmente aquelas relacionadas à navegação e controle de altitude.

Por fim, o módulo de leitor de cartão SD nos permite armazenar dados de forma rápida e eficiente, o que é crucial para garantir a integridade e disponibilidade das informações coletadas durante as missões.

Esquema Elétrico

O sensor BMP280 utiliza o protocolo de comunicação I2C. Sendo assim, não é necessário muito trabalho para conecta-lo a placa ESP32. Pasta você conectar a alimentação VCC (5V ou 3.3V) e GND (0V) e em seguida utilizar os pinos SDA SLC da placa ESP32. Na imagem que segue podemos ver o esquema eletrônico para esse projeto de forma completa.

O sensor MPU6050 ,também como o BMP280, utiliza o protocolo de comunicação I2C. Sendo assim, também não é necessário muito trabalho para conecta-lo a placa ESP32. Pasta você conectar a alimentação VCC (5V ou 3.3V) e GND (0V) e em seguida utilizar os pinos GPIO 22 ( SLC ) GPIO 21 ( SDA )  da placa ESP32. Na imagem que segue podemos ver o esquema eletrônico para esse projeto de forma completa.  

O módulo de leitor de cartão SD também utiliza o protocolo de comunicação SPI (Serial Peripheral Interface), que é comumente usado para dispositivos de armazenamento de dados. Conectar o módulo de leitor de cartão SD à placa ESP32 é relativamente simples. Você precisa conectar a alimentação VCC (5V ou 3.3V) e GND (0V) do módulo ao ESP32 e também conectar os pinos de comunicação SPI, que são MISO (Master In Slave Out), MOSI (Master Out Slave In), SCK (Serial Clock) e CS (Chip Select).

Programação do ESP32

Depois que temos o hardware montado podemos começar a programar a placa ESP32 para obter os dados do sensores e guardar esses dados no cartão SD. Nessa parte vamos utilizar a biblioteca da Adafruit que facilita bastante o uso de sensores padrão Adafruit e que usam a plataforma I2C. O GitHub dessa biblioteca para o MPU6050 pode ser encontrado aqui, enquanto a biblioteca para o BMP280 pode ser encontrado aqui.

Arduino
				#include <Wire.h>
#include <SPI.h>
#include <SD.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BMP280.h>
#include <Adafruit_MPU6050.h>

#define LED_PIN 13 
#define BMP_SDA 21 
#define BMP_SCL 22 

Adafruit_BMP280 bmp;
Adafruit_MPU6050 mpu;

File dataFile;
float checkAltitude[3] = {0,0,0};

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("Teste");
  pinMode(LED_PIN, OUTPUT);
  
  Serial.println("1");

  if (!mpu.begin()) {
    Serial.println(F("Erro ao iniciar o MPU6050. Verifique as conexões!"));
    while (1);
  }
  
  if (!bmp.begin(0x76)) {
    Serial.println(F("Erro ao iniciar o BMP280. Verifique as conexões!"));
    while (1);
  }

  Serial.println("2");

  if (!SD.begin()) {
    Serial.println(F("Erro ao iniciar o cartão SD. Verifique a conexão e o formato do cartão."));
    while (1);
  }
  

  mpu.setAccelerometerRange(MPU6050_RANGE_8_G);
  mpu.setGyroRange(MPU6050_RANGE_500_DEG);
  mpu.setFilterBandwidth(MPU6050_BAND_5_HZ);
  

  float altitudeInicial = bmp.readAltitude();


  dataFile = SD.open("/altitude_data.txt", FILE_APPEND);
  if (dataFile) {
    dataFile.println("-------------------------------------------------- TESTE --------------------------------------------------");
    dataFile.println("------------------------------------------------- LIGADO --------------------------------------------------");
    dataFile.println("-----------------------------------------------------------------------------------------------------------");
    dataFile.close();
  } else {
    Serial.println(F("Erro ao abrir o arquivo no cartão SD."));
  }
}

void loop() {
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);
  float altitude = bmp.readAltitude();
  float aceX, aceY, aceZ, giroX, giroY, giroZ;
  aceX = a.acceleration.x;
  aceY = a.acceleration.y;
  aceZ = a.acceleration.z;
  giroX = g.gyro.x;
  giroY = g.gyro.y;
  giroZ = g.gyro.z;

  bool recuperar = false;

  /*checkAltitude mantém as informações de altitude dos últimos 3 segundos, se no
  decorrer dos 3 segundos a altitude apenas diminuir, acionaremos a recuperação */
  checkAltitude[0] = checkAltitude[1];
  checkAltitude[1] = checkAltitude[2];
  checkAltitude[2] = altitude;

  float margemErro = 0.5;
  if (checkAltitude[0] > (checkAltitude[1] + margemErro) && checkAltitude[1] > (checkAltitude[2] + margemErro)) {
    Serial.println("recuperacao pela Altitude");
    recuperar = true;
  }

  //sensGiro é a velocidade em graus por segundo que ativará a recuperação, aumente ou diminua conforme necessidade
  float sensGiro = 0.75;
  if ((giroX > sensGiro || giroX < -sensGiro) || (giroY > sensGiro || giroY < -sensGiro)){
    Serial.println("recuperacao pelo Giroscopio");
    recuperar = true;
  }

  if(recuperar){
    digitalWrite(LED_PIN, HIGH);
  } else{
    digitalWrite(LED_PIN, LOW);
  }
  recuperar = false;

  dataFile = SD.open("/altitude_data.txt", FILE_APPEND);
  if (dataFile) {
    dataFile.println("Altitude: " + String(altitude) + " metros" + ", Aceleração X: " + String(aceX)
    + ", Y:" + String(aceY) + ", Z:" + String(aceZ) + "m/s^2" + ", Giroscópio X:" + String(giroX) 
    + ", Y:" + String(giroY) + ", Z:" + String(giroZ) + " deg/s");
    dataFile.close();
  } else {
    Serial.println(F("Erro ao abrir o arquivo no cartão SD."));
  }

  delay(1000);
}
			

Fonte: Autor

Obrigado por ler esse post até aqui. Não perca os próximos posts com cada vez mais informações e curiosidades sobre a Programação Embarcada e outras atividades do GDAe. Avante com a eletrônica, rumo ao infinito e além! 🚀

Márcio Renan

Estudante de Engenharia da Computação na Universidade Federal do Ceará, Membro do subsistema da Eletrônica do GDAe e responsável pela programação embarcada do Thunder.🚀

Roberto Sérgio

Estudante de Ciência da Computação na Universidade Federal do Ceará, Membro do subsistema da Eletrônica do GDAe.🚀

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *