Revolucionando visuais compactos: módulo de exibição OLED de 0,91 polegadas 128×32 com interface I2C – uma visão geral

Este artigo se aprofunda no mundo dos compactos Módulos de exibição OLED, com foco específico no 0,91 polegada 128×32 Tela OLED que utiliza o Interface I2C. Exploraremos a parte técnica visão geral disto monocromático mostrar, suas características e como ele pode ser integrado em vários projetos, especialmente com Arduino Uno. Vale a pena ler este artigo porque fornece uma compreensão abrangente de um tipo muito específico e popular de mostrar tecnologia. Seja você um amador, um engenheiro ou simplesmente alguém curioso sobre eletrônica, este artigo irá equipá-lo com o conhecimento para utilizar efetivamente esses pequenos, mas poderosos exibe no seu próximo projeto. Você encontrará OLED branco para ser muito útil. Também discutiremos os fundamentos de OLED de 0,91 polegadas e é fácil de usar Interface I2C. Você pode encontrar semelhantes módulo sobre Compartilhamento de ondas site, mas usaremos o nosso próprio Módulo OLED e fornecer a você um serviço dedicado tutorial e apoiar.

1. Introdução aos módulos de exibição OLED de 0,91 polegadas 128×32

Tela OLED a tecnologia revolucionou a maneira como interagimos com dispositivos eletrônicos, oferecendo cores vibrantes, alto contraste, e amplos ângulos de visão. Dentro do reino de Telas OLED, o 0.91 polegada 128×32 Módulo de exibição OLED destaca-se como uma solução compacta, mas poderosa, para projetos que exigem um pequeno, mas altamente legível mostrar. Esses as exibições são pequenas, frequentemente usado em dispositivos portáteis, wearables e vários sistemas embarcados onde o espaço é um prêmio. O 0,91 polegada tamanho refere-se a diagonal medição do mostrar área, enquanto a 128×32 resolução indica que o mostrar é composto por 128 horizontais píxeis e 32 verticais píxeis.

Apesar de seu pequeno tamanho, esses Módulos OLED fornecer visuais nítidos e claros, graças às vantagens inerentes de OLED tecnologia, como a capacidade de desligar dispositivos individuais píxeis completamente, resultando em pretos verdadeiros e alto contraste proporções. Isto 0.91 128×32 monocromático Módulo OLED é controlado por um controlador incorporado, normalmente o SSD1306 driver IC, que simplifica o processo de interfaceamento do mostrar com microcontroladores. O SSD1306 é um Driver OLED que tem um embutido chip controlador. Tela OLED é uma escolha popular entre amadores e profissionais.

2. Descrição detalhada do módulo OLED: principais recursos e especificações

O 0,91 polegada 128×32 Módulo de exibição OLED é um monocromático exibição gráfica que reúne uma série de recursos em seu formato compacto. Especificação pode variar entre os fabricantes. Uma das principais características deste módulo é seu OLED tecnologia, que permite a cada pixel para emitir sua própria luz. Isso elimina a necessidade de um luz de fundo, resultando em um mais fino mostrar com superior contraste e menor consumo de energia em comparação com os tradicionais LCD módulos. Os mostrar é compatível com muitos dispositivos.

Aqui está uma tabela resumindo o típico especificações de 0,91 polegada 128×32 Módulo de exibição OLED:

O Módulo OLED normalmente opera em um tensão entre 3,3 V e 5V, fazendo isso compatível com uma ampla gama de microcontroladores, incluindo Arduino placas. Os requisitos de energia dependem de como grande parte da exibição está aceso. O interface é mais comumente I2C, o que simplifica a fiação e reduz o número de entrada pinos necessários. Alguns módulos também oferecem um SPI interface opção. Verificar detalhe a respeito de interface na sua página de produto. O SSD1306 controlador lida com o nível baixo detalhes de dirigir o OLED painel, incluindo pixel endereçamento, taxas de atualização e gerenciamento de energia.

3. Compreendendo a interface I2C: como ela funciona com o display OLED?

O I2C (Circuito Inter-Integrado) interface é um protocolo de comunicação serial que permite que vários dispositivos se comuniquem entre si usando apenas dois fios: SDA (Serial Data) e SCL (Serial Clock). É uma escolha popular para conectar periféricos como exibe, sensores e chips de memória para microcontroladores devido à sua simplicidade e eficiência. O Interface I2C é particularmente adequado para 0,91 polegada 128×32 Módulo de exibição OLED porque minimiza o número de conexões necessárias, o que é crucial em aplicações com restrições de espaço.

Em um I2C configurar com o Módulo OLED, o microcontrolador (por exemplo, um Arduino) normalmente atua como mestre dispositivo, enquanto o Tela OLED age como um escravo dispositivo. O mestre inicia a comunicação e controla o sinal do relógio, enquanto o escravo responde aos comandos do mestre. Cada dispositivo no I2C o barramento tem um endereço exclusivo de 7 ou 10 bits e o Módulo de exibição OLED não é exceção. O SSD1306 controlador usado nestes exibe tem um específico I2C endereço que permite ao microcontrolador selecionar para comunicação. O OLED de 0,91 polegadas é comunicando via interface I2C. A vantagem de usar o Interface I2C com o Tela OLED é que simplifica a fiação, pois você só precisa conectar duas linhas de dados (SDA e SCL), além de energia e aterramento. Isso é especialmente benéfico ao trabalhar com microcontroladores que têm entrada/saída pinos. Além disso, I2C permite que vários dispositivos compartilhem o mesmo barramento, desde que cada dispositivo tem um endereço exclusivo, facilitando a expansão do seu projeto com sensores ou periféricos adicionais.

4. Visão geral do hardware: examinando os componentes físicos do módulo OLED

O ferragens de um típico 0,91 polegada 128×32 Módulo de exibição OLED consiste em vários componentes principais integrados em uma pequena placa de circuito impresso (PCB). O componente mais proeminente é o OLED painel em si, que é uma superfície fina e plana mostrar que contém o 128×32 matriz de píxeis. O OLED O painel é normalmente coberto por uma camada protetora de vidro ou plástico. Você deve verificar o contorno do seu módulo.

O controlador chip, geralmente o SSD1306, é montado na parte traseira do PCB. Este chip é responsável por receber comandos e dados do microcontrolador via I2C e dirigindo o indivíduo píxeis no OLED painel. O SSD1306 tem embutido gráfico mostrar dados BATER (GDDRAM) que armazena o imagem dados a serem exibidos. O tamanho disto BATER determina o resolução do mostrar que o controlador pode suportar. Para um 128×32 mostrar, o controlador precisa de pelo menos 512 bytes de RAM desde cada pixel é representado por um bit (ligado ou desligado) em um monocromático mostrar, e 128 * 32 bits é igual a 512 bytes de dados. As exibições são pequenas e muito útil em muitos projetos. O PCB também inclui outros componentes necessários, como resistores, capacitores e reguladores de tensão. Esses componentes garantem que o OLED painel e controlador receba a energia correta fornecer e condições de operação. O módulo normalmente tem uma linha de cabeçalho alfinete conexões ao longo de uma borda do PCB, permitindo que você facilmente conectar para uma placa de ensaio ou microcontrolador usando fios de ligação. O específico alfinete a configuração pode variar ligeiramente entre os diferentes fabricantes, mas geralmente inclui pinos para alimentação (fornecer), solo e o I2C linhas de comunicação (SDA e SCL).

5. Interface com Arduino: Um guia passo a passo para conectar e usar o display OLED com Arduino Uno

Interfaceando o 0.91 polegada 128×32 Módulo de exibição OLED com um Arduino Uno é um processo simples, graças à Interface I2C e a disponibilidade de bibliotecas que simplificam o código necessário. Aqui está um guia passo a passo para você começar:

1. Conecte o Hardware:Primeiro, você precisará fisicamente conectar o Módulo OLED para o seu Arduino Uno. Conectar o VCC alfinete no Módulo OLED para o 5V alfinete no Arduino, e o GND alfinete para um dos pinos GND no Arduino. Próximo, conectar o SDA alfinete no Módulo OLED para o A4 alfinete (SDA) sobre o Arduino, e o SCL alfinete para a A5 alfinete (SCL) sobre o Arduino.
2. Instalar a biblioteca: Para simplificar o processo de controle do Tela OLED, você precisará instalar um biblioteca no Arduino IDE. Duas escolhas populares são o Adafruit SSD1306 biblioteca e o U8g2 biblioteca. Você pode instalar estes bibliotecas através do Arduino Biblioteca Gerenciador indo em Esboço > Incluir Biblioteca > Gerenciar Bibliotecas, procurando por “SSD1306” ou “U8g2” e clicando em “Instalar”.
3. Carregar o código:Uma vez que o biblioteca está instalado, você pode fazer upload de um amostra esboce para o seu Arduino para testar o mostrar. A Adafruta SSD1306 biblioteca vem com esboços de exemplo que demonstram como inicializar o mostrar, desenhe formas básicas e exiba texto. Você pode encontrar esses exemplos no Arduino IDE em Arquivo > Exemplos > Adafruit SSD1306. Selecione o exemplo para 128×32 I2C exibe.
4. Modificar o código:Após verificar que o mostrar está funcionando corretamente, você pode modificar o exemplo código ou escreva seus próprios esboços para criar gráficos personalizados e exibir informações no OLED. O biblioteca fornece funções para desenho pixels, linhas, retângulos, círculos e texto.

Lembre-se de consultar a documentação específica biblioteca você está usando para entender todas as funções disponíveis e seu uso. Com essas etapas simples, você pode obter rapidamente seu 0,91 polegada 128×32 Tela OLED instalado e funcionando com um Arduino Uno.

6. SPI vs. I2C para displays OLED: qual interface é a certa para seu projeto?

Ao trabalhar com Módulos de exibição OLED, você frequentemente encontrará duas interfaces de comunicação serial comuns: SPI (Periférico serial Interface) e I2C (Circuito Inter-Integrado). Ambas as interfaces têm suas vantagens e desvantagens, e a escolha entre elas depende dos requisitos específicos do seu projeto.

Interface I2C:

• Simplicidade: I2C utiliza apenas dois fios para comunicação (SDA e SCL), o que simplifica a fiação e reduz o número de entrada pinos necessários no microcontrolador.
• Endereçamento: Cada dispositivo no I2C O barramento tem um endereço único, permitindo que o microcontrolador se comunique com vários dispositivos usando os mesmos dois fios.
• Velocidade: I2C é geralmente mais lento que SPI, com velocidades padrão de 100 kHz, 400 kHz e, às vezes, até 1 MHz ou mais.
• Consumo de energia:Devido à sua menor velocidade e protocolo mais simples, I2C normalmente consome menos energia do que SPI, tornando-o uma boa escolha para dispositivos alimentados por bateria.

Interface SPI:

• Velocidade: SPI é geralmente mais rápido que I2C, com velocidades que muitas vezes atingem vários megahertz ou mesmo dezenas de megahertz. Isso faz SPI adequado para aplicações que exigem altas taxas de atualização ou grandes quantidades de transferência de dados.
• Complexidade: SPI normalmente requer mais fios para comunicação (MOSI, MISO, SCK e CS), o que pode complicar a fiação, especialmente quando vários dispositivos estão envolvidos.
• Endereçamento: SPI usa um chip selecionar (CS) linha para cada dispositivo, o que significa que o microcontrolador precisa de um entrada alfinete para cada um dispositivo com quem ele quer se comunicar.
• Consumo de energia:Devido à sua maior velocidade e protocolo mais complexo, SPI normalmente consome mais energia do que I2C.

Para o 0.91 polegada 128×32 Módulo de exibição OLED, o Interface I2C é frequentemente a escolha preferida devido à sua simplicidade e menor contagem de pinos. No entanto, se o seu projeto requer uma conexão muito rápida mostrar atualizações ou se você já estiver usando SPI para outros componentes, então usando um SPI versão do Módulo OLED pode ser mais adequado.

7. Display Library: Explorando o Lado do Software – Bibliotecas e Exemplos de Código

Para controlar o 0,91 polegada 128×32 Módulo de exibição OLED de um microcontrolador como o Arduino Uno, você precisará usar um software biblioteca que fornece um conjunto de funções para enviar comandos e dados para o mostrar. Diversos bibliotecas estão disponíveis para trabalhar com SSD1306-baseado Telas OLED, sendo dois dos mais populares o Adafruit SSD1306 biblioteca e o U8g2 biblioteca.

A Adafruta SSD1306 biblioteca é projetado especificamente para monocromático Telas OLED que usam o SSD1306 controlador, incluindo o 0,91 polegada 128×32 módulo. Ele fornece uma API simples e fácil de usar para inicializar o mostrar, desenho formas básicas e exibindo texto. O biblioteca é construído em cima do Adafruit GFX biblioteca, que fornece um conjunto comum de funções gráficas que funcionam em diferentes tipos de exibe.

Aqui está um código exemplo que demonstra como inicializar o mostrar e exibir alguns texto usando o Adafruit Biblioteca SSD1306:

    #incluir <SPI.h>
    #incluir <Wire.h>
    #incluir <Adafruit_GFX.h>
    #incluir <Adafruit_SSD1306.h>

    #definir LARGURA_DA_TELA 128 // Largura da tela OLED, em pixels
    #definir ALTURA_DA_TELA 32 // Altura da tela OLED, em pixels

    // Declaração para uma interface I2C
    #definir OLED_REINICIAR 4 // Redefinir pino # (ou -1 se estiver compartilhando pino de redefinição do Arduino)
    #definir ENDEREÇO_DE_TELA 0x3C ///< Veja a folha de dados para Endereço; 0x3D para 128x64, 0x3C para 128x32
    Adafruit_SSD1306 mostrar(LARGURA_DA_TELA, ALTURA_DA_TELA, &Arame, OLED_RESET);

    vazio configurar() {
      Serial.começar(9600);

      // SSD1306_SWITCHCAPVCC = gerar tensão de exibição de 3,3 V internamente
      se(!mostrar.começar(SSD1306_SWITCHCAPVCC, ENDEREÇO_DE_TELA)) {
        Serial.imprimir(F("Falha na alocação SSD1306"));
        para(;;); // Não prossiga, faça um loop para sempre
      }

      // Mostrar o conteúdo inicial do buffer de exibição na tela --
      // a biblioteca inicializa isso com uma tela inicial do Adafruit.
      mostrar.mostrar();
      atraso(2000); // Pausa por 2 segundos

      // Limpar o buffer
      mostrar.clearDisplay();

      // Desenha um único pixel em branco
      mostrar.desenharPixel(10, 10, SSD1306_BRANCO);

      // Mostra o buffer de exibição na tela. Você DEVE chamar display() depois
      // comandos de desenho para torná-los visíveis na tela!
      mostrar.mostrar();
      atraso(2000);
      // display.display() NÃO é necessário após cada comando de desenho,
      // a menos que seja isso que você queira... em vez disso, você pode agrupar um monte de
      // operações de desenho e então atualizar a tela de uma vez chamando
      // display.display(). Esses exemplos demonstram ambas as abordagens...

      testedesenharlinha();      // Desenhe muitas linhas

      testedesenharrect();      // Desenhar retângulos (contornos)

      testefillrect();      // Desenhar retângulos (preenchidos)

      testedesenharcirculo();    // Desenhar círculos (contornos)

      testefillcircle();    // Desenhar círculos (preenchidos)

      testedesenharredondoret(); // Desenhar retângulos arredondados (contornos)

      testepreencherredondoretângulo(); // Desenhar retângulos arredondados (preenchidos)

      testedesenhartriângulo();  // Desenhar triângulos (contornos)

      testefilltriangle();  // Desenhar triângulos (preenchidos)

      testedrawchar();      // Desenhar caracteres da fonte padrão

      estilosdeteste();    // Desenhar personagens 'estilizados'

      testescrolltext();    // Desenhar texto de rolagem

      testedesenharbitmap();    // Desenha uma pequena imagem bitmap

      // Inverte e restaura a exibição, pausando no meio
      mostrar.invertDisplay(verdadeiro);
      atraso(1000);
      mostrar.invertDisplay(falso);
      atraso(1000); testanimate(logo_bmp, LARGURA_DO_LOGO, ALTURA_DO_LOGO); // Animar bitmaps
    }

O U8g2 biblioteca é mais abrangente biblioteca que suporta uma ampla gama de monocromático exibe, incluindo OLEDs, LCDs e e-paper exibe. Ele oferece recursos mais avançados do que o Adafruit Biblioteca SSD1306, como suporte para várias fontes, caracteres Unicode e vários desenho operações.

Ambos bibliotecas são bem documentados e vêm com esboços de exemplo que demonstram como usar as várias funções. Você pode encontrar esses exemplos no Arduino IDE em Arquivo > Exemplos após instalar o bibliotecas. Você pode download ambos bibliotecas da internet.

8. Desenho e exibição de imagens: técnicas para criar gráficos no OLED 128×32

Criação de gráficos e exibição de imagens no 0.91 polegada 128×32 Tela OLED envolve o uso das funções fornecidas pelo mostrar biblioteca para manipular o indivíduo píxeis ou desenhar formas predefinidas. As técnicas específicas que você usará dependerão da complexidade dos gráficos que deseja criar e dos recursos do biblioteca que você está usando.

Desenho Básico:

O mais fundamental desenho a operação é definir a cor do indivíduo píxeis. Você pode usar o drawPixel(x, y, cor) função para transformar um específico pixel ligado ou desligado (no caso de um monocromático mostrar). Ao combinar múltiplos desenharPixel chamadas, você pode criar formas e padrões simples.

O mostrar bibliotecas também fornecem funções para desenho formas básicas como linhas, retângulos e círculos. Por exemplo, o Adafruit GFX biblioteca oferece funções como desenharLinha(), desenharRect(), preencherRect(), desenharCírculo(), e preencherCírculo(). Essas funções usam parâmetros como as coordenadas inicial e final, a largura e a altura (para retângulos), o raio (para círculos) e a cor.

Exibição de texto:

Exibindo texto no OLED é um requisito comum para muitos projetos. O mostrar bibliotecas normalmente fornecem funções para definir a fonte, tamanho, e a cor do texto, bem como posicionar o cursor e imprimir strings para o mostrar.

O Adafruit GFX biblioteca, por exemplo, inclui uma fonte padrão e permite que você selecionar diferentes tamanhos de fonte usando definirTamanhoDoTexto(). Você pode definir a posição do cursor com definirCursor(x, y) e imprimir texto usando imprimir() ou imprimir(). O U8g2 biblioteca oferece mais avançado texto recursos de manuseio, incluindo suporte para diversas fontes e caracteres Unicode.

Exibição de imagem:

Exibindo mapa de bits imagens no OLED requer a conversão do imagem dados em um formato que o mostrar controlador pode entender. Isso normalmente envolve a criação de uma matriz de bytes onde cada bit representa um pixel no mostrar. Para o 128×32 OLED, você precisaria de uma matriz de 512 bytes (128 * 32 / 8 = 512).

Você pode usar ferramentas de software especializadas para converter imagem arquivo para o apropriado mapa de bits formato. Depois de ter o mapa de bits dados, você pode usar uma função como desenharBitmap() (fornecido por alguns bibliotecas) para exibir o imagem no OLED. Você precisará especificar as coordenadas iniciais, a largura e a altura do imagem, e o mapa de bits variedade.

Aqui está um exemplo de como você pode definir um simples mapa de bits para um formato de coração e exibi-lo usando o Adafruit Biblioteca SSD1306:

    const estático unsigned char PROGMEM heart_bmp[] = { 0b00000000, 0b00000000,
      0b00000110, 0b01100000,
      0b00001111, 0b11110000,
      0b00011111, 0b11111000,
      0b00111111, 0b11111100,
      0b00111111, 0b11111100,
      0b01111111, 0b11111110,
      0b01111111, 0b11111110,
      0b00111111, 0b11111100,
      0b00011111, 0b11111000,
      0b00001111, 0b11110000,
      0b00000111, 0b11100000,
      0b00000011, 0b11000000,
      0b00000001, 0b10000000,
      0b00000000, 0b00000000
    }; // No seu loop principal ou uma função:
    mostrar.desenharBitmap(50, 0, coração_bmp, 16, 16, 1);
    mostrar.mostrar();

Tenha em mente que o 0,91 polegada 128×32 OLED tem memória limitada e uma capacidade relativamente baixa resolução. Imagens complexas podem precisar ser simplificadas ou reduzidas para se adequarem a essas restrições.

9. Considerações sobre a fonte de alimentação para seu módulo de display OLED

Ao trabalhar com o 0,91 polegada 128×32 Módulo de exibição OLED, é importante considerar o poder fornecer requisitos para garantir o funcionamento adequado e evitar danos ao mostrar. Telas OLED são geralmente mais eficientes em termos de energia do que os tradicionais LCD porque eles não requerem um luz de fundo. No entanto, o consumo de energia ainda pode variar dependendo de fatores como a brilho configuração, o número de píxeis que são iluminados, e o específico OLED tecnologia utilizada.

O 0,91 polegada 128×32 Módulo OLED normalmente opera com uma voltagem entre 3,3 V e 5 V. A maioria dos módulos são projetados para serem compatível com níveis lógicos de 3,3 V e 5 V, tornando-os versáteis para uso com diferentes microcontroladores. É crucial verificar o especificação folha para o seu específico módulo para determinar a tensão operacional recomendada. Os requisitos reais de energia dependem de como grande parte da tela está iluminada a qualquer momento. Quando todos os píxeis estão desligados, o mostrar consome muito pouca energia. Quando todos os píxeis estão ligados, o o display usa cerca de 20mA sobre média que a exibição usa cerca de 20-25 mA de corrente em carga máxima brilho. No entanto, se apenas uma pequena parte do mostrar estiver aceso, o consumo de corrente será significativamente menor.

Para alimentar o Módulo OLED, normalmente você pode conectar o pino VCC ao 3,3 V ou 5 V fornecer pino no seu microcontrolador. Se você estiver usando um Arduino Uno, por exemplo, você pode conectar o VCC alfinete para o 5V alfinete no Arduino. Alguns Módulos OLED possuem reguladores de voltagem integrados que permitem aceitar uma gama mais ampla de entrada tensões.

É importante notar que, embora Telas OLED são relativamente eficientes em termos de energia, mas ainda podem consumir uma quantidade significativa de corrente ao exibir imagens brilhantes ou quando uma grande parte do tela está aceso. Se você estiver projetando um dispositivo alimentado por bateria, precisará levar isso em consideração ao calcular seu orçamento de energia e escolher uma bateria.

Para otimizar o consumo de energia, você pode ajustar o brilho do mostrar usando comandos fornecidos pelo mostrar biblioteca. Muitos bibliotecas permite que você defina o contraste ou brilho nível, o que afeta o consumo geral de corrente. Reduzindo o brilho pode reduzir significativamente o consumo de energia, especialmente ao exibir conteúdo predominantemente escuro.

10. Detalhes técnicos e onde baixar recursos: planilhas de dados, exemplos de código e muito mais

Para usar efetivamente o 0,91 polegada 128×32 Módulo de exibição OLED em seus projetos, é essencial ter acesso às informações relevantes técnico documentação, folhas de dados, código amostras e outros recursos. Esses recursos fornecem informações valiosas sobre o exibição especificações, pinagem, interface, controlador, e programação.

O documento mais importante é a ficha técnica do Módulo de exibição OLED em si. Esta folha de dados é normalmente fornecida pelo fabricante e contém detalhes técnico informações sobre o mostrar, incluindo:

• Especificações: Características elétricas, como tensão de operação, consumo de corrente e interface tempo.
• Pinagem: Um diagrama que mostra as atribuições dos pinos para o módulo, incluindo linhas de energia, aterramento e comunicação.
• Interface: Detalhes no protocolo de comunicação (I2C ou SPI), incluindo diagramas de tempo e formatos de comando.
• Controlador:Informações sobre o controlador chip usado no módulo (por exemplo, SSD1306), incluindo seus recursos, mapa de memória e conjunto de comandos.
• Dimensões: Desenhos mecânicos mostrando as dimensões físicas tamanho e furos de montagem do módulo.

Normalmente você pode encontrar a folha de dados para o seu produto específico Módulo OLED no site do fabricante ou no site do revendedor onde você comprou o mostrar. Alguns fabricantes populares de Módulos de exibição OLED incluem Adafruit, Waveshare e vários fabricantes chineses cujos produtos são vendidos por meio de mercados online como AliExpress e Banggood.

Além da folha de dados, você também precisará da documentação do biblioteca você está usando para controlar o mostrar. Por exemplo, se você estiver usando o Adafruit SSD1306 biblioteca, você pode encontrar a documentação no site da Adafruit ou no repositório GitHub para o biblioteca. A documentação normalmente inclui uma descrição das funções disponíveis, por exemplo código, e detalhes sobre como instalar e usar o biblioteca.

Aqui estão alguns links úteis para encontrar recursos relacionados ao 0.91 polegada 128×32 Módulo de exibição OLED:

• Adafruta SSD1306 Biblioteca (GitHub): [https://github.com/adafruit/Adafruit\_SSD1306](https://github.com/adafruit/Adafruit_SSD1306)
• Biblioteca Adafruit GFX (GitHub): [https://github.com/adafruit/Adafruit-GFX-Library](https://github.com/adafruit/Adafruit-GFX-Library)
• Biblioteca U8g2 (GitHub): [https://github.com/olikraus/u8g2](https://github.com/olikraus/u8g2)
• SSD1306 Ficha técnica (exemplo da Solomon Systech): [https://www.solomon-systech.com/en/products/oled-display-driver-ic/ssd1306/](https://www.solomon-systech.com/en/products/oled-display-driver-ic/ssd1306/)

Lembre-se de consultar a documentação específica para o seu Módulo OLED e biblioteca, pois pode haver variações em recursos, pinagens e comandos entre diferentes fabricantes e versões. É aconselhável clique em alguns links e faça uma pesquisa adequada antes de iniciar um projeto.

Conclusão: 10 principais conclusões sobre 0.91 Módulos de exibição OLED de 128×32 polegadas

1. O 0,91 polegada 128×32 Módulo de exibição OLED é um compacto, monocromático exibição gráfica que oferece alto contraste e amplos ângulos de visão graças ao seu OLED tecnologia.
2. O Interface I2C simplifica a conexão do Módulo OLED para microcontroladores como o Arduino Uno, exigindo apenas duas linhas de dados (SDA e SCL), além de energia e aterramento.
3. O SSD1306 é um comumente usado controlador chip para 0,91 polegada 128×32 Telas OLED, fornecendo um integrado gráfico buffer e lidar com os detalhes de baixo nível da condução do OLED painel.
4. Bibliotecas como o Adafruit SSD1306 e U8g2 simplificam o processo de controle do Tela OLED de um Arduino ou outro microcontrolador, oferecendo funções para desenho formas, texto e imagens.
5. O mostrar normalmente opera em 3,3 V ou 5 V, com consumo de energia dependendo do brilho configuração e o número de píxeis que estão acesas. A média de uso do display cerca de 20mA.
6. SPI é uma alternativa interface para I2C para Telas OLED, oferecendo velocidades mais rápidas, mas exigindo mais conexões.
7. Básico desenho no OLED envolve a manipulação individual píxeis usando funções como desenharPixel(), enquanto formas mais complexas podem ser desenhadas usando funções como desenharLinha(), desenharRect(), e desenharCírculo().
8. Exibindo texto envolve definir a fonte, tamanho, e cor, posicionando o cursor e imprimindo strings para o mostrar usando funções fornecidas pelo biblioteca.
9. Mapa de bits as imagens podem ser exibidas convertendo-as em uma matriz de bytes onde cada bit representa um pixel e usando uma função como desenharBitmap() para transferir os dados para o exibição memória.
10. Acessando planilhas de dados, código amostras, e biblioteca a documentação é crucial para o uso eficaz do 0.91 polegada 128×32 Módulo de exibição OLED. Os recursos geralmente podem ser encontrados nos sites de fabricantes como Adafruit ou nos repositórios do GitHub para o bibliotecas.

Ao compreender essas principais conclusões, você estará bem equipado para incorporar o 0,91 polegada 128×32 Módulo de exibição OLED em seu próximo projeto eletrônico, adicionando um visual nítido e compacto interface para suas criações. Lembre-se de que você pode encontrar coisas úteis tutorial online, também podemos fornecer-lhe apoiar se você precisar.