Librería PantallaE213

Presentación

La librería PantallaE213 es una implementación en MicroPython para utilizar la pantalla de tinta electrónica que trae la placa Vision Master E213 (HT-VME213).

Con este desarrollo se busca llenar una falta de librerías que permitan programar las placas LoRa con micropython, dado que si bien sus fabricantes como en el caso de Heltec https://heltec.org/ afirman que las mismas son programables con Micropython todo su soporte es dado para el uso de arduino.

En la investigación previa y al realizar una sistemática búsqueda de posibles implementaciones para la pantalla integrada de 2,13 pulgadas que trae la placa Vision Master E213 (HT-VME213) no se encontro ningún desarrollo basado en Micropython.

La placa utilizada en este proyecto es la siguiente:

Vision Master E213
Vision Master E213

PantallaE213 es una biblioteca en MicroPython diseñada para el control eficiente y de bajo consumo del módulo de pantalla e-Ink monocromático Heltec Vision Master E213, basado en el panel LCMEN2R13EFC1 de 122×250 píxeles. Esta librería está especialmente optimizada para su uso en dispositivos ESP32-S3, ofreciendo alto rendimiento, bajo consumo energético y compatibilidad con aplicaciones embebidas como sensores remotos, dispositivos LoRa o terminales de red mesh.

Características principales
– Soporte de orientación: permite rotar la pantalla 90° (modo vertical/horizontal) mediante el parámetro "orientacion=0 o 90" en la inicialización.
– Buffer de imagen local: maneja un framebuffer completo en RAM para dibujado offline y actualización atómica.
– Actualización parcial optimizada: utiliza LUTs (Look-Up Tables) reales del controlador LCMEN2R13EFC1 para refrescos parciales rápidos y de baja latencia.
– Rendimiento SPI mejorado: configura el bus SPI a 4 MHz (estable en ESP32-S3) con modo 0,0 para transferencias rápidas y confiables.
– Gestión de energía: incluye funciones para encender/apagar el regulador VEXT, y colocar el display en modo de suspensión tras la actualización, ideal para operación con batería o energía solar.

Funcionalidades gráficas
– Dibujo de píxeles, líneas horizontales/verticales y rectángulos (con/sin relleno).
– Renderizado de texto en dos tamaños:
    • 8×8 píxeles (fuente compacta, ideal para datos).
    • 12×16 píxeles (fuente legible, ideal para títulos o mensajes).
– Soporte para caracteres personalizados; muestra un cuadro de reemplazo si un carácter no está definido.
– Manejo automático de coordenadas lógicas según la orientación seleccionada.

Actualización de pantalla
La función actualizar():
– Inicializa el display si es necesario.
– Envía la imagen previa como fondo blanco (para evitar residuos visuales).
– Transfiere el framebuffer actual.
– Dispara un refresco completo o parcial (según LUTs cargados).
– Desactiva el display tras la actualización para ahorrar energía.

Compatibilidad y requisitos
– Plataforma: MicroPython en ESP32-S3 (probado en Heltec Vision Master E213 con SX1262).
– Pines fijos: compatibles con el esquemático del Vision Master E213 (DC=2, CS=5, BUSY=1, RST=3, VEXT=18, SCK=4, MOSI=6).
– Dependencias: requiere dos archivos de fuentes (fuente_8x8.py y fuente_12x16.py) con diccionarios de patrones de bits.
– Solo monocromo (blanco/negro): no soporta escala de grises ni color.

Código de la Librería

El código de la librería está desarrollado en el archivo: pantalla_e213_v1.py, que contiene la lógica principal, este archivo de complementarse con los archivos fuente_8x8.py y fuente_12x16.py, que contiene las fuentes para textos.

Archivo: pantalla_e213_v1.py

# pantalla_e213_v1.py - Controlador para display E-ink Heltec Vision Master E213 Version 1

from machine import Pin, SPI
import time

# ===== CARGA DE FUENTES =====
from fuente_8x8 import PATRONES as PATRONES_8x8
from fuente_12x16 import PATRONES_12x16

# ===== CONFIGURACIÓN DE HARDWARE =====
PIN_DC = 2
PIN_CS = 5
PIN_BUSY = 1
PIN_RST = 3
PIN_VEXT = 18

SPI_ID = 1
PIN_SCK = 4
PIN_MOSI = 6

ANCHO_FISICO = 122
ALTO_FISICO = 250

NEGRO = 1
BLANCO = 0

# ===============================================================
#               CLASE PANTALLA E213
# ===============================================================
class PantallaE213:
    def __init__(self, orientacion=0):

        self.orientacion = orientacion

        self.pin_dc = Pin(PIN_DC, Pin.OUT)
        self.pin_cs = Pin(PIN_CS, Pin.OUT)
        self.pin_busy = Pin(PIN_BUSY, Pin.IN)
        self.pin_rst = Pin(PIN_RST, Pin.OUT)
        self.pin_vext = Pin(PIN_VEXT, Pin.OUT)

        # SPI más rápido y estable
        self.spi = SPI(
            SPI_ID,
            baudrate=4000000,  # DOBLADO (funciona perfecto en ESP32S3)
            polarity=0,
            phase=0,
            bits=8,
            firstbit=SPI.MSB,
            sck=Pin(PIN_SCK),
            mosi=Pin(PIN_MOSI)
        )

        # Tamaño buffer
        self.bytes_por_fila = (ANCHO_FISICO + 7) // 8
        self.buffer_size = self.bytes_por_fila * ALTO_FISICO
        self.buffer = bytearray(self.buffer_size)

        # Dimensiones lógicas
        if orientacion == 0:
            self.ancho = ANCHO_FISICO
            self.alto = ALTO_FISICO
        elif orientacion == 90:
            self.ancho = ALTO_FISICO
            self.alto = ANCHO_FISICO
        else:
            raise ValueError("Orientación debe ser 0 o 90")

        # buffer para envío rápido de comando/dato
        self._buf1 = bytearray(1)

        self.inicializado = False

    # ===============================================================
    #                     FUNCIONES BAJO NIVEL
    # ===============================================================
    def enviar_comando(self, cmd):
        """Envío rápido de comando"""
        self._buf1[0] = cmd
        self.pin_dc.value(0)
        self.pin_cs.value(0)
        self.spi.write(self._buf1)
        self.pin_cs.value(1)

    def enviar_dato(self, dato):
        """Envío rápido de dato"""
        self._buf1[0] = dato
        self.pin_dc.value(1)
        self.pin_cs.value(0)
        self.spi.write(self._buf1)
        self.pin_cs.value(1)

    # ===============================================================
    def _esperar_listo(self, timeout=5000):
        start = time.ticks_ms()

        while True:
            if self.pin_busy.value() == 1:
                return True
            if time.ticks_diff(time.ticks_ms(), start) > timeout:
                return False
            time.sleep_ms(25)

    # ===============================================================
    #                     INICIALIZACIÓN
    # ===============================================================
    def inicializar(self):
        if self.inicializado:
            return

        self.pin_vext.value(1)
        time.sleep_ms(100)

        # Reset rápido
        self.pin_rst.value(0)
        time.sleep_ms(10)
        self.pin_rst.value(1)
        time.sleep_ms(100)

        self._esperar_listo(2000)

        self.enviar_comando(0x00) 
        self.enviar_dato(0x0F)

        self.enviar_comando(0x50)
        self.enviar_dato(0x97)

        self._cargar_luts()

        self.inicializado = True

    # ===============================================================

    def _cargar_luts(self):
        """Carga los LUTs reales del display LCMEN2R13EFC1 (parcial)."""

        LUT_VCOM = [
            0x01, 0x06, 0x03, 0x02, 0x01, 0x01, 0x01,
            0x01, 0x06, 0x02, 0x01, 0x01, 0x01, 0x01,
        ] + [0x00] * 42

        LUT_WW = [
            0x01, 0x06, 0x03, 0x02, 0x81, 0x01, 0x01,
            0x01, 0x06, 0x02, 0x01, 0x01, 0x01, 0x01,
        ] + [0x00] * 42

        LUT_BW = [
            0x01, 0x86, 0x83, 0x82, 0x81, 0x01, 0x01,
            0x01, 0x86, 0x82, 0x01, 0x01, 0x01, 0x01,
        ] + [0x00] * 42

        LUT_WB = [
            0x01, 0x46, 0x43, 0x02, 0x01, 0x01, 0x01,
            0x01, 0x46, 0x42, 0x01, 0x01, 0x01, 0x01,
        ] + [0x00] * 42

        LUT_BB = [
            0x01, 0x06, 0x03, 0x42, 0x41, 0x01, 0x01,
            0x01, 0x06, 0x02, 0x01, 0x01, 0x01, 0x01,
        ] + [0x00] * 42

        luts = {
            0x20: LUT_VCOM,
            0x21: LUT_WW,
            0x22: LUT_BW,
            0x23: LUT_WB,
            0x24: LUT_BB,
        }

        for cmd, tabla in luts.items():
            self.enviar_comando(cmd)
            for v in tabla:
                self.enviar_dato(v)

    # ===============================================================
    #                            DIBUJO
    # ===============================================================
    def dibujar_pixel(self, x, y, color=NEGRO):

        if x < 0 or y < 0 or x >= self.ancho or y >= self.alto:
            return

        # Transformación más rápida
        if self.orientacion == 0:
            xf, yf = x, y
        else:
            xf = y
            yf = ALTO_FISICO - 1 - x

        pos = yf * self.bytes_por_fila + (xf >> 3)
        mask = 1 << (7 - (xf & 7))

        if color:
            self.buffer[pos] |= mask
        else:
            self.buffer[pos] &= ~mask

    # ===============================================================
    def limpiar(self, color=BLANCO):
        v = 0xFF if color else 0x00
        self.buffer[:] = bytes([v]) * self.buffer_size

    # ===============================================================
    #                           TEXTO
    # ===============================================================
    def dibujar_texto(self, txt, x, y, color=NEGRO, tamaño=8):
        if tamaño == 8:
            for c in txt:
                self._char8(c, x, y, color)
                x += 8
        elif tamaño == 16:
            for c in txt:
                self._char16(c, x, y, color)
                x += 12

    def _char8(self, c, x, y, color):
        p = PATRONES_8x8.get(c)
        if not p:
            for i in range(8):
                self.dibujar_pixel(x, y+i, color)
                self.dibujar_pixel(x+7, y+i, color)
            for i in range(8):
                self.dibujar_pixel(x+i, y, color)
                self.dibujar_pixel(x+i, y+7, color)
            return

        for fy, fila in enumerate(p):
            for cx in range(8):
                if fila & (1 << (7 - cx)):
                    self.dibujar_pixel(x + cx, y + fy, color)

    def _char16(self, c, x, y, color):
        p = PATRONES_12x16.get(c)
        if not p:
            for i in range(12):
                self.dibujar_pixel(x+i, y, color)
                self.dibujar_pixel(x+i, y+15, color)
            for i in range(16):
                self.dibujar_pixel(x, y+i, color)
                self.dibujar_pixel(x+11, y+i, color)
            return

        for fy, fila in enumerate(p):
            for cx in range(12):
                if fila & (1 << (15 - cx)):
                    self.dibujar_pixel(x + cx, y + fy, color)

    # ===============================================================
    #                       LINEAS Y RECTANGULOS
    # ===============================================================

    #         Linea horizontal

    def dibujar_linea_horizontal(self, x, y, longitud, color=NEGRO):
        """Dibuja una línea horizontal optimizada (usa escritura por bytes)."""
        if y < 0 or y >= self.alto:
            return

        if x < 0:
            longitud += x
            x = 0
        if x + longitud > self.ancho:
            longitud = self.ancho - x
        if longitud <= 0:
            return

        # Recalculamos posiciones físicas según la orientación
        for i in range(longitud):
            self.dibujar_pixel(x + i, y, color)

    #               Linea vertical

    def dibujar_linea_vertical(self, x, y, longitud, color=NEGRO):
        """Dibuja una línea vertical optimizada."""
        if x < 0 or x >= self.ancho:
            return

        if y < 0:
            longitud += y
            y = 0
        if y + longitud > self.alto:
            longitud = self.alto - y
        if longitud <= 0:
            return

        for i in range(longitud):
            self.dibujar_pixel(x, y + i, color)

    #              Rectangulo

    def dibujar_rectangulo(self, x, y, ancho, alto, color=NEGRO, relleno=False):
        """Dibuja un rectángulo (con o sin relleno)."""
        if ancho <= 0 or alto <= 0:
            return

        if relleno:
            # Relleno por líneas horizontales (más rápido)
            for dy in range(alto):
                self.dibujar_linea_horizontal(x, y + dy, ancho, color)
        else:
            # Bordes (4 líneas)
            self.dibujar_linea_horizontal(x, y, ancho, color)
            self.dibujar_linea_horizontal(x, y + alto - 1, ancho, color)
            self.dibujar_linea_vertical(x, y, alto, color)
            self.dibujar_linea_vertical(x + ancho - 1, y, alto, color)

    # ===============================================================
    #                             ACTUALIZACIÓN
    # ===============================================================
    def actualizar(self):
        self.inicializar()

        # Power on
        self.enviar_comando(0x04)
        self._esperar_listo(3000)

        # OLD DATA (pantalla anterior)
        self.enviar_comando(0x10)
        self.pin_dc.value(1)
        self.pin_cs.value(0)
        self.spi.write(bytes([0xFF]) * len(self.buffer))  # SIEMPRE BLANCO
        self.pin_cs.value(1)

        # NEW DATA (imagen actual)
        self.enviar_comando(0x13)
        self.pin_dc.value(1)
        self.pin_cs.value(0)
        self.spi.write(self.buffer)
        self.pin_cs.value(1)

        # REFRESH
        self.enviar_comando(0x12)
        self._esperar_listo(10000)

        self.inicializado = False

    # ===============================================================
    def dormir(self):
        self.enviar_comando(0x02)
        self._esperar_listo(2000)
        self.enviar_comando(0x07)
        self.enviar_dato(0xA5)
        self.pin_vext.value(0)
        self.inicializado = False
📥 Descargar pantalla_e213_v1.py

Archivo: fuente_8x8.py

# fuente_8x8.py - Patrones de bits para fuente 8x8

# Diccionario de patrones para caracteres 8x8
PATRONES = {
    # Letras mayúsculas
    'A': [0x3C, 0x42, 0x81, 0x81, 0xFF, 0x81, 0x81, 0x00],
    'B': [0xFC, 0x42, 0x42, 0x7C, 0x42, 0x42, 0xFC, 0x00],
    'C': [0x3C, 0x42, 0x80, 0x80, 0x80, 0x42, 0x3C, 0x00],
    'D': [0xF8, 0x84, 0x82, 0x82, 0x82, 0x84, 0xF8, 0x00],
    'E': [0xFE, 0x80, 0x80, 0xF8, 0x80, 0x80, 0xFE, 0x00],
    'F': [0xFE, 0x80, 0x80, 0xF8, 0x80, 0x80, 0x80, 0x00],
    'G': [0x3C, 0x42, 0x80, 0x8E, 0x82, 0x42, 0x3C, 0x00],
    'H': [0x82, 0x82, 0x82, 0xFE, 0x82, 0x82, 0x82, 0x00],
    'I': [0xFE, 0x10, 0x10, 0x10, 0x10, 0x10, 0xFE, 0x00],
    'J': [0x02, 0x02, 0x02, 0x02, 0x82, 0x84, 0x78, 0x00],
    'K': [0x82, 0x84, 0x88, 0xF0, 0x88, 0x84, 0x82, 0x00],
    'L': [0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFE, 0x00],
    'M': [0x82, 0xC6, 0xAA, 0x92, 0x82, 0x82, 0x82, 0x00],
    'N': [0x82, 0xC2, 0xA2, 0x92, 0x8A, 0x86, 0x82, 0x00],
    'O': [0x3C, 0x42, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00],
    'P': [0xFC, 0x82, 0x82, 0xFC, 0x80, 0x80, 0x80, 0x00],
    'Q': [0x3C, 0x42, 0x81, 0x81, 0x89, 0x46, 0x3D, 0x00],
    'R': [0xFC, 0x82, 0x82, 0xFC, 0x88, 0x84, 0x82, 0x00],
    'S': [0x7C, 0x82, 0x80, 0x7C, 0x02, 0x82, 0x7C, 0x00],
    'T': [0xFE, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00],
    'U': [0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7C, 0x00],
    'V': [0x82, 0x82, 0x82, 0x44, 0x44, 0x28, 0x10, 0x00],
    'W': [0x82, 0x82, 0x92, 0x92, 0x92, 0x92, 0x6C, 0x00],
    'X': [0x82, 0x44, 0x28, 0x10, 0x28, 0x44, 0x82, 0x00],
    'Y': [0x82, 0x44, 0x28, 0x10, 0x10, 0x10, 0x10, 0x00],
    'Z': [0xFE, 0x04, 0x08, 0x10, 0x20, 0x40, 0xFE, 0x00],
    
    # Letras minúsculas
    'a': [0x00, 0x00, 0x7C, 0x02, 0x7E, 0x82, 0x7E, 0x00],
    'b': [0x80, 0x80, 0xFC, 0x82, 0x82, 0x82, 0xFC, 0x00],
    'c': [0x00, 0x00, 0x7C, 0x82, 0x80, 0x82, 0x7C, 0x00],
    'd': [0x02, 0x02, 0x7E, 0x82, 0x82, 0x82, 0x7E, 0x00],
    'e': [0x00, 0x00, 0x7C, 0x82, 0xFE, 0x80, 0x7C, 0x00],
    'f': [0x1C, 0x22, 0x20, 0x78, 0x20, 0x20, 0x20, 0x00],
    'g': [0x00, 0x00, 0x7E, 0x82, 0x82, 0x7E, 0x02, 0x7C],
    'h': [0x80, 0x80, 0xFC, 0x82, 0x82, 0x82, 0x82, 0x00],
    'i': [0x10, 0x00, 0x70, 0x10, 0x10, 0x10, 0x7C, 0x00],
    'j': [0x04, 0x00, 0x1C, 0x04, 0x04, 0x04, 0x44, 0x38],
    'k': [0x80, 0x80, 0x84, 0x88, 0xF0, 0x88, 0x84, 0x00],
    'l': [0x70, 0x10, 0x10, 0x10, 0x10, 0x10, 0x7C, 0x00],
    'm': [0x00, 0x00, 0xEC, 0x92, 0x92, 0x92, 0x92, 0x00],
    'n': [0x00, 0x00, 0xFC, 0x82, 0x82, 0x82, 0x82, 0x00],
    'o': [0x00, 0x00, 0x7C, 0x82, 0x82, 0x82, 0x7C, 0x00],
    'p': [0x00, 0x00, 0xFC, 0x82, 0x82, 0xFC, 0x80, 0x80],
    'q': [0x00, 0x00, 0x7E, 0x82, 0x82, 0x7E, 0x02, 0x02],
    'r': [0x00, 0x00, 0xBC, 0xC2, 0x80, 0x80, 0x80, 0x00],
    's': [0x00, 0x00, 0x7E, 0x80, 0x7C, 0x02, 0xFC, 0x00],
    't': [0x20, 0x20, 0x78, 0x20, 0x20, 0x22, 0x1C, 0x00],
    'u': [0x00, 0x00, 0x82, 0x82, 0x82, 0x86, 0x7A, 0x00],
    'v': [0x00, 0x00, 0x82, 0x82, 0x44, 0x28, 0x10, 0x00],
    'w': [0x00, 0x00, 0x82, 0x92, 0x92, 0x92, 0x6C, 0x00],
    'x': [0x00, 0x00, 0x82, 0x44, 0x38, 0x44, 0x82, 0x00],
    'y': [0x00, 0x00, 0x82, 0x82, 0x44, 0x28, 0x10, 0x60],
    'z': [0x00, 0x00, 0xFE, 0x04, 0x38, 0x40, 0xFE, 0x00],
    
        # Vocales con acento
    'á': [0x08, 0x10, 0x7C, 0x02, 0x7E, 0x82, 0x7E, 0x00],  # a con acento
    'é': [0x10, 0x08, 0x7C, 0x82, 0xFE, 0x80, 0x7C, 0x00],  # e con acento  
    'í': [0x10, 0x08, 0x70, 0x10, 0x10, 0x10, 0x7C, 0x00],  # i con acento
    'ó': [0x10, 0x08, 0x7C, 0x82, 0x82, 0x82, 0x7C, 0x00],  # o con acento
    'ú': [0x10, 0x08, 0x82, 0x82, 0x82, 0x86, 0x7A, 0x00],  # u con acento
    
    # Números
    '0': [0x7C, 0x82, 0x8A, 0x92, 0xA2, 0x82, 0x7C, 0x00],
    '1': [0x10, 0x30, 0x50, 0x10, 0x10, 0x10, 0x7C, 0x00],
    '2': [0x7C, 0x82, 0x02, 0x0C, 0x30, 0x40, 0xFE, 0x00],
    '3': [0xFE, 0x04, 0x08, 0x1C, 0x02, 0x82, 0x7C, 0x00],
    '4': [0x0C, 0x14, 0x24, 0x44, 0xFE, 0x04, 0x04, 0x00],
    '5': [0xFE, 0x80, 0xFC, 0x02, 0x02, 0x82, 0x7C, 0x00],
    '6': [0x3C, 0x40, 0x80, 0xFC, 0x82, 0x82, 0x7C, 0x00],
    '7': [0xFE, 0x02, 0x04, 0x08, 0x10, 0x10, 0x10, 0x00],
    '8': [0x7C, 0x82, 0x82, 0x7C, 0x82, 0x82, 0x7C, 0x00],
    '9': [0x7C, 0x82, 0x82, 0x7E, 0x02, 0x04, 0x78, 0x00],
    
    # Símbolos
    ' ': [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
    '!': [0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x10, 0x00],
    '?': [0x38, 0x44, 0x04, 0x08, 0x10, 0x00, 0x10, 0x00],
    '.': [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00],
    ',': [0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x20],
    ':': [0x00, 0x10, 0x10, 0x00, 0x10, 0x10, 0x00, 0x00],
    ';': [0x00, 0x10, 0x10, 0x00, 0x10, 0x10, 0x20, 0x00],
    '-': [0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x00],
    '_': [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00],
    '+': [0x00, 0x10, 0x10, 0x7C, 0x10, 0x10, 0x00, 0x00],
    '=': [0x00, 0x00, 0x7C, 0x00, 0x7C, 0x00, 0x00, 0x00],
    '(': [0x08, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x00],
    ')': [0x20, 0x10, 0x10, 0x10, 0x10, 0x10, 0x20, 0x00],
    '[': [0x38, 0x20, 0x20, 0x20, 0x20, 0x20, 0x38, 0x00],
    ']': [0x38, 0x08, 0x08, 0x08, 0x08, 0x08, 0x38, 0x00],
    '/': [0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00],
    '\\': [0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00],
    '@': [0x7C, 0x82, 0x9A, 0xAA, 0xAA, 0x9C, 0x80, 0x7C],
    '#': [0x28, 0x28, 0xFE, 0x28, 0xFE, 0x28, 0x28, 0x00],
    '$': [0x10, 0x7C, 0x90, 0x7C, 0x12, 0xFC, 0x10, 0x00],
    '%': [0xC2, 0xC4, 0x08, 0x10, 0x20, 0x46, 0x86, 0x00],
    '&': [0x60, 0x90, 0x90, 0x60, 0x94, 0x88, 0x74, 0x00],
    '*': [0x10, 0x54, 0x38, 0x10, 0x38, 0x54, 0x10, 0x00],
    '"': [0x28, 0x28, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00],
    "'": [0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00],
    '<': [0x08, 0x10, 0x20, 0x40, 0x20, 0x10, 0x08, 0x00],
    '>': [0x40, 0x20, 0x10, 0x08, 0x10, 0x20, 0x40, 0x00],
}
📥 Descargar fuente_8x8.py

Archivo: fuente_12x16.py

# fuente_12x16.py - Patrones de bits para fuente 12x16
# Cada carácter: 12 píxeles ancho × 16 píxeles alto (2 bytes por fila)

PATRONES_12x16 = {
    # Letras mayúsculas - 12x16
    'A': [
        0x0F00, 0x1F80, 0x39C0, 0x70E0, 0x6060, 0x6060, 
        0x6060, 0x6060, 0x7FE0, 0x7FE0, 0x6060, 0x6060,
        0x6060, 0x6060, 0x6060, 0x6060
    ],
    'B': [
        0x7F80, 0x7FC0, 0x60E0, 0x6060, 0x6060, 0x60E0,
        0x7FC0, 0x7FC0, 0x6060, 0x6060, 0x6060, 0x6060,
        0x60E0, 0x7FC0, 0x7F80, 0x0000
    ],
    'C': [
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x6000, 0x6000,
        0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6060,
        0x70E0, 0x3FC0, 0x1F80, 0x0000
    ],
    'D': [
        0x7F00, 0x7F80, 0x61C0, 0x60E0, 0x6060, 0x6060,
        0x6060, 0x6060, 0x6060, 0x6060, 0x6060, 0x60E0,
        0x61C0, 0x7F80, 0x7F00, 0x0000
    ],
    'E': [
        0x7FE0, 0x7FE0, 0x6000, 0x6000, 0x6000, 0x6000,
        0x7FC0, 0x7FC0, 0x6000, 0x6000, 0x6000, 0x6000,
        0x6000, 0x7FE0, 0x7FE0, 0x0000
    ],
    'F': [
        0x7FE0, 0x7FE0, 0x6000, 0x6000, 0x6000, 0x6000,
        0x7FC0, 0x7FC0, 0x6000, 0x6000, 0x6000, 0x6000,
        0x6000, 0x6000, 0x6000, 0x0000
    ],
    'G': [
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x6000, 0x6000,
        0x6000, 0x63E0, 0x63E0, 0x6060, 0x6060, 0x6060,
        0x70E0, 0x3FE0, 0x1FE0, 0x0000
    ],
    'H': [
        0x6060, 0x6060, 0x6060, 0x6060, 0x6060, 0x6060,
        0x7FE0, 0x7FE0, 0x6060, 0x6060, 0x6060, 0x6060,
        0x6060, 0x6060, 0x6060, 0x0000
    ],
    'I': [
        0x7FE0, 0x7FE0, 0x0600, 0x0600, 0x0600, 0x0600,
        0x0600, 0x0600, 0x0600, 0x0600, 0x0600, 0x0600,
        0x0600, 0x7FE0, 0x7FE0, 0x0000
    ],
    'J': [
        0x03E0, 0x03E0, 0x0060, 0x0060, 0x0060, 0x0060,
        0x0060, 0x0060, 0x0060, 0x6060, 0x6060, 0x6060,
        0x70E0, 0x3FC0, 0x1F80, 0x0000
    ],
    'K': [
        0x6060, 0x60E0, 0x61C0, 0x6380, 0x6700, 0x6E00,
        0x7C00, 0x7C00, 0x6E00, 0x6700, 0x6380, 0x61C0,
        0x60E0, 0x6060, 0x6060, 0x0000
    ],
    'L': [
        0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000,
        0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000,
        0x6000, 0x7FE0, 0x7FE0, 0x0000
    ],
    'M': [
        0x6060, 0x70E0, 0x79E0, 0x7FE0, 0x6F60, 0x6660,
        0x6660, 0x6060, 0x6060, 0x6060, 0x6060, 0x6060,
        0x6060, 0x6060, 0x6060, 0x0000
    ],
    'N': [
        0x6060, 0x7060, 0x7860, 0x7C60, 0x6E60, 0x6760,
        0x6360, 0x61E0, 0x60E0, 0x6070, 0x6038, 0x601C,
        0x600E, 0x6006, 0x6006, 0x0000
    ],
    'O': [
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x6060, 0x6060, 0x6060, 0x6060, 0x6060, 0x6060,
        0x70E0, 0x3FC0, 0x1F80, 0x0000
    ],
    'P': [
        0x7F80, 0x7FC0, 0x60E0, 0x6060, 0x6060, 0x6060,
        0x60E0, 0x7FC0, 0x7F80, 0x6000, 0x6000, 0x6000,
        0x6000, 0x6000, 0x6000, 0x0000
    ],
    'Q': [
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x6060, 0x6060, 0x6660, 0x6760, 0x63E0, 0x61C0,
        0x70E0, 0x3FE0, 0x1F60, 0x0000
    ],
    'R': [
        0x7F80, 0x7FC0, 0x60E0, 0x6060, 0x6060, 0x6060,
        0x60E0, 0x7FC0, 0x7F80, 0x6380, 0x61C0, 0x60E0,
        0x6060, 0x6060, 0x6060, 0x0000
    ],
    'S': [
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x6000, 0x7000,
        0x3F00, 0x1FC0, 0x00E0, 0x0060, 0x0060, 0x6060,
        0x70E0, 0x3FC0, 0x1F80, 0x0000
    ],
    'T': [
        0x7FE0, 0x7FE0, 0x0600, 0x0600, 0x0600, 0x0600,
        0x0600, 0x0600, 0x0600, 0x0600, 0x0600, 0x0600,
        0x0600, 0x0600, 0x0600, 0x0000
    ],
    'U': [
        0x6060, 0x6060, 0x6060, 0x6060, 0x6060, 0x6060,
        0x6060, 0x6060, 0x6060, 0x6060, 0x6060, 0x6060,
        0x70E0, 0x3FC0, 0x1F80, 0x0000
    ],
    'V': [
        0x6060, 0x6060, 0x6060, 0x6060, 0x6060, 0x6060,
        0x70E0, 0x70E0, 0x39C0, 0x39C0, 0x1F80, 0x1F80,
        0x0F00, 0x0F00, 0x0600, 0x0000
    ],
    'W': [
        0x6060, 0x6060, 0x6060, 0x6060, 0x6060, 0x6660,
        0x6660, 0x6660, 0x6F60, 0x7FE0, 0x79E0, 0x70E0,
        0x6060, 0x6060, 0x6060, 0x0000
    ],
    'X': [
        0x6060, 0x6060, 0x70E0, 0x39C0, 0x1F80, 0x0F00,
        0x0600, 0x0600, 0x0F00, 0x1F80, 0x39C0, 0x70E0,
        0x6060, 0x6060, 0x6060, 0x0000
    ],
    'Y': [
        0x6060, 0x6060, 0x70E0, 0x39C0, 0x1F80, 0x0F00,
        0x0600, 0x0600, 0x0600, 0x0600, 0x0600, 0x0600,
        0x0600, 0x0600, 0x0600, 0x0000
    ],
    'Z': [
        0x7FE0, 0x7FE0, 0x0060, 0x00E0, 0x01C0, 0x0380,
        0x0700, 0x0E00, 0x1C00, 0x3800, 0x7000, 0x6000,
        0x6000, 0x7FE0, 0x7FE0, 0x0000
    ],
    
        # Letras minúsculas - 12x16
    'a': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x1F80, 0x3FC0, 0x70E0, 0x0060, 0x1FE0, 0x3FE0,
        0x7060, 0x6060, 0x70E0, 0x3FE0, 0x1F60, 0x0000
    ],
    'b': [
        0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000,
        0x6F80, 0x7FC0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x6060, 0x70E0, 0x7FC0, 0x6F80, 0x0000, 0x0000
    ],
    'c': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x6000, 0x6000,
        0x6000, 0x70E0, 0x3FC0, 0x1F80, 0x0000, 0x0000
    ],
    'd': [
        0x0060, 0x0060, 0x0060, 0x0060, 0x0060, 0x0060,
        0x1F60, 0x3FE0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x6060, 0x70E0, 0x3FE0, 0x1F60, 0x0000, 0x0000
    ],
    'e': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x7FE0, 0x7FE0,
        0x6000, 0x70E0, 0x3FC0, 0x1F80, 0x0000, 0x0000
    ],
    'f': [
        0x0F80, 0x1FC0, 0x38E0, 0x3060, 0x3000, 0x3000,
        0x7F00, 0x7F00, 0x3000, 0x3000, 0x3000, 0x3000,
        0x3000, 0x3000, 0x3000, 0x3000, 0x0000, 0x0000
    ],
    'g': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x1F60, 0x3FE0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x6060, 0x70E0, 0x3FE0, 0x1F60, 0x0060, 0x70E0,
        0x3FC0, 0x1F80
    ],
    'h': [
        0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000,
        0x6F80, 0x7FC0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x6060, 0x6060, 0x6060, 0x6060, 0x0000, 0x0000
    ],
    'i': [
        0x0600, 0x0600, 0x0000, 0x0000, 0x0000, 0x0000,
        0x3E00, 0x3E00, 0x0600, 0x0600, 0x0600, 0x0600,
        0x0600, 0x0600, 0x3FE0, 0x3FE0, 0x0000, 0x0000
    ],
    'j': [
        0x00C0, 0x00C0, 0x0000, 0x0000, 0x0000, 0x0000,
        0x03C0, 0x03C0, 0x00C0, 0x00C0, 0x00C0, 0x00C0,
        0x00C0, 0x00C0, 0x00C0, 0x00C0, 0x60C0, 0x71C0,
        0x3F80, 0x1F00
    ],
    'k': [
        0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000,
        0x60E0, 0x61C0, 0x6380, 0x6700, 0x6E00, 0x7C00,
        0x7C00, 0x6E00, 0x6700, 0x6380, 0x61C0, 0x60E0
    ],
    'l': [
        0x3E00, 0x3E00, 0x0600, 0x0600, 0x0600, 0x0600,
        0x0600, 0x0600, 0x0600, 0x0600, 0x0600, 0x0600,
        0x0600, 0x0600, 0x3FE0, 0x3FE0, 0x0000, 0x0000
    ],
    'm': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x6D80, 0x7FC0, 0x6660, 0x6660, 0x6660, 0x6660,
        0x6660, 0x6660, 0x6660, 0x6660, 0x0000, 0x0000
    ],
    'n': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x6F80, 0x7FC0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x6060, 0x6060, 0x6060, 0x6060, 0x0000, 0x0000
    ],
    'o': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x6060, 0x70E0, 0x3FC0, 0x1F80, 0x0000, 0x0000
    ],
    'p': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x6F80, 0x7FC0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x6060, 0x70E0, 0x7FC0, 0x6F80, 0x6000, 0x6000,
        0x6000, 0x6000
    ],
    'q': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x1F60, 0x3FE0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x6060, 0x70E0, 0x3FE0, 0x1F60, 0x0060, 0x0060,
        0x0060, 0x0060
    ],
    'r': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x6F80, 0x7FC0, 0x70E0, 0x6060, 0x6000, 0x6000,
        0x6000, 0x6000, 0x6000, 0x6000, 0x0000, 0x0000
    ],
    's': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x1F80, 0x3FC0, 0x70E0, 0x6000, 0x7F80, 0x3FC0,
        0x00E0, 0x0060, 0x70E0, 0x3FC0, 0x1F80, 0x0000
    ],
    't': [
        0x1800, 0x1800, 0x1800, 0x1800, 0x1800, 0x1800,
        0x7F00, 0x7F00, 0x1800, 0x1800, 0x1800, 0x1800,
        0x1800, 0x1CE0, 0x0FC0, 0x0780, 0x0000, 0x0000
    ],
    'u': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x6060, 0x6060, 0x6060, 0x6060, 0x6060, 0x6060,
        0x6060, 0x70E0, 0x3FE0, 0x1F60, 0x0000, 0x0000
    ],
    'v': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x6060, 0x6060, 0x70E0, 0x39C0, 0x39C0, 0x1F80,
        0x1F80, 0x0F00, 0x0F00, 0x0600, 0x0000, 0x0000
    ],
    'w': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x6060, 0x6060, 0x6660, 0x6660, 0x6F60, 0x7FE0,
        0x79E0, 0x70E0, 0x6060, 0x6060, 0x0000, 0x0000
    ],
    'x': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x6060, 0x70E0, 0x39C0, 0x1F80, 0x0F00, 0x0600,
        0x0F00, 0x1F80, 0x39C0, 0x70E0, 0x6060, 0x0000
    ],
    'y': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x6060, 0x6060, 0x6060, 0x6060, 0x6060, 0x6060,
        0x6060, 0x70E0, 0x3FE0, 0x1F60, 0x0060, 0x70E0,
        0x3FC0, 0x1F80
    ],
    'z': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x7FE0, 0x7FE0, 0x00E0, 0x01C0, 0x0380, 0x0700,
        0x0E00, 0x1C00, 0x3800, 0x7FE0, 0x7FE0, 0x0000
    ],
    
        # Vocales con acento - 12x16
    'á': [
        0x0300, 0x0600, 0x0C00, 0x0000, 0x0000, 0x0000,
        0x1F80, 0x3FC0, 0x70E0, 0x0060, 0x1FE0, 0x3FE0,
        0x7060, 0x6060, 0x70E0, 0x3FE0, 0x1F60, 0x0000
    ],
    'é': [
        0x0300, 0x0600, 0x0C00, 0x0000, 0x0000, 0x0000,
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x7FE0, 0x7FE0,
        0x6000, 0x70E0, 0x3FC0, 0x1F80, 0x0000, 0x0000
    ],
    'í': [
        0x0300, 0x0600, 0x0C00, 0x0000, 0x0000, 0x0000,
        0x3E00, 0x3E00, 0x0600, 0x0600, 0x0600, 0x0600,
        0x0600, 0x0600, 0x3FE0, 0x3FE0, 0x0000, 0x0000
    ],
    'ó': [
        0x0300, 0x0600, 0x0C00, 0x0000, 0x0000, 0x0000,
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x6060, 0x70E0, 0x3FC0, 0x1F80, 0x0000, 0x0000
    ],
    'ú': [
        0x0300, 0x0600, 0x0C00, 0x0000, 0x0000, 0x0000,
        0x6060, 0x6060, 0x6060, 0x6060, 0x6060, 0x6060,
        0x6060, 0x70E0, 0x3FE0, 0x1F60, 0x0000, 0x0000
    ],
    
    # Números - 12x16
    '0': [
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x6060, 0x6060, 0x6060, 0x6060, 0x6060, 0x6060,
        0x70E0, 0x3FC0, 0x1F80, 0x0000
    ],
    '1': [
        0x0600, 0x0E00, 0x1E00, 0x3600, 0x2600, 0x0600,
        0x0600, 0x0600, 0x0600, 0x0600, 0x0600, 0x0600,
        0x0600, 0x0600, 0x0600, 0x0000
    ],
    '2': [
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x0060, 0x0060,
        0x00E0, 0x01C0, 0x0380, 0x0700, 0x0E00, 0x1C00,
        0x3800, 0x7FE0, 0x7FE0, 0x0000
    ],
    '3': [
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x0060, 0x0060,
        0x01C0, 0x01C0, 0x0060, 0x0060, 0x0060, 0x6060,
        0x70E0, 0x3FC0, 0x1F80, 0x0000
    ],
    '4': [
        0x00E0, 0x01E0, 0x0360, 0x0660, 0x0C60, 0x1860,
        0x3060, 0x6060, 0x7FE0, 0x7FE0, 0x0060, 0x0060,
        0x0060, 0x0060, 0x0060, 0x0000
    ],
    '5': [
        0x7FE0, 0x7FE0, 0x6000, 0x6000, 0x6000, 0x7F80,
        0x7FC0, 0x00E0, 0x0060, 0x0060, 0x0060, 0x6060,
        0x70E0, 0x3FC0, 0x1F80, 0x0000
    ],
    '6': [
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x6000, 0x6000,
        0x7F80, 0x7FC0, 0x60E0, 0x6060, 0x6060, 0x6060,
        0x70E0, 0x3FC0, 0x1F80, 0x0000
    ],
    '7': [
        0x7FE0, 0x7FE0, 0x0060, 0x00E0, 0x01C0, 0x0380,
        0x0700, 0x0600, 0x0600, 0x0600, 0x0600, 0x0600,
        0x0600, 0x0600, 0x0600, 0x0000
    ],
    '8': [
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x6060, 0x70E0,
        0x3FC0, 0x3FC0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x70E0, 0x3FC0, 0x1F80, 0x0000
    ],
    '9': [
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x6060, 0x6060,
        0x70E0, 0x3FE0, 0x1FE0, 0x0060, 0x0060, 0x6060,
        0x70E0, 0x3FC0, 0x1F80, 0x0000
    ],
    
    # Símbolos básicos - 12x16
    ' ': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x0000, 0x0000, 0x0000, 0x0000
    ],
    '!': [
        0x0600, 0x0600, 0x0600, 0x0600, 0x0600, 0x0600,
        0x0600, 0x0600, 0x0600, 0x0600, 0x0000, 0x0000,
        0x0600, 0x0600, 0x0000, 0x0000
    ],
    '?': [
        0x1F80, 0x3FC0, 0x70E0, 0x6060, 0x0060, 0x00E0,
        0x01C0, 0x0380, 0x0700, 0x0600, 0x0000, 0x0000,
        0x0600, 0x0600, 0x0000, 0x0000
    ],
    '.': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x0600, 0x0600, 0x0000, 0x0000
    ],
    ',': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x0000, 0x0000, 0x0000, 0x0000, 0x0600, 0x0600,
        0x0600, 0x0C00, 0x0000, 0x0000
    ],
    '-': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x7FE0, 0x7FE0, 0x0000, 0x0000, 0x0000, 0x0000,
        0x0000, 0x0000, 0x0000, 0x0000
    ],
    '_': [
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
        0x0000, 0x0000, 0x7FE0, 0x7FE0
    ],
}
📥 Descargar fuente_12x16.py

Implementación basica

Funcionamiento:
– Se instala MicroPython en el dispositivo y se suben los archivos pantalla_e213_v1.py, modelo/fuente_8x8.py y modelo/fuente_12x16.py ya ya queda listo para su uso.
– En el siguiente archivo basicopantalla.py muestro un programa simeple para el uso de la libreria:

Archivo: basicopantalla.py

from pantalla_e213_v1 import PantallaE213, NEGRO, BLANCO
import time


pantalla = PantallaE213(orientacion=90)
pantalla.limpiar(BLANCO)


pantalla.dibujar_texto("Vision Master E213", 20, 20, tamaño=16)
pantalla.dibujar_texto("Pantalla de tinta electrónica", 10, 50, tamaño=8)
pantalla.dibujar_texto("Hola, mundo!", 40, 80, tamaño=16)
pantalla.actualizar()
time.sleep(3)
pantalla.dormir()  # Ahorro de energía
📥 Descargar basicopantalla.py

– A continuacion el archivo pruebapantalla01.py muestra la ejecución de una una serie de funciones desarrolladas en la libreria:

Archivo: pruebapantalla01.py

from pantalla_e213_v1 import PantallaE213, NEGRO, BLANCO
import time


pantalla = PantallaE213(orientacion=90)

pantalla.limpiar(BLANCO)
pantalla.actualizar()
time.sleep(3)

pantalla.dibujar_texto("Controlador para pantalla", 10, 30, NEGRO, 8)
pantalla.dibujar_texto("E-ink Heltec Vision Master E213", 0, 50, NEGRO, 8)

pantalla.actualizar()
time.sleep(3)
  
pantalla.limpiar(BLANCO)  

pantalla.dibujar_texto("RECTANGULO Y LINEAS", 10, 40, NEGRO, 16)
pantalla.dibujar_texto("orientacion=0", 30, 70, NEGRO, 8)


pantalla.actualizar()
time.sleep(3)






pantalla = PantallaE213(orientacion=0)

print("============================================")
print("===        Controlador para Pantalla      ===")
print("===    E-ink Heltec Vision Master E213   ===")
print("=== Orientacion vertical (orientacion=0) ===")
print("===   RECTANGULO FLANQUEADO POR LINEAS   ===")
print("============================================")


pantalla.limpiar(BLANCO)
    
# Cuadrado grande negro en el centro
pantalla.dibujar_rectangulo(40, 40, 40, 140, NEGRO, relleno=True)
   
# Líneas horizontales
pantalla.dibujar_linea_horizontal(0, 20, 120)

pantalla.dibujar_linea_horizontal(0, 200, 120)

# Líneas verticales
pantalla.dibujar_linea_vertical(20, 0, 300)
    
pantalla.dibujar_linea_vertical(100, 0, 300)


pantalla.actualizar()
time.sleep(3)
  
pantalla.limpiar(BLANCO)
#pantalla.actualizar()
#time.sleep(3)

print("=== PRUEBA TERMINADA ===")



pantalla = PantallaE213(orientacion=90)

pantalla.dibujar_texto("FUENTE TAMANO 8", 10, 40, NEGRO, 16)
pantalla.dibujar_texto("orientacion=0", 30, 70, NEGRO, 8)


pantalla.actualizar()
time.sleep(3)

pantalla = PantallaE213(orientacion=0)

t = 8

print("============================================")
print("===        Controlador para Pantalla      ===")
print("===    E-ink Heltec Vision Master E213   ===")
print("=== Orientacion vertical (orientacion=0) ===")
print("===     PRUEBA FUENTE EXTERNA TAMAÑO 8   ===")
print("============================================")
    
pantalla.limpiar(BLANCO)

pantalla.dibujar_texto("ABCDEFGHIJ", 10, 10, NEGRO, t)
pantalla.dibujar_texto("KLMNOPQRST", 10, 30, NEGRO, t)
pantalla.dibujar_texto("UVWXYZ", 10, 50, NEGRO, t)
pantalla.dibujar_texto("abcdefghij", 10, 70, NEGRO, t)
pantalla.dibujar_texto("klmnopqrst", 10, 90, NEGRO, t)
pantalla.dibujar_texto("uvwxyz", 10, 120, NEGRO, t)
pantalla.dibujar_texto("0123456789", 10, 150, NEGRO, t)
    

pantalla.actualizar()
time.sleep(3)
  
pantalla.limpiar(BLANCO)
pantalla.actualizar()
time.sleep(3)

print("=== PRUEBA TERMINADA ===")
time.sleep(5)
     


pantalla = PantallaE213(orientacion=90)



pantalla.dibujar_texto("FUENTE TAMANO 16", 10, 40, NEGRO, 16)
pantalla.dibujar_texto("orientacion=90", 30, 70, NEGRO, 8)


pantalla.actualizar()
time.sleep(3)




t = 16

print("==============================================")
print("===         Controlador para Pantalla       ===")
print("===     E-ink Heltec Vision Master E213    ===")
print("===Orientacion Horizontal (orientacion=90) ===")
print("===    PRUEBA FUENTE EXTERNA TAMAÑO 16     ===")
print("==============================================")
    
pantalla.limpiar(BLANCO)


pantalla.dibujar_texto("ABCDEFGHIJKLM", 50, 10, NEGRO, t)
pantalla.dibujar_texto("NOPQRSTUVWXYZ", 50, 30, NEGRO, t)

pantalla.dibujar_texto("abcdefghijklm", 50, 50, NEGRO, t)
pantalla.dibujar_texto("nopqrstuvwxyz", 50, 70, NEGRO, t)
pantalla.dibujar_texto("0123456789", 50, 90, NEGRO, t)
    
pantalla.actualizar()
time.sleep(3)
  
#pantalla.limpiar(BLANCO)
#pantalla.actualizar()
#time.sleep(3)

print("=== PRUEBA TERMINADA ===")



pantalla.limpiar(BLANCO)  

pantalla.dibujar_texto("RECTANGULO Y LINEAS", 10, 40, NEGRO, 16)
pantalla.dibujar_texto("orientacion=90", 30, 70, NEGRO, 8)


pantalla.actualizar()
time.sleep(3)




print("===============================================")
print("===          Controlador para Pantalla       ===")
print("===      E-ink Heltec Vision Master E213    ===")
print("=== Orientacion Horizontal (orientacion=90) ===")
print("===     RECTANGULO FLANQUEADO POR LINEAS    ===")
print("===============================================")


pantalla.limpiar(BLANCO)
    
# Cuadrado grande negro en el centro
pantalla.dibujar_rectangulo(40, 40, 160, 40, NEGRO, relleno=True)
   
# Líneas horizontales
pantalla.dibujar_linea_horizontal(0, 20, 300)

pantalla.dibujar_linea_horizontal(0, 100, 300)

# Líneas verticales
pantalla.dibujar_linea_vertical(20, 0, 300)
    
pantalla.dibujar_linea_vertical(220, 0, 300)


pantalla.actualizar()
time.sleep(3)


pantalla.limpiar(BLANCO)  

pantalla.dibujar_texto("FIN", 50, 50, NEGRO, 16)



pantalla.actualizar()
time.sleep(3)
  
pantalla.limpiar(BLANCO)
pantalla.actualizar()
time.sleep(3)

print("=== PRUEBA TERMINADA ===")
📥 Descargar pruebapantalla01.py

Cerrar