Aprender

Una pantalla de papel electrónico en un Arduino: una etiqueta de precio de estante

Intermedio

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: una etiqueta de precio de estante en papel electrónicoen vivo0.000 s 0.00x
Presiona Ejecutar, espera la actualización, luego presiona el botón
El ejemplo de etiqueta de estante: un panel SSD1680 de 2.9 pulgadas con GxEPD2. Espera la actualización completa, luego presiona el botón para una parcial.

El papel electrónico (también llamado tinta electrónica) es la pantalla de los lectores de libros electrónicos y las etiquetas de precio electrónicas. Se ve como papel impreso, se lee bien a la luz del sol y conserva la imagen sin energía, así que una etiqueta puede mostrar un precio durante años con una pila de botón. El problema es la velocidad: una actualización completa tarda segundos.

El circuito de arriba es un Uno manejando un panel de papel electrónico de 2.9 pulgadas y 296 por 128 píxeles con la biblioteca GxEPD2, como etiqueta de precio en el estante de una tienda. Dibuja la etiqueta una vez con una actualización completa y luego pone el panel a dormir. Presiona el botón y baja el precio con una actualización parcial rápida solo del precio. Presiona Ejecutar y dale unos seis segundos.

Lo que necesitas

  • Un Arduino Uno
  • Un módulo de papel electrónico SPI de 2.9 pulgadas, 296x128, SSD1680 (como el de Waveshare)
  • Un botón pulsador
  • Una protoboard y cables jumper

Cableado

Componente y pinVa aNota
VCC del papel electrónico3.3 VEl panel funciona con 2.2 a 3.7 V
GND del papel electrónicoGND
SDA del papel electrónico (DIN)Pin 11Datos SPI (MOSI)
SCL del papel electrónico (CLK)Pin 13Reloj del SPI
CS del papel electrónicoPin 10
DC del papel electrónicoPin 9Comando o datos
RES del papel electrónico (RST)Pin 8
BUSY del papel electrónicoPin 7En alto mientras el panel se actualiza
BotónPin 2 y GNDINPUT_PULLUP, así al presionarlo se lee LOW

Cómo funciona el papel electrónico

Dentro del panel hay millones de cápsulas diminutas con partículas negras y blancas de cargas opuestas. Un voltaje en un píxel atrae las negras hacia arriba o las blancas, y se quedan ahí cuando el voltaje desaparece. Por eso la imagen dura sin energía, y por eso cambiarla toma tiempo: las partículas tienen que moverse.

El panel tiene su propio controlador, aquí un SSD1680, con memoria para la imagen. El Arduino escribe la imagen nueva en esa memoria por SPI y luego le dice al controlador que se actualice. Mientras corre la actualización, el controlador mantiene su pin BUSY en alto e ignora lo que envíes.

El sketch

La pantalla se configura con GxEPD2_290_BS(10, 9, 8, 7): CS, DC, RES y BUSY. GxEPD2 dibuja con las funciones de Adafruit GFX, dentro de un ciclo firstPage() / nextPage(). Luego hibernate() pone el controlador en sueño profundo, donde no consume nada, y la imagen se queda en el vidrio.

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".

El sketch de la etiqueta de estante
#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 en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Por qué dibuja por páginas

Una imagen completa de este panel es 128 x 296 / 8 = 4,736 bytes, un bit por píxel. El Uno tiene 2,048 bytes de RAM en total, así que la imagen no se puede tener toda a la vez. La solución de GxEPD2 es la paginación: mantiene un búfer para una franja de la pantalla, ejecuta tu código de dibujo una vez por cada franja y envía cada franja al terminar.

Las dos líneas al inicio del sketch dimensionan ese búfer a 800 bytes, que para este panel son 50 filas. 296 filas en franjas de 50 son seis franjas, así que el código dentro del ciclo do ... while (display.nextPage()) se ejecuta seis veces. Por eso todo lo que dibujes debe estar dentro del ciclo, y por qué debe dibujar lo mismo en cada vuelta.

En un ESP32, con abundante RAM, puedes darle a la plantilla la altura completa y el ciclo se ejecuta una sola vez.

Actualización completa y parcial

Una actualización completa pasa cada píxel por negro y blanco varias veces, que es el parpadeo que ves en un panel real. Aquí tarda unos tres segundos y borra cualquier fantasma de la imagen anterior. Una actualización parcial cambia solo una ventana, aquí el precio, sin parpadeo, en unos 0.3 segundos.

Las actualizaciones parciales dejan fantasmas tenues con el tiempo, así que los productos reales hacen una actualización completa de vez en cuando, digamos cada pocas decenas de parciales. Y actualizar cada segundo es mala idea: es lento, y la vida de un panel se mide en actualizaciones. El papel electrónico sirve para cosas que cambian de vez en cuando: un precio, el clima, una lista de pendientes.

Errores comunes

BUSY sin conectar. El Uno no puede saber cuándo termina el panel, así que envía sus siguientes comandos a una actualización que sigue en curso, y el panel los ignora. Quita el cable de BUSY en el circuito de arriba: el monitor serie sigue diciendo "label drawn", pero el vidrio queda en blanco.

La clase de panel equivocada. GxEPD2 tiene una clase por cada panel y controlador (GxEPD2_290_BS, GxEPD2_290_T94_V2 y muchas más). La equivocada da una pantalla en blanco, con ruido o medio dibujada. Haz coincidir la clase con la parte de atrás de tu panel.

Dibujar fuera del ciclo de páginas, o dibujar algo distinto en cada pasada. Cada pasada debe dibujar la imagen completa.

Alimentarlo con 5 V. El panel es un componente de 3.3 V. Las placas de módulo de Waveshare dicen que aceptan lógica de 3.3 V o 5 V; un panel desnudo en un adaptador sencillo quiere 3.3 V en cada pin.

Dejarlo despierto. Llama a hibernate() después de cada actualización; la imagen se queda y el panel casi no consume nada.

Abre este circuito en el editor. Arduino Uno: una etiqueta de estante en papel electrónico, conectada como se ejecuta en la parte superior de esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Abrir el circuito

Preguntas

¿Qué biblioteca debo usar para una pantalla de papel electrónico?

GxEPD2, de Jean-Marc Zingg. Es compatible con la mayoría de paneles de Waveshare y Good Display, dibuja con las funciones de Adafruit GFX y maneja la paginación en placas con poca RAM como el Uno.

¿Una pantalla de tinta electrónica necesita energía para conservar la imagen?

No. Las partículas se quedan donde se dejaron, así que la imagen se mantiene sin energía. La energía solo se necesita para cambiarla.

¿Cuánto tarda un refresco de una pantalla de tinta electrónica?

Un refresco completo tarda unos tres segundos en un panel de 2.9 pulgadas como este; un refresco parcial, unos 0.3 segundos. Los paneles a color con rojo o amarillo tardan mucho más, 15 segundos o más.

¿Por qué no se actualiza mi pantalla de tinta electrónica?

Revisa primero BUSY, luego que la clase del panel coincida con tu panel, y después los cables SPI. Una clase equivocada es la razón más común de un panel en blanco.

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.