Estação meteorológica com LilyGO TTGO T5-4.7 E-Paper

O LilyGO TTGO T5-4.7 E-Paper é um módulo de desenvolvimento integrado que combina um ecrã E-paper (e-ink) de 4,7 polegadas com um microcontrolador ESP32-S3.

O ecrã E-paper da placa funciona com uma resolução de 540 × 960 pixels, com 16 níveis de escala de cinza, e só consome energia durante as operações de atualização, o que minimiza o consumo para dados que mudam lentamente, como dados meteorológicos.

Neste tutorial, vais aprender a começar a usar a placa LilyGO TTGO T5-4.7 E-Paper. Além disso, vamos construir uma estação meteorológica que obtém os seus dados pela internet a partir de OpenWeatherMap e os exibe no E-Paper.

Peças Necessárias

Podes adquirir o LilyGO TTGO T5-4.7 E-Paper na DFRobot ou na Amazon através dos links abaixo. Se quiseres usar o ecrã com bateria, também precisarás de uma bateria.

Recomendo uma bateria recarregável 18650 com o respetivo suporte para bateria. No entanto, terás de soldar os fios do suporte ao conector de bateria do LilyGO E-Paper Display. Não é difícil, mas precisas de um ferro de soldar.

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.

Hardware do LilyGO TTGO T5-4.7 E-Paper

A plataforma LilyGO TTGO T5-4.7 E-Paper é uma placa controladora de ecrã E Ink de 4,7 polegadas que integra um módulo ESP32-S3 com um painel E-paper a tons de cinza acoplado.

O design destina-se a aplicações que beneficiam de informação persistente no ecrã e baixo consumo médio de energia, onde o conteúdo do ecrã pode permanecer visível sem atualização contínua. A foto abaixo mostra a frente e o verso da placa LilyGO TTGO T5-4.7 E-Paper.

Processador e Subsistema de Memória

A placa é construída em torno do módulo ESP32-S3-WROOM-1-N16R18. Esta configuração oferece 16 MB de flash onboard para firmware e recursos, e 8 MB de PSRAM para suportar operações que exigem muita memória, como buffers gráficos, renderização de fontes e gestão de dados de rede.

O ESP32-S3 também permite conectividade Wi-Fi e capacidade de processamento suficiente para aquisição periódica de dados, processamento local e atualizações do ecrã típicas de estações meteorológicas.

Características do Ecrã E-Paper

O painel E-paper integrado tem uma resolução de 540 × 960 pixels em orientação vertical e suporta renderização em escala de cinza de 16 níveis. O ecrã permite atualização parcial, com atualizações seletivas de regiões para reduzir o tempo de atualização e o consumo de energia quando apenas uma parte do conteúdo muda.

No entanto, o ecrã não deve ser atualizado parcialmente por longos períodos, pois imagens residuais podem ficar permanentemente!

Entrada do Utilizador e Controlo a Bordo

A entrada física é suportada por três botões, incluindo um botão personalizável pelo utilizador para funções a nível de aplicação. Os outros botões são reset e boot.

A placa também expõe uma interface dedicada de 6 pinos para ligar um painel touchscreen, que pode ser comprado separadamente.

Interface de Alimentação por Bateria

Para alimentação por bateria, a placa inclui um conector PH 2.0 projetado para ligação a uma bateria de 3,7 V. A proteção contra carga e descarga da bateria é fornecida por um IC de proteção HX6610S.

Cabeçalho de Expansão e Compatibilidade com Host

Um cabeçalho de 40 pinos está disponível na parte superior da placa e é compatível com a interface BUS do Raspberry Pi. Aqui está o pinout do cabeçalho:

Note que as interfaces I2C (SDA, SCL) e SPI (MISO, MOSI, CS) são acessíveis aí. A imagem abaixo mostra os pinouts dos outros conectores da placa:

GPIO

A tabela seguinte lista os pinos GPIO e o seu uso interno pelo ESP32 incorporado. Apenas os pinos GPIO 45, 10, 48 e 39 estão disponíveis para aplicações do utilizador.

GPIO do ESP32S3	Ligado a	Livre
13	74HCT4094D CFG_DATA	❌
12	74HCT4094D CFG_CLK	❌
0	74HCT4094D CFG_STR	❌
38	E-paper CKV	❌
40	E-paper STH	❌
41	E-paper CKH	❌
8	E-paper D0	❌
1	E-paper D1	❌
2	E-paper D2	❌
3	E-paper D3	❌
4	E-paper D4	❌
5	E-paper D5	❌
6	E-paper D6	❌
7	E-paper D7	❌
21	Botão	❌
14	ADC da Bateria	❌
16	SD MISO	❌*
15	SD MOSI	❌*
11	SD SCK	❌*
42	SD CS	❌*
18	SDA	❌
17	SCL	❌
47	IRQ do Painel Tátil	❌
45	Não Ligado	✅
10	Não Ligado	✅
48	Não Ligado	✅
39	Não Ligado	✅

Especificações Técnicas

A tabela seguinte resume as especificações técnicas da estação meteorológica com LilyGO TTGO T5-4.7 E-Paper:

MCU	ESP32-S3-WROOM-1-N16R8
Conectividade Sem Fios	Wi-fi Bluetooth V5.0
Flash	16MB
PSRAM	8MB
Suporte PCF8563 RTC	Deteção de capacidade da bateria
Driver IC	EDO47TC1
Tamanho	4,7 polegadas
Níveis de cinza	16
Resolução	540 x 960 pixels
Corrente em deep-sleep	~170µA

Os esquemas da placa de ecrã podem ser encontrados em github repo.

Versões

Note que existem pelo menos três versões diferentes do LilyGO TTGO T5-4.7 E-Paper. Existe uma versão inicial com cinco botões e suporte para bateria 18650. Veja a foto abaixo:

Não tenho esta versão e, portanto, não posso garantir que os exemplos de código deste tutorial funcionem para esta placa.

No entanto, tenho as placas das duas versões mais recentes V2.3 de 2021-06-10 e V2.4 de 2024-12-03. Testei o código para ambas as placas e funciona. Note que estas placas têm três botões e não têm suporte para bateria. A foto abaixo mostra as duas placas com os números de versão visíveis no verso:

Instalação do Core ESP32

O LilyGO TTGO T5-4.7 usa um ESP32 e precisamos instalar uma versão específica (2.017) do core ESP32. Começa por abrir o diálogo de Preferências selecionando “Preferences…” no menu “File”. Isto abrirá o diálogo de Preferências mostrado abaixo.

Na aba Settings encontrarás uma caixa de edição na parte inferior do diálogo rotulada “Additional boards manager URLs“:

Neste campo de entrada copia o seguinte URL:

https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json

Isto permite que o Arduino IDE saiba onde encontrar as bibliotecas do core ESP32. A seguir, vamos instalar as placas ESP32 usando o Gestor de Placas.

Abre o Gestor de Placas via “Tools -> Boards -> Board Manager”. Verás o Gestor de Placas a aparecer na barra lateral esquerda. Introduz “ESP32” no campo de pesquisa no topo e deverás ver dois tipos de placas ESP32; as “Arduino ESP32 Boards” e as placas “esp32 by Espressif”. Queremos as “esp32 libraries by Espressif”.

No menu suspenso para o esp32 seleciona a versão 2.0.17 e depois pressiona o botão INSTALL. Após uma instalação bem-sucedida, deverás ver a imagem seguinte:

Outras versões (mais antigas) do core ESP32 provavelmente também funcionam, mas não testei. O que não funciona por enquanto são as versões mais recentes 3.x.

Instalação das Bibliotecas

A seguir, precisamos instalar bibliotecas específicas e versões específicas. Primeiro clica neste EPD47 Library link da biblioteca e descarrega o ficheiro “EPD47-master.zip”.

Descompacta o ficheiro ZIP para extrair o seu conteúdo. Deverás ver os seguintes ficheiros numa pasta descompactada chamada “EPD47-master”:

Precisamos copiar a pasta “EPD47-master” para a pasta “libraries” do Arduino IDE. No Windows, a pasta “libraries” está tipicamente localizada em:

C:\Users\<username>\OneDrive\Documents\Arduino\libraries

Como esta pasta já contém bibliotecas instaladas, recomendo que a renomes temporariamente, por exemplo para “_libraries”, e crias uma nova pasta chamada “libraries”. Assim evitas conflitos com as bibliotecas já instaladas e não as perdes. Depois podes facilmente reverter esta alteração. A imagem abaixo mostra como a tua pasta “Arduino” com as bibliotecas deve ficar:

Depois copiamos a pasta “EPD47-master” para a nova pasta “libraries” como mostrado abaixo:

Finalmente, precisamos instalar a versão 6.19.0 da Arduinojson biblioteca de Benoit Blanchon. Abre o LIBRARY MANAGER, escreve “arduinojson” na barra de pesquisa e instala a biblioteca. Após uma instalação bem-sucedida deverás ver a imagem seguinte:

Se voltares a olhar na pasta das bibliotecas, agora encontrarás a biblioteca EPD47-master e a biblioteca ArduinoJson:

Placa ESP32-S3 e Configurações

O LilyGO TTGO T5-4.7 E-Paper usa um ESP32-S3, por isso selecionamos a placa “ESP32S3 Dev Module”. Para isso, clica no menu suspenso e depois em “Select other board and port…”:

Isto abrirá um diálogo onde podes escrever “esp32s3 dev” na barra de pesquisa. Verás a placa “ESP32S3 Dev Module” em Boards. Clica nela, seleciona a porta COM para ativá-la e depois clica OK:

Note que precisas de ligar a placa ao computador via cabo USB antes de poderes selecionar uma porta COM.

Configurações da Ferramenta

Antes de poderes programar a placa, precisas ajustar as configurações. Vai a “Tools” e seleciona as configurações mostradas abaixo:

Importantes são “USB CDC On Boot: Enable” para permitir comunicação serial com a placa, “Flash Size : 16MB(128Mb)”, “Partition Scheme: 16M Flash(3M APP/9.9MB FATFS)”, e “PSRAM: OPI PSRAM” para configurar a memória. As outras configurações padrão devem estar bem como estão.

Upload

Normalmente, podes agora simplesmente carregar o código via Arduino IDE e a placa mudará automaticamente para o modo de upload. No entanto, se a placa estiver em deep-sleep ou presa num ciclo de crash, podes usar a seguinte sequência para forçá-la a entrar em modo de upload:

1. Pressiona e mantém o botão BOOT(IO0)
2. Enquanto manténs o botão BOOT(IO0) pressionado, pressiona RST
3. Liberta o RST
4. Liberta o botão BOOT(IO0)

Exemplo de Código: Botão

Neste primeiro exemplo de código verificamos apenas se conseguimos programar a placa, detetar o pressionar de um botão e se a comunicação serial funciona:

#define BTN 21

void setup() {
  Serial.begin(112500);
  pinMode(BTN, INPUT);
  Serial.println("running...");
}

void loop() {
  if (!digitalRead(BTN)) {
    Serial.println("pressed");
    delay(100);
  }
}

Começamos por definir o pino GPIO 21 para o botão rotulado SENSOP_VN na placa.

#define BTN 21

Este é o único botão que podemos usar para entrada do utilizador. É o botão ao lado do slot do cartão SD:

Na função setup iniciamos a comunicação serial, declaramos o pino do botão como entrada e imprimimos “running…” no monitor serial. O botão está internamente ligado com um resistor pullup, o que significa que não precisamos ativar os pullups ao configurar o modo do pino.

void setup() {
  Serial.begin(112500);
  pinMode(BTN, INPUT);
  Serial.println("running...");
}

Na função loop, lemos o estado atual do botão e, se o valor retornado for falso, sabemos que o botão está pressionado e imprimimos o texto “pressed” no monitor serial.

void loop() {
  if (!digitalRead(BTN)) {
    Serial.println("pressed");
    delay(100);
  }
}

Deves experimentar este código primeiro para garantir que consegues programar a placa e ver a saída serial. Se tiveres problemas, certifica-te de que as configurações da ferramenta estão corretas.

Exemplo de Código: Ecrã

O segundo exemplo de código mostra como controlar o ecrã E-paper. Vamos desenhar um círculo e imprimir o texto “Makerguides” no ecrã:

Dá uma vista rápida ao código completo primeiro e depois entramos nos detalhes:

#include "epd_driver.h"
#include "firasans.h"

uint8_t *framebuffer = NULL;

void create_framebuffer() {
  size_t framesize = EPD_WIDTH * EPD_HEIGHT / 2;
  framebuffer = (uint8_t *)ps_calloc(sizeof(uint8_t), framesize);
  if (!framebuffer) {
    Serial.println("alloc memory failed !!!");
    return;
  }
  memset(framebuffer, 0xFF, framesize);
}

void init_display() {
  create_framebuffer();
  epd_init();
  epd_poweron();
  epd_clear();
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  init_display();

  epd_draw_circle(EPD_WIDTH / 2, EPD_HEIGHT / 2, 150, 0, framebuffer);
  
  const char *text= "Makerguides";
  int cursor_x = 355;
  int cursor_y = 270;
  writeln((GFXfont *)&FiraSans, text, &cursor_x, &cursor_y, framebuffer);

  epd_draw_grayscale_image(epd_full_screen(), framebuffer);
  epd_poweroff_all();
}

void loop() {
}

Importações

Começamos por incluir dois ficheiros header que fornecem a API do driver do ecrã e uma definição de fonte. “epd_driver.h” expõe funções como inicialização, controlo de energia, desenho de primitivas e envio de buffer de pixels para o painel, enquanto “firasans.h” fornece os dados dos glifos usados pela rotina de renderização de texto.

#include "epd_driver.h"
#include "firasans.h"

Estado Global

De seguida, criamos um ponteiro global chamado framebuffer para armazenar o endereço de um buffer de pixels alocado dinamicamente na memória. As funções do driver do ecrã neste sketch desenham primeiro neste buffer, e só depois o buffer completo é enviado para o painel E-paper para ser exibido.

uint8_t *framebuffer = NULL;

create_framebuffer

A função create_framebuffer() é responsável por alocar RAM para a imagem em escala de cinza que será exibida. A ideia principal é que o painel E-paper espera uma representação compactada, e a expressão EPD_WIDTH * EPD_HEIGHT / 2 reflete quantos bytes são necessários quando cada pixel usa 4 bits (meio byte). Com escala de cinza de 4 bits, dois pixels podem ser armazenados por byte, por isso o total de pixels é dividido por dois.

Depois de calcular o tamanho, a função usa ps_calloc para alocar e inicializar a memória a zero. Em alvos da classe ESP32, este alocador é tipicamente usado para colocar buffers grandes na PSRAM quando disponível, o que é importante porque um buffer de escala de cinza de quadro completo pode ser demasiado grande para a RAM interna. Se a alocação falhar, a função imprime uma mensagem de diagnóstico no console serial e retorna cedo.

Finalmente, o buffer é preenchido com 0xFF. Em muitos formatos de buffer de quadro para E-paper, 0xFF corresponde a “branco” ou ao valor mais claro de escala de cinza em todo o buffer, por isso este passo cria efetivamente uma tela branca limpa antes de qualquer desenho.

void create_framebuffer() {
  size_t framesize = EPD_WIDTH * EPD_HEIGHT / 2;
  framebuffer = (uint8_t *)ps_calloc(sizeof(uint8_t), framesize);
  if (!framebuffer) {
    Serial.println("alloc memory failed !!!");
    return;
  }
  memset(framebuffer, 0xFF, framesize);
}

init_display

A função init_display() centraliza a sequência de inicialização do hardware E-paper e garante que o buffer de quadro existe antes de qualquer chamada de desenho. Primeiro chama create_framebuffer() para que as funções de desenho posteriores tenham um destino válido.

A chamada a epd_init() normalmente inicializa o controlador do ecrã, configura GPIO/SPI e prepara o estado interno do driver. epd_poweron() ativa as linhas de alimentação do painel e coloca o hardware num estado operacional. E epd_clear() limpa o painel, o que é útil no E-paper porque o conteúdo antigo pode persistir se o painel não for explicitamente atualizado.

void init_display() {
  create_framebuffer();
  epd_init();
  epd_poweron();
  epd_clear();
}

setup

A função setup() executa uma vez no arranque e realiza todo o trabalho neste sketch, por isso loop() está vazia. Começamos por inicializar a porta serial a 115200 baud para permitir saída de debug. Depois esperamos brevemente para garantir que a ligação serial está estável antes de continuar. A seguir, chamamos init_display() para alocar o buffer de quadro, ligar a energia e limpar o painel.

void setup() {
  Serial.begin(115200);
  delay(1000);
  init_display();

Após a inicialização, desenhamos um círculo no buffer de quadro. O círculo está centrado no ecrã usando metade da largura e altura do ecrã. O raio é 150, e o valor da cor 0 é passado como nível de escala de cinza. Nas convenções típicas de escala de cinza de 4 bits usadas por muitos drivers E-paper, valores numéricos mais baixos geralmente correspondem a pixels mais escuros, por isso 0 é comumente usado para preto. O argumento final é framebuffer, que torna explícito que a operação de desenho modifica o buffer de memória em vez de atualizar o ecrã imediatamente.

  epd_draw_circle(EPD_WIDTH / 2, EPD_HEIGHT / 2, 150, 0, framebuffer);

De seguida, preparamos uma string C para ser renderizada e definimos as coordenadas do cursor. A chamada a writeln() desenha a string usando a fonte FiraSans no buffer de quadro na posição inicial especificada.

  const char *text= "Makerguides";
  int cursor_x = 355;
  int cursor_y = 270;
  writeln((GFXfont *)&FiraSans, text, &cursor_x, &cursor_y, framebuffer);

Depois de o círculo e o texto serem desenhados na RAM, o sketch realiza a atualização real do ecrã. A chamada a epd_draw_grayscale_image() envia o buffer para o ecrã. O primeiro argumento, epd_full_screen(), indica que a região de atualização é o ecrã inteiro em vez de um sub-retângulo, o que corresponde ao facto de o sketch preparar um buffer de quadro completo. Finalmente, epd_poweroff_all() desliga a energia do E-paper, já que o E-paper pode manter a imagem sem energia depois da atualização estar completa.

  epd_draw_grayscale_image(epd_full_screen(), framebuffer);
  epd_poweroff_all();
}

loop

A função loop() está vazia porque o sketch é desenhado para renderização única. O dispositivo inicializa, desenha no buffer, atualiza o ecrã uma vez, desliga o painel e depois não faz mais nada. Este padrão é típico para projetos E-paper alimentados por bateria que acordam, atualizam o conteúdo e voltam ao estado de deep-sleep.

Mais Exemplos

Para mais exemplos, por exemplo como desenhar linhas, retângulos e imagens em escala de cinza, vê a pasta em Xinyuan-LilyGO/LilyGo-EPD47/tree/esp32s3/examples.

Exemplo de Código: Estação Meteorológica

Neste último exemplo vais aprender a executar uma estação meteorológica no LilyGO TTGO T5-4.7 E-Paper. Os dados meteorológicos são recebidos pela internet do serviço OpenWeatherMap, que é gratuito mas precisas de te registar – mais sobre isso depois.

O código original que uso aqui é do David Bird de 2021 e várias versões deste código podem ser encontradas em Xinyuan-LilyGO/LilyGo-EPD47/tree/esp32s3, Xinyuan-LilyGO/LilyGo-EPD-4-7-OWM-Weather-Display e DzikuVx/LilyGo-EPD-4-7-OWM-Weather-Display, por exemplo. No entanto, nenhum desses exemplos funcionava bem no meu LilyGO TTGO T5-4.7 E-Paper. Por isso fiz algumas modificações.

Modificações

Primeiro, corrigi alguns problemas com o layout dos dados meteorológicos exibidos. Se olhares para o ecrã criado pelo código original, podes ver que o texto das temperaturas não está bem alinhado:

Por isso, movi os elementos de texto um pouco para melhorar o layout:

Também integrei a imagem da lua e os ícones do pôr e nascer do sol do DzikuVx/LilyGo-EPD-4-7-OWM-Weather-Display no código Xinyuan-LilyGO/LilyGo-EPD-4-7-OWM-Weather-Display.

Carga da Bateria

Depois, notei que o ecrã não funciona e não mostra o ícone de carga da bateria quando alimentado por bateria. Isto porque 1) o código original bloqueia até a comunicação serial ser estabelecida, o que não acontece sem ligação USB a um computador:

    Serial.begin(115200);
    while (!Serial) ;

O código while (!Serial) precisa ser removido e substituído por um pequeno atraso, por exemplo delay(1000).

2) O código original lê a tensão da bateria no pino 36, mas nos meus ecrãs descobri que a tensão da bateria é medida no pino 14:

float voltage = analogRead(14) / 4096.0 * 6.566 * (vref / 1000.0);

Com estas alterações podes alimentar o teu LilyGO TTGO T5-4.7 E-Paper com bateria e o ícone da bateria indicará a carga restante.

Localização da Cidade

O código original usa o nome de uma cidade para obter a informação meteorológica dessa localização. No entanto, o serviço OpenWeatherMap também permite obter os dados meteorológicos atuais para uma localização dada pela sua latitude e longitude:

https://api.openweathermap.org/data/2.5/weather?lat={lat}&lon={lon}&appid={API key}

Potencialmente, isto é mais preciso e não precisas de usar o nome específico da cidade reconhecido pelo OpenWeatherMap. Encontrar a latitude e longitude da tua localização é fácil. Basta ir ao Google Maps e clicar com o botão direito. Aparecerá um diálogo popup com os números de latitude e longitude no topo. Vê a captura de ecrã seguinte:

Ligação USB

Finalmente, o código original atualiza os dados meteorológicos no ecrã uma vez por hora e entra em modo deep-sleep entre atualizações para preservar a bateria. Isto é ótimo, mas torna as alterações de código difíceis, pois a ligação USB é perdida em deep-sleep e não podes gravar a placa.

Precisas de reiniciar a placa e cronometrar para que a gravação comece enquanto a ligação USB ainda está ativa logo após o reset. Vê a secção Upload acima. Como isto é difícil, adicionei código que garante que o deep-sleep NÃO é ativado quando o botão programável pelo utilizador SENSOP_VN está pressionado:

  if(digitalRead(21)) {  // SENSOP_VN button NOT pressed
    BeginSleep();
  }

Isto significa que, se quiseres gravar novo código, basta pressionar e manter SENSOP_VN durante a gravação. A placa não entrará em deep-sleep após o reset e a ligação USB permanecerá ativa. Depois de gravado, podes simplesmente pressionar RST novamente para reiniciar a placa com deep-sleep ativo.

Open weather map

O código usa o serviço gratuito OpenWeatherMap para receber dados meteorológicos da internet. No entanto, antes de poderes usar qualquer uma das APIs do OpenWeather, precisas de uma chave API e para isso precisas de uma conta. Para criar uma conta gratuita, vai ao sign-up page e insere os teus dados lá.

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

Assim que tiveres a tua chave API (e a latitude e longitude da tua localização), podes testá-la no teu navegador. Introduz o seguinte URL, com a tua chave API, no navegador:

https://api.openweathermap.org/data/2.5/weather?lat=44.34&lon=10.99&appid={API key}

Note que o navegador Chrome tem um botão Pretty Print que podes clicar e ele mostrará os dados meteorológicos obtidos em JSON formatado de forma legível:

Desta forma, podes testar a tua chave API e os valores de latitude e longitude. Se precisares de mais ajuda, vê o nosso tutorial: Simple ESP32 Internet Weather Station.

Descarregar Código e Definir Parâmetros

Depois de verificares a tua chave API, podes descarregar o código para a estação meteorológica como um ficheiro ZIP: weather_lilygo_t5_epd.zip . Descompacta-o e abre o ficheiro “weather_lilygo_t5_epd.ino” na pasta “weather_lilygo_t5_epd” no teu Arduino IDE.

Como último passo, precisas definir as credenciais Wi-Fi e os parâmetros dos dados meteorológicos. Clica na aba “owm_credentials.h” e define o teu SSID, Password, chave API e a informação da localização:

Dependendo da tua localização, podes também querer alterar os parâmetros Language, Hemisphere, Units e Timezone.

Existe também código de exemplo sobre como configurar a estação meteorológica via interface web: Xinyuan-LilyGO/LilyGo-EPD-4-7-OWM-Weather-Display/tree/web, se preferires isso em vez de codificar as definições diretamente.

Depois de ajustares as definições, grava o código na tua placa LilyGO TTGO T5-4.7 e, após algum breve piscar, deverás ver os dados meteorológicos a aparecer no ecrã:

Ligação da Bateria 18650

A placa LilyGO TTGO T5-4.7 E-Paper vem com um conector e circuito de carregamento para uma bateria LiPo externa. Liguei uma bateria recarregável 18650. Podes usar uma bateria LiPo menor (plana) também, mas tendem a ser mais caras ou ter menos capacidade. A foto abaixo mostra como ligar a bateria 18650:

Tempo de Funcionamento

Uma bateria típica 18650 tem uma capacidade de 2300 a 3600mAh e a corrente de pico que o ESP32 consome ao usar Wi-Fi pode chegar a 400mA. A corrente em deep-sleep da placa LilyGO TTGO T5-4.7 é aparentemente cerca de 170µA, mas não a medi.

Se usarmos uma 18650 com 3300mAh, e se ativarmos o Wi-Fi por um segundo uma vez por hora para descarregar os dados meteorológicos, obtemos um tempo estimado de funcionamento superior a um ano com uma única carga.

Aqui está o cálculo: com uma corrente média de 400mA × 1s / 3600s = 0.111mA para Wi-Fi e uma corrente em deep-sleep de 0.17mA, a corrente média total é 0.111mA + 0.17mA = 0.281mA por segundo. Assumindo uma bateria de 3300mAh, o tempo estimado de funcionamento é então 3300mAh / 0.281mA ≈ 11744h ≈ 1,34 anos.

Conclusões

Neste tutorial aprendeste a construir uma estação meteorológica com o ecrã LilyGO TTGO T5-4.7 E-Paper. Para mais informações sobre o LilyGO TTGO T5, vê o Wiki e os exemplos de código em Xinyuan-LilyGO/LilyGo-EPD47/tree/esp32s3/examples.

A documentação menciona que o ecrã não deve ser atualizado parcialmente por longos períodos, pois isso deixará imagens residuais irreversíveis. Por isso, tem cuidado ao construir aplicações que usem Partial Refresh.

Para mais exemplos sobre ecrãs E-paper, vê os nossos Weather Station on e-Paper Display, Simple ESP32 Internet Weather Station, Temperature Plotter on e-Paper Display, Monthly Calendar on E-Paper Display e os Digital Clock on e-Paper Display tutoriais.

Se tiveres alguma dúvida, não hesites em deixar nos comentários.

Boas experiências a criar 😉