Weact ePaper com CircuitPython

Se você está procurando uma solução de baixo consumo de energia e alta legibilidade para seus projetos IoT, os displays ePaper (ou E-Ink) são a escolha ideal. Neste tutorial, vamos explorar como conectar e programar o display WeAct Studio ePaper 2.13" (versão tricolor: Vermelho, Preto e Branco) usando um Raspberry Pi Pico e a linguagem CircuitPython.

O objetivo final é exibir um clássico "Hello World" colorido na tela. Vamos lá!

Requisitos

Antes de começar, certifique-se de ter os seguintes itens e ferramentas instalados:

• Hardware:
  • WeAct Studio ePaper 2.13" (Versão B - Tricolor).
  • Raspberry Pi Pico (ou qualquer placa compatível com CircuitPython com suporte a SPI).
• Software:
  • Python instalado no seu computador.
  • circup: Gerenciador de bibliotecas do CircuitPython.
  • mpremote: Ferramenta para interagir com o microcontrolador via linha de comando.

Pinagem (Hardware)

A comunicação entre o Pico e o display acontece via protocolo SPI. Abaixo, detalho como você deve conectar os fios do módulo WeAct aos pinos do Raspberry Pi Pico, baseando-se no código que utilizaremos.

Nota: Certifique-se de que sua placa está desconectada da energia enquanto faz as conexões.

Instalando as Bibliotecas

Com o CircuitPython já instalado no seu Pico, precisamos adicionar os drivers necessários. O driver para este display específico é o SSD1680. Além dele, precisamos da biblioteca de texto.

Conecte o Pico ao USB e execute o seguinte comando no seu terminal:

circup install adafruit_ssd1680 adafruit_display_text

Isso baixará e copiará automaticamente as dependências para a pasta lib do seu dispositivo.

O Código (main.py)

Crie um arquivo chamado main.py e cole o código abaixo. Ele configura o barramento SPI, inicializa o display e desenha o texto na tela.

import board
import busio
import displayio
import terminalio
import adafruit_ssd1680
import fourwire
from adafruit_display_text import label

displayio.release_displays()

spi = busio.SPI(clock=board.GP10, MOSI=board.GP11)
epd_cs = board.GP9
epd_dc = board.GP8
epd_reset = board.GP12
epd_busy = board.GP13

display_bus = fourwire.FourWire(
    spi, command=epd_dc, chip_select=epd_cs, reset=epd_reset, baudrate=1000000
)

display = adafruit_ssd1680.SSD1680(
    display_bus, 
    width=250, 
    height=122, 
    rotation=270, 
    busy_pin=epd_busy, 
    seconds_per_frame=1.0,
    highlight_color=0xFF0000
)

g = displayio.Group()

bg_bitmap = displayio.Bitmap(display.width, display.height, 1)
palette = displayio.Palette(1)
palette[0] = 0xFFFFFF
bg_sprite = displayio.TileGrid(bg_bitmap, pixel_shader=palette, x=0, y=0)
g.append(bg_sprite)

text_hello = label.Label(
    terminalio.FONT, text="Hello ", color=0xFF0000,scale=3, x=10, y=60
)
g.append(text_hello)

text_world = label.Label(
    terminalio.FONT, text="World", color=0x000000, scale=3, x=118, y=60
)
g.append(text_world)

display.root_group = g
display.refresh()

Entendendo o Código

Vamos quebrar o funcionamento do script para entender o que está acontecendo "nos bastidores":

• Configuração do Hardware: Primeiro, definimos os pinos SPI e de controle (CS, DC, RESET, BUSY). O objeto display_bus usa a classe FourWire para gerenciar a comunicação de dados com a tela.
• O Driver SSD1680: Aqui instanciamos a classe SSD1680. Note os parâmetros importantes:
  • width=250 e height=122: Resolução específica deste modelo de 2.13".
  • highlight_color=0xFF0000: Isso instrui o driver que a terceira cor disponível é o Vermelho. Se você tiver a versão amarela, o código hexadecimal mudaria, mas a lógica é a mesma.
• Fundo da Tela: Diferente de displays OLED ou LCD, no ePaper precisamos desenhar explicitamente o fundo. Criamos um Bitmap do tamanho da tela e definimos sua cor na Palette como branco (0xFFFFFF).
• Desenhando Texto: Usamos a biblioteca label para criar os objetos de texto.
  • Hello: Definimos a cor 0xFF0000 (Vermelho) e escala 3x.
  • World: Definimos a cor 0x000000 (Preto), também em escala 3x.
  • A posição (x, y) define onde o texto começa.
• Atualização (Refresh): O comando display.refresh() envia o buffer de imagem para o ePaper. Lembre-se: telas ePaper demoram alguns segundos para atualizar (piscam preto/branco/vermelho) para organizar as partículas de tinta eletrônica.

Rodando o Projeto

Com o hardware conectado e o código salvo, abra seu terminal e utilize o mpremote para rodar o script diretamente no Pico:

mpremote run main.py

Observe a tela do seu WeAct. Ela começará a piscar e atualizará com o texto final.

Resultado Final

Se tudo correu bem, este deve ser o resultado no seu display: