Diodos emissores de luz orgânicos ou telas OLED tornaram-se essenciais para muitos dispositivos embarcados. Os OLEDs são considerados um dos monitores da mais alta qualidade para exibir informações do dispositivo.
Normalmente, os dispositivos embarcados usam gráficos de tela única, mas interfaces complexas são necessárias quando há diversas interações do usuário. Por exemplo, tais interfaces podem usar menus ou outra navegação gráfica. Adicionar um menu ou interface gráfica de várias páginas em displays incorporados é uma tarefa complicada. Os microcontroladores têm memória flash e RAM limitadas, portanto não podem hospedar interfaces gráficas ricas.
A única alternativa é o texto animado. O texto pode ser animado para exibir menus e submenus, mostrar várias telas de navegação e hospedar interfaces de usuário com várias telas.
Neste projeto, hospedaremos uma interface multitela em um OLED SSD1306 controlado pelo microcontrolador ESP8266. MicroPython é o firmware incorporado, então usaremos um script MicroPython na placa para hospedar o front-end do SSD1306. A interface do usuário exibirá uma coleção de telas com texto animado horizontal e vertical.
Componentes necessários
1. ESP8266x1
2. SSD1306 OLEDx1
3. Fios Dupont
4. Cabo micro USB (para conectar o ESP8266 ao computador)
Conexões de circuito
Conecte o SSD1306 OLED com ESP8266 usando software SPI.
- Os pinos DC, RST e CS do OLED se conectam com GPIO4, GPIO5 e GPIO15.
- Os pinos D0 e D1 do OLED se conectam ao GPIO14 e GPIO13.
- Os pinos VCC e GND do OLED se conectam à saída 3V e GND do ESP8266.
Preparando o ESP8266
O IDE MicroPython deve estar pronto para escrever, editar e fazer upload de códigos antes de continuar com este projeto. Você pode usar uPyCraft IDE ou Thonny IDE para desenvolvimento de software. Certifique-se de que o firmware MicroPython foi carregado corretamente no ESP8266. Aprenda como aqui.
Estendendo a biblioteca ssd1306.py para animação de texto
O firmware MicroPython contém a biblioteca para o OLED SSD1306. Para trabalhar com o SSD1306 OLED usando MicroPython, primeiro aprenda como interface SSD1306 com ESP32 e ESP8266. Você notará que o link do Github para o código-fonte do MicroPython mudou. O código-fonte no Github também exclui a biblioteca SSD1306. Felizmente, a biblioteca ainda está disponível no código-fonte no site oficial.
Esta biblioteca é suficiente para fazer a interface do OLED SSD1306 com as portas do MicroPython, especialmente através da porta SPI. A interface através da porta I2C não está mais funcionando corretamente.
A biblioteca deve ser estendida para criar animações de texto. Os métodos a seguir devem ser adicionados à classe SSD1306 da biblioteca.
def fill(self, col):
self.framebuf.fill(col)
def pixel(self, x, y, col):
self.framebuf.pixel(x, y, col)
def scroll(self, dx, dy):
self.framebuf.scroll(dx,dy)
def texto(self, string, x, y, col=1):
self.framebuf.text(string, x, y, col)
Os métodos adicionados à classe SSD1306 são chamados da mesma forma que na classe MicroPython FrameBuffer. A classe FrameBuffer fornece um buffer de pixel que representa um pixel, linha, forma ou texto.
Esses métodos FrameBuffer são usados para estender a biblioteca….
- FrameBuffer.preenchimento(c): preenche todo o buffer de quadros com uma cor especificada. O driver OLED SSD1306 usa esse método para preencher a tela OLED com cores monocromáticas.
- FrameBuffer.pixel(x, y(, c)): usado para obter ou definir a cor de um pixel especificado. A posição do pixel é passada como argumentos 'x' e 'y'. Se for usado para definir a cor do pixel, 'c' é a cor passada como argumento.
- FrameBuffer.scroll(dx,dy): usado para deslocar o conteúdo do FrameBuffer por um determinado vetor.
- FrameBuffer.text(s, x, y(, c)): usado para escrever uma string de texto no display OLED. O texto começa a ser impresso na tela a partir das posições dos pixels 'x' e 'y'. A cor do texto pode ser definida como 'c.'
A biblioteca SSD1306 estendida possui este código-fonte:
Carregando o driver OLED usando uPyCraft IDE
Para usar o uPyCraft IDE para carregar o driver OLED para ESP8266 ou ESP32, conecte a placa a um computador usando um cabo USB. O firmware MicroPython já deve estar carregado para ESP8266/ESP32.
Em seguida, selecione a porta COM. ESP8266/ESP32 é conectado navegando até Ferramentas-> Serial. Escolha sua placa MicroPython navegando até Ferramentas->placa. Agora conecte a placa ao uPyCraft IDE clicando no botão conectar.
Assim que a placa estiver conectada, navegue boot.py na pasta do dispositivo. Para adicionar o driver OLED SSD1306, crie um novo arquivo navegando até Arquivo->Novo ou clicando no botão Novo.
Copie o código da biblioteca do driver OLED SSD1306 e salve o arquivo como ssd1306.py. Em seguida, clique no botão ‘Baixar e Executar’ para fazer upload do arquivo da biblioteca para ESP8266/ESP32.
Criando telas
A interface do usuário deve ser organizada como telas separadas para adicionar submenus ou um layout de vários painéis. Isso significa que diferentes submenus ou painéis de navegação são abertos como telas separadas no display. Cada tela pode ser considerada como uma lista de linhas de pixels onde cada linha contém um texto ou forma.
O código a seguir define três telas diferentes. Cada tela é uma lista de linhas contendo texto simples.
screen1_row1 = “Tela 1, linha 1”
screen1_row2 = “Tela 1, linha 2”
screen1_row3 = “Tela 1, linha 3”
screen2_row1 = “Tela 2, linha 1”
screen2_row2 = “Tela 2, linha 2”
screen3_row1 = “Tela 3, linha 1”
tela1 = ((0, 0, tela1_linha1), (0, 16, tela1_linha2), (0, 32, tela1_linha3)) tela2 = ((0, 0, tela2_linha1), (0, 16, tela2_linha2)) tela3 = (( 0, 40, tela3_row1))
Rolando o texto horizontalmente
Para rolar o texto horizontalmente da esquerda para a direita (com o texto entrando na tela), a coordenada 'x' de cada linha de texto é incrementada em quatro pixels em um loop aninhado – até que a variável do loop exceda a largura do LED.
def scroll_h_in(tela):
para i no intervalo (0, oled_width+1, 4):
para linha na tela:
oled.text(linha(2), -oled_width+i, linha(1))
oled.show
se eu!= oled_width:
oled.fill(0)
Para rolar o texto horizontalmente da esquerda para a direita (com o texto saindo da tela), a coordenada 'x' de cada linha é incrementada pelo número de pixels definido pelo usuário – até que o texto desapareça da tela.
def scroll_h_out(velocidade):
para i no intervalo ((oled_width+1)/speed):
para j no intervalo (oled_height):
oled.pixel(i, j, 0)
oled.scroll(velocidade,0)
oled.show
Para rolar o texto horizontalmente para dentro e para fora, a coordenada 'x' de cada linha é incrementada continuamente para permitir que o texto entre e saia da tela.
def scroll_h_in_out(tela):
para i no intervalo (0, (oled_width+1)*2, 1):
para linha na tela:
oled.text(linha(2), -oled_width+i, linha(1))
oled.show
se eu!= oled_width:
oled.fill(0)
Rolando o texto verticalmente
Para rolar o texto verticalmente de cima para baixo (com o texto entrando na tela), a coordenada 'y' de cada linha é incrementada em quatro pixels em um loop aninhado – até que a variável do loop exceda a altura do LED.
def scroll_v_in(tela):
para i no intervalo (0, (oled_height+1), 1):
para linha na tela:
oled.text(linha(2), linha(0), -oled_height+i+linha(1))
oled.show
se eu! = oled_height:
oled.fill(0)
Para rolar o texto verticalmente de cima para baixo (com o texto saindo da tela), a coordenada 'y' de cada linha é incrementada pelo número de pixels definido pelo usuário – até que o texto desapareça da tela.
def scroll_v_out(velocidade):
para i no intervalo ((oled_height+1)/speed):
para j no intervalo (oled_width):
oled.pixel(j, i, 0)
oled.scroll(0,velocidade)
oled.show
Para rolar o texto verticalmente para dentro e para fora, a coordenada 'y' de cada linha é continuamente incrementada para permitir que o texto entre e saia da tela.
def scroll_v_in_out(tela):
para i no intervalo (0, (oled_height*2+1), 1):
para linha na tela:
oled.text(linha(2), linha(0), -oled_height+i+linha(1))
oled.show
se eu! = oled_height:
oled.fill(0)
O script MicroPython
Experimente o seguinte código em main.py. Este script cria três telas diferentes compostas por texto simples e testa a rolagem horizontal e vertical de cada uma.
Como funciona
O script usa as funções adicionadas à biblioteca SSD1306.py. Ele cria telas com texto simples e altera as posições 'x' e 'y' de cada linha para mover horizontal e verticalmente sobre o quadro da tela.
Formulários
O código demonstrado aqui pode ser reutilizado para hospedar uma interface de usuário com vários menus em um dispositivo incorporado com tecnologia MicroPython ou uma interface gráfica com vários painéis.
Resultados
