Tutorial US2066: OLED de caracteres com Arduino

Se está interessado em começar a utilizar ecrãs OLED de caracteres com o chip controlador US2066, então está no lugar certo. O chip tudo-em-um US2066 simplifica o acionamento de ecrãs OLED, facilitando o início para qualquer pessoa, independentemente do seu nível de habilidade. Esteja a trabalhar com dispositivos portáteis, instrumentos industriais ou qualquer outra coisa, este guia fornecerá o conhecimento necessário para explorar todo o potencial dos ecrãs OLED com o controlador US2066.

Visão geral do tutorial

Neste tutorial, exploraremos e destacaremos algumas funcionalidades importantes do controlador OLED US2066. Também abordaremos como ligar o visor e forneceremos exemplos de código para ajudá-lo a começar a configurar o seu OLED com o Arduino, incluindo como exibir texto, ajustar o contraste e realizar a mudança de caracteres.

O controlador US2066 está no centro de uma ampla gama de nossos monitores OLED. Atualmente, oferecemos vários monitores OLED que utilizam o controlador US2066, disponíveis nos tamanhos2x16,2x20 e4x20, e em várias cores monocromáticas.

Os ecrãs OLED oferecem várias vantagens em relação aos LCDs tradicionais, incluindo:

• Imagens nítidas e vivas com elevadas relações de contraste.
• Qualidade de imagem consistente a partir de ângulos de visão amplos.
• Desempenho em vários ambientes devido à sua ampla faixa de temperatura.
• Menor consumo de energia, especialmente com cores escuras.
• Taxas de atualização superiores para imagens mais suaves com o mínimo de desfocagem de movimento.
• Perfil fino e leve.
• Precisão de cor superior e uma gama de cores mais ampla para uma experiência de visualização vibrante.

O que vai precisar

• Placa Arduino UNO
• OLED fino de 4x20 caracteres - NHD-0420CW-AB3 (pode ser adquirido com pinos pré-soldados)
• Fios de ligação
• Software Arduino IDE
• Conector de pinos de uma fila 1x20 (opcional se o OLED for adquirido com pinos pré-soldados)
• Placa de ensaio (opcional)

Você também pode seguir este tutorial com qualquer OLED semelhante que tenha o controlador US2066.

Recursos do tutorial

• Detalhes do produto OLED de 4x20 caracteres
• Folha de dados do produto OLED de 4x20 caracteres
• Ficha técnica do controlador US2066
• Descarregar Arduino IDE

Visão geral do controlador US2066: um controlador de IC para ecrã OLED

O US2066 é um circuito integrado (IC) de chip único que simplifica o acionamento de pequenos ecrãs OLED. Esta solução compacta e eficiente oferece imagens nítidas com alto contraste, ao mesmo tempo que minimiza o consumo de energia – ideal para dispositivos alimentados por bateria. Mas o US2066 oferece mais do que apenas portabilidade. A sua versatilidade se estende a uma variedade de resoluções, opções de energia e interfaces (incluindo I2C, SPI e Paralela). Essa flexibilidade torna-o adequado para aplicações além de dispositivos vestíveis e ecrãs industriais.

Características do US2066

• Design de chip único.
• Possui um oscilador integrado.
• Suporta várias resoluções de exibição: 1, 2, 3 ou 4 linhas com formato de 5x8 ou 6x8 pontos.
• Suporta múltiplas interfaces (I2C, SPI e paralela 6800/8080 de 4/8 bits).
• Baixo consumo de energia e opções de alimentação flexíveis.
• Controlo de contraste de 256 níveis.
• Ciclo de trabalho selecionável (1/8, 1/16, 1/24, 1/32).
• Suporta caracteres personalizados.
• Conjuntos de caracteres selecionáveis por software.
• Remapeamento de linhas e colunas.
• Caracteres com altura dupla.
• Todos os caracteres são exibidos invertidos.
• Permite a rolagem do texto nas direções esquerda e direita.
• Rolagem independente de linhas.
• Funcionalidade de fade in/out do protetor de ecrã.
• Permite inverter todos os caracteres no visor OLED.
• Quando a energia é ligada, ele reinicia automaticamente para garantir que esteja sempre em um estado conhecido.
• Suporta funcionalidades de fade in/out para poupar o ecrã.
• Possui frequência de quadros programável.
• Inclui um esquema inteligente de compensação de interferência para reduzir a interferência entre os pixels.
• Opera numa ampla gama de temperaturas de funcionamento: -40 °C a 85 °C.

Tabelas de comando US2066

O controlador US2066 possui três conjuntos de comandos diferentes, cada um fornecendo diferentes funções e opções de controlo para o ecrã OLED:

• Conjunto de comandos fundamentais: Este conjunto inclui comandos básicos para controlo do ecrã, tais como limpar o ecrã, definir a posição do cursor e controlar o estado ON/OFF do ecrã.
• Conjunto de comandos alargado: Estes comandos alargam a funcionalidade do visor, permitindo funcionalidades como a mudança bidirecional e o ajuste dos modos de visualização.
• Conjunto de comandos OLED: específico para o controlo OLED, este conjunto inclui comandos para ajustar o contraste, ativar/desativar a rolagem e configurar as características do ecrã.

Os conjuntos de comandos podem ser acedidos definindo os bits lógicos IS, RE e SD de acordo com o necessário. Cada comando nas tabelas especifica como esses bits devem ser definidos para garantir a configuração adequada.

Esquema e diagrama de ligações elétricas

Vamos começar a ligar tudo!

• A0 a A2 (Arduino) para os pinos 17 a 19 (OLED): Seleção da interface (vamos configurá-la para paralela através do código).
• D0 a D7 (Arduino) para os pinos 7 a 14 (OLED): Linhas de dados.
• D8 (Arduino) para o pino 4 (OLED): Sinal de seleção de dados/comando.
• D9 (Arduino) para o pino 5 (OLED): Sinal de seleção de leitura/gravação.
• D10 (Arduino) para o pino 6 (OLED): Sinal de ativação.
• D11 (Arduino) para o pino 15 (OLED): Sinal de seleção do chip.
• D12 (Arduino) para o pino 16 (OLED): Sinal de reinicialização.

Certifique-se de ligar também o terra (GND) do OLED e a fonte de alimentação de 3,3 V ao Arduino UNO.

Esquema OLED para Arduino UNO

Diagrama do Character Slim OLED para Arduino UNO

O diagrama Tinkercad abaixo fornece uma representação mais visual para ajudar nas ligações dos fios.

Caractere OLED - Código de exemplo do Arduino UNO

Usando o controlador US2066 no modo de interface paralela 8080 de 8 bits, o código a seguir inicializa e faz a interface de um Arduino Uno com um display OLED.

/*
* Newhaven Display invests time and resources providing this open source code,
* Please support Newhaven Display by purchasing products from Newhaven Display! 
*
* This code is provided as an example only and without any warranty by Newhaven Display. 
* Newhaven Display accepts no responsibility for any issues resulting from its use.
* The developer on the final application incorporating any parts of this 
* sample code is responsible for ensuring its safe and correct operation
* and for any consequences resulting from its use. 
* See the GNU General Public License for more details.
* Pin setup (Uses 3.3V Arduino Uno in 8-bit 8080 mode): DB0-DB7 connected to PORT D on UNO
*------------------------------
* Arduino        OLED Board   |
* GND          1  (VSS)       |
* 3.3V         2  (VDD)       |
* GND          3  (REGVDD)    |
* 8            4  (DC)        |
* 9            5  (WR)        |
* 10           6  (RD)        |
* 0            7  (DB0)       |
* 1            8  (DB1)       |
* 2            9  (DB2)       |
* 3            10 (DB3)       |
* 4            11 (DB4)       |
* 5            12 (DB5)       |
* 6            13 (DB6)       |
* 7            14 (DB7)       |
* 11           15 (CS)        |
* 12           16 (RES)       |
* A0           17 (BS0)       |
* A1           18 (BS1)       |
* A2           19 (BS2)       |
* GND          20 (VSS)       |
*------------------------------
*/
#define DC   8       //DC pin connected to Arduino digital pin 8
#define WR   9       //WR pin connected to Arduino digital pin 9
#define RD   10      //RD pin connected to Arduino digital pin 10
#define CS   11      //CS pin connected to Arduino digital pin 11
#define RES  12      //RES pin connected to Arduino digital pin 12
#define BS0  A0      //BS0 pin connected to Arduino Analog pin A0
#define BS1  A1      //BS1 pin connected to Arduino Analog pin A1
#define BS2  A2      //BS2 pin connected to Arduino Analog pin A2
void Init_OLED(){
  delay(1);          
  Command(0x2A);     // Function set (extended Command set)
  Command(0x71);     // Function selection A
  Data(0x00);        // Disable internal VDD regulator for 3.3V application
  Command(0x28);     // Function set (fundamental Command set)
  Command(0x08);     // Display off, cursor off, blink off
  Command(0x2A);     // Function set (extended Command set)
  Command(0x79);     // OLED Command set enabled 
  Command(0xD5);     // Set display clock divide ratio/oscillator frequency
  Command(0x70);     // Set display clock divide ratio/oscillator frequency
  Command(0x78);     // OLED Command set disabled
  Command(0x09);     // extended function set (4‐lines)
  Command(0x06);     // COM SEG direction
  Command(0x72);     // function selection B
  Data(0x03);        // ROM CGRAM selection
  Command(0x79);     // OLED Command set enabled
  Command(0xDA);     // Set SEG pins hardware configuration
  Command(0x10);     // Set SEG pins hardware configuration
  Command(0xDC);     // Function selection C
  Command(0x00);     // Function selection C
  Command(0x81);     // Set contrast control
  Command(0x7F);     // Set contrast control
  Command(0xD9);     // Set phase length
  Command(0xF1);     // Set phase length
  Command(0xDB);     // Set VCOMH deselect level
  Command(0x40);     // Set VCOMH deselect level
  Command(0x78);     // OLED Command set disabled
  Command(0x28);     // Function set (fundamental Command set)
  Command(0x01);     // Clear display
  delay(10);
  Command(0x80);     // Set DDRAM address to 0x00
  Command(0x0C);     // Display ON
  delay(10);         
}
void Command(unsigned char c){  // To send Commands
  PORTD=c;
  digitalWrite(DC,LOW);         // DC set to HIGH for Data
  delay(1);
  digitalWrite(WR,LOW);         // WR set to LOW for latching
  delay(1);
  digitalWrite(WR,HIGH);        // WR set to HIGH for latching
  delay(1);
}
void Data(unsigned char d){     // To send Data
  PORTD=d;
  digitalWrite(DC,HIGH);        // DC set to HIGH for Data
  delay(1);
  digitalWrite(WR,LOW);         // WR set to LOW for latching
  delay(1);
  digitalWrite(WR,HIGH);        // WR set to HIGH for latching
  delay(1);
}
void Set_contrast(unsigned char d){
Command(0x2A);                  // Set RE=1
Command(0x79);                  // Set SD=1
Command(0x81);                  // Set Contrast command 
Command(d);                     // Contrast level data
Command(0x78);                  // Set SD=0
Command(0x28);                  // Set RE=0
}
void Set_Scroll(int x){
Command(0x2A);                  // Set RE=1
Command(0x11);                  // Set DH' bit to enable shift
Command(0x28);                  // Set RE=0
Command(0x29);                  // Set IS=1
Command(0x2A);                  // Set RE=1
Command(0x1F);                  // Set lines to shift
Command(0x28);                  // Set RE=0 and IS=0
for(int i=0;i<x;i++){
  Command(0x1C);                // Shift right
  delay(130);                   // Control speed of shift
 }
}
void text1(){
Command(0xC0);                   // Brings The Cursor to Home Position
Command(0x80);                   // Clear Screen
for(int i=0; i<4;i++){
Data(0x20);              //Space
Data(0x4E);              //N
Data(0x65);              //e 
Data(0x77);              //w
Data(0x68);              //H
Data(0x61);              //a
Data(0x76);              //v
Data(0x65);              //e
Data(0x6E);              //n
Data(0x20);              //Space   
Data(0x44);              //D
Data(0x69);              //i
Data(0x73);              //s
Data(0x70);              //p
Data(0x6C);              //l
Data(0x61);              //a
Data(0x79);              //y
Data(0x21);              //!
Data(0x20);              //Space   
Data(0x20);              //Space
}
}
void setup() {
  DDRD=0xFF;                       // Set PORTD as output
  DDRB=0xFF;                       // Set PORTB as output
  pinMode(BS0,OUTPUT);      
  pinMode(BS1,OUTPUT);             // Interface selection pins
  pinMode(BS2,OUTPUT);
  digitalWrite(CS,LOW);            // CS Active LOW
  digitalWrite(RES,HIGH);          // Set RES HIGH
  digitalWrite(RD,HIGH);           // Set READ HIGH 
  digitalWrite(BS0,LOW);
  digitalWrite(BS1,HIGH);          // 8080 8-bit Parallel interface 
  digitalWrite(BS2,HIGH);
  Init_OLED();                     // Initialize OLED
  text1();                         // Display text
  delay(1200);                 
} 
void loop() {
  Set_Scroll(20);                  // Shift display one full rotation (20 Characters)
  delay(1000);
  Set_contrast(0x00);              // Set contrast Min
  delay(1200);
  Set_contrast(0x3C);              // Set contrast Medium
  delay(1200);
  Set_contrast(0xFF);              // Set contrast Max
  delay(1200);
}
	

Embora os comentários no código sejam úteis, aqui está uma breve explicação do que este código faz:

Definições dos pinos: O código define os pinos utilizados para a comunicação entre o Arduino e o ecrã OLED, incluindo DC (Dados/Comando), escrita, leitura, seleção de chip, reinicialização e pinos de seleção de interface de barramento.

Inicialização OLED: O Init_OLED A função inicializa o visor OLED enviando uma sequência de comandos para configurar as definições do visor, tais como contraste, modo de exibição e frequência do relógio.

Funções de comando e dados: O Comando e Dados As funções são utilizadas para enviar comandos e dados para o visor OLED.

Ajuste de contraste: O Definir_contraste A função permite ajustar o contraste do ecrã enviando os comandos e dados apropriados.

Rolagem de texto: O Definir_Rolagem A função permite a mudança de texto no visor, proporcionando uma maneira de rolar o texto pela tela.

Exibição de texto: O texto1 A função é responsável por escrever o texto «Newhaven Display!» no visor OLED, colocando o cursor na posição inicial com Command(0xC0);, limpando o ecrã com Command(0x80); e usando um loop para garantir que o texto seja escrito quatro vezes, uma vez para cada linha do visor.

Configuração e loop do Arduino: O configuração configura as portas do Arduino e inicializa o visor OLED, enquanto o loop A função demonstra continuamente os recursos de rolagem e ajuste de contraste.

Processo de ajuste do contraste OLED

O fluxograma abaixo descreve as etapas para ajustar o contraste em um ecrã OLED usando comandos específicos. O procedimento envolve mudar para um conjunto de comandos estendido, ativar comandos específicos para OLED, definir o nível de contraste desejado e, em seguida, redefinir para o conjunto de comandos padrão.

Efeito de deslocamento/rolagem de caracteres OLED

O fluxograma abaixo ilustra como ativar a mudança de caracteres (efeito de rolagem) no visor OLED. O processo inclui alternar entre conjuntos de comandos, ativar modos de mudança, configurar parâmetros de mudança e executar a mudança com tempo controlado.

Instruções para carregar e executar o código

1. Abra o Arduino IDE: Inicie o Ambiente de Desenvolvimento Integrado (IDE) do Arduino no seu computador.
2. Criar um novo esboço: Vá para Arquivo > Novo para abrir um novo esboço.
3. Copie e cole o código: Copie todo o código acima e cole-o no novo esboço.
4. Salvar o esboço: Guarde o esboço indo para Arquivo > Guardar.
5. Ligue o seu Arduino: Ligue o seu Arduino Uno ao computador usando um cabo USB.
6. Selecione a sua placa e porta:
   • Ir para Ferramentas > Quadro e selecione «Arduino Uno».
   • Ir para Ferramentas > Porta e selecione a porta à qual o seu Arduino está conectado.
7. Carregue o código: Clique no botão de carregamento (ícone de seta para a direita) na barra de ferramentas do Arduino IDE para compilar e carregar o código para o seu Arduino Uno.
8. Execute o código: Assim que o upload estiver concluído, o código será executado automaticamente no seu Arduino. Deverá ver o ecrã OLED inicializar e exibir o texto de amostra, juntamente com os recursos de ajuste de contraste e rolagem de texto.

Dicas para resolução de problemas

• Verifique a sua ligação: uma ligação incorreta é um dos problemas mais comuns durante a resolução de problemas. Verifique se os cabos de ligação estão ligados aos pinos corretos, seguindo o diagrama de ligação fornecido. Se tiver acesso a um multímetro, também pode verificar a continuidade entre os pinos (com a alimentação desligada). Os cabos de ligação podem avariar, por isso, mesmo quando ligados corretamente, pode não conseguir uma ligação adequada.
• Reinicie ou reflash o Arduino: também pode tentar reiniciar o Arduino usando o botão de reinicialização ou desligando e ligando novamente. Observe que interromper o processo de flash do Arduino pode corromper o programa. Ao carregar um programa para o seu Arduino, não desligue o dispositivo até ver a mensagem «Carregamento concluído».
• Verifique as tensões dos pinos: Se tiver acesso a um multímetro, use-o para verificar se o pino VDD está a receber a tensão adequada (3,3 V). Também pode verificar os pinos da interface para garantir que estão a ser definidos como Alto ou Baixo corretamente (use a ficha técnica do visor para opções de interface).
• Fonte de alimentação: Em alguns casos, alimentar o Arduino através do cabo de programação não fornecerá energia suficiente. Tente usar a tomada DC com uma fonte de alimentação adequada (7-12 V).
• Verifique se há danos físicos: inspecione o ecrã OLED para verificar se há danos físicos, como pinos ou traços quebrados.
• Verificar código: Se forem feitas quaisquer modificações no código, verifique se elas foram feitas corretamente. Ao usar comandos específicos das várias tabelas de comandos, verifique se está a retornar à tabela de comandos principal (Conjunto de Comandos Fundamentais) antes de tentar enviar dados para o visor.
• Diferentes modelos Arduino: Se estiver a tentar implementar este código com um modelo Arduino diferente, verifique se o nível lógico é 3,3 V. Também poderá ter de alterar quaisquer chamadas para portas específicas dentro do código, uma vez que estas variam de modelo para modelo.

Conclusão

O controlador US2066 de chip único oferece uma maneira simples e eficiente de integrar visuais de alta qualidade com excelentes recursos para muitas aplicações OLED de caracteres. Este tutorial ofereceu uma maneira fácil de começar, mas o US2066 oferece uma ampla gama de recursos além do que foi abordado aqui. Recomendamos que explore os recursos deste controlador para criar visuais incríveis para os seus projetos.