En este tutorial aprenderás a controlar una pantalla ePaper de 3 colores (Negro, Rojo y Blanco) usando una Raspberry Pi Pico y MicroPython, desde la instalación de librerías hasta mostrar imágenes generadas con image2cpp.

📜 Introducción

Las pantallas ePaper (Electronic Paper Display, EPD) son una tecnología de visualización que simula la apariencia de la tinta en papel. A diferencia de las pantallas LCD u OLED, el ePaper no emite luz y puede mantener la imagen sin consumir energía.

🧰 Materiales necesarios

• Raspberry Pi Pico con MicroPython instalado ( Si aún no tienes MicroPython instalado, aquí te dejo el enlace a nuestro tutorial:
  👉 Cómo instalar MicroPython en tu Raspberry Pi Pico fácilmente)
• Pantalla e-Paper Waveshare 4.2" (modelo B de 3 colores)
• Conector con cables Dupont 
  
• Computadora con Thonny IDE

🖥️ ¿Cómo se definen los píxeles en una pantalla ePaper?

En una imagen monocromática tradicional, los píxeles se representan con valores binarios:

• 0 representa un píxel negro.
• 1 representa un píxel blanco.

Por ejemplo, si tenemos una fila de 16 píxeles donde los primeros 8 son negros y los últimos 8 son blancos, se representarían en código binario de la siguiente manera:

Los datos se almacenan en formato MSB (Most Significant Bit first), lo que significa que cada byte controla 8 píxeles.

Así, un solo byte puede representar 8 píxeles y se necesitan 2 bytes para controlar 16 píxeles.

🎨 Pantallas ePaper de tres colores

En una pantalla ePaper de tres colores (negro, rojo y blanco), los datos se dividen en dos capas:

• Una capa para negro y blanco.
• Una capa para rojo y blanco.

Esto significa que cada imagen debe separarse en dos partes: una con los píxeles en blanco y negro, y otra con los píxeles en rojo y blanco. Cada una de estas capas es controlada por un conjunto de bytes independiente.

Ejemplo de separación de capas

Supongamos que tenemos 8 píxeles donde los primeros 4 son rojos y los últimos 4 son negros:

Se descompone en dos imágenes:

• Imagen Black/White: donde los primeros 4 píxeles son blancos y los últimos 4 son negros.
• Imagen Red/White: donde los primeros 4 píxeles son rojos y los últimos 4 son blancos.

Codificación de datos

Los datos en código binario se ven así:

📚 En el siguiente enlace tienes más información y documentación para distintas plataformas de desarrollo, incluyendo ejemplos, diagramas y detalles técnicos directamente del fabricante:
👉 https://www.waveshare.com/wiki/4.2inch_e-Paper_Module_(B)_Manual#Working_With_Raspberry_Pi

🔌 Conexiones (SPI)

✅ Código demo

📁 En el siguiente enlace encontrarás el código demo, donde se muestran algunas de las funciones que puedes usar con la pantalla, así como una imagen de ejemplo convertida en un array de datos.

Demo.rar

🕒 Recuerda que el tiempo de refresco de la pantalla ePaper es algo lento, por lo que tardará algunos segundos en aparecer todo el contenido.

💡 Usa Thonny para subir los archivos al sistema de archivos de la Raspberry Pi Pico y ejecutar el archivo demo.py.

🖼️ Mostrar imágenes con image2cpp

1. Ve a image2cpp
2. Sube una imagen blanco/negro o rojo/blanco (máximo 400x300 px).
3. Configura:
   • Output format: Plain bytes-Horizontal-1bit
   • Invert colors: según necesidad
4. Copia solo el array generado const unsigned char.
5. Convierte el array a bytearray en MicroPython.
   
   
   

📌 Conclusión

Las pantallas ePaper de tres colores funcionan dividiendo la imagen en dos capas: una para negro/blanco y otra para rojo/blanco. Cada capa se maneja por separado usando bytes en formato MSB.

Para mostrar una imagen correctamente, es necesario convertirla en un conjunto de bytes en los que cada bit representa un píxel. Esta conversión se puede hacer manualmente o con herramientas como image2cpp.

Ahora que comprendes cómo se definen los píxeles y cómo se estructuran los datos, puedes avanzar a programar tu pantalla ePaper y mostrar imágenes personalizadas con MicroPython.

¿Tienes dudas ? ¡Déjanos un comentario!