En este tutorial, aprenderás a conectar una pantalla E-ink tricolor con un Arduino o un ESP32.
E-Ink, o papel electrónico (E-Paper), es una tecnología de pantalla que imita la apariencia de la tinta sobre papel. Utiliza microcápsulas diminutas llenas de partículas coloreadas. Cuando se aplica un campo eléctrico, las partículas se desplazan hacia la superficie, creando texto e imágenes.
El papel electrónico ofrece varias ventajas. Su bajo consumo de energía permite que los dispositivos funcionen durante semanas o meses con una sola carga. La pantalla imita el papel tradicional, proporcionando una excelente legibilidad bajo la luz solar directa y amplios ángulos de visión sin reflejos. Además, el E-Paper es delgado y ligero. Sin embargo, tiene una actualización lenta, una gama de colores limitada y es comparativamente más caro.
Partes necesarias
Necesitarás una pantalla E-Paper y para este tutorial elegí una pantalla tricolor de 2.9 pulgadas con una resolución de 296×128 píxeles. Sin embargo, también podrías usar una pantalla E-Paper monocroma de otro tamaño.
Conectaremos la pantalla E-Paper a un Arduino y a un ESP32. Casi cualquier modelo de Arduino o ESP32 funcionará, pero el ESP32 es la mejor opción. El ESP32 lite listado a continuación es especialmente adecuado, ya que tiene una interfaz para batería y los E-Paper son ideales para proyectos alimentados por batería.
Pantalla E-Paper tricolor de 2.9″
Arduino Uno
Cable USB para Arduino UNO
ESP32 lite
Cable USB de datos
Juego de cables Dupont
Protoboard
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.
Conceptos básicos de pantallas E-Paper
La tecnología E-Paper se basa en la tecnología Microcapsule Electrophoretic Display (EPD). La hoja de E-Paper consta de una capa de polímero conductor transparente que sirve como electrodo frontal, junto con millones de microcápsulas, cada una del diámetro de un cabello humano, incrustadas en un material polimérico. Estas microcápsulas contienen partículas o pigmentos coloreados (negro, blanco, …) en un fluido transparente. La hoja de E-Paper se lamina sobre un sustrato que actúa como electrodo inferior.
El electrodo inferior suele estar dividido en segmentos o píxeles, lo que permite controlar de forma independiente el voltaje en cada segmento. Esta capacidad permite que la pantalla forme diversas imágenes. Una vez creada una imagen, se puede eliminar el voltaje y las partículas permanecerán en sus posiciones actuales. Esta característica permite que un E-Paper mantenga una imagen estática sin consumir energía.
Sistema de tinta de dos pigmentos
En un sistema de tinta electrónica de dos pigmentos, cada microcápsula contiene partículas blancas cargadas negativamente y partículas negras cargadas positivamente suspendidas en un fluido transparente. Cuando se aplica un campo eléctrico, ya sea positivo o negativo, las partículas correspondientes migran a la parte superior de la microcápsula. Este movimiento hace que las partículas sean visibles, haciendo que la superficie aparezca blanca o negra en esa ubicación específica.
Controlando los campos eléctricos aplicados a cada microcápsula, la pantalla puede mostrar una gama de tonos grises, aunque la mayoría de los E-Paper monocromos solo soportan negro y blanco.
Sistema de tinta de tres pigmentos
Un sistema de tinta electrónica de tres pigmentos amplía los principios del sistema de dos pigmentos incorporando un color adicional. En este sistema, las microcápsulas o microcápsulas contienen partículas blancas cargadas negativamente, partículas negras cargadas positivamente y un tercer conjunto de pigmentos cargados positivamente, típicamente rojo o amarillo.
Cuando se aplica un campo eléctrico, las partículas responden según su carga. Por ejemplo, un campo eléctrico negativo hará que las partículas rojas cargadas positivamente suban a la superficie. Una carga dividida hace que las partículas negras suban a la parte superior. Y una carga positiva traerá las partículas blancas al frente.
Módulo de pantalla E-Paper tricolor de 2.9″
Si quieres controlar un E-Paper desde un microcontrolador, necesitarás un controlador que gestione los campos eléctricos de la pantalla. Puedes comprar el E-Paper y el controlador por separado o como un módulo que integra ambos en una sola unidad.
El módulo de pantalla que usamos en este tutorial es una pantalla tricolor (blanco, negro, rojo) de 2.9 pulgadas, con una resolución de 296×128 píxeles y un controlador integrado con una interfaz SPI para comunicación. La imagen a continuación muestra el frente y la parte trasera del módulo de pantalla:
Ten en cuenta que el módulo tiene un pequeño jumper/palanca en la parte trasera para cambiar de SPI de 4 hilos a SPI de 3 hilos. Usaremos el SPI de 4 hilos por defecto aquí, por lo que no deberías cambiar nada.SPI
El módulo de pantalla funciona a 3.3V o 5V, con un consumo en espera de 0.017mW y consume solo unos 26.4mW durante la actualización. El tiempo para una actualización completa es de 15 segundos y no soporta actualización parcial. Si quieres aprender más sobre las diferencias entre actualización completa y parcial, consulta nuestro Partial Refresh of e-Paper Display tutorial.
Pinout de la pantalla E-Paper
El modelo de pantalla viene con un conector de 8 pines para SPI comunicación y alimentación que tiene los siguientes pines:
BUSY indica que la pantalla está ocupada actualizando contenido. RST significa Reset. DC es el pin de Comando de Datos, CS es Chip Select, y CLK es el pin de reloj. DIN es el pin de entrada de datos. VCC y GND son para la alimentación. La pantalla tiene un regulador de voltaje integrado y puedes usar 3.3V o 5V para alimentarla.
Instalación de la librería GxEPD2 para E-Paper
Antes de poder dibujar o escribir en el E-Paper necesitamos install two libraries. La librería Adafruit_GFX es una librería gráfica básica que proporciona un conjunto común de primitivas gráficas (texto, puntos, líneas, círculos, etc.). Y la librería GxEPD2 proporciona el software controlador gráfico para controlar un E-Paper vía SPI.
Abre el Library Manger, busca «Adafruit_GFX» y «GxEPD2» y pulsa «INSTALL». Tras la instalación, las librerías deberían aparecer en el Library Manager como sigue.
En las siguientes dos secciones, te mostraré cómo conectar la pantalla E-Paper a un ESP32 o a un Arduino. El ESP32 es preferible al Arduino, ya que tiene mucha más memoria, lo que simplifica el código.
Conexión de la pantalla E-Paper al ESP32
La imagen a continuación muestra cómo conectar un ESP32 lite a la pantalla E-Paper. Aunque la mayoría de los pines pueden configurarse, necesitas conocer los pines SPI por defecto para tu placa ESP32, específicamente para las señales DIN y CLK. En el caso del ESP32 lite, DIN está en el pin 23 y CLK en el pin 18.
Si necesitas ayuda para encontrar los pines SPI por defecto, consulta el Find I2C and SPI default pins tutorial.
La siguiente tabla muestra todas las conexiones que debes hacer. Ten en cuenta que puedes alimentar el módulo de pantalla con 3.3V o 5V, pero el ESP32-lite solo tiene salida de 3.3V.
| Pantalla 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 |
Puedes usar una protoboard para conectar todo. Pero yo conecté la pantalla directamente al ESP32 con cables Dupont. La imagen a continuación muestra cómo quedó mi montaje.
Código de prueba para E-Paper con ESP32
A continuación escribiremos un código simple para probar el funcionamiento de la pantalla. Mostraremos el texto «Makerguides», con «Maker» en color negro y «guides» en rojo.
#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 a desglosar el código en partes para entenderlo mejor.
Inclusión de librerías
Comenzamos incluyendo la librería necesaria para controlar la pantalla E-Paper. La librería GxEPD2_3C.h proporciona las funciones necesarias para interactuar con la pantalla tricolor.
#include "GxEPD2_3C.h"
Si tienes una pantalla de 4 colores, incluirías GxEPD2_4C.h o GxEPD2_7C.h para una pantalla de 7 colores, respectivamente. Si tienes un E-Paper en blanco y negro (BW), incluye GxEPD2_BW.h
Definición de pines
Luego definimos los pines usados para conectar la pantalla al ESP32 vía la interfaz SPI:
#define EPD_CS 5 #define EPD_DC 0 #define EPD_RST 2 #define EPD_BUSY 15
Creación del objeto pantalla
Creamos una instancia del objeto pantalla E-Paper usando los pines definidos. Los parámetros de plantilla también especifican el tipo de pantalla y su altura.
GxEPD2_3C<GxEPD2_290_C90c, GxEPD2_290_C90c::HEIGHT> epd(GxEPD2_290_C90c(EPD_CS , EPD_DC, EPD_RST, EPD_BUSY));
Esta es la línea más crítica del código. Si tu pantalla no muestra nada o muestra texto/imágenes corruptas, es porque la pantalla no está correctamente cableada o se ha elegido un controlador incorrecto.
La Readme for GxEPD2 librería lista todas las pantallas soportadas y puedes encontrar los detalles en los archivos de cabecera, por ejemplo GxEPD2.h. Encuentra el controlador específico para tu pantalla. Esto puede requerir prueba y error.
Función Setup
En la función setup(), inicializamos la comunicación con la pantalla a una velocidad de 115200 baudios. También configuramos la rotación de la pantalla a 1 (90 grados), que es modo horizontal.
epd.init(115200); epd.setRotation(1);
Luego configuramos el tamaño del texto y preparamos la pantalla para dibujar.
epd.setTextSize(2); epd.setFullWindow(); epd.fillScreen(GxEPD_WHITE);
Después, establecemos la posición del cursor y el color del texto en negro antes de imprimir «Maker» en la pantalla.
epd.setCursor(80, 60);
epd.setTextColor(GxEPD_BLACK);
epd.print("Maker");
Luego cambiamos la posición del cursor y el color del texto a rojo para imprimir «guides».
epd.setCursor(140, 60);
epd.setTextColor(GxEPD_RED);
epd.print("guides");
Ambos comandos de impresión juntos mostrarán el texto «Makerguides» en el centro de la pantalla. La salida en tu pantalla debería verse así:
Finalmente, llamamos a epd.display() para renderizar el texto en pantalla y poner la pantalla en modo hibernación para ahorrar energía.
epd.display(); epd.hibernate();
Función Loop
La función loop() está vacía en este ejemplo, ya que solo necesitamos inicializar y mostrar el texto una vez. La pantalla permanecerá en un estado de bajo consumo y seguirá mostrando el texto, incluso si se desconecta la alimentación por completo.
void loop() {}
Si subes y ejecutas el código, verás que la pantalla parpadea durante unos 15 segundos, mientras el texto aparece lentamente (mira el breve video a continuación).
Esto se llama «actualización completa» y borra toda la pantalla para redibujar todos los píxeles. Este proceso asegura que cualquier imagen residual o fantasma de contenidos anteriores se elimine.
Una «actualización parcial», en cambio, solo actualiza áreas específicas de la pantalla. Este método es mucho más rápido (< 0.3 seg) y evita el parpadeo. Para ejemplos, consulta el Partial Refresh of e-Paper Display tutorial.
Mientras que las actualizaciones parciales son comúnmente soportadas por pantallas E-Paper monocromas, muchas pantallas tricolor, incluyendo la usada en este proyecto, no las soportan. Esto limita su uso a casos donde las actualizaciones de contenido son poco frecuentes, por ejemplo, una vez por hora. De lo contrario, el parpadeo y la lenta actualización resultan demasiado molestos.
Conexión de la pantalla E-Paper al Arduino
En esta sección conectamos la pantalla E-Paper a un Arduino Uno en lugar de un ESP32. El número de conexiones es el mismo, solo cambian los pines. Como se mencionó antes, la mayoría de los pines pueden configurarse, pero para las líneas DIN y CLK debemos usar los pines SPI específicos. En el caso del Arduino Uno, DIN está en el pin 11 y CLK en el pin 13.
La siguiente tabla lista todas las demás conexiones que debes hacer. Para alimentación podrías usar 5V en lugar de 3.3V.
| Pantalla 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 prueba para E-Paper con Arduino Uno
El código para probar el E-Paper con un Arduino Uno es similar al usado con ESP32, con dos diferencias importantes, causadas por la pequeña memoria del Arduino Uno.
Echa un vistazo rápido al código primero y quizá lee el ejemplo para ESP32 para contexto. Luego discutiremos las diferencias.
#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, el código escribe el texto «Makerguides» en negro y rojo en la pantalla. Sin embargo, la forma en que se crea el objeto pantalla es diferente. Específicamente, debemos definir la altura (MAX_HEIGHT) de la pantalla:
#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));
La pantalla E-Paper tiene una resolución de 296 * 128 píxeles, lo que significa que un total de 37888 píxeles deben configurarse para actualizar el contenido mostrado. Normalmente, el contenido se escribe primero en un búfer de pantalla y luego se envía a la pantalla. Sin embargo, un Arduino Uno solo tiene 2KB de SRAM = 2048 bytes, que es demasiado pequeño para contener el búfer completo. Por eso definimos un búfer de pantalla más pequeño MAX_BUFF = 1024.
Con el búfer más pequeño no podemos enviar el búfer completo sino solo una franja de MAX_HEIGHT, que se deriva de MAX_BUFF y el ancho (EPD::WIDTH) de la pantalla. Calculamos la altura de la pantalla mediante MAX_HEIGHT(GxEPD2_290_C90c).
Dibujo por páginas
La pantalla se actualiza usando un modo de dibujo por páginas. Este método divide la pantalla en secciones más pequeñas o franjas llamadas «páginas». En lugar de cargar todo el contenido, el Arduino procesa una página a la vez.
Puedes ver esto en el bucle do–while en la función setup, donde las páginas se dibujan repetidamente hasta que se actualiza todo el contenido de la pantalla.
epd.firstPage();
do {
...
} while (epd.nextPage());
Al actualizar la pantalla, el Arduino dibuja el contenido para la página actual en memoria, luego envía esa página a la pantalla E-Paper. Después de actualizar la página, el Arduino puede limpiar el búfer y cargar la siguiente página.
Ten en cuenta que el búfer de pantalla y el código del sketch comparten la misma memoria. Si tu código crece, puede que tengas que reducir MAX_BUFF para que ambos quepan en la SRAM. Si recibes el siguiente mensaje de error al compilar, sabes que MAX_BUFF está configurado 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
El bucle explícito do-while para dibujo por páginas es algo engorroso y poco elegante. Por suerte, la librería GxEPD2 ofrece otra opción. Puedes definir una función de dibujo y luego llamar a epd.drawPaged(...) para dibujo por páginas. El siguiente ejemplo muestra cómo sería para el código de prueba anterior:
...
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() {}
La función de dibujo draw() recibe un puntero pv, que permite pasar parámetros, aunque aquí no lo usamos. Al llamar a epd.drawPaged(draw, 0), simplemente pasamos 0 como puntero de parámetro.
El uso de funciones de dibujo para redibujos por páginas hace el código más legible y extensible. Puedes tener múltiples funciones de dibujo, especialmente útiles al realizar actualizaciones parciales y completas. Consulta el Digital Clock on e-Paper Display tutorial para un ejemplo.
Ten en cuenta que puedes usar dibujo por páginas incluso si tu microcontrolador es lo suficientemente grande para contener el búfer completo. Por ejemplo, el código de prueba para Arduino Uno funcionaría sin cambios (aparte del cableado) en un ESP32 y en general se recomienda el dibujo por páginas.
Recomendaciones
La Waveshare Manual ofrece las siguientes recomendaciones al operar una pantalla E-Paper (resumidas y parafraseadas por mí):
Actualización completa: La pantalla E-Paper parpadeará varias veces durante el proceso de actualización (el número de parpadeos depende del tiempo de actualización), y el parpadeo sirve para eliminar imágenes residuales y lograr el mejor efecto visual.
Actualización parcial: En este caso, la pantalla no parpadea durante la actualización. Después de varias actualizaciones parciales, se debe realizar una actualización completa para eliminar la imagen residual. De lo contrario, la imagen residual puede volverse permanente.
Se recomienda establecer el intervalo de actualización de la pantalla de tinta electrónica en al menos 180 segundos (excepto para productos que soportan actualización parcial).
Después de una actualización, se recomienda apagar o hibernar la pantalla. Esto prolongará la vida útil de la pantalla y reducirá el consumo de energía.
Al usar una pantalla de tinta electrónica tricolor, se recomienda actualizar la pantalla al menos una vez cada 24 horas.
Se recomienda usar pantallas E-Paper en interiores y no en exteriores. Si quieres usar la pantalla al aire libre, colócala en un área sombreada y cubre completamente la parte blanca del adhesivo de la cinta de conexión de la pantalla E-Paper con cinta 3M.
Conclusiones
Las pantallas E-Paper ofrecen varias ventajas que las hacen atractivas para diversos proyectos. Consumen muy poca energía, especialmente al mostrar imágenes estáticas, lo que es ideal para dispositivos alimentados por batería. Su excelente legibilidad bajo luz solar directa las hace adecuadas para aplicaciones al aire libre, mientras que sus amplios ángulos de visión garantizan claridad desde diferentes perspectivas. Además, las pantallas E-Paper son delgadas y ligeras, lo que facilita su integración en diversos diseños.
Sin embargo, las pantallas E-Paper tienen una tasa de actualización lenta en comparación con LCD u OLED, lo que puede limitar su uso en proyectos que requieren contenido dinámico. Las opciones de color también son limitadas; las pantallas en blanco y negro solo muestran dos colores, mientras que las tricolor están restringidas a tres colores, lo que puede afectar la flexibilidad del diseño. Además, las pantallas E-Paper pueden ser más caras que otros tipos de pantalla, especialmente en tamaños grandes.
Las pantallas E-Paper monocromas tienen tasas de actualización mucho más rápidas (< 3 segundos) que las tricolor y típicamente soportan actualización parcial para una actualización aún más rápida y sin parpadeos. Son lo suficientemente rápidas para pantallas de reloj, por ejemplo. Consulta nuestros tutoriales Digital Clock on e-Paper Display y Analog Clock on e-Paper Display.
El tiempo de actualización muy lento (15 segundos) de las pantallas tricolor limita sus aplicaciones. El caso de uso más común son etiquetas electrónicas de precios. Pero también podrías usarlas para otras aplicaciones con ciclos de actualización lentos. Por ejemplo, los datos meteorológicos solo necesitan actualizarse cada 15 minutos aproximadamente.
Nuestro tutorial Weather Station on e-Paper Display usa un E-Paper monocromo, pero una pantalla tricolor sería una opción. Y si necesitas aún más colores, echa un vistazo al tutorial 4-color E-paper display with ESP32.
Si tienes alguna pregunta, no dudes en preguntar en la sección de comentarios.
¡Feliz bricolaje ; )
