Aprender

Um display e-paper em um Arduino: uma etiqueta de preço de prateleira

Intermediário

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: uma etiqueta e-paper de prateleiraao vivo0.000 s 0.00x
Aperte Rodar, espere a atualização e depois aperte o botão
O exemplo Etiqueta de prateleira: um painel SSD1680 de 2,9 polegadas com GxEPD2. Espere a atualização completa e depois aperte o botão para uma parcial.

E-paper (também chamado de e-ink) é a tela de leitores digitais e etiquetas eletrônicas de prateleira. Parece papel impresso, se lê bem sob o sol e mantém a imagem mesmo sem energia, então uma etiqueta pode mostrar um preço por anos com uma pilha botão. O problema é a velocidade: uma atualização completa leva segundos.

O circuito acima é um Uno controlando um painel e-paper de 2,9 polegadas, 296 por 128 pixels, com a biblioteca GxEPD2, como etiqueta de preço na prateleira de uma loja. Ele desenha a etiqueta uma vez com uma atualização completa e depois coloca o painel para dormir. Aperte o botão e ele reduz o preço com uma atualização parcial rápida, só do preço. Aperte Rodar e dê uns seis segundos.

O que você precisa

  • Um Arduino Uno
  • Um módulo e-paper SPI de 2,9 polegadas, 296x128, SSD1680 (como o da Waveshare)
  • Um botão de pressão
  • Uma protoboard e jumpers

Ligação

Componente e pinoVai paraNota
e-paper VCC3.3 VO painel funciona de 2,2 a 3,7 V
e-paper GNDGND
e-paper SDA (DIN)Pino 11Dados SPI (MOSI)
e-paper SCL (CLK)Pino 13Clock do SPI
e-paper CSPino 10
e-paper DCPino 9Comando ou dado
e-paper RES (RST)Pino 8
e-paper BUSYPino 7Alto enquanto o painel atualiza
BotãoPino 2 e GNDINPUT_PULLUP, então pressionado lê LOW

Como funciona o e-paper

Dentro do painel há milhões de cápsulas minúsculas com partículas pretas e brancas de cargas opostas. Uma tensão em um pixel puxa as pretas para o topo ou as brancas, e elas ficam lá quando a tensão sai. É por isso que a imagem dura sem energia, e por que mudá-la demora: as partículas precisam se mover.

O painel tem seu próprio controlador, aqui um SSD1680, com memória para a imagem. O Arduino grava a nova imagem nessa memória por SPI e depois manda o controlador atualizar. Durante a atualização, o controlador mantém o pino BUSY em nível alto e ignora o que você enviar.

O sketch

O display é configurado com GxEPD2_290_BS(10, 9, 8, 7): CS, DC, RES e BUSY. O GxEPD2 desenha com as chamadas da Adafruit GFX, dentro de um laço firstPage() / nextPage(). Depois hibernate() coloca o controlador em sono profundo, onde ele não consome quase nada, e a imagem fica no vidro.

Watch the serial monitor and the timing. The label takes about six seconds from Run: nearly three to draw the picture and send it, then about three for the full refresh, with BUSY high. Then "label drawn". Press the button and the price changes from $4.99 to $2.99 with a partial refresh that takes about 0.3 seconds, and the serial monitor says "marked down". Press again for "full price".

O sketch da etiqueta de prateleira
#include <GxEPD2_BW.h>

#define MAX_DISPLAY_BUFFER_SIZE 800
#define MAX_HEIGHT(EPD) (EPD::HEIGHT <= MAX_DISPLAY_BUFFER_SIZE / (EPD::WIDTH / 8) ? \
                         EPD::HEIGHT : MAX_DISPLAY_BUFFER_SIZE / (EPD::WIDTH / 8))

GxEPD2_BW<GxEPD2_290_BS, MAX_HEIGHT(GxEPD2_290_BS)>
    display(GxEPD2_290_BS(10, 9, 8, 7));  // CS, DC, RES, BUSY

const int BUTTON = 2;
bool sale = false;

void price() {
  display.fillRect(150, 40, 146, 60, GxEPD_WHITE);
  display.setTextColor(GxEPD_BLACK);
  display.setTextSize(4);
  display.setCursor(156, 52);
  display.print(sale ? "$2.99" : "$4.99");
}

void drawLabel() {
  display.setFullWindow();
  display.firstPage();
  do {
    display.fillScreen(GxEPD_WHITE);
    display.fillRect(0, 0, 296, 28, GxEPD_BLACK);
    display.setTextColor(GxEPD_WHITE);
    display.setTextSize(2);
    display.setCursor(8, 6);
    display.print("FRESH BREAD");
    display.setTextColor(GxEPD_BLACK);
    display.setTextSize(2);
    display.setCursor(8, 52);
    display.print("Sourdough");
    display.setCursor(8, 76);
    display.print("800 g");
    display.drawFastHLine(8, 108, 280, GxEPD_BLACK);
    price();
  } while (display.nextPage());
}

void drawPrice() {
  display.setPartialWindow(150, 40, 146, 60);
  display.firstPage();
  do {
    price();
  } while (display.nextPage());
}

void setup() {
  Serial.begin(9600);
  pinMode(BUTTON, INPUT_PULLUP);
  display.init(115200);
  display.setRotation(1);
  drawLabel();
  display.hibernate();
  Serial.println("label drawn");
}

void loop() {
  if (digitalRead(BUTTON) == LOW) {
    sale = !sale;
    drawPrice();
    display.hibernate();
    Serial.println(sale ? "marked down" : "full price");
    delay(300);
  }
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Por que ele desenha em páginas

Uma imagem completa deste painel tem 128 x 296 / 8 = 4.736 bytes, um bit por pixel. O Uno tem 2.048 bytes de RAM no total, então a imagem não cabe de uma vez. A resposta do GxEPD2 é a paginação: ele mantém um buffer para uma faixa da tela, roda seu código de desenho uma vez por faixa e envia cada faixa assim que termina.

As duas linhas no topo do sketch definem esse buffer com 800 bytes, que neste painel dá 50 linhas. 296 linhas em faixas de 50 são seis faixas, então o código dentro do laço do ... while (display.nextPage()) roda seis vezes. É por isso que tudo o que você desenha precisa estar dentro do laço, e por que ele precisa desenhar a mesma coisa a cada volta.

Em um ESP32, com RAM de sobra, você pode dar ao modelo a altura completa e o laço roda uma vez só.

Atualização completa e parcial

Uma atualização completa leva cada pixel pelo preto e pelo branco algumas vezes, o que é aquele piscar que você vê em um painel real. Aqui ela leva uns três segundos e apaga qualquer fantasma da imagem antiga. Uma atualização parcial muda só uma janela, aqui o preço, sem piscar, em cerca de 0,3 segundos.

Atualizações parciais vão deixando fantasmas fracos com o tempo, então produtos reais fazem uma atualização completa de vez em quando, digamos a cada algumas dezenas de parciais. E atualizar a cada segundo é uma má ideia: é lento, e a vida de um painel é medida em atualizações. O e-paper serve para coisas que mudam de vez em quando: um preço, o clima, uma lista de tarefas.

Erros comuns

BUSY não ligado. O Uno não consegue saber quando o painel terminou, então ele envia os próximos comandos durante uma atualização que ainda está rodando, e o painel os ignora. Remova o fio do BUSY no circuito acima: o monitor serial ainda diz "label drawn", mas o vidro fica em branco.

A classe errada de painel. O GxEPD2 tem uma classe para cada painel e controlador (GxEPD2_290_BS, GxEPD2_290_T94_V2 e muitos outros). A errada dá tela em branco, ruidosa ou desenhada pela metade. Combine a classe com o que está escrito atrás do seu painel.

Desenhar fora do laço de páginas, ou desenhar algo diferente a cada passada. Cada passada precisa desenhar a imagem inteira.

Alimentar com 5 V. O painel é um componente de 3,3 V. As placas de módulo da Waveshare dizem aceitar lógica de 3,3 V ou 5 V; um painel nu em um adaptador comum quer 3,3 V em todos os pinos.

Deixá-lo acordado. Chame hibernate() depois de cada atualização; a imagem fica, e o painel quase não consome.

Abra este circuito no editor. Arduino Uno: uma etiqueta e-paper de prateleira, ligada como aparece rodando no topo desta página. Troque um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

Qual biblioteca devo usar para um display e-paper?

GxEPD2, de Jean-Marc Zingg. Ela dá suporte à maioria dos painéis Waveshare e Good Display, desenha com as chamadas da Adafruit GFX e cuida da paginação em placas com pouca RAM, como o Uno.

Um display de e-paper precisa de energia para manter a imagem?

Não. As partículas ficam onde foram colocadas, então a imagem permanece com a energia desligada. A energia só é necessária para mudá-la.

Quanto tempo leva uma atualização de e-paper?

Uma atualização completa leva cerca de três segundos em um painel de 2,9 polegadas como este; uma atualização parcial, cerca de 0,3 segundos. Painéis coloridos com vermelho ou amarelo levam muito mais tempo, 15 segundos ou mais.

Por que meu display de e-paper não atualiza?

Verifique primeiro o BUSY, depois se a classe do painel corresponde ao seu painel e, então, os fios do SPI. Uma classe errada é o motivo mais comum de um painel em branco.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.