Interligar Arduino com E-ink Display

Neste tutorial, vais aprender a ligar um ecrã E-ink tricolor a um Arduino ou a um ESP32.

E-Ink, ou papel eletrónico (E-Paper), é uma tecnologia de ecrã que imita a aparência da tinta no papel. Utiliza microcápsulas minúsculas preenchidas com partículas coloridas. Quando um campo elétrico é aplicado, as partículas movem-se para a superfície, criando texto e imagens.

O papel eletrónico oferece várias vantagens. O seu baixo consumo de energia permite que os dispositivos funcionem durante semanas ou meses com uma única carga. O ecrã imita o papel tradicional, proporcionando excelente legibilidade à luz solar direta e amplos ângulos de visualização sem reflexos. Além disso, o E-Paper é fino e leve. No entanto, o E-Paper tem uma atualização lenta, uma gama de cores limitada e é relativamente caro.

Peças Necessárias

Vais precisar de um ecrã E-Paper e, para este tutorial, escolhi um ecrã tricolor de 2,9 polegadas com resolução de 296×128 pixels. No entanto, também podes usar um E-Paper monocromático de tamanho diferente.

Vamos ligar o E-Paper a um Arduino e a um ESP32. Quase qualquer modelo de Arduino ou ESP32 funciona, mas o ESP32 é a melhor escolha. O ESP32 lite listado abaixo é especialmente adequado, pois tem interface para bateria e os E-Papers são ótimos para projetos alimentados por bateria.

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.

Noções básicas sobre ecrãs E-Paper

A tecnologia E-Paper baseia-se na tecnologia Microcapsule Electrophoretic Display (EPD). A folha de E-Paper consiste numa camada de polímero condutor transparente que serve como eletrodo frontal, juntamente com milhões de microcápsulas, cada uma com cerca do diâmetro de um fio de cabelo humano, embutidas num material polimérico. Estas microcápsulas contêm partículas coloridas ou pigmentos (preto, branco, …) num fluido transparente. A folha de E-Paper é depois laminada num substrato, que atua como eletrodo inferior.

O eletrodo inferior é tipicamente dividido em segmentos ou pixels, permitindo o controlo independente da voltagem em cada segmento. Esta capacidade permite que o ecrã forme várias imagens. Uma vez criada a imagem, a voltagem pode ser removida e as partículas permanecem nas suas posições atuais. Esta característica permite que um E-Paper mantenha uma imagem estática sem consumir energia.

Sistema de Tinta com Dois Pigmentos

Num sistema de tinta eletrónica com dois pigmentos, cada microcápsula contém partículas brancas carregadas negativamente e partículas pretas carregadas positivamente suspensas num fluido transparente. Quando um campo elétrico é aplicado, positivo ou negativo, as partículas correspondentes migram para o topo da microcápsula. Este movimento torna as partículas visíveis, fazendo com que a superfície apareça branca ou preta naquele local específico.

Controlando os campos elétricos aplicados a cada microcápsula, o ecrã pode mostrar uma gama de tons de cinzento, embora a maioria dos E-Papers monocromáticos suporte apenas preto e branco.

Sistema de Tinta com Três Pigmentos

Um sistema de tinta eletrónica com três pigmentos expande os princípios do sistema de dois pigmentos ao incorporar uma cor adicional. Neste sistema, as microcápsulas ou microcopos contêm partículas brancas carregadas negativamente, partículas pretas carregadas positivamente e um terceiro conjunto de pigmentos carregados positivamente, tipicamente vermelho ou amarelo.

Quando um campo elétrico é aplicado, as partículas respondem conforme a sua carga. Por exemplo, um campo elétrico negativo fará com que as partículas vermelhas carregadas positivamente subam à superfície. Uma carga dividida faz subir as partículas pretas para o topo. E uma carga positiva traz as partículas brancas para a frente.

Módulo de Ecrã E-Paper tricolor de 2,9″

Se quiseres controlar um E-Paper a partir de um microcontrolador, vais precisar de um driver que controle os campos elétricos do ecrã. Podes comprar o E-Paper e o driver separadamente ou como um módulo que integra o E-Paper e o driver numa única unidade.

O módulo de ecrã que estamos a usar neste tutorial é um ecrã tricolor (branco, preto, vermelho) com tamanho de 2,9 polegadas, resolução de 296×128 pixels e um controlador embutido com uma interface SPI para comunicação. A imagem abaixo mostra a frente e o verso do módulo de ecrã:

Note que o módulo tem um pequeno jumper/switch na parte de trás para alternar entre SPI de 4 fios e SPI de 3 fios. Vamos usar o SPI de 4 fios por defeito aqui. Portanto, não precisas de alterar nada.SPI

O módulo de ecrã funciona a 3,3V ou 5V, com um consumo em standby de 0,017mW e consome apenas cerca de 26,4mW durante a atualização. O tempo para uma atualização completa é de 15 segundos e a atualização parcial não é suportada. Se quiseres saber mais sobre as diferenças entre atualização completa e parcial, consulta o nosso Partial Refresh of e-Paper Display tutorial.

Pinout do Ecrã E-Paper

O modelo de ecrã vem com um conector de 8 pinos para SPI comunicação e alimentação que tem os seguintes pinos:

BUSY indica que o ecrã está ocupado a atualizar o conteúdo. RST significa Reset. DC é o pino Data Command, CS é Chip Select, e CLK é o pino Clock. DIN é o pino Data Input. VCC e GND são para a alimentação. O ecrã tem um regulador de voltagem integrado e podes usar 3,3V ou 5V para o alimentar.

Instalar a biblioteca GxEPD2 para E-Paper

Antes de podermos desenhar ou escrever no E-Paper, precisamos de install two libraries. 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 E-Paper via SPI.

Abre o Library Manger, procura por “Adafruit_GFX” e “GxEPD2” e clica em “INSTALL”. Após a instalação, as bibliotecas devem aparecer no Library Manager da seguinte forma.

Nas duas secções seguintes, vou mostrar como ligar o ecrã E-Paper a um ESP32 ou a um Arduino. O ESP32 é preferível ao Arduino, pois tem uma memória muito maior, o que torna o código mais simples.

Ligar o Ecrã E-Paper ao ESP32

A imagem abaixo mostra como ligar um ESP32 lite ao ecrã E-Paper. Embora a maioria dos pinos possa ser configurada, precisas de saber os pinos SPI por defeito para a tua placa ESP32, especificamente para os sinais DIN e CLK. No caso do ESP32 lite, DIN está no pino 23 e CLK no pino 18.

Se precisares de ajuda para encontrar os pinos SPI por defeito, consulta o Find I2C and SPI default pins tutorial.

A tabela seguinte mostra todas as ligações que tens de fazer. Nota que podes alimentar o módulo do ecrã com 3,3V ou 5V, mas o ESP32-lite tem apenas uma saída de 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

Podes usar uma breadboard para ligar tudo. Mas eu liguei o ecrã diretamente ao ESP32 com fios Dupont. A imagem abaixo mostra como ficou o meu setup.

Código de teste para E-Paper com ESP32

De seguida, vamos escrever um código simples para testar o funcionamento do ecrã. Vamos mostrar o texto “Makerguides”, com “Maker” a preto e “guides” a vermelho.

#include "GxEPD2_3C.h"

#define EPD_CS 5  
#define EPD_DC 0  
#define EPD_RST 2  
#define EPD_BUSY 15  
// SCL/SCK/CLK  = 18,
// SDA/DIN/MOSI = 23

GxEPD2_3C<GxEPD2_290_C90c, GxEPD2_290_C90c::HEIGHT> 
  epd(GxEPD2_290_C90c(EPD_CS , EPD_DC, EPD_RST, EPD_BUSY));

void setup() {
  epd.init(115200);
  epd.setRotation(1);
  
  epd.setTextSize(2);
  epd.setFullWindow();
  epd.fillScreen(GxEPD_WHITE);     

  epd.setCursor(80, 60);
  epd.setTextColor(GxEPD_BLACK);
  epd.print("Maker"); 

  epd.setCursor(140, 60);
  epd.setTextColor(GxEPD_RED);
  epd.print("guides");   

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

void loop() {}

Vamos dividir o código em partes para melhor compreensão.

Inclusão de Bibliotecas

Começamos por incluir a biblioteca necessária para controlar o ecrã E-Paper. A biblioteca GxEPD2_3C.h fornece as funções necessárias para interagir com o ecrã tricolor.

#include "GxEPD2_3C.h"

Se tiveres um ecrã de 4 cores, incluirias GxEPD2_4C.h ou GxEPD2_7C.h para um ecrã de 7 cores, em vez disso. Se tiveres um ecrã E-Paper preto e branco (BW), inclui GxEPD2_BW.h

Definição dos Pinos

De seguida, definimos os pinos usados para ligar o ecrã ao ESP32 via interface SPI:

#define EPD_CS 5  
#define EPD_DC 0  
#define EPD_RST 2  
#define EPD_BUSY 15  

Criação do Objeto Display

Criamos uma instância do objeto do ecrã E-Paper usando os pinos definidos. Os parâmetros do template especificam também o tipo de ecrã e a sua altura.

GxEPD2_3C<GxEPD2_290_C90c, GxEPD2_290_C90c::HEIGHT>
  epd(GxEPD2_290_C90c(EPD_CS , EPD_DC, EPD_RST, EPD_BUSY));

Esta é a linha mais crítica do código. Se o teu ecrã não mostrar nada ou mostrar texto/imagens corrompidas, ou o ecrã não está corretamente ligado ou foi escolhido o driver errado.

A biblioteca Readme for GxEPD2 lista todos os ecrãs suportados e podes encontrar os detalhes nos ficheiros header, por exemplo GxEPD2.h. Encontra o driver específico para o teu ecrã. Isto pode requerer alguma tentativa e erro.

Função Setup

Na função setup(), inicializamos a comunicação com o ecrã com uma taxa de 115200 baud. Também definimos a rotação do ecrã para 1 (90 graus), que é o modo Paisagem.

epd.init(115200);
epd.setRotation(1);

De seguida, configuramos o tamanho do texto e preparamos o ecrã para desenhar.

epd.setTextSize(2);
epd.setFullWindow();
epd.fillScreen(GxEPD_WHITE);     

Depois, definimos a posição do cursor e a cor do texto para preto antes de imprimir “Maker” no ecrã.

epd.setCursor(80, 60);
epd.setTextColor(GxEPD_BLACK);
epd.print("Maker"); 

Depois, mudamos a posição do cursor e a cor do texto para vermelho para imprimir “guides”.

epd.setCursor(140, 60);
epd.setTextColor(GxEPD_RED);
epd.print("guides");   

Ambos os comandos de impressão juntos vão mostrar o texto “Makerguides” no centro do ecrã. A saída no teu ecrã deverá ser a seguinte:

Finalmente, chamamos epd.display() para renderizar o texto no ecrã e colocar o ecrã em modo hibernação para poupar energia.

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

Função Loop

A função loop() está vazia neste exemplo, pois só precisamos de inicializar e mostrar o texto uma vez. O ecrã permanecerá num estado de baixo consumo e continuará a mostrar o texto, mesmo que a alimentação seja completamente removida.

void loop() {}

Se carregares e executares o código, vais ver o ecrã a piscar durante cerca de 15 segundos, enquanto o texto surge lentamente (ver o pequeno vídeo abaixo).

Isto chama-se “Atualização completa” e limpa todo o ecrã, redesenhando todos os pixels. Este processo garante que quaisquer imagens residuais ou fantasmas de conteúdos anteriores são eliminados.

Uma “Atualização parcial”, por outro lado, atualiza apenas áreas específicas do ecrã. Este método é muito mais rápido (< 0,3 seg) e evita o piscar. Para exemplos, vê o Partial Refresh of e-Paper Display tutorial.

Enquanto as atualizações parciais são normalmente suportadas por ecrãs E-Paper monocromáticos, muitos ecrãs tricolores, incluindo o usado neste projeto, não as suportam. Isso limita a sua aplicação a casos onde as atualizações de conteúdo são pouco frequentes, por exemplo, uma vez por hora. Caso contrário, o piscar e a atualização lenta são demasiado distrativos.

Ligar o Ecrã E-Paper ao Arduino

Nesta secção, ligamos o ecrã E-Paper a um Arduino Uno em vez de um ESP32. O número de ligações é o mesmo, apenas os pinos são diferentes. Como mencionado antes, a maioria dos pinos pode ser configurada, mas para as linhas DIN e CLK precisamos de usar os pinos SPI específicos. No caso do Arduino Uno, DIN está no pino 11 e CLK no pino 13.

A tabela seguinte lista todas as outras ligações que tens de fazer. Para alimentação, podes usar 5V em vez de 3,3V.

Ecrã E-Paper	Arduino UNO
CS/SS	4
SCL/SCK/CLK	13
SDA/DIN/MOSI	11
BUSY	7
RES/RST	6
DC	5
VCC	3.3V
GND	G

Código de teste para E-Paper com Arduino Uno

O código para testar o E-Paper com um Arduino Uno é semelhante ao usado com o ESP32, com duas diferenças importantes, causadas pela pequena memória do Arduino Uno.

Dá uma vista rápida ao código primeiro e talvez lê o exemplo do ESP32 para contexto. Depois discutiremos as diferenças.

#include "GxEPD2_3C.h"

#define EPD_CS 4
#define EPD_DC 5
#define EPD_RST 6
#define EPD_BUSY 7
// SCL/SCK/CLK  = 13,
// SDA/DIN/MOSI = 11

#define MAX_BUFF 1024
#define MAX_HEIGHT(EPD) ((MAX_BUFF / 2) / (EPD::WIDTH / 8))

GxEPD2_3C<GxEPD2_290_C90c, MAX_HEIGHT(GxEPD2_290_C90c)>
   epd(GxEPD2_290_C90c(EPD_CS, EPD_DC, EPD_RST, EPD_BUSY));

void setup() {
  epd.init(115200);
  epd.setRotation(1);
  epd.setTextSize(2);
  epd.setFullWindow();

  epd.firstPage();
  do {
    epd.fillScreen(GxEPD_WHITE);

    epd.setCursor(80, 60);
    epd.setTextColor(GxEPD_BLACK);
    epd.print("Maker");

    epd.setCursor(140, 60);
    epd.setTextColor(GxEPD_RED);
    epd.print("guides");

  } while (epd.nextPage());
  epd.hibernate();
}

void loop() {}

Como antes, o código escreve o texto “Makerguides” a preto e vermelho no ecrã. No entanto, a forma como o objeto do ecrã é criado é diferente. Especificamente, temos de definir a altura (MAX_HEIGHT) do ecrã:

#define MAX_BUFF 1024
#define MAX_HEIGHT(EPD) ((MAX_BUFF / 2) / (EPD::WIDTH / 8))

GxEPD2_3C<GxEPD2_290_C90c, MAX_HEIGHT(GxEPD2_290_C90c)>
   epd(GxEPD2_290_C90c(EPD_CS, EPD_DC, EPD_RST, EPD_BUSY));

O ecrã E-Paper tem uma resolução de 296 * 128 pixels, o que significa que um total de 37888 pixels precisam ser definidos para atualizar o conteúdo mostrado no ecrã. Normalmente, o conteúdo é escrito primeiro num buffer de ecrã e depois enviado para o ecrã. Contudo, um Arduino Uno tem apenas 2KB de SRAM = 2048 bytes, o que é demasiado pequeno para conter o buffer completo. Por isso, definimos um buffer de ecrã menor MAX_BUFF = 1024.

Com o buffer de ecrã menor, não podemos enviar o buffer completo, mas apenas uma faixa de MAX_HEIGHT, que é derivada de MAX_BUFF e da largura (EPD::WIDTH) do ecrã. Calculamos a altura do ecrã via MAX_HEIGHT(GxEPD2_290_C90c).

Desenho por páginas

O ecrã é então atualizado usando um modo de desenho por páginas. Este método divide o ecrã em secções menores ou faixas chamadas “páginas”. Em vez de carregar todo o conteúdo, o Arduino processa apenas uma página de cada vez.

Podes ver isto no do–while loop na função setup, onde as páginas são desenhadas repetidamente até que o conteúdo completo do ecrã seja atualizado.

  epd.firstPage();
  do {
     ...
  } while (epd.nextPage());

Ao atualizar o ecrã, o Arduino desenha o conteúdo da página atual na memória, depois envia essa página para o ecrã E-Paper. Após a atualização da página, o Arduino pode limpar o buffer e carregar a página seguinte.

Nota que o buffer do ecrã e o código do sketch partilham a mesma memória. Se o teu código crescer, podes ter de reduzir MAX_BUFF para que ambos caibam na SRAM. Se receberes a seguinte mensagem de erro ao compilar, sabes que MAX_BUFF está definido demasiado alto:

Not enough memory; see https://support.arduino.cc/hc/en-us/articles/360013825179 for tips on reducing your footprint. 
data section exceeds available space in board.
Compilation error: data section exceeds available space in board

O loop explícito do-while para desenho por páginas é algo incómodo e pouco elegante. Felizmente, a biblioteca GxEPD2 oferece outra opção. Podes definir uma função de desenho e depois chamar epd.drawPaged(...) para desenho por páginas. O exemplo de código seguinte mostra como isso fica para o código de teste acima:

...

void draw(const void* pv) {
  epd.fillScreen(GxEPD_WHITE);

  epd.setCursor(80, 60);
  epd.setTextColor(GxEPD_BLACK);
  epd.print("Maker");

  epd.setCursor(140, 60);
  epd.setTextColor(GxEPD_RED);
  epd.print("guides");
}

void setup() {
  ...
  epd.drawPaged(draw, 0);
  epd.hibernate();
}

void loop() {}

A função de desenho draw() recebe um ponteiro pv, que permite passar parâmetros, embora não o usemos aqui. Ao chamar epd.drawPaged(draw, 0), passamos simplesmente 0 como ponteiro de parâmetro.

O uso de funções de desenho para redesenhos por páginas torna o código mais legível e extensível. Podes ter várias funções de desenho, o que é especialmente útil ao realizar atualizações parciais e completas. Vê o Digital Clock on e-Paper Display tutorial para um exemplo.

Nota que podes usar desenho por páginas mesmo que o teu microcontrolador seja grande o suficiente para conter o buffer completo do ecrã. Por exemplo, o código de teste para o Arduino Uno funcionaria sem alterações (para além da ligação) num ESP32 e, em geral, o desenho por páginas é recomendado.

Recomendações

A Waveshare Manual fornece as seguintes recomendações ao operar um ecrã E-Paper (resumidas e reformuladas por mim):

Atualização completa: O ecrã E-Paper pisca várias vezes durante o processo de atualização (o número de piscadelas depende do tempo de atualização), e o piscar serve para remover imagens residuais e alcançar o melhor efeito de visualização.

Atualização parcial: Neste caso, o ecrã não pisca durante o processo de atualização. Após várias operações de atualização parcial, deve ser feita uma atualização completa para remover a imagem residual. Caso contrário, a imagem residual pode tornar-se permanente.

Recomenda-se definir o intervalo de atualização do ecrã e-ink para pelo menos 180 segundos (exceto para produtos que suportem atualização parcial).

Após uma operação de atualização, recomenda-se desligar ou hibernar o ecrã. Isto prolonga a vida útil do ecrã e reduz o consumo de energia.

Ao usar um ecrã e-ink tricolor, recomenda-se atualizar o ecrã pelo menos uma vez a cada 24 horas.

Os ecrãs E-Paper são recomendados para uso interior e não para uso exterior. Se quiseres usar o ecrã no exterior, coloca-o numa área sombreada e cobre completamente a parte da cola branca da fita de conexão do ecrã E-Paper com fita 3M.

Conclusões

Os ecrãs E-Paper oferecem várias vantagens que os tornam atraentes para diversos projetos. Consomem muito pouca energia, especialmente ao mostrar imagens estáticas, o que é ideal para dispositivos alimentados por bateria. A sua excelente legibilidade à luz solar direta torna-os adequados para aplicações exteriores, enquanto os amplos ângulos de visualização garantem clareza de diferentes perspetivas. Além disso, os ecrãs E-Paper são finos e leves, permitindo fácil integração em vários designs.

No entanto, os ecrãs E-Paper têm uma taxa de atualização lenta comparada com LCDs ou OLEDs, o que pode limitar o seu uso em projetos que requerem conteúdo dinâmico. As opções de cor também são limitadas; ecrãs preto e branco mostram apenas duas cores, enquanto ecrãs tricolores estão restritos a três cores, o que pode afetar a flexibilidade do design. Além disso, os ecrãs E-Paper podem ser mais caros do que outros tipos de ecrã, especialmente para tamanhos maiores.

Os ecrãs E-Paper monocromáticos têm taxas de atualização muito mais rápidas (< 3 segundos) do que os tricolores e tipicamente suportam atualização parcial para uma atualização ainda mais rápida e sem piscar. São rápidos o suficiente para mostradores de relógio, por exemplo. Vê os nossos tutoriais Digital Clock on e-Paper Display e Analog Clock on e-Paper Display.

O tempo de atualização muito lento (15 segundos) dos ecrãs tricolores limita as suas aplicações. O caso de uso mais comum são etiquetas eletrónicas de preço. Mas podes usá-lo para outras aplicações com ciclos de atualização lentos também. Por exemplo, dados meteorológicos precisam ser atualizados apenas a cada 15 minutos, aproximadamente.

O nosso Weather Station on e-Paper Displaytutorial usa um E-Paper monocromático, mas um E-Paper tricolor seria uma opção. E se precisares de ainda mais cores, vê o 4-color E-paper display with ESP32 tutorial.

Se tiveres alguma dúvida, não hesites em perguntar na secção de comentários.

Boas construções ; )