Você provavelmente já ouviu falar dos monitores de diodo orgânico emissor de luz (OLED) SSD1306 ou SSD1315. Essas telas monocromáticas normalmente têm uma faixa de preço semelhante às telas de caracteres, proporcionando um apelo mais estético. Mais significativamente, eles fornecem uma interface verdadeiramente gráfica para um dispositivo embarcado.
Os monitores OLED estão disponíveis em placas breakout prontas para uso que podem ser facilmente inseridas em praticamente qualquer PCB. Em vez de simples caracteres e números, os OLEDs podem exibir gráficos complexos onde cada pixel individual na tela pode ser programado pelo usuário.
SSD1306 ou SSD1315 são os nomes dos chips de driver OLED. O repositório oficial do MicroPython não possui uma biblioteca de drivers para SSD1306. Embora existam forks da mesma biblioteca feitos por outros desenvolvedores que afirmam funcionar bem com o SSD1315, essas afirmações não foram confirmadas no momento.
Na verdade, até mesmo o driver SSD1306 disponível no repositório oficial de código apresenta bugs na implementação I2C. Para nossos propósitos, cobriremos apenas a biblioteca oficial do driver SSD1306 com uma demonstração de sua implementação SPI, que provou funcionar.
SSD1306 é um driver CMOS OLED/PLED de chip único. Ele pode gerenciar um display gráfico de matriz de pontos de 128×64. Ele foi projetado para controlar painéis OLED de cátodo comum. O chip vem com vários recursos integrados, como controle de brilho de 256 etapas, RAM de exibição, oscilador e controle de contraste. Os recursos integrados do chip SSD1306 significam que não há requisitos adicionais para um controlador ou bloco fazer interface com a tela OLED em uma placa breakout.
O chip de driver SSD1306 é usado para controlar telas OLED monocromáticas com resolução de 128×64 (0,96″), 128×32 (0,91″) ou telas OLED menores. O driver OLED usa interfaces I2C e SPI para conectar-se a um microcontrolador ou microcomputador. Algumas placas breakout usam apenas a interface I2C, enquanto outras oferecem ambas as interfaces.
A implementação I2C da biblioteca de driver OLED MicroPython SSD1306 tem erros de tempo de execução, então vale a pena adquirir um módulo de display OLED SSD1306 com uma interface SPI integrada. O módulo de display OLED SSD1306 pode exibir gráficos altamente complexos, incluindo texto, imagens bitmap e animações.
Esses monitores OLED são populares para projetar wearables e dispositivos IoT.
O display OLED SSD1306
Os displays OLED para dispositivos incorporados vêm em dois tamanhos padrão:
- 0,91″ com resolução de tela de 128×32
- 0,96″ com resolução de tela de 128×64.
Os monitores são azuis monocromáticos, brancos monocromáticos ou amarelo-azulados. O módulo de exibição OLED pode ter uma porta de 3/4 pinos, que é apenas para a interface I2C, ou uma interface de 7 pinos para SPI de 3 fios, SPI de 4 fios ou interface I2C.
O módulo SSD1306 que testaremos no tutorial é uma tela de 0,96″ com resolução de 128×64. É de cor amarelo-azul monocromática.
O módulo aqui possui uma interface de 7 pinos, que permite a interface com qualquer microcontrolador ou SBC por meio de uma interface SPI de 3 fios, SPI de 4 fios e I2C.
O display OLED de 7 pinos tem esta configuração de pinos:
EUinterface de SSD1306 com ESP8266
O módulo OLED SSD1306 pode ser conectado ao ESP8266 usando um barramento I2C ou SPI. Tanto o hardware quanto o software SPI podem ser usados.
Para fazer interface com o barramento I2C, conecte os pinos SCL e SDA no OLED SSD1306 com GPIO5 e GPIO4 do ESP8266, respectivamente. A fonte de alimentação e o aterramento do módulo OLED podem ser fornecidos através da saída de 3V e do GND do ESP8266, respectivamente.
Atualmente, a implementação I2C da biblioteca de driver OLED SSD1306 apresenta erros de tempo de execução para ETIMEOUT. Portanto, é recomendado usar SPI para interface com o módulo OLED.
Conforme mencionado, o SPI de hardware e software pode ser usado. O software SPI pode usar qualquer pino com capacidade de saída para SCK, MOSI, RST, DC e CS. Essas conexões de circuito podem ser usadas para interface do SSD1306 usando hardware e software SPI.
Interface SSD1306 com ESP32
O display OLED SSD1306 pode ser interligado ao ESP32 usando o hardware e software I2C e SPI.
Para fazer interface via I2C, conecte os pinos SCL e SDA no SSD1306 OLED com GPIO22 e GPIO21 do ESP32, respectivamente. A fonte de alimentação e o aterramento do módulo OLED podem ser fornecidos via saída de 3V e GND do ESP32, respectivamente.
Novamente, a implementação I2C da biblioteca de driver OLED SSD1306 apresenta o erro de tempo de execução, ETIMEOUT. Portanto, é recomendado usar o SPI para interface com o módulo OLED. O hardware e software SPI podem ser usados. O software SPI pode usar qualquer pino com capacidade de saída para SCK, MOSI, RST, DC e CS.
As conexões do circuito podem ser usadas para interface do SSD1306 usando hardware e software SPI.
Driver MicroPython SSD1306
A biblioteca de drivers OLED SSD1306 agora faz parte do MicroPython padrão. A biblioteca pode ser encontrado aqui.
Aqui está o código fonte desta biblioteca:
O código do driver SSD1306
O driver OLED SSD1306 começa importando a classe const do módulo MicroPython e do módulo framebuf. A classe const é usada para definir as constantes dos membros da classe. O framebuf é um módulo projetado para manipular o buffer de quadros, como as imagens bitmap.
Isto é seguido por uma declaração das constantes para os registradores SSD1306. As constantes recebem os endereços hexadecimais dos respectivos registros SSD1306.
A seguir, é definida a classe SSD1306, que toma o buffer de quadros como único parâmetro. A função construtora da classe SSD1306 considera a largura da tela em pixels, a altura da tela em pixels e o pino de alimentação externo como parâmetros. Esses argumentos são usados para determinar o número de páginas na tela, criando um objeto buffer que pode armazenar o buffer de quadros de cada página.
A classe SSD1306 inclui estes métodos…
- display_inicial : inicializa a exibição, definindo vários parâmetros, como resolução horizontal, endereço da coluna, relógio da tela, contraste e configurações de RAM.
- desligar : desliga o display.
- ligar : liga o display.
- contraste : define o contraste da tela.
- invertido : inverte a cor do texto.
- girar : gira a tela.
- mostrar : mostra a tela de exibição – como esse método é chamado, o conteúdo gravado na RAM OLED é exibido na tela OLED.
O driver usa vários métodos da classe FrameBuffer do módulo framebuf para escrever o texto ou desenhar formas na tela OLED.
Os seguintes métodos da classe FrameBuffer são úteis na manipulação de texto e formas no OLED SSD1306.
- 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 uma cor monocromática.
- FrameBuffer.pixel(x, y(, c)): obtém ou define a cor de um pixel especificado. A posição do pixel é passada como argumentos 'x' e 'y.' Se usado para definir a cor do pixel, 'c' é a cor passada como argumento.
- FrameBuffer.hline(x, y, w, c): desenha uma linha horizontal de largura 'w', começando nas posições dos pixels 'x' e 'y'. A linha horizontal é preenchida com a cor 'c.'
- FrameBuffer.vline(x, y, h, c): desenha uma linha vertical com a altura, 'h', começando nas posições dos pixels, 'x' e 'y'. A linha vertical é preenchida com a cor 'c.'
- FrameBuffer.line(x1, y1, x2, y2, c): desenha uma linha entre os pixels posicionados em (x1, y1) e (x2, y2). A linha é preenchida com a cor 'c.'
- FrameBuffer.rect(x, y, w, h, c): desenha um retângulo com largura 'w' e altura 'h', começando nas posições dos pixels 'x' e 'y'. As bordas do retângulo são preenchidas com a cor 'c.'
- FrameBuffer.fill_rect(x, y, w, h, c): desenha uma caixa retangular com largura 'w' e altura 'h', começando nas posições dos pixels, 'x' e 'y'. A caixa retangular é preenchida com a cor 'c.'
O display OLED monocromático só pode ter duas cores para cada pixel. Ele é preenchido com a cor monocromática do OLED ou com a cor invertida. Portanto, o valor do argumento c pode ser apenas '0' ou '1'.
O '0' indica a cor monocromática real e o '1' indica a cor invertida. A posição do pixel pode ser especificada como 0~128, ao longo do eixo x e 0~64 ao longo do eixo y no caso de uma resolução OLED de 128×64.
- FrameBuffer.text(s, x, y(, c)): escreve uma sequência de texto no display OLED. O texto começa a ser impresso na tela a partir das posições de pixel, 'x' e 'y'. A cor do texto pode ser definida como 'c'.
A definição de classe do SSD1306 é seguida pela definição de classe de outra classe, o SSD1306_I2C . Esta classe possui uma função construtora e dois métodos – write_cmd para escrever o comando OLED e write_data para escrever os dados de exibição.
Atualmente, a execução desta classe está gerando um erro de tempo de execução.
A classe SSD1306_SPI é definida pela implementação do barramento SPI para o SSD1306 OLED. Esta classe possui uma função construtora e dois métodos – write_cmd para escrever o comando OLED e write_data para escrever os dados de exibição.
Carregando o driver OLED com uPyCraft IDE
Para fazer upload do driver OLED para ESP8266 ou ESP32 usando uPyCraft IDE, conecte a placa a um computador usando um cabo USB. Garantir a Firmware MicroPython para ESP8266/ESP32 é carregado.
Selecione a porta COM ESP8266/ESP32 para garantir que ela esteja conectada navegando até Ferramentas-> Serial e escolha sua placa MicroPython navegando até Ferramentas-> placa. Em seguida, conecte a placa ao uPyCraft IDE clicando no botão conectar.
Assim que a placa estiver conectada, você poderá navegar pelo boot.py na pasta do dispositivo. Para adicionar o driver SSD1306 OLED, 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. Por fim, clique no botão Baixar e Executar para carregar o arquivo da biblioteca no ESP8266/ESP32.
Depois que o arquivo for carregado, ele poderá ser importado para o script principal e usado para fazer a interface do display OLED.
Carregando o driver OLED com Thonny IDE
Se você estiver usando o Thonny IDE, crie um novo arquivo navegando até Arquivo->Novo. Copie o código da biblioteca do driver OLED SSD1306 aqui e salve o arquivo como ssd1306.py. Para fazer upload do arquivo para ESP8266/ESP32, navegue até Dispositivo -> Carregar script atual com o nome atual.
Para verificar se o arquivo foi carregado com sucesso no ESP8266/ESP32, digite este comando no shell:
%lsdispositivo
Ele retornará uma lista de arquivos carregados no quadro. A lista deve incluir ssd1306.py.
Exibindo dados do sensor no SSD1306
O display OLED SSD1306 pode ser usado com ESP8266/ESP32 para exibir dados do sensor, mostrar parâmetros de rede ou exibir insights recebidos de um servidor IoT remoto.
O método text da classe FrameBuffer requer um argumento string. Os valores retornados pelos sensores, os valores dos parâmetros de rede ou insights de IoT são frequentemente inteiros ou valores de ponto flutuante. Esses valores devem primeiro ser convertidos em uma string usando a função str do cPython/MicroPython.
Este é um exemplo válido de conversão de um valor inteiro ou de ponto flutuante de um sensor em uma string.
temperatura = 25
string_temp = str(temp)
O objeto string pode ser passado diretamente como um argumento para o método text para exibir no OLED.
oled.text(temp_string, 0, 0)
oled.show
Exibindo texto no SSD1306 com ESP8266
Agora vamos exibir mensagens de texto no SSD1306 OLED. Neste tutorial, o SSD1306 é interfaceado com ESP8266.
Componentes necessários
1. ESP8266x1
2. SSD1306 OLED com interface SPI x1
3. Conectando fios/fios de jumper
Conexões de circuito
Conectamos o SSD1306 OLED ao ESP8266 usando o software SPI. Os pinos DC, RST e CS do OLED estão conectados ao GPIO4, GPIO5 e GPIO15, respectivamente. Os pinos D0 e D1 do módulo OLED estão conectados ao GPIO14 e GPIO13. Os pinos VCC e GND do módulo OLED são conectados à saída 3V e GND do ESP8266.
O script MicroPython
Como funciona
O módulo de exibição OLED faz interface com ESP8266 usando o software SPI. Os métodos da classe ssd1306 são usados para controlar o OLED, enquanto os métodos do módulo framebuf são usados para imprimir mensagens de texto no OLED.
O código
Salve o código acima como main.py e carregue o arquivo para ESP8266 clicando no botão Baixar e Executar. O código começa importando as classes Pin e SoftSPI do módulo da máquina. O módulo ssd1306 é importado, que primeiro deve ser carregado no ESP8266. A classe sleep do módulo time também é importada.
Um objeto, espié criado a partir da classe SoftSPI, que é instanciada com taxa de transmissão de 500.000 Hz, polaridade 1, fase 0, bem como o pino SCK para o pino GPIO14 e o pino MOSI para GPIO13.
O pino MISO não é usado com o módulo OLED. O GPIO12 recebe o MISO para o software SPI. Os pinos DC, RST e CS são configurados para GPIO4, GPIO5 e GPIO15, respectivamente. Essas constantes de pinos são usadas para criar um objeto da classe SSD1306_SPI oled. O objeto de classe é instanciado para uma largura de tela de 128 pixels e uma altura de 64 pixels. O texto é impresso no display SSD1306 chamando o método oled.text . É mostrado na tela quando o método oled.show é chamado.
No script MicroPython acima, duas mensagens de texto são exibidas na tela OLED em intervalos de dois segundos. O método sleep é usado para fornecer o atraso entre as duas mensagens.
Os resultados
Vídeo:
