Diversão com display OLED e Arduino: 12 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Tenho certeza que você definitivamente já ouviu falar sobre a tecnologia de display OLED. É relativamente novo e oferece uma qualidade melhor do que a antiga tecnologia LCD. Neste tutorial, queremos revisar as etapas necessárias para exibir dados em um dos módulos de exibição OLED de cor única mais comuns disponíveis no mercado. Tentarei explicar as funcionalidades fornecidas pela biblioteca Adafruit correspondente para exibir dados neste módulo.

Etapa 1: Quais módulos OLED iremos usar?

Os módulos OLED estão disponíveis em uma ampla variedade de tamanhos e recursos. O que vamos usar neste tutorial é um módulo OLED de 128x64 monocromático. Este tipo de módulo está disponível nos seguintes tamanhos (conforme você vê nas fotos):

• 128x64
• 128x32
• 96x16
• 64x48
• 64x32

Como todos esses módulos suportam o protocolo I2C como meio de comunicação, o código e a fiação de todos eles são exatamente os mesmos. A única diferença é que você deve considerar o tamanho da tela em seu código para que o conteúdo que você vai exibir se encaixe corretamente nele.

Etapa 2: I2C em poucas palavras

O circuito inter-integrado (IIC), normalmente denominado I2C (I ao quadrado C), desenvolvido pela Philips nos anos 80 como um barramento de troca de dados usado para transferir dados entre a unidade central de processamento (CPU) ou unidade de microcontrolador (MCU) de um dispositivo e chips periféricos. Era basicamente direcionado para aplicação na TV. Devido à sua simplicidade, tornou-se tão popular que depois de algum tempo tornou-se um dos principais mecanismos de transferência de dados para CPUs e MCUs e dispositivos periféricos que não são necessariamente parte da mesma placa PCB e estão conectados a ela por meio de fios (por exemplo, sensores, módulos de exibição, etc.).

I2C consiste em um barramento de comunicação feito de dois fios que suporta transferência de dados bidirecional entre um mestre e vários dispositivos escravos. Normalmente, o nó mestre é responsável por controlar o barramento - o que na verdade é feito pela geração de um sinal de sincronização na linha de relógio serial (SCL). É um sinal que seria enviado continuamente pelo mestre durante a transferência e todos os outros nós conectados ao barramento o usarão para sincronizar sua comunicação e detectar a velocidade do barramento. Os dados são transferidos entre o mestre e o escravo por meio de uma linha de dados seriais (SDA). A velocidade de transmissão pode ser de até 3,4 Mbps. Todos os dispositivos que desejam transferir dados via I2C devem ter um endereço único e podem operar como transmissor ou receptor, dependendo da função do dispositivo. Por exemplo, um módulo de display OLED é um receptor que aceita alguns dados e os exibe, enquanto um sensor de temperatura é um transceptor que envia a temperatura capturada via barramento I2C. Normalmente, um dispositivo mestre é o dispositivo que inicia uma transferência de dados no barramento e gera os sinais de relógio para permitir a transferência. Durante essa transferência, qualquer dispositivo endereçado por este mestre é considerado um escravo e lê esses dados.

Quando um nó deseja enviar alguns dados, o primeiro byte dos dados deve ser o endereço do receptor e, em seguida, os dados reais vêm depois. Isso significa que, a fim de enviar dados para um dispositivo de saída usando I2C (por exemplo, módulo de exibição I2C OLED), devemos primeiro encontrar seu endereço I2C e isso é o que faremos primeiro nas próximas etapas.

Se você estiver interessado em saber mais sobre os detalhes e teorias sobre o barramento I2C, você pode usar as seguintes referências:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Etapa 3: Módulos e componentes necessários

Aqui você pode encontrar a lista de componentes necessários para concluir este tutorial:

Links do eBay:

• 1 x Arduino Uno:
• 1 x módulo OLED 128x64:
• 4 x cabo Dupont:
• 1 x Mini placa de ensaio sem solda:

Links da Amazon.com:

• 1 x Arduino Uno:
• 1 x módulo OLED 128x64:
• 4 x cabo Dupont:
• 1 x Mini placa de ensaio sem solda:

Etapa 4: conectando o módulo de display OLED ao Arduino

Uma observação importante sobre os dispositivos habilitados para I2C é que a maneira como você deve conectá-los ao Arduino é sempre a mesma. Isso ocorre porque o Arduino executa sua comunicação I2C apenas em pinos específicos. Neste tutorial, estou usando o Arduino Uno. O Arduino Uno usa o pino A5 como SCK e A4 como SDA. Portanto, podemos conectar o módulo de exibição OLED ao Arduino Uno, conforme mostrado na visualização esquemática. Como você pode notar na foto que tirei do meu módulo de display OLED, o conector para VCC e GND são diferentes da vista esquemática. Lembre-se de verificar os rótulos dos pinos em seus módulos para certificar-se de que você está conectando-os da maneira certa.

Precisamos de apenas 4 pinos que devem ser conectados conforme abaixo:

Arduino VCC -> Módulo OLED VCC

Arduino GND -> Módulo OLED GND

Arduino 4 -> Módulo OLED SDA

Arduino 5 -> Módulo OLED SCK

Etapa 5: Encontrar o endereço do módulo de exibição

Como uma primeira etapa na conexão a um dispositivo habilitado para I2C, você precisa ter o endereço do módulo. Para fazer isso, depois de conectar o módulo ao seu Arduino, você deve apenas fazer o upload do código anexado para o seu Arduino. Este código incorpora a biblioteca Wire, que é uma biblioteca incluída no Arduino IDE que lida com a comunicação I2C. Ele tenta escanear dispositivos I2C conectados e envia seus endereços via porta serial para o seu computador. Portanto, você pode acessar sua saída por meio da ferramenta Serial Monitor no Arduino IDE. A versão original está disponível no Arduino Playground). Além disso, você pode visualizá-lo de uma forma mais legível no meu Editor Arduino online. Não espere que nada seja exibido na tela enquanto esse código estiver em execução.

Como você pode ver na foto, meu módulo está ligado ao endereço 0x3C. Normalmente, todos os dispositivos em uma linha de produto específica (por exemplo, todos os módulos OLED de 128x64) têm o mesmo endereço.

O endereço dos dispositivos I2C é limitado de 1 a 126. Este código simplesmente tenta se conectar a cada dispositivo em ordem (sem transmitir nenhum dado) e, em seguida, verifica se houve algum erro relatado pela biblioteca subjacente ao conectar-se ao endereço fornecido. Se não houver erro, imprime o endereço como um módulo disponível para conexão. Também deve ser notado que os primeiros 15 endereços são reservados, então ele salta sobre eles e apenas imprime aqueles acima deste intervalo. Lembre-se de que o endereço desses módulos I2C são codificados no dispositivo e não podem ser alterados. Portanto, seria uma boa ideia anotar em algum lugar ou colocar uma etiqueta no módulo quando for colocá-lo de volta na prateleira do laboratório para que, da próxima vez, não seja necessário executar o código do scanner. No entanto, não é um procedimento complicado;)

Etapa 6: instalação de bibliotecas necessárias para exibir dados no módulo OLED

A biblioteca Wire pode lidar com comunicação de baixo nível com dispositivos I2C. Quando você deseja se conectar a um dispositivo específico para ler / gravar dados dele, normalmente você usaria uma biblioteca fornecida pela empresa que originalmente construiu esse módulo. Esta biblioteca lida com todos os detalhes de comunicação I2C com determinado módulo e vamos nos concentrar mais em nosso negócio que, neste caso, é exibir os dados da maneira que desejamos.

Adafruit, a empresa que fabrica a versão original de tais módulos de exibição, fornece uma biblioteca chamada Adafruit SSD1306 para exibir dados nesses monitores monocromáticos. Portanto, antes de iniciar a codificação, temos que instalar esta biblioteca por meio do Gerenciador de Biblioteca (acessível por meio do menu Sketch> Incluir Biblioteca> Gerenciar Bibliotecas …) no Arduino IDE. Há também outra biblioteca chamada Adafruit GFX Library que lida com mais material gráfico de baixo nível e é usada internamente pelo Adafruit SSD1306. Você precisa ter ambos instalados em seu IDE Arduino como você pode ver nas fotos.

Etapa 7: inicializando o módulo de exibição

O desenho no módulo de exibição está incluído em uma classe chamada Adafruit_SSD1306. A definição desta classe está na biblioteca Adafruit, portanto, primeiro precisamos incluir essa biblioteca. Então, temos que instanciar uma instância desta classe primeiro. O construtor desta classe pega o número da porta na qual o display pode ser redefinido, que é o pino 4 (conectado ao SCK). Esta parte do código deve estar localizada no início do arquivo (fora das funções setup () e loop ()).

#incluir

Visor Adafruit_SSD1306 (4);

Agora, dentro da função setup (), devemos chamar a função inicial do objeto de exibição passando nosso endereço I2C conforme abaixo (o SSD1306_SWITCHCAPVCC é um valor constante especificando o tipo de fonte de energia para a biblioteca):

void setup () {

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.display (); } void loop () {} // loop pode estar vazio por enquanto

Agora o objeto de exibição está pronto e podemos chamar suas funções (por exemplo, display.write (), display.drawLine, etc.). A observação importante é que sempre que desenhamos algo chamando nosso objeto de exibição, precisamos chamar a função display.display () para fazer o desenho real acontecer no nível do hardware. Isso se deve principalmente ao fato de que as funções de desenho que chamamos, apenas atualizam a representação "na memória" da tela por motivos de desempenho. Na verdade, ele armazena em cache as alterações na memória. Portanto, devemos sempre lembrar de chamar a função display () quando terminarmos de desenhar algo na tela.

display.write (…); // continua atualizando na memória

display.drawLine (…); // continua atualizando na memória. display.display (); // libera todas as mudanças no hardware de exibição

Se você tentar fazer upload de seu código nesta etapa, notará que o logotipo da Adafruit Industries será exibido. Você pode se perguntar quem pediu para desenhar isso! Na verdade, é isso que a biblioteca Adafruit faz. Ele inicializa a memória do módulo (a representação na memória do hardware do display) com o logotipo desta empresa. Se não quiser ver isso durante a inicialização, você pode tentar chamar a função display.clearDisplay () antes de chamar display.display () em sua função de configuração. Esta função, como o próprio nome sugere, limpa a tela completamente.

#incluir

Visor Adafruit_SSD1306 (4); void setup () {display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); display.display (); } void loop () {}

Com base na documentação da biblioteca Adafruit_SSD1306, você pode usar diferentes funções fornecidas por esta classe para desenhar na tela ou manipular diretamente os pixels nela. Nas próximas seções tentaremos apresentar um exemplo para cada um deles para que você tenha uma ideia de como funciona. A maioria desses exemplos exibirá apenas um conteúdo estático simples, portanto, podemos apenas colocá-los dentro de nossa função setup () (após o código de inicialização). Ao fazer isso, ele seria executado apenas uma vez e permaneceria lá.

Etapa 8: exibir um texto simples

Para exibir um texto, podemos usar a função display.println () simples da biblioteca. Ele aceita o texto como uma string e tenta exibi-lo. É importante saber que temos que dizer à biblioteca onde no display iremos apresentar o texto. Cada pixel na tela tem uma coordenada que é especificada com um X e Y. O X aumenta da esquerda para a direita e Y aumenta de cima para baixo. O canto superior esquerdo da tela é (X = 0, Y = 0) e o canto inferior direito é (X = 127, Y = 63). Observei as coordenadas dos cantos da primeira foto. Podemos usar a função display.setCursor () para especificar onde no display iremos exibir o texto.

Outra propriedade do texto é sua cor. Podemos especificar a cor usando display.setTextColor () conforme exibido no exemplo a seguir.

display.clearDisplay ();

display.setTextColor (WHITE); display.setCursor (35, 30); display.println ("Olá, mundo!"); display.display ();

Também podemos usar a função display.write () para exibir um único caractere. Ele aceita um código de caractere como um tipo uint8_t e exibe o caractere correspondente a esse código na string. Por exemplo, se quisermos exibir a mesma string usando esta função, podemos usar o seguinte trecho:

display.clearDisplay ();

display.setTextColor (WHITE); display.setCursor (35, 30); display.write (72); display.write (101); display.write (108); display.write (108); display.write (111); display.write (32); display.write (87); display.write (111); display.write (114); display.write (108); display.write (100); display.write (33); display.display ();

Também é possível desenhar textos em preto com fundo branco. Para fazer isso, você deve chamar a função display.setTextColor conforme abaixo:

display.clearDisplay ();

// Define a cor para preto com um fundo branco display.setTextColor (BLACK, WHITE); display.setCursor (25, 30); display.println ("Texto invertido!"); display.display ();

Você também tem a opção de definir o tamanho do texto usando a função display.setTextSize (). Ele aceita um número inteiro como tamanho. Quanto maior o número, maior será o texto. O menor tamanho é 1, que é o tamanho padrão dos textos. O código a seguir tenta escrever a letra "A" em 6 tamanhos diferentes:

display.clearDisplay ();

display.setTextColor (WHITE); display.setCursor (0, 0); display.setTextSize (1); display.print ("A"); display.setTextSize (2); display.print ("A"); display.setTextSize (3); display.print ("A"); display.setTextSize (4); display.print ("A"); display.setTextSize (5); display.print ("A"); display.setTextSize (6); display.print ("A"); display.display ();

Etapa 9: Desenhar formas básicas

Desenhar formas básicas como retângulo, círculo, triângulo, linha ou ponto é muito fácil e existe uma função específica para cada um.

Desenho de linha

Para desenhar uma linha, você pode chamar display.drawLine (startX, startY, endX, endY, color). Por exemplo, o código a seguir desenha linhas diagonais na tela para formar um grande X:

display.clearDisplay ();

display.drawLine (0, 0, display.width () - 1, display.height () - 1, BRANCO); display.drawLine (display.width () - 1, 0, 0, display.height () - 1, BRANCO); display.display ();

Você pode acessar a largura e a altura da tela usando as funções display.width () e display.height (). Ao fazer isso, seu código seria independente do tamanho da tela.

Retângulo de desenho

A função para desenhar um retângulo é display.drawRect (upperLeftX, upperLeftY, width, height, color). Aqui está o código que desenha três retângulos em alguns lugares aleatórios:

display.clearDisplay ();

display.drawRect (100, 10, 20, 20, BRANCO); display.fillRect (10, 10, 45, 15, BRANCO); display.drawRoundRect (60, 20, 35, 35, 8, BRANCO); display.display ();

Ao chamar display.fillRect (upperLeftX, upperLeftY, width, height, WHITE), você pode desenhar um retângulo preenchido pela cor especificada. Além disso, a terceira função neste exemplo é display.drawRoundRect (upperLeftX, upperLeftY, width, height, cornerRadius, color) que, como você pode ver na imagem, é usada para desenhar um retângulo com cantos arredondados. Ele aceita um parâmetro extra antes da cor que é um número inteiro que indica o raio do canto. Quanto maior o valor, mais arredondado é o canto. Ele também tem uma função de preenchimento correspondente chamada display.drawFillRoundRect que eu acho que você pode adivinhar o que ele faz.

Desenho de círculo

A função é display.drawCircle (centerX, centerY, radius, color). Aqui está um exemplo que desenha uma forma semelhante a um smiley:

display.drawCircle (60, 30, 30, BRANCO);

display.fillCircle (50, 20, 5, BRANCO); display.fillCircle (70, 20, 5, BRANCO);

Como os retângulos, você pode usar a função display.fillCircle para desenhar um círculo preenchido com a cor fornecida.

Desenhando triângulo

Ahh, novamente uma função chamada display.drawTriangle (ponto1X, ponto1Y, ponto2X, ponto2Y, ponto3X, ponto3Y, cor) e display.fillTriangle correspondente que desenha um triângulo preenchido.

display.drawTriangle (24, 1, 3, 55, 45, 55, BRANCO);

display.fillTriangle (104, 62, 125, 9, 83, 9, BRANCO);

Desenhe um ponto

Você também pode colorir um ponto específico (que é chamado de pixel) na tela por meio da função display.drawPixel (pixelX, pixelY, color).

display.drawPixel (20, 35, BRANCO);

display.drawPixel (45, 12, BRANCO); display.drawPixel (120, 59, BRANCO); display.drawPixel (97, 20, BRANCO); display.drawPixel (35, 36, BRANCO); display.drawPixel (72, 19, BRANCO); display.drawPixel (90, 7, BRANCO); display.drawPixel (11, 29, BRANCO); display.drawPixel (57, 42, BRANCO); display.drawPixel (69, 34, BRANCO); display.drawPixel (108, 12, BRANCO);

Etapa 10: Desenhar a imagem

Desenhar uma imagem é diferente e um pouco complicado. Como o módulo de exibição é monocromático, precisamos primeiro converter nossa imagem em um formato denominado bitmap monocromático (também denominado preto e branco). Nesse formato, cada pixel da imagem é apresentado com 0 ou 1. O 1s representa a existência da cor e os 0s significa um espaço vazio. Você pode ver um exemplo do logotipo do Arduino neste formato no topo desta seção. A função para desenhar uma imagem bitmap é display.drawBitmap (topLeftX, topLeftY, imageData, width, height, color). O parâmetro imageData é uma matriz de números em bytes. Cada byte possui 8 bits, portanto cada byte contém os dados de 8 pixels da imagem. Especificando a largura e a altura da imagem, a função drawBitmap saberá de qual bit a próxima linha de pixels começa.

A solução que escolhi para converter minha imagem para este formato foi primeiro usar um dos "conversores de imagem para ASCII" online (por exemplo, https://my.asciiart.club) para converter minha imagem para um conjunto de caracteres ASCII e então substituir os caracteres usados para espaços vazios por 0 e outros por 1. Isso é o que você vê abaixo. Você pode pensar em cada 0 e 1 como um pixel na tela. Portanto, o tamanho da imagem não deve exceder o tamanho da tela, que é 128x64.

Nota: Usar esta técnica ASCII não é uma abordagem recomendada porque, devido à proporção dos caracteres, sua imagem será deformada (os caracteres não são quadrados). Tentei essa técnica apenas porque torna mais fácil converter a imagem para o formato necessário. Caso contrário, seria possível obter o melhor resultado por meio de alguma programação ou usando alguns aplicativos utilitários que estão completamente fora do escopo deste texto.

00000000000000000000011111111111111111111110000000000000000000000000000000000000011111111111111111111111111111100000000000000000 0000000000000111111111111111111111111111111111111110000000000000 0000000000011111111111111111111111111111111111111111100000000000 0000000001111111111111111111111111111111111111111111111000000000 0000000111111111111111111111111111111111111111111111111110000000 0000011111111111111111111111111111111111111111111111111111100000 0000111111111111111111111111111111111111111111111111111111110000 0001111111111111111111111111111111111111111111111111111111111000 0011111111111111111111111111111111111111111111111111111111111100 0111111111111111000000011111111111111111100000001111111111111110 0111111111110000000000000001111111111000000000000000111111111110 1111111111000000001111000000001111000000001111000000001111111111 1111111110000011111111111100000110000011111111111100000111111111 1111111100000111111111111111000000001111111001111110000011111111 1111111100001111100000011111100000011111100000011111000011111111 1111111100001111100000011111100000011111100000011111000011111111 1111111100000111111111111111000000001111111001111110000011111111 1111111110000011111111111100000110000011111111111100000111111111 1111111111000000001111000000001111000000001111100000001111111111 0111111111110000000000000000111111110000000000000000111111111110 0111111111111111000000001111111111111111000000001111111111111110 0011111111111111111111111111111111111111111111111111111111111100 0001111111111111111111111111111111111111111111111111111111111000 0000111111111111111111111111111111111111111111111111111111110000 0000011111111111111111111111111111111111111111111111111111100000 0000000111111111111111111111111111111111111111111111111110000000 0000000011111111111111111111111111111111111111111111111100000000 0000000000011111111111111111111111111111111111111111100000000000 0000000000000111111111111111111111111111111111111110000000000000 0000000000000000111111111111111111111111111111110000000000000000 0000000000000000000001111111111111111111111000000000000000000000

Agora devemos dividir cada linha por 8, representando um byte e armazená-los em uma matriz como abaixo:

static const unsigned char PROGMEM arduino_logo = {

B00000000, B00000000, B00000111, B11111111, B11111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B11111111, B11111111, B11111110, B00000000, B00000000,… // continue até o final da imagem};

Então, podemos desenhá-lo na tela chamando a função drawBitmap.

display.drawBitmap (32, 16, arduino_logo, 64, 32, BRANCO);

Etapa 11: Solução de problemas

Este foi um longo tutorial e, portanto, é altamente provável que algo dê errado. Aqui está a lista de alguns erros comuns que você pode encontrar ao configurar o módulo de exibição OLED para o seu projeto (alguns deles aconteceram comigo durante a preparação deste tutorial).

Nada está sendo exibido

Isso pode acontecer por vários motivos, então sugiro verificar a seguinte lista que está em ordem que pode ocorrer em seu projeto:

O endereço I2C provavelmente está errado

Certifique-se de definir o endereço obtido no código i2c-scanner na função display.begin () ao configurar seu objeto de exibição.

SCL e SDA estão conectados de maneira errada

Isso realmente aconteceu para mim. Se você estiver usando o Arduino Uno, terá que verificar suas conexões novamente para ter certeza de que estão conectadas da mesma forma que a minha. Se você estiver usando outra edição do Arduino (por exemplo, Mega, Leonardo, etc.), você deve saber que eles podem ter seu I2C configurado para outros pinos. Você pode verificar isso na documentação da biblioteca Wire.

Você está desenhando algo fora da área visível

Este é um problema de software. É muito comum quando se usa funções de desenho para calcular mal algumas coordenadas e assim seu desenho ficaria deformado ou no pior cenário pode estar completamente fora de cena. Reveja seus cálculos e tente fazer um desenho passo a passo para ver o que está acontecendo.

O texto não está sendo exibido de forma alguma

Você se esqueceu de definir a cor do texto ou configurou-o com um valor errado

Você precisa chamar setTextColor antes de desenhar textos. Caso contrário, você não terá erros, mas não verá nada em exibição. Além disso, você pode ter definido a cor do texto igual à cor de fundo.

Você está usando uma fonte muito grande

Se você definir o tamanho do texto para um valor muito grande, pode ser possível que os caracteres fiquem completamente fora da área visível.

Há um erro de compilação sobre o tamanho da tela

Isso também aconteceu comigo e acho que aconteceria com a maioria de vocês. É por causa dos valores constantes do tamanho de exibição que são definidos dentro do arquivo de cabeçalho Adafruit_SSD1306.h que incluímos no topo do nosso script. Este arquivo está localizado em {sua pasta de projeto} libraries / Adafruit_SSD1306 / Adafruit_SSD1306.h. Se você abrir este arquivo, notará que há uma seção de comentários como a abaixo, na qual descreve que você precisa descomentar apenas a constante que representa o tamanho do módulo de exibição OLED. Para módulos de exibição 128x64, a linha #define SSD1306_128_64 deve ser descomentada.

/*=====================================================================

SSD1306 exibe ------------------------------------------------ ---------------------- O driver é usado em vários monitores (128x64, 128x32, etc.). Selecione a exibição apropriada abaixo para criar um framebuffer de tamanho apropriado, etc. SSD1306_128_64 Exibição de 128x64 pixels SSD1306_128_32 Exibição de 128x32 pixels SSD1306_96_16 --------------------------- -------------------------------------------- * / #define SSD1306_128_64 / / #define SSD1306_128_32 // #define SSD1306_96_16 / * ========================================= ================================= * /

Etapa 12: O que fazer a seguir?

O display OLED como um módulo de saída pode dar a você uma grande oportunidade de fornecer uma interface de aparência profissional para seus projetos de hobby. Você pode tentar seguir as ideias como um ponto de partida para exibir dados significativos ou ajudar o usuário a saber o que está acontecendo ou se ele precisa fazer algo. Seria muito mais claro para um usuário ler uma mensagem em um display do que interpretar o estado de um projeto / dispositivo por meio de alguns LEDs.

O que você pode fazer como ponto de partida pode ser:

• Leia um valor do sensor de temperatura e exiba-o no módulo OLED. Você pode adicionar sensor de pressão ou umidade a ele e criar um projeto de estação meteorológica totalmente funcional.
• Tente desenhar algo no módulo de exibição usando um módulo de joystick como dispositivo de entrada.
• Tente desenhar uma animação na tela por uma sequência de chamadas de função de desenho / atraso ou interrupção do Arduino
• Exibir seu logotipo personalizado na inicialização do sistema (em vez do logotipo Adafruit)

Não se esqueça de me dizer nos comentários, o que você faria (ou já fez) usando o módulo de exibição OLED.