Vitor Hugo
- 12 de mar. de 2023
- 6 min para ler

Monitorando temperatura, pressão e altitude utilizando o sensor BMP180, ESP8266 e a plataforma IOTA

Atualizado: 2 de dez. de 2023

Introdução

Com a crescente popularidade da Internet das Coisas (IoT), monitorar e coletar dados de sensores em tempo real tornou-se uma tarefa cada vez mais comum. Neste post, vamos explorar como monitorar temperatura, pressão e altitude usando o sensor BMP180 e o módulo ESP8266. Além disso, vamos enviar os dados via MQTT para a visualização em tempo real dos dados atráves de uma dashboard criada na plataforma IOTA .

Materiais necessários

Sensor BMP180
ESP8266
Placa de prototipagem (protoboard)
Jumpers
Cabo USB
Plataforma IOTA

Sensor BMP180

O BMP180 é um sensor de pressão barométrica e temperatura que pode ser usado para medir a altitude com base na pressão do ar. Ele é um dispositivo relativamente simples que se comunica com o microcontrolador através do protocolo I2C. O BMP180 é capaz de medir pressão de 300 a 1100 hPa com uma resolução de 0,1 hPa e temperatura de -40 a 85 graus Celsius com uma resolução de 0,1 grau Celsius.

Módulo ESP8266

O ESP8266 é um módulo de Wi-Fi que pode ser programado como um microcontrolador. Ele é capaz de se conectar a uma rede Wi-Fi e se comunicar com outros dispositivos na rede. O ESP8266 tem vários pinos GPIO que podem ser usados para se comunicar com outros dispositivos, como o BMP180, usando protocolos como I2C e SPI.

Plataforma IOTA

Plataforma IoT desenvolvida pela VIMAC SOLUÇÕES com o intuito de facilitar a criação de aplicações IoT na nuvem de forma gratuita e intuitiva. Nesse tutorial, a plataforma será utilizada para apresentação real-time dos dados do sensor BMP180.

Montando o circuito

O circuito é bastante simples e requer apenas a conexão do sensor BMP180 ao ESP8266. O sensor BMP180 é um dispositivo I2C, o que significa que ele se comunica utilizando dois pinos: SDA (Serial Data) e SCL (Serial Clock). O ESP8266 também possui esses dois pinos, que são o D1 e o D2, respectivamente.

Para conectar o sensor BMP180 ao ESP8266, siga o esquema de ligação abaixo:

Conecte o pino VCC do BMP180 ao pino 3V3 do ESP8266
Conecte o pino GND do BMP180 ao pino GND do ESP8266
Conecte o pino SDA do BMP180 ao pino D2 do ESP8266
Conecte o pino SCL do BMP180 ao pino D1 do ESP8266

A figura apresenta como conectar os componentes.

Cadastrando o dispositivo na plataforma IOTA

Após a montagem do circuito na protoboard, será necessário cadastrar o dispositivo na plataforma IOTA. Selecione o connector "Custom MQTT", defina nome e descrição e click em "Create"

Observação: caso você ainda não possua um cadastro na plataforma, cadastre-se gratuitamente através do seguinte link: Sing UP

Ao realizar o cadastro, serão gerados na aba MQTT as credenciais de autenticação do dispositivo. Guarde essas informações, pois elas serão utilizadas em seguida no código para autenticação e envio das informações do sensor para a plataforma IOTA via protocolo MQTT.

Configurando o ambiente de desenvolvimento

Para programar o ESP8266, vamos utilizar a IDE do Arduino. Se você ainda não tem a IDE do Arduino instalada, faça o download e a instale.

Em seguida, abra a IDE do Arduino e siga os passos abaixo:

Vá em "Arquivo" -> "Preferências" e cole o link abaixo no campo "URLs Adicionais para Gerenciadores de Placas": http://arduino.esp8266.com/stable/package_esp8266com_index.json
Vá em "Ferramentas" -> "Placa" -> "Gerenciador de Placas" e pesquise por "ESP8266". Instale a placa ESP8266.
Vá em "Ferramentas" -> "Placa" e selecione a placa "NodeMCU 1.0 (ESP-12E Module)".

Instalando as bibliotecas necessárias

Antes de começar a construir nosso projeto, precisamos instalar algumas bibliotecas. Para este projeto, precisaremos instalar as seguintes bibliotecas: Adafruit_BMP085, PubSubClient, ESPDateTime e ArduinoJson.

Para instalar a biblioteca Adafruit_BMP085, abra o Arduino IDE e vá para Sketch > Incluir Biblioteca > Gerenciar Bibliotecas. Na caixa de pesquisa, digite "Adafruit_BMP085" e clique em "Instalar".

Para instalar as demais bibliotecas, repita o mesmo procedimento apresentado acima, procurando pelo nome das demais biblioteca na caixa de pesquisa.

Escrevendo o código

Agora que já configuramos o ambiente de desenvolvimento, vamos escrever o código para ler os dados do sensor BMP180 e enviá-los via MQTT para a plataforma IOTA.

Abra o Arduino IDE e crie um novo projeto. Copie e cole o código abaixo:

#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <ESPDateTime.h>
#include <ArduinoJson.h>
#include <Adafruit_BMP085.h>

Adafruit_BMP085 bmp;

// Update these with values suitable for your network.
const char* ssid = "seu_wifi";
const char* password = "senha_do_seu_wifi";
const char* mqtt_server = "iota.vimacsolucoes.com.br";

const char* ntpServer = "pool.ntp.org";
const char* gmtOffset = "GMT+3";     //Replace with your GMT offset
const char* dateTime;
const char* mqttTopic = "topico_mqtt_criado_na_iota";
const char* clientID = "client_ID_criado_na_iota";
const char* username = "usuario_criado_na_iota";
const char* passwd = "password_criado_na_iota";

String datetime, mac;
float temperature, pressure, altitude;

WiFiClient espClient;
PubSubClient client(espClient);
unsigned long updateInterval = 300000;  //Intervalo de envio de dados p/ plataforma (em milisegundos)
unsigned long lastMsg = 2000 - updateInterval; //Variável de controle do loop

#define MSG_BUFFER_SIZE  (200)
char msg[MSG_BUFFER_SIZE];

void setup_wifi() {
  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  randomSeed(micros());

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Attempt to connect
    if (client.connect(clientID, username, passwd)) {
      Serial.println("connected");
      // Once connected, publish an announcement...
//      client.publish("outTopic", "hello world");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

void setup_datetime(){
  //setup datetime config
  DateTime.setServer(ntpServer);
  DateTime.setTimeZone(gmtOffset);
  DateTime.begin();
  if (!DateTime.isTimeValid()) {
    Serial.println("Failed to get time from server.");
  } else {
    Serial.printf("Date Now is %s\n", DateTime.toISOString().c_str());
//    Serial.printf("Timestamp is %ld\n", DateTime.now());
  }
}

void setup() {
  pinMode(BUILTIN_LED, OUTPUT);     // Initialize the BUILTIN_LED pin as an output
  Serial.begin(115200);
  
  // Código de conexão Wi-Fi e conexão ao Broker MQTT
  setup_wifi();
  client.setServer(mqtt_server, 1883);

  //start and config datetime
  setup_datetime();

  if (!bmp.begin()) {
    Serial.println("Could not find a valid BMP085 sensor, check wiring!");
    while (1);
  }
}

void loop() {

  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  unsigned long now = millis();
  if (now - lastMsg > updateInterval) {
    lastMsg = now;

    if (!DateTime.isTimeValid()) {
      Serial.println("Failed to get time from server, retry.");
      DateTime.begin();
    } else {
      Serial.println(DateTime.toISOString());
    }

    // Código de leitura do sensor BMP180
    temperature = bmp.readTemperature();
    pressure = bmp.readPressure();
    altitude = bmp.readAltitude();

    if (isnan(temperature) || isnan(pressure)) {
      Serial.println("Failed to read temperature and pressure from DHT sensor");
      return;
    }

    // Allocate the JSON document
    DynamicJsonDocument  doc(MSG_BUFFER_SIZE);
    // Atribui os valores ao documento JSON
    doc["ts"] = DateTime.toISOString();
    doc["device"] = WiFi.macAddress();
    doc["temperature"] = String(temperature);
    doc["pressure"] = String(pressure); 
    doc["altitude"] = String(altitude);
    serializeJson(doc, msg);

    // Publica os dados no tópico MQTT
    client.publish(mqttTopic, msg);
    
    Serial.print("Publish message: ");
    Serial.println(msg);   

  }
}

Observação: Lembre-se de preencher as variáveis ssid e password com as suas próprias credenciais do Wi-Fi. Preencha também as variáveis clientID, mqttTopic, username e passwd com as credencias geradas na aba MQTT ao cadastrar os dispositivo.

Executando o código e publicando as messagens para a plataforma IOTA

Em seguida, compile e grave o código no seu ESP8266. Quando terminar a gravação, abra o monitor serial e coloque 115200 na velocidade de comunicação da porta serial. Verifique se o ESP8266 se conectou a rede WiFi (“Wifi connected”) e também ao broker MQTT da plataforma ("Attempting MQTT connection...connected"). Se tudo ocorrer como esperado, você verá as menssagens sendo publicadas para a plataforma IOTA, conforme a imagem abaixo.

Vá até a aba "Live Data" da plataforma para verificar as informações recebidas pela plataforma.

Você verá que foram definas cinco váriaveis no JSON do código-fonte para envio dos dados para a plataforma IOTA. São elas:

"ts": horário de leitura das medidas do sensor;
"device": endereço MAC do ESP8266;
“temperature”: temperatura ambiente;
“pressure”: pressão atmosférica;
"altitude": altitude local;

Guarde bem o nome das três últimas variáveis, pois elas serão utilizados em seguida para criação da dashboard.

Criando uma dashboard para visualização dos dados

Agora que os dados do sensor BMP180 já estão sendo enviados para a plataforma IOTA, chegou a hora de criar uma dashboard para visualização das medidas de temperatura, pressão e altitude.

A plataforma IOTA permite a criação de dashboards customizadas de uma forma fácil e intuitiva. A construção da dashboard é feita através da adição de widgets. Os widgets, por sua vez, podem ser ajustados para customizar a dashboard da forma que mais agradar o usuário. Alguns exemplos de customizações incluem a mudança dos títulos, estilo dos gráficos, redimencionamento dos widgets, reorganização do layout dentro da dashboard, etc.

O vídeo abaixo apresenta de forma detalhada como adicionar e customizar os widgets no processo de criação da dashboard:

Observação: Ao criar um novo widget, lembre-se de escrever na opção "Variable" o nome de umas das variáveis definidas no JSON do código fonte, as mesmas váriaveis visualizadas no monitor serial da etapa anterior (temperature, pressure ou altitude).

Conclusão

Com este projeto, aprendemos a como monitorar temperatura, pressão e altitude usando o sensor BMP180, o ESP8266 e a plataforma IOTA. Aprendemos como enviar esses dados via WiFi e protocolo MQTT para a plataforma IOTA e como criar de forma fácil e intuitiva dashboards customizáveis para visualização das informações, tornando este projeto uma ótima opção para monitorar condições ambientais em tempo real e também as condições atmosféricas de um local remoto.