Início / Projetos Arduino / Projetos Squids / Básico / Projeto 90 - Como controlar um Display OLED SSD1306 com Arduino - biblioteca Adafruit

---

Projeto 90 - Como controlar um Display OLED SSD1306 com Arduino - biblioteca Adafruit

Angelo Luis Ferreira | 22/09/2020 Acessos: 23.007

Objetivo

Neste projeto vamos mostrar como utilizar um display OLED SSD1306 com Arduino. No projeto mostraremos como instalar e utilizar o display para visualizar caracteres, símbolos e desenhos através das bibliotecas Adafruit_GFX e Adafruit_SSD1306 via comunicação I2C ou SPI. Utilizamos no projeto um Display OLED 0.96″ I2C Azul Amarelo com controlador SSD1306, mas você poderá utilizar qualquer display Oled SSD1306.

Definições

Atenção: Não utilize o display em locais molhados ou úmidos, pois a água pode danificar o componente.

Display OLED (Organic Light-Emitting Diode, ou Diodo Emissor de Luz Orgânico): Display gráfico com alto contraste, excelente nitidez, leve e muito econômico, pois como possui luz própria não precisa de backlight utilizado nas telas de LCD ou LED, por exemplo. Outra grande vantagem do display OLED é possibilidade de gerar imagens. Como desvantagens, o display possui uma vida útil menor (entre 10mil e 40mil horas de uso) e não deve ser utilizado em locais úmidos, pois a água danifica facilmente o componente.

Funcionamento: O display OLED é formado por camadas de material orgânico posicionadas entre eletrodos. O material orgânico tem uma propriedade denominada de eletroluminescência (EL) que faz com que o material "ilumine" ao ser estimulada por uma corrente elétrica ou por um campo eletromagnético. Portanto, essa camada orgânica quando estimulada emite luz nas cores vermelho, verde e azul (RGB), que é o padrão utilizado nos displays gráficos.

Display OLED SSD1306: É um display OLED que possui um controlador SSD1306. Este chip é responsável por fazer o controle entre o dispositivo e algum microcontrolador ou CPU. No caso, vamos utilizar o ATmega328 como microcontrolador (Arduino UNO).

a) Comunicação com o microcontrolador: O poderoso controlador CMOS OLED SSD1306 pode se comunicar com o microcontrolador Arduino de várias formas, incluindo I2C e SPI (as mais comuns). O protocolo de comunicação I2C requer apenas 2 pinos de conexão, enquanto que o SPI requer mais pinos de conexão, porém é geralmente mais rápido.

 b) Resolução, tamanho e cores: Graças a versatilidade do controlador SSD1306, o display pode ser fornecido em diferentes tamanhos e cores. Por exemplo, temos os OLEDs com resolução 128X64 (0,96") e OLEDs 128X32 (0,91") nas cores branco, azul, dual color (azul com uma faixa amarela na parte superior) ou colorido.

 c) Alimentação: Como já mencionamos anteriormente, o display OLED funciona sem a necessidade de luz de fundo porque produz a sua própria luz. Isto explica o seu alto contraste, nitidez e o seu baixo consumo de energia. Em média, o display usa no máximo 20mA de corrente. O display poderá ser conectado perfeitamente em qualquer microcontrolador lógico de 3.3V a 5V sem a necessidade de nenhum conversor.

d) Mapa de memória OLED: Independente do tamanho do display OLED, o driver SSD1306 possui 1KB de memória RAM embutida. Esta área de memória de 1K é organizada em 8 faixas (páginas de 0 a 7). Cada página contém 128 colunas (blocos de 0 a 127) e cada coluna pode armazenar 8 bits de dados (de 0 a 7). Portanto, temos 8 páginas X 128 colunas X 8 bits = 1024 bytes = 1kB de memória.

Obs.: A tela OLED 128 X 64 poderá exibir todo o conteúdo da RAM (8 páginas = 1Kb), enquanto que a tela OLED 128 X 32 exibe apenas a metade (4 páginas = 512bytes)

e) Especificação geral:

Aplicação

Para fins didáticos e projetos onde é necessária a exibição de dados. Ideal para projetos que precisam exibir figuras geométricas, textos com fontes e tamanhos variados, caracteres especiais e figuras plotadas a partir de uma imagem em bitmap ou que exijam baixo consumo de energia.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Protoboard	Protoboard 830 pontos	1		No mínimo utilizar protoboard com 830 pontos
Jumpers	Kit cabos ligação macho / macho	1
Display OLED	Display OLED SSD1306	1		– Tensão de operação: 3,3-5V – Controlador: SSD1306 – Cor: Azul e Amarelo – Comunicação: I2C – Resolução: 128×64 – Dimensões: 30 x 27mm Você também poderá utilizar na cor azul, branco ou colorido. A comunicação poderá ser I2C ou SPI
Arduino UNO R3	Arduino UNO	1		Você poderá utilizar uma placa Arduino UNO original ou similar

Montagem do Circuito

Conecte os componentes no Protoboard como mostra a figura abaixo (display OLED com comunicação I2C). Verifique cuidadosamente os cabos de ligação antes de ligar seu Arduino. Lembre-se que o Arduino deve estar totalmente desconectado da força enquanto você monta o circuito.

Atenção

Comunicação I2C

1. Para a montagem do display OLED SSD1306 via protocolo I2C, verifique a "pinagem" do módulo com comunicação I2C:

Obs.: Em algumas marcas os pino Vcc e GND estão invertidos. Portanto, preste atenção fazer a conexão correta.

 1.1. Faça a conexão dos pinos SCL e SDA com o Arduino da seguinte forma:

1.2. No nosso projeto utilizamos um display OLED SSD1306 I2C e Arduino Uno. Veja abaixo como fizemos a conexão.

Comunicação serial SPI

2. Para a montagem do display OLED com comunicação SPI, temos os seguintes pinos: GND, VCC, (CLK ou D0), (MOSI ou D1), RES e DC.

2.1. Abaixo temos os modelos mais comuns de display OLE com comunicação serial SPI:

Obs.:  O modelo mais à esquerda possui 6 pinos e pode ser ligado nas 2 formas (I2C e SPI)

2.1. Recomendamos para uso nos projetos deste tutorial, a seguinte configuração com o microcontrolador Arduino UNO (usar a mesma ordem dos pinos nos modelos com 7 pinos acima):

3. A montagem do nosso exemplo foi realizada em um protoboard com 400 pontos e com um display OLED SSD1306 com comunicação via protocolo I2C. Verifique sempre se o seu protoboard possui linhas de alimentação contínuas ou separadas - saiba mais em protoboard.

Incluindo as bibliotecas Adafruit SSD1306 e Adafruit GFX

Para utilizar o controlador SSD1306 vamos incluir a biblioteca Adafruit SSD1306. Esta biblioteca foi escrita para resolver a complexidade do controlador SSD1306, oferecendo comandos simples para facilitar o controle de operação do display OLED.

Para obtermos uma experiência completa, precisamos instalar também a biblioteca Adafruit GFX para exibir elementos gráficos primitivos como pontos, linhas, círculos, retângulos, etc.

Instalação das bibliotecas

1. No IDE do Arduino, acesse a aba Sketch, selecione [Incluir Biblioteca] e depois [Gerenciar Bibliotecas...].

 2. No campo de pesquisa digite ssd1306 adafruit. Localizada a biblioteca Adafruit SSD1306 clique no botão [Instalar].

3. Na janela "Dependencies for library Adafruit SSD1306..." clique no botão [Install all]. Desta forma, instalaremos as bibliotecas Adafruit SSD1306, Adafruit GFX library e Adafruit BusIO todas juntas automaticamente.

 4. Após a instalação, observe que aparecerá a informação que as bibliotecas foram instaladas. (Lembre-se que precisaremos das bibliotecas Adafruit SSD1306 e Adafruit GFX Library para controlar nosso display OLED)>

 5. Para mais informações sobre as bibliotecas, acesse: Adafruit SSD1306 e Adafruit GFX library.

Iniciando "Hello Word!" no display OLED

Para termos a compreensão completa sobre como usar o display OLED controlado pelo Arduino vamos iniciar nosso projeto imprimindo a famosa frase "Hello Word!". Desta forma, veremos toda a configuração inicial, bibliotecas, comunicação e comandos obrigatórios, que servirá como base para todas as aplicações com o seu módulo OLED.

Sketch - Comunicação I2C

 /*******************************************************************************
*
*    Projeto: Hello Word! - COMUNICAÇÃO I2C
*    Data: 30/09/2020
*            http://squids.com.br/arduino
*
*******************************************************************************/
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

const byte SCREEN_WIDTH = 128; // OLED display width, in pixels
const byte SCREEN_HEIGHT = 64; // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
const int OLED_RESET = -1; // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup() {

// initialize with the I2C addr 0x3C
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  

// Clear the buffer.
display.clearDisplay();
  
// Display Text "Hello Word"
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(0,28);
display.println("Hello Word!");
display.display();
}

void loop() {}

a) Observe que o scketch acima foi iniciado com a inclusão das quatro bibliotecas obrigatórias para o controle do OLED: SPI.h, Wire.h, Adafruit_GFX.h e Adafruit_SSD1306.h

Obs1: Embora a biblioteca SPI.h não seja necessária para exibições via protocolo I2C, precisamos adicioná-la para compilar o programa corretamente.

Obs2: As bibliotecas SPI.h e Wire.h não precisam ser instaladas, pois fazem parte do rol de bibliotecas nativas do IDE do Arduino.

b) Definimos em seguida a resolução do nosso display OLED, informando a largura (width) e a altura (height) da tela em pixels. Lembre-se que estamos utilizando um display OLED 128 X 64.

c) Continuando, vamos agora criar o objeto display() identificando a resolução e a forma de comunicação, que neste caso é via I2C.

Obs.: Como o OLED que estamos utilizando não possui um pino RESET, enviamos -1 ao construtor para que nenhum dos pinos do Arduino seja utilizado como um reset para o display.

d) Dentro da estrutura void setup() precisamos inicializar o objeto OLED usando a função begin() que possui 2 parâmetros, sendo eles:

• O primeiro parâmetro SSD1306_SWITCHCAPVCC liga os circuitos internos.
• O segundo parâmetro define o endereço I2C do display OLED utilizado. Este endereço é fixo e não pode ser alterado. Geralmente os módulos I2C OLED possuem como padrão o endereço 0x3C.

 Atenção:  A seleção de endereço I2C para display OLED, na maioria dos módulos fornecidos no mercado já vêm configurados com o com o endereço 0x3C. Se você não sabe qual endereço que o seu módulo display OLED I2C está configurado, baixe o seguinte "sketch":

2.3.1 Após instalar e rodar o sketch acima, abra o monitor serial que mostrará qual é o endereço que o seu módulo I2C está configurado:

e) É recomendável limpar o buffer de memória do módulo display OLED antes de qualquer comando de exibição. Na estrutura void setup() ainda, utilize a função clearDisplay() para fazer a limpeza no buffer e apagar tudo na tela. Isso é muito útil no caso de você desligar e ligar o Arduino novamente.

f) os comandos para a exibição da frase "Hello Word" no display OLED nós abordaremos mais para a frente.

Sketch - Comunicação SPI

 /*******************************************************************************
*
*    Projeto: Hello Word! - COMUNICAÇÃO SPI
*    Data: 30/09/2020
*            http://squids.com.br/arduino
*
*******************************************************************************/
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

const byte SCREEN_WIDTH = 128; // OLED display width, in pixels
const byte SCREEN_HEIGHT = 64; // OLED display height, in pixels

// Declaration for SSD1306 display connected using software SPI (default case):
#define OLED_MOSI  11
#define OLED_CLK   13
#define OLED_DC     9
#define OLED_CS    10
#define OLED_RESET  8
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT,
  OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);

void setup() {

// initialize with the SPI pins
display.begin(SSD1306_SWITCHCAPVCC); 

// Clear the buffer.
display.clearDisplay();
  
// Display Text "Hello Word"
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(0,28);
display.println("Hello Word!");
display.display();
}

void loop() {}

 a) Como no exemplo anterior, o scketch acima foi iniciado com a inclusão das quatro bibliotecas obrigatórias para o controle do OLED: SPI.h, Wire.h, Adafruit_GFX.h e Adafruit_SSD1306.h

Obs1: Embora a biblioteca SPI.h não seja necessária para exibições via protocolo I2C, precisamos adicioná-la para compilar o programa corretamente.

Obs2: As bibliotecas SPI.h e Wire.h não precisam ser instaladas, pois fazem parte do rol de bibliotecas nativas do IDE do Arduino.

b) Definimos em seguida a resolução do nosso display OLED, informando a largura (width) e a altura (height) da tela em pixels. Lembre-se que estamos utilizando um display OLED 128 X 64.

c) Continuando, vamos agora criar o objeto display() identificando a resolução e a forma de comunicação, que neste caso é via SPI. 

Obs.: O código utilizado acima foi desenvolvido a partir da montagem do display OLED SPI com o Arduino, como mostra a imagem abaixo.

Atenção: Caso você altere a montagem do display OLED, não esqueça de alterar o Sketch de acordo com a nova configuração.

d) Dentro da estrutura void setup() precisamos inicializar o objeto OLED usando a função begin() com apenas o parâmetro SSD1306_SWITCHCAPVCC definido para ligar os circuitos internos do display.

e) É recomendável limpar o buffer de memória do módulo display OLED antes de qualquer comando de exibição. Na estrutura void setup() ainda, utilize a função clearDisplay() para fazer a limpeza no buffer e apagar tudo na tela. Isso é muito útil no caso de você desligar e ligar o Arduino novamente.

Comandos para a exibição da frase "Hello Word"

a) Primeiro limpamos o display através da função clearDisplay().

b) Definimos o tamanho da fonte através da função setTextSize(). O tamanho da fonte começa em 1, onde os caracteres são renderizados na proporção de 7:10. (Nesta configuração, temos 21 caracteres na horizontal e 8 caracteres na vertical).

c) Definimos a cor da fonte e do fundo através da função setTextColor(). O parâmetro WHITE define o fundo escuro e o parâmetro BLACK o fundo claro.

d) Definimos a posição do cursor (onde se inicia o texto) através das função setCursor(x, y). Os pixels na tela são endereçados por suas coordenadas horizontal (x) e vertical (y). O sistema de coordenadas tem como origem (0,0) o canto superior esquerdo, com x positivo aumentado para a direita e y positivo aumentando para baixo. Obs.: Lembramos que o display utilizado possui resolução de 128 pixels (horizontal) e 64 pixels (vertical).

e) O comando display() é necessário para instruir a biblioteca a realizar a transferência em massa do buffer de tela no Atmega328 para a memória interna do controlador SSD1306. Assim que a memória estiver sendo transferida, os pixels correspondentes ao buffer de tela aparecerão no display OLED.

1. Sketch Arduino - Exibindo textos no display OLED

1.1 Neste projeto vamos apresentar os principais métodos para exibição de textos e números:

1.1.1. Faça o download e abra o arquivo projeto90a.ino no IDE do Arduino:  DOWNLOAD - projeto90a.ino

Obs: Se estiver utilizando um display OLED com comunicação SPI, substitua as linhas 18, 19 e 20 pelas linhas abaixo:

// Declaration for SSD1306 display connected using software SPI (default case):
#define OLED_MOSI  11
#define OLED_CLK   13
#define OLED_DC     9
#define OLED_CS    10
#define OLED_RESET  8
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT,
  OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);

 1.2. Se preferir, copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************

     Projeto 90a - Exibindo textos e números no display OLED
     Autor: Angelo Luis Ferreira
     Data: 30/09/2020
             http://squids.com.br/arduino

*******************************************************************************/
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Fonts/FreeMonoOblique9pt7b.h> // alternative font

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup() {

  // initialize with the I2C addr 0x3C
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);

  // Clear the buffer.
  display.clearDisplay();
  
}

void loop() {
  // Display Text
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(24, 0);
  display.println("Squids Arduino");
  display.setCursor(0, 28);
  display.println("Hellow Word!");
  display.setCursor(0, 57);
  display.println("Squids Arduino");
  display.display();
  delay(2000);
  display.clearDisplay();

  // Display Inverted Text
  display.setTextSize(1);
  display.setTextColor(BLACK, WHITE);
  display.setCursor(24, 0);
  display.println("Squids Arduino");
  display.setCursor(0, 28);
  display.println("Hellow Word!");
  display.setCursor(0, 57);
  display.println("Squids Arduino");
  display.display();
  delay(2000);
  display.clearDisplay();

  // Changing Font Size
  display.setTextColor(WHITE);
  display.setCursor(0, 17);
  display.setTextSize(2);
  display.println("Squids!");
  display.setCursor(18, 37);
  display.println("Arduino!");
  display.setTextSize(1);
  display.setCursor(24, 0);
  display.println("Font Size");
  display.display();
  delay(2000);
  display.clearDisplay();

  // Changin Font type
  display.setCursor(24, 0);
  display.println("Font Type");
  display.setFont(&FreeMonoOblique9pt7b);
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0, 28);
  display.println("Squids");
  display.println(" Arduino!");
  display.display();
  delay(2000);
  display.setFont(); // return to original font
  display.clearDisplay();

  // Display Numbers
  display.setTextSize(1);
  display.setCursor(0, 28);
  display.println(1234567890);
  display.display();
  delay(2000);
  display.clearDisplay();

  // Specifying Base For Numbers
  display.setCursor(0, 28);
  display.print("0x"); 
  display.print(0xFF, HEX);
  display.print("(HEX) = ");
  display.print(0xFF, DEC);
  display.println("(DEC)");
  display.display();
  delay(2000);
  display.clearDisplay();

  // Display ASCII Characters
  display.setCursor(0, 24);
  display.setTextSize(2);
  display.write(123);
  display.write(1);
  display.write(2);
  display.write(3);
  display.write(4);
  display.write(5);
  display.write(6);
  display.write(125);
  display.display();
  delay(2000);
  display.clearDisplay();

  // Scroll full screen
  display.setCursor(0, 0);
  display.setTextSize(1);
  display.println("Full");
  display.println("screen");
  display.println("scrolling!");
  display.display();
  display.startscrollright(0x00, 0x07);
  delay(2000);
  display.stopscroll();
  delay(1000);
  display.startscrollleft(0x00, 0x07);
  delay(2000);
  display.stopscroll();
  delay(1000);
  display.startscrolldiagright(0x00, 0x07);
  delay(2000);
  display.startscrolldiagleft(0x00, 0x07);
  delay(2000);
  display.stopscroll();
  display.clearDisplay();

  // Scroll part of the screen
  display.setCursor(0, 0);
  display.setTextSize(1);
  display.println("Squids Arduino");
  display.println("Scroll de alguma");
  display.println("parte da tela.");
  display.display();
  display.startscrollright(0x00, 0x00);
  delay(2000);
  display.stopscroll();
  delay(1000);
  display.startscrollright(0x00, 0x00);
  delay(2000);
  display.startscrollright(0x00, 0x00);
  delay(2000);
  display.startscrollright(0x00, 0x00);
  delay(2000);
  display.startscrollright(0x00, 0x00);
  delay(2000);
  display.stopscroll();
  delay(2000);
  display.clearDisplay();

}

Principais comandos para exibição de textos

a. Exibir texto simples: Podemos usar as funções print(" ") ou println(" ") para imprimir mensagens na tela do OLED, da mesma forma que imprimimos textos no monitor serial. Lembre-se, println(" ") irá mover o cursor para uma nova linha.

b. Exibir texto invertido: Para exibir um texto invertido, usaremos a função setTextColor(FontColor, BackgroundColor). Observe que neste caso usamos a função setTextColor(BLACK, WHITE) com 2 parâmetros, de forma que o texto será renderizado com o texto escuro (BLACK) e o fundo claro (WHITE).

 c. Alterar o tamanho da fonte: Nós chamamos a função setTextSize() e se passarmos o parâmetro 1 (default), os caracteres serão renderizados na razão de 7:10, ou seja, 7pixels por 10pixels por caractere. Se passarmos o parâmetro 2, por exemplo, teremos a renderização na razão 2 vezes maior, ou seja, 14X20.

d. Alterar o tipo de fonte: A biblioteca Adafruit GFX permite usar algumas fontes alternativas além das fontes internas padrão. Podemos escolher entre Serif, Sans e Mono. Cada fonte está disponível em negrito, itálico e em tamanhos diferentes. As fontes também estão definidas em tamanhos pré fixados com 9, 12, 18 e 24 pontos e também contêm caracteres de 7bits (códigos ASCII). Portanto, o método setTextSize() não funciona nessas fontes.

d.1. Abaixo seguem algumas fontes alternativas que você poderá utilizar nos seus projeto:

FreeMono12pt7b.h		FreeSansBoldOblique12pt7b.h
FreeMono18pt7b.h		FreeSansBoldOblique18pt7b.h
FreeMono24pt7b.h		FreeSansBoldOblique24pt7b.h
FreeMono9pt7b.h			FreeSansBoldOblique9pt7b.h
FreeMonoBold12pt7b.h		FreeSansOblique12pt7b.h
FreeMonoBold18pt7b.h		FreeSansOblique18pt7b.h
FreeMonoBold24pt7b.h		FreeSansOblique24pt7b.h
FreeMonoBold9pt7b.h		FreeSansOblique9pt7b.h
FreeMonoBoldOblique12pt7b.h	FreeSerif12pt7b.h
FreeMonoBoldOblique18pt7b.h	FreeSerif18pt7b.h
FreeMonoBoldOblique24pt7b.h	FreeSerif24pt7b.h
FreeMonoBoldOblique9pt7b.h	FreeSerif9pt7b.h
FreeMonoOblique12pt7b.h		FreeSerifBold12pt7b.h
FreeMonoOblique18pt7b.h		FreeSerifBold18pt7b.h
FreeMonoOblique24pt7b.h		FreeSerifBold24pt7b.h
FreeMonoOblique9pt7b.h		FreeSerifBold9pt7b.h
FreeSans12pt7b.h		FreeSerifBoldItalic12pt7b.h
FreeSans18pt7b.h		FreeSerifBoldItalic18pt7b.h
FreeSans24pt7b.h		FreeSerifBoldItalic24pt7b.h
FreeSans9pt7b.h			FreeSerifBoldItalic9pt7b.h
FreeSansBold12pt7b.h		FreeSerifItalic12pt7b.h
FreeSansBold18pt7b.h		FreeSerifItalic18pt7b.h
FreeSansBold24pt7b.h		FreeSerifItalic24pt7b.h
FreeSansBold9pt7b.h		FreeSerifItalic9pt7b.h

d.2. Para utilizar alguma fonte alternativa acima, primeiro você deverá incluí-la no sketch através do comando

d.3. Em seguida, você deverá usar método setFont() e passar como argumento, a fonte especificada e para voltar a usar a fonte original, chamar o método setFont() sem argumentos:

e. Exibir números inteiros:  Para exibir números no display OLED basta chamar a função print() ou println() - sem utilizar aspas. Podem ser exibidos números inteiros de 0 a 4.296.967.295, o que equivale a uma resolução de 32bits.

f. Base Numérica:  As funções print() e println() possuem um segundo parâmetro opcional que especifica a base numérica utilizada. Os valores permitidos são BIN (binário ou base 2), OCT (octal ou base 8), DEC (decimal ou base 10) e HEX (hexadecimal ou base 16). Também podemos especificar números fracionários (com ponto flutuante), utilizando o segundo parâmetro com o número de casas decimais: Veja alguns exemplos:

    print (78, BIN) // 1001110
    print (78, OCT) // 116
    imprimir (78, DEC) // 78
    imprimir (78, HEX) // 4E
    println (1.23456, 0) // 1
    println (1.23456, 2) // 1.23
    println (1.23456, 4) // 1.2346

g. Exibindo símbolos ASCII: As funções print () e println () enviam dados para o display como texto ASCII legível, enquanto a função write () envia dados binários para o display. Portanto, podemos usar esta função para exibir símbolos ASCII.

Veja abaixo uma tabela com os símbolos ASCII relacionados com os códigos binários entre 0 e 255 (8bits).

 h. Exibindo um texto em scroll: Para rolar uma exibição horizontalmente utilizamos as funções startscrollright () - rolar o texto para a direita e startscrollleft () - rolar o texto para a esquerda. Para rolar o texto na diagonal utilizaremos as funções startscrolldiagright () e startscrolldiagleft (). Para interromper a rolagem do display, utilizamos a função stopscroll ().

h.1. Rolagem da tela inteira: Para rolar a tela inteira, ou parte da tela, precisaremos definir quais são as páginas (linhas) display que se deseja executar. Vimos anteriormente em mapa de memória OLED que o display 128 X 64 está organizado em 8 faixas definidas como páginas de 0 a 7. Portanto, para rolar a tela inteira, precisamos definir como parâmetros todas as páginas da tela, ou seja, a página inicial 0X00 e a página final 0X07. Os números das páginas devem estar na base hexadecimal. Veja abaixo o nosso exemplo para rolar a tela inteira do display LED:

 h.2. Rolagem de parte da tela: Para rolar apenas uma parte da tela precisamos apenas indicar a página inicial e a página final da parte da tela que queremos executar. No nosso exemplo passamos os parâmetros página inicial e página final como 0x00. Isso rolará apenas a primeira página, ou seja, as primeiras 8 linhas da tela.

// Declaration for SSD1306 display connected using software SPI (default case):
#define OLED_MOSI  11
#define OLED_CLK   13
#define OLED_DC     9
#define OLED_CS    10
#define OLED_RESET  8
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT,
  OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);

/*******************************************************************************

     Projeto 90b - Desenhando em um display OLED
     Autor: Angelo Luis Ferreira
     Data: 05/10/2020
             http://squids.com.br/arduino

*******************************************************************************/
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup() {
  // initialize with the I2C addr 0x3C
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
}

void loop() {                
  // Clear the buffer.
  display.clearDisplay();

  // Texto: Squids Arduino
  display.setTextColor(WHITE);
  display.setCursor(0, 17);
  display.setTextSize(2);
  display.println("Squids!");
  display.setCursor(18, 37);
  display.println("Arduino!");
  display.setTextSize(1);
  display.setCursor(24, 0);
  display.println("Programando");
  display.display();
  delay(2000);
  display.clearDisplay();

  // Texto: Desenhando no display
  display.setTextColor(WHITE);
  display.setCursor(0, 17);
  display.setTextSize(1);
  display.println("Desenhando no");
  display.setCursor(18, 37);
  display.println("Display OLED!");
  display.setTextSize(1);
  display.setCursor(24, 0);
  display.println("Squids Arduino");
  display.display();
  delay(2000);
  display.clearDisplay();

  // Retângulo
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println("Rectangle");
  display.drawRect(0, 17, 60, 40, WHITE);
  display.display();
  delay(2000);
  display.clearDisplay();
  
  // Retãngulo preenchido
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println("Filled Rectangle");
  display.fillRect(0, 17, 60, 40, WHITE);
  display.display();
  delay(2000);
  display.clearDisplay();
  
  // Retângulo com bordas arredondadas
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println("Round Rectangle");
  display.drawRoundRect(0, 17, 60, 40, 8, WHITE);
  display.display();
  delay(2000);
  display.clearDisplay();

  //Retângulo como bordas arredondas preenchido
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println("Filled Round Rectangl");
  display.fillRoundRect(0, 17, 60, 40, 8, WHITE);
  display.display();
  delay(2000);
  display.clearDisplay();

  // Círculo
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println("Circle");
  display.drawCircle(22, 37, 20, WHITE);
  display.display();
  delay(2000);
  display.clearDisplay();

  // Círculo preenchido
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println("Filled Circle");
  display.fillCircle(22, 37, 20, WHITE);
  display.display();
  delay(2000);
  display.clearDisplay();

  // Triângulo
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println("Triangle");
  display.drawTriangle(30, 17, 0, 60, 60, 60, WHITE);
  display.display();
  delay(2000);
  display.clearDisplay();

  // Triângulo preenchido
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println("Filled Triangle");
  display.fillTriangle(30, 17, 0, 60, 60, 60, WHITE);
  display.display();
  delay(2000);
  display.clearDisplay();
}

Comentários