Displays, vem do inglês: “exibir”, “mostrar”. São dispositivos eletrônicos, usados para mostrar informações, números, textos, imagens e tudo o que o desenvolvedor quiser para o usuário final. Qualquer coisa que nos passe informação pode ser considerada um display. Hoje em dia, na eletrônica, temos muitos tipos displays de todas as formas e tamanhos. Neste artigo, vamos abordar alguns destes.

Display de 7 segmentos

Sobre

Displays de 7 segmentos são um dos tipos mais simples disponíveis no mercado, com seu uso muito simples e de extremo baixo custo, além de baixo consumo de energia. Normalmente é utilizado em projetos em que é necessário mostrar números de 0 a 9 ou letras de A a F.

Resumindo, o display de 7 segmentos não passa de 7 LEDs (8 LEDs nos displays com um “ponto” no canto inferior direito) ligados em uma placa com um cátodo ou ânodo comum e uma abertura segmentada na parte de cima. Majoritariamente, você o verá na cor vermelha e pode vir de varias formas, tamanhos e com vários displays em um único modulo para facilitar a montagem.

Possui 8 pinos, sendo um pino comum (cátodo ou ânodo) e os outros 7 pinos responsáveis pelo acionamento de cada um dos LEDs nos segmentos da placa. Sendo cada segmento um LED, sua tensão e corrente de operação em cada pino se assemelha a de um LED, dependendo da intensidade de brilho, cor e modelo (sempre verifique as especificações no datasheet).

Utilização

Para utilizá-lo, podemos usar circuitos integrados próprios que convertem numeração binária para decimal (como o CD4511, por exemplo) ou microcontroladores que podem ser programados de acordo com a necessidade.

Neste tutorial, iremos utilizar o Arduino uno pela facilidade de aplicação e versatilidade.

O exemplo a seguir começa a contar quando pressionamos um botão e o mesmo para de contar quando pressionamos de novo. Lembre-se que, como o display de 7 segmentos é formado por LEDs, precisamos sempre utilizar resistores em série com os segmentos para limitar a corrente nos LEDs e nos pinos do Arduino, caso contrário podemos queimar o LED ou pior, o Arduino!

Para montar o circuito, precisaremos de materiais simples:

• Arduino uno
• Protoboard
• Display de 7 segmentos
• Resistores (220 OHM)
• Jumpers

// Contador com botão e display 7 segmentos
//
// Criado por: Lucas Jácome Cabral, 2022

int a = 13;    // pino correspondente ao LED a
int b = 12;    // pino correspondente ao LED b
int c = 11;    // pino correspondente ao LED c
int d = 10;    // pino correspondente ao LED d
int e = 9;     // pino correspondente ao LED e
int f = 8;     // pino correspondente ao LED f
int g = 7;     // pino correspondente ao LED g
int botao = 2; // pino correspondente ao botão 
int tempo_ms = 500; // tempo de espera, em milissegundos

// este código só é rodado uma vez, no início
void setup () {
    pinMode(a, OUTPUT);           // Define o pino 'a' como saída
    pinMode(b, OUTPUT);           // Define o pino 'b' como saída
    pinMode(c, OUTPUT);           // Define o pino 'c' como saída
    pinMode(d, OUTPUT);           // Define o pino 'd' como saída
    pinMode(e, OUTPUT);           // Define o pino 'e' como saída
    pinMode(f, OUTPUT);           // Define o pino 'f' como saída
    pinMode(g, OUTPUT);           // Define o pino 'g' como saída
    pinMode(botao, INPUT_PULLUP); // Define o pino 'botao' como entrada
}

// este código se repete indefinidamente
void loop () {
    if (digitalRead(botao) == LOW) {
        digitalWrite(a, 1); //zero
        digitalWrite(b, 1);
        digitalWrite(c, 1);
        digitalWrite(d, 1);
        digitalWrite(e, 1);
        digitalWrite(f, 1);
        digitalWrite(g, 0);
        delay(tempo_ms);    
        digitalWrite(a, 0); //um
        digitalWrite(b, 1);
        digitalWrite(c, 1);
        digitalWrite(d, 0);
        digitalWrite(e, 0);
        digitalWrite(f, 0);
        digitalWrite(g, 0);
        delay(tempo_ms);
        digitalWrite(a, 1); //dois
        digitalWrite(b, 1);
        digitalWrite(c, 0);
        digitalWrite(d, 1);
        digitalWrite(e, 1);
        digitalWrite(f, 0);
        digitalWrite(g, 1);
        delay(tempo_ms);
        digitalWrite(a, 1); //três
        digitalWrite(b, 1);
        digitalWrite(c, 1);
        digitalWrite(d, 1);
        digitalWrite(e, 0);
        digitalWrite(f, 0);
        digitalWrite(g, 1);
        delay(tempo_ms);
        digitalWrite(a, 0); //quatro
        digitalWrite(b, 1);
        digitalWrite(c, 1);
        digitalWrite(d, 0);
        digitalWrite(e, 0);
        digitalWrite(f, 1);
        digitalWrite(g, 1);
        delay(tempo_ms);
        digitalWrite(a, 1); //cinco
        digitalWrite(b, 0);
        digitalWrite(c, 1);
        digitalWrite(d, 1);
        digitalWrite(e, 0);
        digitalWrite(f, 1);
        digitalWrite(g, 1);
        delay(tempo_ms);
        digitalWrite(a, 1); //seis
        digitalWrite(b, 0);
        digitalWrite(c, 1);
        digitalWrite(d, 1);
        digitalWrite(e, 1);
        digitalWrite(f, 1);
        digitalWrite(g, 1);
        delay(tempo_ms);
        digitalWrite(a, 1); // sete
        digitalWrite(b, 1);
        digitalWrite(c, 1);
        digitalWrite(d, 0);
        digitalWrite(e, 0);
        digitalWrite(f, 0);
        digitalWrite(g, 0);
        delay(tempo_ms);
        digitalWrite(a, 1); //oito
        digitalWrite(b, 1);
        digitalWrite(c, 1);
        digitalWrite(d, 1);
        digitalWrite(e, 1);
        digitalWrite(f, 1);
        digitalWrite(g, 1);
        delay(tempo_ms);
        digitalWrite(a, 1); //nove
        digitalWrite(b, 1);
        digitalWrite(c, 1);
        digitalWrite(d, 1);
        digitalWrite(e, 0);
        digitalWrite(f, 1);
        digitalWrite(g, 1);
        delay(tempo_ms);
    }
}

Veja a seguir o circuito em funcionamento:

Entendendo o código

Nas linhas de 1 a 3, temos um comentário (ignorado pelo compilador), com uma descrição simples do programa.

Nas linhas de 5 a 13, definimos nossas variáveis. Aqui escolhemos em quais pinos do Arduino ligamos cada porta do display de 7 segmentos, em qual pino ligamos nosso botão, e por quanto tempo o display irá mostrar cada número.

Nas linhas 16 a 25, temos nossa função setup(). Como vimos anteriormente, essa função só roda uma única vez, quando sua placa Arduino é ligada. Aqui definimos que as portas ‘a’ a ‘f’ serão usadas como saídas (para acionar o display), e que a porta ‘botao’ (pino 2), será usada como entrada. Neste último caso, é importante saber se seu botão, quando acionado, vai ligar este pino no GND ou ao 5V, e o que acontece quando o botão não está acionado. No circuito utilizado, quando o botão não está acionado, o pino 2 não fica ligado em nada, e assim, seu nível de tensão é indefinido, o que faz com que o Arduino possa ler um nível lógico baixo ou alto aqui. Para evitar esse problema, o Arduino possui internamente resistores especiais, chamados de resistores Pull Up. O que eles fazem é definir para que lado o nível lógico vai ficar, quando um pino de entrada não estiver ligado em nada (como o próprio nome diz, o resistor Pull Up joga o nível para cima, para HIGH). Aqui, como definimos, na linha 24, a entrada como “INPUT_PULLUP”, estamos dizendo ao Arduino para ligar o resistor interno Pull Up, e assim, quando o pino não estiver ligado em nada, seu nível lógico estará em HIGH (alto); desse modo, o botão deve alterar esse nível lógico, ligando o pino no GND quando acionado, fazendo o nível lógico ser alterado para LOW (baixo).

Nas linhas 27 a 111 temos nossa função loop(), que vai ficar se repetindo indefinidamente, até o Arduino ser desligado. No início da nossa função, na linha 29, verificamos se o botão está acionado, ou seja, se seu nível lógico mudou para LOW. Caso continue em HIGH (o padrão, já que estamos utilizando o resistor interno Pull Up), o código pula para o final do if, para a linha 110. Caso o botão seja acionado, ou seja, se seu nível lógico estiver em LOW, o código entra no if, rodando o que estiver dentro dele, nas linhas 30 a 109. Aqui podemos ver que o código aciona cada um dos pinos do display, correspondendo a um número, e aguarda um determinado tempo, definido pela variável tempo_ms.

Podemos perceber que o código entre as linhas 30 e 109 é bastante repetitivo. Isso deixa o código grande e de difícil leitura. Para facilitar nossa vida, podemos definir nossas próprias funções, que irão rodar trechos de código a cada vez que forem chamadas, como mostra o código a seguir, com exatamente o mesmo funcionamento do anterior:

// Contador com botão e display 7 segmentos, utilizando funções
//
// Criado por: Erick León, 2022
// Baseado no código disponível em:
// https://github.com/edlbcamargo/embarcasaude/blob/main/display_7segmentos_longo/display_7segmentos_longo.ino

int a = 13;    // pino correspondente ao LED a
int b = 12;    // pino correspondente ao LED b
int c = 11;    // pino correspondente ao LED c
int d = 10;    // pino correspondente ao LED d
int e = 9;     // pino correspondente ao LED e
int f = 8;     // pino correspondente ao LED f
int g = 7;     // pino correspondente ao LED g
int botao = 2; // pino correspondente ao botão 
int tempo_ms = 500; // tempo de espera, em milissegundos

// este código só roda quando é chamado em outra função
void mostra_numero(int va, int vb, int vc, int vd, int ve, int vf, int vg) {
        digitalWrite(a, va);
        digitalWrite(b, vb);
        digitalWrite(c, vc);
        digitalWrite(d, vd);
        digitalWrite(e, ve);
        digitalWrite(f, vf);
        digitalWrite(g, vg);
        delay(tempo_ms);    
}

// este código só é rodado uma vez, no início
void setup () {
    pinMode(a, OUTPUT);           // Define o pino 'a' como saída
    pinMode(b, OUTPUT);           // Define o pino 'b' como saída
    pinMode(c, OUTPUT);           // Define o pino 'c' como saída
    pinMode(d, OUTPUT);           // Define o pino 'd' como saída
    pinMode(e, OUTPUT);           // Define o pino 'e' como saída
    pinMode(f, OUTPUT);           // Define o pino 'f' como saída
    pinMode(g, OUTPUT);           // Define o pino 'g' como saída
    pinMode(botao, INPUT_PULLUP); // Define o pino 'botao' como entrada
}

// este código se repete indefinidamente
void loop () {
    if (digitalRead(botao) == LOW) {
        mostra_numero(1, 1, 1, 1, 1, 1, 0); // zero
        mostra_numero(0, 1, 1, 0, 0, 0, 0); // um
        mostra_numero(1, 1, 0, 1, 1, 0, 1); // dois
        mostra_numero(1, 1, 1, 1, 0, 0, 1); // tres
        mostra_numero(0, 1, 1, 0, 0, 1, 1); // quatro
        mostra_numero(1, 0, 1, 1, 0, 1, 1); // cinco
        mostra_numero(1, 0, 1, 1, 1, 1, 1); // seis
        mostra_numero(1, 1, 1, 0, 0, 0, 0); // sete
        mostra_numero(1, 1, 1, 1, 1, 1, 1); // oito
        mostra_numero(1, 1, 1, 1, 0, 1, 1); // nove
    }
}

Repare que aqui criamos uma função mostra_numero(), definida nas linhas 17 a 27, que recebe 7 valores inteiros (‘va’ a ‘vg’), e escreve esses valores nos pinos ‘a’ a ‘g’. Assim, nossa função loop() fica muito mais simples e fácil de visualizar, chamando a função criada com os valores apropriados (linhas 44 a 53).

Display LCD

Sobre

Os displays de LCD (Liquid Crystal Display) começaram a ficar populares no inicio do século XX mas, apesar de ser uma tecnologia antiga, é ao mesmo tempo extremamente atual. Utilizado em vários dispositivos eletrônicos, os displays LCD são extremamente úteis para exibir informações em forma de texto e são preferidos pelos fabricantes pelo seu preço e padronização. Muito utilizada em vários dispositivos, essa tecnologia ganhou muita popularidade no inicio da era digital com os televisores LCD, que ofereciam melhor qualidade de imagem, e hoje ainda os vemos em smart-watches, TV’S de baixo custo, celulares e muitos outros.

Para uso com microcontroladores, como o Arduino, seus tamanhos podem variar, sendo normalmente de 16 colunas por 2 linhas de texto, porém podem ser com até 40 colunas e 8 linhas dependendo do modelo. Também variam de acordo com as cores, sendo amarelo a mais comum.

Utilização

Displays de LCD padrão da indústria vêm com 14 a 16 pinos de alimentação, controle e dados. Sua interface de conexão é padronizada. Isto é, não varia de fabricante para fabricante.

• pino 1 – VSS – Pino de alimentação (zero volts – GND)
• pino 2 – VDD – Pino de alimentação de +5V
• pino 3 – VO – Pino de ajuste do contraste do LCD – depende da tensão aplicada (ajustável)
• pino 4 – RS – Seleção de Comandos (nível 0)  ou Dados (nível 1)
• pino 5 – R/W – Read(leitura – nível 1) / Write (escrita – nível 0)
• pino 6 – E – Enable (Ativa o display com nível 1 ou Desativa com nível 0)
• pino 7 – D0 – data bit 0 (usado na interface de 8 bits)
• pino 8 – D1 – data bit 1 (usado na interface de 8 bits)
• pino 9 – D2 – data bit 2 (usado na interface de 8 bits)
• pino 10 – D3 – data bit 3 (usado na interface de 8 bits)
• pino 11 – D4 – data bit 4 (usado na interface de 4 e 8 bits)
• pino 12 – D5 – data bit 5 (usado na interface de 4 e 8 bits)
• pino 13 – D6 – data bit 6 (usado na interface de 4 e 8 bits)
• pino 14 – D7 – data bit 7 (usado na interface de 4 e 8 bits)
• pino 15 – A – Ânodo do LED de iluminação (+5V CC) (opcional)
• pino 16 – K – Cátodo do LED de iluminação (GND) (opcional)

Exemplo de utilização

Podemos utilizar esse tipo de display com microcontroladores de todos os tipos, desde que atendam a tensão e corrente necessárias para operação do display (5v e 40mA). Neste exemplo vamos utilizar com Arduino uno.

Este projeto escreve texto, previamente escolhido, nas duas linhas do display.

Materiais necessários:

• Protoboard
• Resistor 460 OHM
• Arduino Uno
• Display LCD
• Potenciômetro 10k OHM
• Jumpers

Ligações:

Para que este display funcione, devemos alimentá-lo (pinos GND e VCC, ligados aos pinos GND e 5V do Arduino). Além disso, existem dois pinos de alimentação do LED de iluminação de fundo do display, pinos A e K, que devem ser ligados, em série com o resistor de 460 OHM, entre os pinos GND e 5V do Arduino. O controle de luz do LCD (se as letras ficam mais claras ou mais escuras) é feito através de um potenciômetro, que nada mais é que um resistor de valor variável. Essa ligação é feita conectando os pinos nos cantos do potenciômetro aos pinos GND e 5V do Arduino, e o pino central do potenciômetro no pino VO do display:

Para mostrar o funcionamento do display, escrevemos um código que fica mostrando um determinado texto na tela:

// Teste com display LCD
//
// Criado por: Lucas Jácome Cabral, 2022

#include <LiquidCrystal.h> // comando para incluir biblioteca para facilitar o uso do display

// Configura os pinos conectados do display: rs, enable, d4, d5, d6, d7
LiquidCrystal lcd(6, 7, 5, 4, 3, 2); // rs, enable, d4, d5, d6, d7

// esta função só roda uma vez, no início
void setup() {
    lcd.begin(16, 2); // Numero de colunas e linhas do display
}

// esta função se repete indefinidamente
void loop() 
{
    lcd.clear();             // limpa o display e ajusta o cursor no canto superior esquerdo
    lcd.print("Eu amo");     // Comando para enviar texto para o display
    lcd.setCursor(0, 1);     // Comando para enviar o cursor para um ponto do display, neste caso coluna zero, linha 1
    lcd.print("1..");        // Comando para enviar texto para o display
    delay(1000);             // aguarda 1 segundo (1000 ms)
    lcd.setCursor(0,1);      // voltando cursor para a posição 0,1; senão ele continua escrevendo de onde parou...
    lcd.print("1..2..");     // Comando para enviar texto para o display
    delay(1000);             // aguarda 1 segundo (1000 ms)
    lcd.setCursor(0,1);      // voltando cursor para a posição 0,1; senão ele continua escrevendo de onde parou...
    lcd.print("1..2..3..");  // Comando para enviar texto para o display
    delay(1000);             // aguarda 1 segundo (1000 ms)
    lcd.setCursor(0,1);      // voltando cursor para a posição 0,1; senão ele continua escrevendo de onde parou...
    lcd.print("Eletronica"); // Comando para enviar texto para o display
    delay(3000);             // aguarda 3 segundos (3000 ms)
}

Entendendo o código

A primeira coisa que fazemos é incluir uma biblioteca de uso do LCD, chamada LiquidCrystal.h, na linha 5. Uma biblioteca nada mais é que um conjunto de funções prontas, que facilitam muito o uso de determinados dispositivos. Você pode encontrar diversas bibliotecas prontas para uso na internet, ou pode até escrever a sua própria biblioteca! A biblioteca utilizada aqui pode ser baixada neste link. Nele, você também encontra uma lista das funções disponíveis na biblioteca e explicações, com exemplos, de como utilizar cada função.

Para utilizar essa ou muitas outras bibliotecas na IDE do Arduino, temos disponível um gerenciador de bibliotecas na própria IDE, que geralmente se encarrega de baixar e instalar a biblioteca para que a gente possa usá-la. Basta acessar, no menu “Ferramentas” da IDE, a opção “Gerenciar bibliotecas…”. Na janela que se abre, você pode buscar por “LiquidCrystal” e instalar a biblioteca desejada.

Na linha 8, informamos à biblioteca quais são os pinos que queremos utilizar para fazer a comunicação com o nosso display. A comunicação pode ser feita através de 4 ou de 8 pinos de dados, e neste exemplo estamos utilizando 4 pinos para isso. Além desses 4 pinos, temos um pino de seleção de comandos (RS) e um de ativação (E ou Enable), também utilizados pela biblioteca.

Na função setup(), a única coisa que precisamos fazer é informar a biblioteca que estamos utilizando um display LCD de 16 caracteres por linha, e 2 linhas (linha 12).

Na função loop(), finalmente, colocamos o que queremos que apareça na tela. Podemos controlar a posição do cursor (posição onde o próximo texto será iniciado), limpar a tela e fazer diversas outras coisas, como definir rolagem automática ou fazer a tela piscar! Você pode encontrar mais informações sobre as funções disponíveis na biblioteca neste link.

A seguir vemos o resultado:

Display OLED

Sobre

Displays OLED são o que tem de mais novo em matéria de displays. OLED é uma sigla para Organic Light-Emitting Diodes. É composto por de duas a três camadas de material orgânico e várias outras camadas para filtro e adição de cores. Quando a corrente elétrica passa pelas camadas, pode emitir luz e imagens especificas, dependendo da forma em que cruza a camada. São bastante utilizados pois permitem uma definição maior na imagem, com alto contraste e nitidez.

Tal como acontece com muitos outros tipos de tela, uma matriz OLED pode ser usada para apresentar imagens, texto, vídeo e muito mais em uma tela ou painel de quase qualquer tamanho, e a tecnologia tem sido especialmente prevalente no mercado de entretenimento doméstico de ponta no decorrer dos anos. Graças aos pontos fortes únicos que oferecem em termos de potência e desempenho, atualmente, as telas OLED também estão em uso cada vez mais difundido como ferramentas de exibição de desempenho em todas as indústrias e setores.

O tipo de display que vamos utilizar neste tutorial é o modelo de 0.96” com comunicação I2C.

Utilização e especificações

– Tensão de operação: 3 – 5VDC
– Nível lógico: 3,3 e 5V
– Interface de comunicação: I2C
– Resolução: 128×64 px
– Tela: 0,96”

Esse display tem 4 pinos para conexão com o Arduino, sendo dois relacionados à alimentação do display (VCC = alimentação positiva e GND = alimentação negativa). Também temos dois pinos relacionados à comunicação (SDA e SCL), típicos de uma comunicação I2C, comunicação esta que utiliza apenas dois fios e pode se conectar com vários dispositivos ao mesmo tempo, utilizando os mesmos fios. Para que se determine como vai ser a comunicação, temos sempre um dispositivo que controla a comunicação, o “controlador”, no nosso caso o Arduino, e vários dispositivos “periféricos”, cada um com um endereço específico, no nosso caso o display OLED, no endereço 0x3C.

Exemplo de utilização com arduino uno

Existem diversas bibliotecas disponíveis para controlar displays OLED como o nosso. Cada uma possui suas vantagens e desvantagens, sendo algumas bem simples e com uso de pouca memória, e algumas mais complexas. Neste exemplo utilizaremos a biblioteca Adafruit_SSD1306, que pode ser instalada pelo gerenciador de bibliotecas da IDE do Arduino, no menu “Ferramentas”, e é uma biblioteca bastante poderosa. Ela depende de outra biblioteca para construção de gráficos, chamada Adafruit_GFX, que também deve ser instalada.

/*******************************************************************************
  * 
  * Exemplo de uso do display OLED com controlador SSD1306.
  * 
  * Referências:
  * https://learn.adafruit.com/adafruit-gfx-graphics-library/graphics-primitives
  * https://github.com/adafruit/Adafruit_SSD1306
  * 
  * Criado por: Erick León, 2022
  * 
  ********************************************************************************/

#include <Wire.h>                  // Biblioteca para uso da comuicação I2C
#include <Adafruit_GFX.h>          // Biblioteca para construção de gráficos
#include <Adafruit_SSD1306.h>      // Biblioteca para comunicação com o display OLED

// Configuração do display OLED. Parâmetros:
//    - largura_do_display: 128 pixels
//    - altura_do_display: 64 pixels
//    - biblioteca de comunicação I2C utilizada
//    - pino de Reset do display (-1 em caso de não ter)
Adafruit_SSD1306 display(128, 64, &Wire, -1); 

int x = 0;                         // variável que guarda a posição dos objetos em movimento
unsigned long time = millis();     // variável que guarda o instante da última atualização da tela do display

// esta função só roda uma vez, no início
void setup() {
    Wire.begin();                  // inicia a comunicação I2C
    delay(500);                    // aguarda 500ms

    // inicializa a comunicação com o display, no endereço I2C 0x3C
    if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
      for(;;);   // Se não conseguiu inicializar o display, fica aqui e não continua o programa
    }

    display.setTextSize(1);        // escolhe o tamanho da letra
    display.setTextColor(WHITE);   // escolhe a cor da letra
}

// esta função se repete indefinidamente
void loop() {
    x++;                           // aumenta a posição desejada, para a direita
    if (x>display.width()) x = 0;  // se chegou no final da tela, volta para o início
    
    display.clearDisplay();        // limpa o buffer da tela
    display.setCursor(0,0);        // coloca o cursor de texto no canto superior esquerdo do buffer da tela
    display.print(millis()-time);  // mostra no buffer da tela quanto tempo passou desde a última atualização
    time = millis();               // guarda o instante desta atualização
    display.println(" ms");        // mostra no buffer da tela a unidade de tempo do intervalo

    // desenha no buffer da tela, na posição 'x', um círculo grande vazio, com cor branca:
    display.drawCircle(x+1, display.height()/2, display.height()/2 -1, SSD1306_WHITE);
    // desenha no buffer da tela, na posição 'x', um círculo pequeno cheio, com cor branca:
    display.fillCircle(x+1, display.height()/2, x/4, SSD1306_WHITE);
    // desenha no buffer da tela uma curva senoidal, invertendo a cor (branco fica preto, preto fica branco):
    for (int idx=0; idx<128;idx++) display.drawPixel(idx, 32+32*sin(float(idx+x)/18.0), SSD1306_INVERSE);
    
    display.display();             // atualiza a tela com as informações do buffer
}

Entendendo o código

Nas linhas 1 a 11, temos um bloco de comentário. Blocos de comentário se iniciam com /* e terminam com */. Tudo que estiver entre esses caracteres, é ignorado pelo compilador. Os demais asteriscos são apenas estéticos, e também são ignorados.

Na linha 13, incluímos a biblioteca Wire. Essa biblioteca é a padrão para comunicação I2C no Arduino, e não precisa ser instalada.

Nas linhas 14 e 15, incluímos as bibliotecas que serão utilizadas para controle do display, a Adafruit_GFX e a Adafruit_SSD1306. Essas bibliotecas devem ser instaladas pelo gerenciador de bibliotecas, disponível no menu “Ferramentas” da IDE do Arduino.

Na linha 22, configuramos nosso display, informando para a biblioteca seu tamanho (128×64 pixels) e a biblioteca de comunicação que desejamos utilizar.

Na linha 24, criamos uma variável ‘x’. Essa variável vai guardar a posição horizontal dos objetos na tela.

Na linha 25, criamos uma variável ‘time’. Nessa variável, guardamos o instante da última atualização da tela. Para isso, utilizamos a função millis(), que retorna, toda vez que é chamada, o número de milissegundos passados desde que a placa Arduino começou a executar o programa atual.

Na nossa função setup(), inicializamos a comunicação I2C (linha 29), e verificamos se é possível se comunicar com o display. A função display.begin() faz essa verificação, retornando TRUE em caso de comunicação bem sucedida e FALSE em caso de erro. Nesse último caso, o programa entra no if e fica em um loop infinito (for). Caso a comunicação seja bem sucedida, escolhemos o tamanho e a cor da fonte (linhas 37 e 38).

Na função loop(), acrescentamos 1 ao valor de ‘x’ (linha 43). Aqui, vale comentar que ‘x++’ é o mesmo que ‘x = x + 1’. Como dissemos, essa variável vai guardar a posição horizontal dos objetos na tela, então ao acrescentarmos 1 ao seu valor, estamos ‘andando’ para a direita. Caso essa posição alcance a largura da tela, voltamos para o início, definindo ‘x’ como ‘0’ (linha 44).

Nas linhas 53, 55 e 57, criamos 3 desenhos, dois círculos e um conjunto de pontos, desenhando uma senóide. Aqui você poderia fazer um desenho, criar linhas ou desenhar um gráfico, o que você quiser!

Com essa biblioteca que estamos trabalhando, nós não desenhamos diretamente na tela, e sim em um espaço da memória do dispositivo, chamado de buffer, que funciona como uma cópia da tela. Depois que todas as informações desejadas (textos, figuras, gráficos etc) são atualizadas no buffer, nós solicitamos ao dispositivo para jogar a informação do buffer na tela (linha 59).

A saída desse programa no display OLED pode ser vista a seguir:

Referencias

https://www.embarcados.com.br/modulo-de-display-lcd/

https://ie.rs-online.com/web/generalDisplay.html?id=ideas-and-advice/oled-displays-guide#:~:text=OLED%20Improved resolution of D¿bar images of ventilation using a Schur complement property and an anatomical atlasdisplays%20are%20electronic%20visual,for%20their%20core%20illumination%20power.

https://dronebotworkshop.com/oled-arduino/

Texto por: Lucas Jácome Cabral e Erick León