Display OLED I2C Tutorial do Arduino / NodeMCU: 15 etapas

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

O primeiro programa que você escreve quando começa a aprender um

a nova linguagem de programação é: "Hello World!".

O próprio programa não faz nada mais do que imprimir um texto “Hello World” na tela.

Então, como fazemos com que nosso Arduino exiba a mensagem "Hello World!"?

Neste vídeo, mostrarei como começar com os pequenos monitores OLED I2C de 0,91 (128x32) e 0,96 (128x64).

Existem centenas de tutoriais na web explicando a mesma coisa de maneiras diferentes, mas não consegui encontrar um que me contasse tudo sobre a tela OLED e como usá-la em diferentes cenários. Levei algum tempo para resolver tudo. Então, achei que deveria criar um tutorial sobre o que aprendi e combinar todos os recursos e maneiras como os visores OLED podem ser usados em nossos projetos.

Etapa 1: coisas que vamos aprender hoje

Neste vídeo estaremos falando sobre:

- O que é um display OLED?

- Em seguida, veremos mais de perto as telas I2C OLED de 0,91 (128x32) e 0,96 (128x64)

- A seguir, falaremos sobre a instalação da Adafruit Library em seu Arduino IDE

- Em seguida, conectaremos o NodeMCU e o Arduino a um display OLED

- A seguir, daremos uma olhada no código e exibiremos alguns gráficos e textos nele

- Também falaremos sobre a aplicação de fontes personalizadas e a exibição de imagens

- Em seguida, conectaremos vários OLEDs a um microcontrolador usando o multiplexador I2C

- Por fim, falaremos sobre alguns erros comuns que as pessoas cometem ao usar telas OLED

Etapa 2: Requisito de Hardware

Para este tutorial, precisamos:

- Uma tábua de pão

- Telas I2C OLED de 0,91 "(128x32) e 0,96" (128x64)

- Arduino UNO / NANO (o que for útil)

- NodeMCU

- Multiplexador TCA9548A I2C

- Alguns cabos de conexão

- e um cabo USB para fazer upload do código

Etapa 3: O que é um display OLED?

OLED ou diodo orgânico emissor de luz é um emissor de luz

diodo (LED) em que a camada eletroluminescente emissiva é uma película de composto orgânico (milhões de pequenas luzes LED) que emite luz em resposta a uma corrente elétrica.

Os OLEDs são usados para criar telas digitais em dispositivos como telas de televisão, monitores de computador, sistemas portáteis como telefones celulares, consoles de jogos portáteis e PDAs. Um display OLED funciona sem luz de fundo porque emite luz visível.

Passo 4:

Existem muitos tipos de visores OLED disponíveis no

mercado com base em seus

- Tamanhos

- Cor

- Marcas

- Protocolo

- SPI (Interface Periférica Serial) ou I2C

- Esquema de controle de matriz passiva (PMOLED) ou matriz ativa (AMOLED)

Neste tutorial, vou falar sobre como conectar o

cor azul 0,91 (128x32 OLED) e 0,96 (128x64 OLED) I2C OLDE exibe para um Arduino NANO e NodeMCU. A tecnologia de barramento I2C usa apenas 2 pinos do MCU, portanto, temos heaps disponíveis para outros sensores.

Etapa 5: olhar mais de perto

Vamos examinar mais de perto esses dois monitores.

Na parte de trás dessas telas, há montes de capacitores e resistores SMD soldados na placa; mas, como é um dispositivo I2C, só nos importamos com esses 2 pinos (SCL e SDA)

O display se conecta ao Arduino usando apenas quatro fios - dois para alimentação (VCC e GND) e dois para dados (relógio serial SCL e

serial data SDA), tornando a fiação muito simples. A conexão de dados é I2C (I²C, IIC ou Inter-Integrated Circuit) e esta interface também é chamada de TWI (Two Wire Interface).

- Os pinos on-board podem estar em ordem diferente, portanto, sempre verifique três vezes antes de conectá-los ao seu projeto.

- A tensão de operação está entre 3v a 5v, mas é melhor usar a orientação da ficha de dados do fabricante.

- Às vezes precisamos usar 2 monitores em nossos projetos. Então, como podemos conseguir isso?

O truque é ter um endereço configurável em sua tela. Esta unidade possui um endereço configurável entre 0x78 e 0x7A. Apenas retirando a solda do resistor 0Ohm de um lado e puxando-o para o outro ou apenas colocando uma solda global, podemos mudar o endereço. Falaremos sobre isso em detalhes quando conectarmos vários monitores a um Arduino na seção posterior deste tutorial.

Na imagem, essas telas parecem muito grandes. Mas, na prática, eles são minúsculos. Eles são feitos de 128 x 32/64 pixels individuais de OLED e não requerem luz de fundo. Basta dar uma olhada nisso e ver como é pequeno. Mesmo sendo pequenos, eles podem ser muito úteis em qualquer projeto eletrônico.

Etapa 6: Biblioteca

Existem várias bibliotecas disponíveis para controlar estes

exibe. No passado, usei a "biblioteca u8glib", mas acho a biblioteca AdaFruit muito fácil de entender e usar em nossos projetos. Portanto, usarei a biblioteca AdaFruit neste tutorial.

Para controlar o display OLED, você precisará da biblioteca "adafruit_GFX.h" e da biblioteca "adafruit_SSD1306.h".

Existem duas maneiras de baixar e instalar a biblioteca em seu Arduino IDE.

Método 1

Vá para o "Gerenciador de biblioteca" e pesquise "adafruit_SSD1306" e "adafruit_gfx"

Selecione a versão mais recente e clique no botão Instalar.

Depois de instaladas, você pode usar essas bibliotecas em seu programa.

Método 2

Essas duas bibliotecas também podem ser baixadas do github (você precisa de ambas):

Fornecerei os links na descrição abaixo.

A biblioteca de exibição:

A biblioteca GFX:

Depois de fazer o download, copie a pasta Adafruit_SSD1306-master do arquivo compactado baixado para a pasta de bibliotecas do Arduino. Essa pasta geralmente é encontrada em Documentos> Arduino> bibliotecas em sistemas Windows. No Linux, ele geralmente é encontrado na pasta inicial> Arduino> bibliotecas. Finalmente, na pasta da biblioteca do Arduino, renomeie a pasta Adafruit_SSD1306-master para Adafruit_SSD1306. Mesmo se você não renomear, tudo bem.

Etapa 7:

Agora, vamos dar uma olhada no "Adafruit_SSD1306.h"

Arquivo

Duas coisas que precisamos saber nesta biblioteca:

1. Se você quiser usar a tela menor, use o padrão 128_32, caso contrário, para o comentário maior da tela, o 128_32 e descomente o 128_64

2. Se você soldou o endereço 0x7A na placa (sobre o qual falaremos mais tarde), use o endereço 0x3D de 7 bits para as telas maiores, caso contrário, use o endereço 0x3C padrão. Para telas menores, o endereço é 0x3C.

Etapa 8: Fiação de 128 X 64/32 OLEDs

Vamos começar conectando o NodeMCU ao monitor.

A primeira e mais importante coisa a notar é que alguns dos monitores podem ter os pinos de alimentação GND e VCC trocados. Verifique o seu visor para se certificar de que é igual à imagem. Se os pinos forem trocados, certifique-se de alterar as conexões para o Arduino ou NodeMCU.

- Fiação OLED do NodeMCU

OLED VCC - NodeMCU 3.3V

OLED GND - NodeMCU GND

OLED SCL - NodeMCU D1

OLED SDA - NodeMCU D2

- Fiação OLED do Arduino Uno

OLED VCC - Arduino 5V

OLED GND - Arduino GND

OLED SCL - Arduino Uno A5

OLED SDA - Arduino Uno A4

- Fiação OLED do Arduino MEGA 2560

OLED VCC - Arduino 5V

OLED GND - Arduino GND

OLED SCL - Arduino MEGA 2560 pino 21

OLED SDA - Arduino MEGA 2560 pino 20

Etapa 9: Código

A biblioteca Adafruit vem com exemplos realmente bons para ambos

Exibições de 128x32 e 128x64.

A biblioteca está localizada em Arquivo> Exemplos> Adafruit SSD1306> e, em seguida, o tipo de exibição no IDE do Arduino.

Usaremos o exemplo I2C 128x32 e o modificaremos para funcionar com monitores 128x64 e 128x32 primeiro, conectando-o a um Arduino e, em seguida, a uma placa NodeMCU.

O código começa incluindo ambas as bibliotecas Adafruit. Neste tutorial, vou enfatizar apenas as partes do código que são necessárias para carregarmos nas placas e monitores. Se você quiser saber mais sobre o código, por favor deixe um comentário no meu blog ou na seção de comentários abaixo e eu me esforço para entrar em contato com você.

- Primeiro vamos carregar o código em um Arduino Nano conectado a um display 128x32.

Podemos usar o código como está, sem nenhuma modificação.

128x32 usa o endereço 0x3C, então este bit parece bom aqui, vamos verificar a biblioteca de cabeçalho, sim, também está usando o endereço 0x3C e o tipo de exibição é 128x32.

- Agora vamos conectar a tela de 128x64. Como sabemos, ele usa o endereço 0x3C por padrão, então não precisamos atualizar o endereço no código ou na biblioteca.

Precisamos apenas comentar 128_32 e descomentar 128_64 na biblioteca de cabeçalho e alterar LCDHEIGHT para 64 em nosso código.

- Agora, para executar o mesmo código em um NodeMCU, precisamos alterar mais uma linha em nosso código.

O resto do código "#define OLED_RESET 4"> "#define OLED_RESET LED_BUILTIN" é igual ao Arduino

Praticamente para exibir qualquer coisa, primeiro precisamos limpar a tela anterior usando

display.clearDisplay (); // Limpe o buffer

Em seguida, desenhe o objeto

testdrawline (); // Desenhe uma linha

Mostre no hardware

display.display (); // Torne-os visíveis no hardware de exibição!

Espere um pouco antes de exibir o próximo item.

atraso (2000); // Aguarde 2 segundos

Neste exemplo, estamos exibindo alguns itens como texto, linhas, círculos, texto de rolagem, triângulos e muito mais. Vá em frente, use sua imaginação e exiba o que quiser nesses minúsculos monitores.

Etapa 10: Personalização de texto e adição de imagens

Às vezes, seu código precisa exibir fontes personalizadas e

imagens. Se você é muito bom em mapeamento de bits, precisa apenas criar matrizes de bytes ligando ou desligando os minúsculos LEDs da tela para criar fontes e imagens personalizadas.

No entanto, não sou muito bom em fazer esses mapeamentos e não quero perder horas criando as tabelas de bitmap.

Então, quais são minhas opções? Eu geralmente uso dois sites para gerar fontes e imagens personalizadas. Os links são fornecidos na descrição abaixo.

Fontes personalizadas

Vá para o site do conversor de fontes, selecione a família da fonte, o estilo, o tamanho, a versão da biblioteca como "Fonte Adafruit GFX" e clique no botão "Criar". No lado direito desta página, você pode ver como sua fonte ficará no visor real.

Com base na sua seleção, a página da web gera o arquivo de cabeçalho das fontes. Crie um arquivo chamado "modify_font.h" na mesma pasta onde está seu código e copie e salve o código gerado nele. Em seguida, você só precisa incluir o arquivo de cabeçalho em seu código para usar a fonte personalizada.

#include "modify_font.h"

Em seguida, você só precisa definir a fonte antes de exibir o texto para aplicar a fonte personalizada a ele.

display.setFont (& Your_Fonts_Name);

Você pode obter o nome da fonte no arquivo de cabeçalho que acabou de adicionar ao projeto. É isso, fácil.

A memória é sempre uma preocupação ao usar fontes personalizadas, portanto, sempre considere os bytes que serão consumidos pela memória. Lembre-se de que o Arduino UNO tem apenas 32K de memória.

Imagens personalizadas

Para exibir uma imagem bitmap em sua tela, você primeiro precisa criar uma imagem de tamanho 128 x 64/32.

Estou usando o bom e velho "MS Paint" para criar uma imagem bitmap de 128 x 64 que irei enviar para este site de conversão de imagens. O site converte imagens em cadeias de bytes, que podem ser usadas com Arduino e visores OLED.

Comece enviando a imagem para o site. Em seguida, marque a caixa de seleção "Inverter cores da imagem" e altere o "Formato do código de saída" para "Código do Arduino", selecione a orientação e clique no botão "Gerar código" para gerar a matriz de bytes. A seção "Visualização" mostra como sua imagem ficará na tela real.

Incluí o código junto com este tutorial que você pode usar para exibir suas imagens. Você só precisa substituir o array em meu código pelo que acabou de gerar e carregá-lo em seu Arduino.

Etapa 11: Conectando 2 monitores

Conectar dois monitores de 128 x 64 ao seu projeto é fácil.

Você só precisa dessoldar o resistor 0Ohm do endereço 0x78 e colocá-lo em 0x7A e então usar o endereço 0x3D em seu código em vez do 0x3C padrão.

Você deve estar se perguntando por que estamos usando os endereços 0x3C e 0x3D e não os 0x78 e 0x7A reais. O Arduino aceita endereços de 7 bits e não endereços de hardware de 8 bits. Portanto, primeiro precisamos converter o endereço de 8 bits em binário e, em seguida, cortar o bit menos significativo para obter os 7 bits. Em seguida, converta os 7 bits em HEX para obter os endereços 0x3C ou 0x3D que você inseriu em seu código.

Primeiro, inicialize a exibição dando a ela um nome exclusivo:

Adafruit_SSD1306 display1 (OLED_REST);

Adafruit_SSD1306 display2 (OLED_REST);

Então, em seu código, use a tela 1 e a tela 2 para chamar as instruções begin com os endereços do dispositivo nelas:

display1.begin (SSD1306_SWITCHCAPVCC, 0x3C); // exibe 1 endereço operacional 0x3C

display2.begin (SSD1306_SWITCHCAPVCC, 0x3D); // exibe 2 endereços op 0x3D

É isso, agora você pode ir em frente e fazer o que quiser usando o Display 1 ou Display 2 no resto do seu código. Eu forneci um exemplo com este tutorial.

A fiação é exatamente a mesma que fizemos antes, basicamente você só precisa adicionar outro monitor aos mesmos pinos I2C do Arduino ou do NodeMCU. Com base nos endereços, o MCU então envia os dados na linha de dados I2C.

Etapa 12: Conectando mais de 2 monitores

Agora, e se você quiser conectar mais de 2 monitores?

O Arduino tem um número limitado de pinos e, portanto, você não pode ter mais do que uma certa quantidade de escudos anexados a ele. Além disso, possui apenas um par de barramentos I2C.

Então, como podemos conectar mais de 2 monitores I2C a um Arduino? O truque é usar um multiplexador TCA9548.

O TCA9548 permite que um único microcontrolador se comunique com até '64 sensores ', todos com o mesmo endereço I2C ou diferente, atribuindo um canal exclusivo a cada sub-barramento escravo do sensor.

Quando falamos sobre o envio de dados por 2 fios para vários dispositivos, precisamos encontrar uma maneira de abordá-los. É o mesmo que o carteiro vindo por uma única estrada e deixando os pacotes de correspondência em casas diferentes porque eles têm endereços diferentes escritos neles.

O Multiplexador se conecta às linhas 3V3, GND, SDA e SCL do microcontrolador. Os sensores escravos são conectados a uma das oito portas escravas SCL / SDA na placa. Os canais são selecionados enviando ao TCA9548A seu endereço I2C (0x70 {padrão} - 0x77) seguido pelo número do canal (0b00000001 - 0b10000000). Você poderia ter no máximo 8 desses multiplexadores conectados entre si nos endereços 0x70-0x77 para controlar 64 das mesmas partes endereçadas I2C. Ao conectar os três bits de endereço A0, A1 e A2 ao VIN, você pode obter diferentes combinações de endereços. Explicarei isso detalhadamente em meu próximo tutorial sobre a placa de breakout TCA9548A. Por enquanto, vamos conectar 8 OLEDs a esta placa e dar uma olhada rápida no código.

Conexão:

VIN a 5V (ou 3,3V)

GND para aterrar

SCL para relógio I2C

Dados SDA para I2C

Em seguida, conecte os sensores ao VIN, GND e use um dos barramentos multiplexados SCn / SDn

Agora, Int o código, vamos começar incluindo a biblioteca "Wire" e definindo o endereço dos multiplexadores.

#include "Wire.h"

#incluir

#define MUX_Address 0x70 // TCA9548A Encoders address

Em seguida, precisamos selecionar a porta com a qual queremos nos comunicar e enviar os dados usando esta função:

void tcaselect (uint8_t i) {

se (i> 7) retornar;

Wire.beginTransmission (MUX_Address);

Wire.write (1 << i);

Wire.endTransmission ();

}

Em seguida, inicializaremos a exibição na seção de configuração chamando "u8g.begin ();" para cada monitor conectado ao MUX "tcaselect (i);"

Uma vez inicializado, podemos fazer o que quisermos apenas chamando a função "tcaselect (i);" onde "i" é o valor do barramento multiplexado e, em seguida, envia os dados e o relógio de acordo.

Etapa 13: Vantagens e Desvantagens

A imagem de um OLED é linda. No entanto, os OLEDs também têm

desvantagens. Como as telas OLED contêm material orgânico, sua vida útil é menor do que as telas LCD. Além disso, muitos monitores OLED são queimados depois de mostrar a mesma imagem por um longo tempo. Após um burn-in, a imagem permanece na tela mesmo depois de mostrar outra imagem. Portanto, certifique-se de atualizar a tela a cada poucos segundos. A água pode danificar instantaneamente os materiais orgânicos desses monitores.

Vantagens

Não há necessidade de luz de fundo

Os monitores são muito finos e leves

Baixo consumo de energia

Os ângulos de visão são mais largos que os LCDs

O brilho e o contraste são ótimos

Alta velocidade e baixo tempo de resposta

Cor preta profunda

Desvantagens

Tecnologia cara

Ciclo de vida curto

OLEDS são mais propensos a queimar

Danos causados pela água

Etapa 14: Erros comuns

Para concluir o tutorial, vamos falar sobre alguns erros comuns

as pessoas fazem ao usar estes monitores:

- Sempre verifique três vezes os pinos antes de usá-los em seu projeto

- Pegue o endereço de biblioteca correto no arquivo de cabeçalho e em seu código

#define SSD1306_I2C_ADDRESS 0x3C // em Adafruit_SSD1306.h

e

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); // em seu código

Se o endereço estiver errado, o OLED não exibirá nada

- O tamanho da tela deve ser alterado no driver antes de poder ser usado. Se não for alterado, você receberá uma mensagem de erro ao tentar verificar o código

#error ("Altura incorreta, corrija Adafruit_SSD1306.h!");

- Se estiver usando NodeMCU, certifique-se de substituir o OLED_RESET de 4 para LED_BUILTIN

#define OLED_RESET LED_BUILTIN

Tenho pessoas que fazem cena fazendo todo tipo de coisa usando esse display OLED. Alguns até fizeram videogames e tudo. Não estou realmente interessado em fazer um videogame usando este minúsculo display. No entanto, agora vou deixá-lo explorar sua imaginação e apresentar ideias incríveis.

Etapa 15: Links

- Blog:

- Adicionar imagem:

- Texto personalizado:

- Biblioteca de exibição Adafruit:

- Biblioteca Adafruit GFX:

- Biblioteca u8glib: https://code.google.com/archive/p/u8glib/ ou

Se você quiser usar a exibição menor, use o padrão 128_32, caso contrário, para o comentário maior da exibição, o 128_32 e descomente o 128X64 NO_ACK em seu código (apenas descomente o tipo de tela que você está usando) (as fontes estão na biblioteca de fontes)