Estação Meteorológica num Ecrã e-Paper

Aprenda a construir uma estação meteorológica com um ESP32 que exibe informações meteorológicas locais ou da internet num ecrã e-Paper.

Neste tutorial, vai aprender a construir uma estação meteorológica alimentada por bateria que usa o modo deep-sleep do ESP32 e um ecrã e-Paper para uma longa duração. Na verdade, vamos construir duas versões. Uma versão exibe a temperatura ambiente, humidade e pressão do ar recolhidas através de um sensor BME280. A outra versão lê dados meteorológicos da internet usando OpenWeather e usa o software ESP32-e-Paper-Weather-Display para os exibir.

Vamos começar!

Peças Necessárias

Para este projeto, estou a usar uma placa ESP32 mais antiga (ESP32 lite), que já foi descontinuada mas ainda pode ser encontrada. É a que está listada abaixo. Existe um modelo sucessor (Amazon) com especificações melhoradas. E a placa padrão que a biblioteca ESP32-e-Paper-Weather-Display usa é uma LOLIN D32, que tem um monitor integrado de voltagem da bateria.

Mas qualquer outro ESP32, ESP8266 ou Arduino (com WiFi) também funciona. Preferencialmente, quer uma placa de desenvolvimento com capacidades de carregamento de bateria e baixo consumo em deep-sleep, como as placas ESP32 mencionadas acima.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Ecrã e-Paper

Uma palavra rápida sobre o ecrã e-Paper que vamos usar para a nossa estação meteorológica. Os ecrãs e-Paper, também chamados de ecrãs e-Ink, têm a vantagem de consumir muito pouca energia. Na verdade, a energia só é necessária para atualizar o ecrã. Uma vez atualizado, o conteúdo permanece praticamente para sempre, sem consumir energia.

Outra vantagem do ecrã e-Paper é que tem ângulos de visão fantásticos (>170 graus) e é fácil de ler mesmo sob luz solar direta.

As desvantagens são o tempo lento de atualização, a gama limitada de cores e a ausência de retroiluminação; por isso não se consegue ler no escuro.

Normalmente, um ecrã e-Paper demora 2 segundos a atualizar, embora possa fazer atualizações parciais de secções do ecrã que são muito mais rápidas (0,3 segundos). Isto aplica-se a ecrãs a preto e branco. Os ecrãs a cores são muito, muito mais lentos a atualizar (> 20 segundos), têm poucas cores e são muito mais caros.

Mas para uma estação meteorológica alimentada por bateria que atualiza os dados apenas de alguns em alguns minutos, os ecrãs e-Paper são uma excelente escolha e têm um aspeto muito bom.

Módulo de ecrã e-Paper de 2,9″

Para este projeto, estou a usar especificamente um módulo de ecrã e-Paper de 2,9″, com resolução de 296×128 pixels e um controlador embutido com interface SPI.

Note que a maioria dos módulos de ecrã e-Paper com SPI tem um pequeno interruptor ou jumper que permite alternar entre SPI de 4 fios e SPI de 3 fios. Vamos usar o SPI de 4 fios por defeito.

O módulo de ecrã funciona a 3,3V ou 5V, tem um consumo de sono super baixo de 0,01µA e consome apenas cerca de 26,4mW durante a atualização do conteúdo. Isso significa que pode usar um ecrã e-Paper durante muito tempo mesmo com uma bateria pequena.

Para mais informações sobre ecrãs e-Paper, veja o nosso tutorial Interfacing Arduino To An E-ink Display.

Sensor BME280

Para a nossa estação meteorológica, também queremos medir alguns dados ambientais, como temperatura, humidade e pressão do ar. Vou usar um BME280 sensor aqui. A principal razão é que também tem um modo de baixo consumo, sleep mode, onde consome apenas 0,1µA (3,6 μA em modo normal).

Em combinação com um e-Paper e o ESP32-lite com um consumo em deep-sleep de 5,65mA (a 5V), isto cria uma configuração de muito baixo consumo que pode funcionar durante muito tempo com bateria.

O sensor BME280 é pequeno e normalmente vem numa placa breakout com interface I2C; veja a imagem abaixo.

A interface I2C torna muito fácil a ligação e utilização. O sensor pode medir pressão de 300 hPa a 1100 hPa, temperatura de -40°C a +85°C, e humidade de 0% a 100%. Para mais informações sobre o BME280, leia o nosso tutorial sobre How To Use BME280 Pressure Sensor With Arduino.

Ligação e Teste do e-Paper

Antes de tentar algo mais avançado, vamos ligar e testar o funcionamento do e-Paper. A imagem seguinte mostra a ligação completa para alimentação e SPI.

E aqui está a tabela com todas as ligações. Note que pode alimentar o ecrã com 3,3V ou 5V, mas o ESP32-lite tem apenas saída de 3,3V e as linhas de dados SPI devem ser 3,3V.

Ecrã e-Paper	ESP32 lite
CS/SS	5
SCL/SCK	18
SDA/DIN/MOSI	23
BUSY	15
RES/RST	2
DC	0
VCC	3.3V
GND	G

Instalar a biblioteca GxEPD2

Antes de podermos usar o ecrã e-Paper, precisamos de instalar duas bibliotecas. A biblioteca Adafruit_GFX é uma biblioteca gráfica base que fornece um conjunto comum de primitivas gráficas (texto, pontos, linhas, círculos, etc.). E a biblioteca GxEPD2 fornece o software driver gráfico para controlar um ecrã E-Paper via SPI.

Basta instalar as bibliotecas da forma habitual. Após a instalação, deve vê-las no Library Manager da seguinte forma.

Código de teste

Aqui está um código simples de teste que mostra o texto “Hello Makers!” no ecrã. Veja o código completo primeiro e depois discutimos alguns detalhes.

#define ENABLE_GxEPD2_GFX 0

#include "GxEPD2_BW.h"
#include "Fonts/FreeMonoBold9pt7b.h"

//CS(SS)=5, SCL(SCK)=18, SDA(MOSI)=23, BUSY=15, RES(RST)=2, DC=0
GxEPD2_BW<GxEPD2_290_BS, GxEPD2_290_BS::HEIGHT> epd(GxEPD2_290_BS(5, 0, 2, 15));

void initDisplay() {
  epd.init(115200, true, 50, false);
  epd.setRotation(1);
  epd.setFont(&FreeMonoBold9pt7b);
  epd.setTextColor(GxEPD_BLACK);   
  epd.setFullWindow();
  epd.fillScreen(GxEPD_WHITE);   
}

void displayText() {
  epd.setCursor(20, 20);
  epd.print("Hello");
  epd.setCursor(20, 40);
  epd.print("Makers!");    
}

void setup() {
  initDisplay();
  displayText();
  epd.display();
  epd.hibernate();
}

void loop() {
}

Vamos decompor o código nos seus componentes para entender como funciona.

Constantes e Bibliotecas

O código começa por definir uma constante ENABLE_GxEPD2_GFX como 0. Pode definir para 1, o que segundo a documentação permite que a classe base GxEPD2_GFX passe referências ou ponteiros para a instância do ecrã como parâmetro. Mas isso usa cerca de 1,2k mais código e não precisamos, por isso está definido como 0.

#define ENABLE_GxEPD2_GFX 0

De seguida, incluímos o ficheiro header GxEPD2_BW.h para um ecrã e-Paper a preto e branco (BW) e a fonte que vamos usar. Se tiver um ecrã a 3 cores, teria de incluir GxEPD2_3C.h, ou GxEPD2_4C.h para um ecrã a 4 cores, e GxEPD2_7C.h para um ecrã a 7 cores, em vez disso.

#include "GxEPD2_BW.h"
#include "Fonts/FreeMonoBold9pt7b.h"

A biblioteca Adafruit_GFX vem com muitas fontes diferentes e pode encontrá-las na sua pasta de bibliotecas em {application_path}\Arduino\libraries\Adafruit_GFX_Library\Fonts.

Objeto do Ecrã

A linha seguinte é importante. Cria o objeto do ecrã e depende do tipo ou marca do ecrã. Testei um WeAct e um WaveShare e a linha seguinte funciona para ambos.

GxEPD2_BW<GxEPD2_290_BS, GxEPD2_290_BS::HEIGHT> epd(GxEPD2_290_BS(5, 0, 2, 15));

A lista Readme para a biblioteca GxEPD2 inclui um enorme número de ecrãs suportados e pode encontrar os detalhes nos ficheiros header, por exemplo GxEPD2.h.

Inicialização do Ecrã

A função initDisplay() é responsável por inicializar o ecrã e-Paper. Define parâmetros do ecrã como velocidade de comunicação, rotação, fonte, cor do texto e cor de fundo. Se tiver problemas com a atualização do ecrã, pode ter de ajustar o parâmetro da função init().

void initDisplay() {
  epd.init(115200, true, 50, false);
  epd.setRotation(1);
  epd.setFont(&FreeMonoBold9pt7b);
  epd.setTextColor(GxEPD_BLACK);   
  epd.setFullWindow();
  epd.fillScreen(GxEPD_WHITE);   
}

Exibir Texto

A função displayText() posiciona o cursor no ecrã e imprime o texto “Hello” e “Makers!” em coordenadas específicas.

void displayText() {
  epd.setCursor(20, 20);
  epd.print("Hello");
  epd.setCursor(20, 40);
  epd.print("Makers!");    
}

Função Setup

Na função setup(), o ecrã é inicializado usando initDisplay(), o texto é exibido usando displayText(), e depois o conteúdo é mostrado no ecrã e-Paper. Finalmente, o ecrã é colocado em modo hibernação, desligando o ecrã e colocando o controlador em modo deep-sleep.

void setup() {
  initDisplay();
  displayText();
  epd.display();
  epd.hibernate();
}

Função Loop

A função loop() está vazia neste código, pois o conteúdo do ecrã é configurado na função setup() e não precisa de ser atualizado continuamente. O ESP32 não executa ações específicas no loop.

void loop() {
}

Carregar e Executar Código

Agora estamos prontos para carregar e executar o código. Selecione a placa que tem no board manager. No meu caso é a WEMOS LOLIN32 Lite que estava listada nas Peças Necessárias:

Depois pressione upload e, após algum piscar, o seu ecrã deve mostrar o seguinte texto:

Se funcionar, podemos avançar para algo um pouco mais complicado. Se não, verifique as ligações e a linha onde o objeto do ecrã é criado. Especificamente, quais os pinos atribuídos à interface SPI.

Ligação do e-Paper e BME280 ao ESP32

Queremos mostrar temperatura ambiente, humidade e pressão do ar usando o sensor BME280. Adicionar o sensor é fácil, devido à interface I2C. Basta ligar SDA ao pino 33 e SCL ao pino 25, como mostrado abaixo.

Pode usar pinos diferentes para I2C, mas se o fizer, não se esqueça de ajustar o código na próxima secção em conformidade.

Note que existem versões de 5V e 3,3V da placa breakout do BME280. Estou a usar a versão de 3,3V e por isso ligo o VCC ao pino 3,3V do ESP32.

Como a WEMOS LOLIN32 Lite tem uma porta de bateria e carregador integrados, pode alimentar todo o sistema com uma bateria LiPo. A imagem abaixo mostra a ligação completa com uma bateria LiPo ligada:

Mesmo com a pequena bateria LiPo de 420mAh usada aqui, consegui fazer o sistema funcionar durante vários dias (com um ciclo de atualização de 5 minutos).

Na próxima secção vamos escrever o código para mostrar os dados do sensor no ecrã e-Paper.

Código para Estação Meteorológica Local

O código seguinte lê temperatura ambiente, humidade e pressão do ar do BME280 a cada 5 minutos e exibe essa informação mais a altitude no ecrã e-Paper. A saída é a seguinte:

Entre os intervalos de 5 minutos, o ESP32, o e-Paper e o BME280 entram todos em modo deep-sleep, o que reduz muito o consumo de energia do sistema. Veja o código completo primeiro e depois analisamos os detalhes:

#define ENABLE_GxEPD2_GFX 0

#include "Wire.h"
#include "GxEPD2_BW.h"
#include "Fonts/FreeMonoBold9pt7b.h"
#include "Fonts/FreeMono9pt7b.h"
#include "Fonts/FreeMonoBold18pt7b.h"
#include "Adafruit_BME280.h"
#include "esp_sleep.h"

#define SECONDS (1000 * 1000)
#define SEALEVELPRESSURE_HPA 1013.25
#define BME280_ADDRESS 0x76

Adafruit_BME280 bme;
GxEPD2_BW<GxEPD2_290_BS, GxEPD2_290_BS::HEIGHT> epd(GxEPD2_290_BS(5, 0, 2, 15));

void initDisplay() {
  epd.init(115200, true, 50, false);
  epd.setRotation(0);
  epd.setFullWindow();
  epd.setTextColor(GxEPD_BLACK);
  epd.fillScreen(GxEPD_WHITE);
}

void initSensor() {
  Wire.begin(33, 25);  // Software I2C for BME280
  bme.begin(BME280_ADDRESS, &Wire);
  bme.setSampling(Adafruit_BME280::MODE_FORCED,
                  Adafruit_BME280::SAMPLING_X1,  // temperature
                  Adafruit_BME280::SAMPLING_X1,  // pressure
                  Adafruit_BME280::SAMPLING_X1,  // humidity
                  Adafruit_BME280::FILTER_OFF);
}

void displayText(int x, int y, const GFXfont* f, const char* text) {
  epd.setFont(f);
  epd.setCursor(x, y);
  epd.print(text);
}

void displayHLine(int y) {
  int o = 8;
  epd.drawFastHLine(o, y, 128 - 2 * o, GxEPD_BLACK);
}

void displayLargeValue(int y, const char* name, float val, const char* unit) {
  static char buffer[32];
  sprintf(buffer, "%7.1f", val);

  displayText(8, y, &FreeMono9pt7b, name);
  displayText(4, y + 30, &FreeMonoBold9pt7b, buffer);
  displayText(86, y + 30, &FreeMono9pt7b, unit);
  displayHLine(y + 50);
}

void displaySmallValue(int y, char* name, float val, char* unit) {
  static char buffer[32];
  sprintf(buffer, "%5.1f", val);

  displayText(8, y, &FreeMono9pt7b, name);
  displayText(4, y + 35, &FreeMonoBold18pt7b, buffer);
  displayText(110, y + 35, &FreeMono9pt7b, unit);
  displayHLine(y + 50);
}

void setup() {
  initSensor();
  initDisplay();

  int o = 20, d = 76;
  bme.takeForcedMeasurement();
  float temp = bme.readTemperature();
  displaySmallValue(o, "temp", temp, "C");
  float hum = bme.readHumidity();
  displaySmallValue(o + d, "hum", hum, "%");
  float alt = bme.readAltitude(SEALEVELPRESSURE_HPA);
  displayLargeValue(o + 2 * d, "alt", alt, "m");
  float pres = bme.readPressure() / 100.0;
  displayLargeValue(o + 3 * d, "pres", pres, "hPa");
  
  epd.display();
  epd.hibernate();

  esp_sleep_enable_timer_wakeup(5 * 60 * SECONDS);
  esp_deep_sleep_start();
}

void loop() {
}

No código acima, estamos a mostrar leituras de temperatura, humidade e pressão do ar de um sensor BME280 num ecrã e-Paper. O sensor está ligado via I2C por software e o ecrã é controlado usando a biblioteca GxEPD2.

Constantes e Bibliotecas

Começamos por incluir as bibliotecas necessárias mais três bibliotecas de fontes diferentes. Note que vai precisar de instalar a Adafruit_BME280 library, se ainda não o fez.

#define ENABLE_GxEPD2_GFX 0

#include "Wire.h"
#include "GxEPD2_BW.h"
#include "Fonts/FreeMonoBold9pt7b.h"
#include "Fonts/FreeMono9pt7b.h"
#include "Fonts/FreeMonoBold18pt7b.h"
#include "Adafruit_BME280.h"
#include "esp_sleep.h"

#define SECONDS (1000 * 1000)
#define SEALEVELPRESSURE_HPA 1013.25
#define BME280_ADDRESS 0x76

O endereço I2C do sensor BME280 é tipicamente 0x76, mas o seu pode ser diferente e em algumas placas breakout pode alternar entre dois endereços. A constante SEALEVELPRESSURE_HPA é usada pela biblioteca BME280 para calcular a altitude com base na pressão do ar. Isto é algo que deve ajustar à sua localização. Veja o nosso tutorial sobre How To Use BME280 Pressure Sensor With Arduino para mais detalhes.

Objetos do Sensor e do Ecrã

De seguida, criamos os objetos para o sensor BME280 e para o ecrã e-Paper. Como mencionado antes, se usar um ecrã diferente ou ligações diferentes, terá de ajustar a construção do objeto do ecrã.

Adafruit_BME280 bme;
GxEPD2_BW<GxEPD2_290_BS, GxEPD2_290_BS::HEIGHT> epd(GxEPD2_290_BS(5, 0, 2, 15));

Funções de Inicialização

A função initDisplay() inicializa o ecrã e-Paper configurando a comunicação, rotação, cor e limpando o ecrã. A função initSensor() inicializa o sensor BME280 iniciando a comunicação I2C e configurando as definições do sensor.

void initDisplay() {
  ...
}

void initSensor() {
  Wire.begin(33, 25);  // Software I2C for BME280
  bme.setSampling(Adafruit_BME280::MODE_FORCED,
  ..
  )
}

Como estamos a usar I2C por software para o sensor BME280, precisamos de chamar Wire.begin(33, 25) com os pinos SDA e SCL que estamos a usar. Se ligar o sensor BME280 a pinos diferentes, terá de alterar o código aqui.

Note que executamos o sensor BME280 com a configuração MODE_FORCED. Em forced mode o sensor faz uma medição, armazena os resultados e depois entra em deep-sleep. É isso que queremos, pois entre medições vamos colocar o ESP32 e o ecrã em deep-sleep também.

Funções de Exibição

Existem várias funções para exibir texto, linhas horizontais, valores grandes (pressão, altitude) e valores pequenos (temperatura, humidade) no ecrã e-Paper. Estas funções tratam da formatação e posicionamento dos dados a mostrar.

void displayText(int x, int y, const GFXfont* f, const char* text) {
  // Display text code
}
void displayHLine(int y) {
  // Display horizontal line code
}
void displayLargeValue(int y, const char* name, float val, const char* unit) {
  // Display large value code
}
void displaySmallValue(int y, char* name, float val, char* unit) {
  // Display small value code
}

Função Setup

Na função setup(), o sensor e o ecrã são inicializados. São feitas leituras de temperatura, humidade, altitude e pressão e exibidas no ecrã e-Paper. O ecrã é depois atualizado e colocado em modo hibernação.

Depois disso, também colocamos o ESP32 em modo deep-sleep e configuramos para acordar automaticamente após 5 minutos.

void setup() {
  initSensor();
  initDisplay();

  bme.takeForcedMeasurement();
  float temp = bme.readTemperature();
  displaySmallValue(o, "temp", temp, "C");
  ...

  epd.display();
  epd.hibernate();

  esp_sleep_enable_timer_wakeup(5 * 60 * SECONDS);
  esp_deep_sleep_start();
}

Função Loop

A função loop() está vazia porque o ESP32 entra em deep sleep após o setup e nunca entra na função loop. Mas acorda a cada 5 minutos e executa novamente a função setup.

Cada atualização do ecrã demora 2-3 segundos e provoca muito piscar, o que é bastante desconfortável e não fica bem. Pode evitar isso fazendo uma atualização parcial. Para mais detalhes, veja o tutorial Partial Refresh of e-Paper Display.

Além disso, agora tem uma pequena estação meteorológica alimentada por bateria que exibe e atualiza temperatura ambiente, humidade, pressão do ar e altitude!

Código para Estação Meteorológica da Internet

Se quiser uma estação meteorológica mais avançada que obtenha os dados da internet, existe a fantástica biblioteca ESP32-e-Paper-Weather-Display que faz isso por si.

Dependendo do tamanho do ecrã, mostra temperatura, humidade, pressão, direção do vento, fases da lua, condições meteorológicas, previsão do tempo e mais. No ecrã e-Paper de 2,9″ que estou a usar aqui, fica assim:

Instalação da biblioteca ESP32-e-Paper-Weather-Display

Para instalar a biblioteca ESP32-e-Paper-Weather-Display, precisa de descarregar o ficheiro zip do repositório github e depois instalá-lo via Sketch -> Include Library -> Add .ZIP Library ....

Também vai precisar da GxEPD2 library e da Adafruit_GFX library, mas essas já as tem instaladas nas secções anteriores.

Configurar a biblioteca ESP32-e-Paper-Weather-Display

Antes de poder exibir dados meteorológicos da internet usando a biblioteca ESP32-e-Paper-Weather-Display, há algum trabalho a fazer. Primeiro, precisamos de obter uma chave API da OpenWeather, depois descarregar o código de exemplo para o nosso ecrã, e finalmente atualizar o ficheiro de configurações no código de exemplo com a chave API e as credenciais Wi-Fi.

Chave API OpenWeather

A biblioteca ESP32-e-Paper-Weather-Display usa o serviço gratuito OpenWeather para receber dados meteorológicos da internet. Antes de poder usar qualquer uma das APIs da OpenWeather, precisa de uma chave API e para isso precisa de uma conta. Para criar uma conta gratuita, vá ao sign-up page e insira os seus dados.

Depois, vá à página de criação de api-key e crie uma chave API. A chave API é aquela longa sequência “sdfd87fakeby6apikeysf4z” que vê na captura de ecrã abaixo. A sua chave será diferente da minha.

Se precisar de mais ajuda, veja o nosso tutorial: Simple ESP32 Internet Weather Station.

De seguida, descarregue o código de exemplo para o tamanho e tipo do seu ecrã do repositório github da biblioteca ESP32-e-Paper-Weather-Display. Por exemplo, eu descarreguei o código para o Waveshare_2_9 example.

Alternativamente, pode usar o Arduino IDE que também tem alguns, mas não todos, os exemplos:

Ficheiro de configurações owm_credential.h

Finalmente, abra o ficheiro .ino (ex. Waveshare_2_9.ino) no Arduino IDE e clique no separador do ficheiro owm_credential.h.

Este ficheiro tem todas as configurações específicas para a sua estação meteorológica, como localização, unidades, idioma, fuso horário e assim por diante. Mais importante, tem as constantes para as suas credenciais Wi-Fi (ssid, password) e a chave API da OpenWeather que precisa de definir aí.

Como mencionado, dependendo do tamanho do ecrã e-Paper, a biblioteca ESP32-e-Paper-Weather-Display mostra informações meteorológicas mais ou menos detalhadas. Num ecrã grande de 7,5″, obtém um conjunto muito rico de dados meteorológicos e fica absolutamente fantástico:

Monitor de bateria

Finalmente, a biblioteca ESP32-e-Paper-Weather-Display também exibe nativamente informações da bateria se usar um Lolin D32 board que tenha o GPIO-35 como entrada ADC:

Noutras placas, terá de alterar a instrução analogRead(35) no código e especificar o pino onde o seu monitor de voltagem está ligado.

Um monitor de voltagem pode ser um simples divisor de tensão ligado aos terminais da bateria. Veja How to Monitor Battery Voltage for Battery Powered Projects para mais detalhes sobre isso. Para estimativas mais precisas da carga da bateria, pode usar ICs específicos de monitorização de bateria, como o MAX1704X.

Conclusões

Neste tutorial aprendeu a construir uma estação meteorológica alimentada por bateria com um ESP32, um sensor BME280 e um ecrã e-Paper.

Usámos um sensor BME280 para medir temperatura ambiente, humidade e pressão do ar. E usamos o software ESP32-e-Paper-Weather-Display para exibir dados meteorológicos da internet.

Com isso tem todos os componentes para construir a sua própria versão que, por exemplo, pode combinar dados meteorológicos da internet com informação local. Também pode recolher informação de sensores remotos e adicioná-los ao ecrã.

Divirta-se a experimentar e se tiver alguma dúvida, não hesite em perguntar 😉