Se siete interessati a iniziare a caratterizzare i display OLED utilizzando il chip controller US2066, siete nel posto giusto. Il chip all-in-one US2066 semplifica il pilotaggio dei display OLED e consente a chiunque di iniziare a lavorare, indipendentemente dal proprio livello di competenza. Sia che stiate lavorando su dispositivi portatili, strumenti industriali o qualsiasi altra cosa, questa guida vi fornirà le conoscenze necessarie per sbloccare il pieno potenziale dei display OLED con il controller US2066.

Panoramica del tutorial

In questa esercitazione esploreremo ed evidenzieremo alcune caratteristiche chiave del controller OLED US2066. Verrà inoltre illustrato come cablare il display e verrà fornito un codice di esempio per iniziare a configurare l'OLED con Arduino, compreso il modo in cui visualizzare il testo, regolare il contrasto ed eseguire lo spostamento dei caratteri.

The US2066 controller is at the heart of a wide range of our  OLED displays. Currently, we offer several OLED displays using the US2066 controller, available in sizes from 2x16, 2x20, to 4x20, and in various monochrome colors.

I display OLED offrono diversi vantaggi rispetto ai tradizionali LCD, tra cui:

• Immagini nitide e vivide con un elevato rapporto di contrasto.
• Qualità dell'immagine costante da ampi angoli di visione.
• Prestazioni in vari ambienti grazie all'ampio intervallo di temperatura.
• Consumo energetico ridotto, soprattutto con i colori scuri.
• Frequenza di aggiornamento superiore per una visione più fluida con un minimo di sfocatura del movimento.
• Profilo sottile e leggero.
• Precisione del colore superiore e una gamma cromatica più ampia per un'esperienza visiva vibrante.

Cose che vi serviranno

• Scheda Arduino UNO
• OLED sottile 4x20 caratteri - NHD-0420CW-AB3 (può essere acquistato con pin pre-saldati)
• Fili di ponticello
• Software Arduino IDE
• Connettore header 1x20 a fila singola (opzionale se l'OLED viene acquistato con pin pre-saldati)
• Lavagna per pane (opzionale)

È possibile seguire questa esercitazione anche con qualsiasi OLED simile dotato del controller US2066.

Risorse didattiche

• Dettagli del prodotto 4x20 Character OLED
• Scheda tecnica del prodotto OLED 4x20 caratteri
• Scheda tecnica del controllore US2066
• Scaricare l'IDE Arduino

Panoramica del controllore US2066: Un controllore IC per display OLED

The US2066 is a single-chip integrated circuit (IC) that simplifies driving small OLED displays. This compact and efficient solution delivers sharp visuals with high contrast, all while minimizing power consumption – ideal for battery-powered devices. But the US2066 offers more than just portability. Its versatility extends to a range of resolutions, power options, and interfaces (including  I2C, SPI, and Parallel). This flexibility makes it suitable for applications beyond wearables and industrial displays.

US2066 Caratteristiche

• Design a chip singolo.
• Dispone di un oscillatore incorporato.
• Supporta diverse risoluzioni di visualizzazione: 1, 2, 3 o 4 linee con formato 5x8 o 6x8 punti.
• Supporta più interfacce (I2C, SPI e parallela 6800/8080 a 4/8 bit).
• Basso consumo energetico e opzioni di alimentazione flessibili.
• Controllo del contrasto a 256 livelli.
• Ciclo di lavoro selezionabile (1/8, 1/16, 1/24, 1/32).
• Supporta i caratteri personalizzati.
• Set di caratteri selezionabili via software.
• Rimappatura di righe e colonne.
• Caratteri di font a doppia altezza.
• Tutti i caratteri vengono visualizzati al contrario.
• Consente lo scorrimento del testo sia a destra che a sinistra.
• Scorrimento indipendente delle righe.
• Funzione di dissolvenza in entrata/uscita dello schermo.
• Consente di invertire tutti i caratteri del display OLED.
• Quando viene alimentato, si resetta automaticamente per garantire che sia sempre in uno stato noto.
• Supporta le funzioni di dissolvenza in entrata e in uscita per il salvataggio dello schermo.
• Frequenza dei fotogrammi programmabile.
• Include uno schema di compensazione intelligente della diafonia per ridurre la diafonia tra i pixel.
• Funziona in un'ampia gamma di temperature operative: Da -40°C a 85°C.

Tabelle di comando US2066

Il controllore US2066 dispone di tre diversi set di comandi, ognuno dei quali fornisce diverse funzioni e opzioni di controllo per il display OLED:

• Set di comandi fondamentali: Questo set comprende i comandi di base per il controllo del display, come la cancellazione del display, l'impostazione della posizione del cursore e il controllo dello stato ON/OFF del display.
• Set di comandi estesi: Questi comandi estendono le funzionalità del display, consentendo di ottenere caratteristiche quali lo spostamento bidirezionale e la regolazione delle modalità di visualizzazione.
• Set di comandi OLED: Specifico per il controllo OLED, questo set comprende comandi per la regolazione del contrasto, l'abilitazione/disabilitazione dello scorrimento e la configurazione delle caratteristiche del display.

È possibile accedere ai set di comandi impostando di conseguenza i bit logici IS, RE e SD. Ogni comando nelle tabelle specifica come devono essere impostati questi bit per garantire una configurazione corretta.

Schema e diagramma di cablaggio

Cominciamo con il cablaggio!

• Da A0 a A2 (Arduino) ai pin 17-19 (OLED): Selezione dell'interfaccia (la imposteremo in parallelo tramite il codice).
• Da D0 a D7 (Arduino) ai pin da 7 a 14 (OLED): Linee dati.
• D8 (Arduino) al pin 4 (OLED): Segnale di selezione dati/comandi.
• D9 (Arduino) al pin 5 (OLED): Segnale di selezione lettura/scrittura.
• D10 (Arduino) al pin 6 (OLED): Segnale di abilitazione.
• D11 (Arduino) al pin 15 (OLED): Segnale di selezione del chip.
• D12 (Arduino) al pin 16 (OLED): Segnale di reset.

Assicurarsi di collegare anche la massa (GND) e l'alimentazione a 3,3 V dell'OLED ad Arduino UNO.

Schema da OLED ad Arduino UNO

Diagramma del personaggio Slim OLED ad Arduino UNO

Il diagramma di Tinkercad riportato di seguito fornisce una rappresentazione più visiva per facilitare i collegamenti di cablaggio.

Carattere OLED - Codice di esempio Arduino UNO

Utilizzando il controller US2066 in modalità interfaccia parallela 8080 a 8 bit, il codice seguente inizializza e interfaccia un Arduino Uno con un 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);
}
	

Anche se i commenti nel codice sono utili, ecco una breve spiegazione di ciò che fa questo codice:

Definizione dei pin: Il codice definisce i pin utilizzati per la comunicazione tra Arduino e il display OLED, compresi i pin DC (dati/comando), di scrittura, lettura, chip select, reset e selezione dell'interfaccia bus.

Inizializzazione OLED: Il Init_OLED La funzione inizializza il display OLED inviando una sequenza di comandi per configurare le impostazioni del display, come il contrasto, la modalità di visualizzazione e la frequenza di clock.

Funzioni di comando e dati: Il Comando e Dati vengono utilizzate per inviare comandi e dati al display OLED.

Regolazione del contrasto: Il Imposta_contrasto consente di regolare il contrasto del display inviando i comandi e i dati appropriati.

Scorrimento del testo: Il Imposta_Scroll consente di spostare il testo sul display e di farlo scorrere sullo schermo.

Visualizzazione del testo: Il testo1 è responsabile della scrittura del testo "Newhaven Display!" sul display OLED, portando il cursore nella posizione iniziale con Command(0xC0), cancellando lo schermo con Command(0x80) e utilizzando un ciclo per garantire che il testo venga scritto quattro volte, una per ogni riga del display.

Configurazione e loop di Arduino: Il impostazione configura le porte di Arduino e inizializza il display OLED, mentre la funzione anello dimostra continuamente le funzioni di scorrimento e di regolazione del contrasto.

Processo di regolazione del contrasto OLED

Il diagramma di flusso seguente illustra i passaggi per regolare il contrasto di un display OLED utilizzando comandi specifici. La procedura prevede il passaggio a un set di comandi esteso, l'abilitazione dei comandi specifici OLED, l'impostazione del livello di contrasto desiderato e il ripristino del set di comandi standard.

Effetto di spostamento/scorrimento dei caratteri OLED

Il diagramma di flusso seguente illustra come attivare lo spostamento dei caratteri (effetto di scorrimento) sul display OLED. Il processo comprende la commutazione tra i set di comandi, l'attivazione delle modalità di spostamento, la configurazione dei parametri di spostamento e l'esecuzione dello spostamento con tempistiche controllate.

Istruzioni per caricare ed eseguire il codice

1. Aprire l'IDE Arduino: Avviare l'ambiente di sviluppo integrato (IDE) Arduino sul computer.
2. Creare un nuovo schizzo: Vai a File > Nuovo per aprire un nuovo schizzo.
3. Copiare e incollare il codice: Copiare l'intero codice qui sopra e incollarlo nel nuovo schizzo.
4. Salva il disegno: Salvare lo schizzo andando su File > Salva.
5. Collegare Arduino: Collegare Arduino Uno al computer tramite un cavo USB.
6. Selezionare la scheda e il porto:
   • Vai a Strumenti > Scheda e selezionare "Arduino Uno".
   • Vai a Strumenti > Porta e selezionare la porta a cui è collegato Arduino.
7. Caricare il codice: Fare clic sul pulsante di caricamento (icona della freccia a destra) nella barra degli strumenti dell'IDE Arduino per compilare e caricare il codice su Arduino Uno.
8. Eseguire il codice: Una volta completato il caricamento, il codice verrà eseguito automaticamente su Arduino. Si dovrebbe vedere il display OLED inizializzarsi e visualizzare il testo di esempio, insieme alle funzioni di regolazione del contrasto e di scorrimento del testo.

Suggerimenti per la risoluzione dei problemi

• Verificare il cablaggio: Il cablaggio errato è uno dei problemi più comuni nella risoluzione dei problemi. Verificare che i cavi di collegamento siano collegati ai pin corretti seguendo lo schema di cablaggio fornito. Se si dispone di un multimetro, si può anche verificare la continuità tra i pin (con l'alimentazione disattivata). I cavi di collegamento possono guastarsi, per cui anche quando sono cablati correttamente, è possibile che non si riesca a stabilire un collegamento corretto.
• Resettare o riflashare Arduino: Si può anche provare a resettare Arduino utilizzando il pulsante di reset o eseguendo un ciclo di alimentazione. Si noti che l'interruzione del processo di flashing di Arduino può causare la corruzione del programma. Quando si carica un programma su Arduino, non scollegare il dispositivo finché non viene visualizzato il messaggio "Done Uploading".
• Controllare le tensioni dei pin: Se si dispone di un multimetro, utilizzarlo per verificare che il pin VDD riceva la tensione corretta (3,3 V). È inoltre possibile controllare i pin dell'interfaccia per verificare che siano impostati correttamente su alto o basso (utilizzare la scheda tecnica del display per le opzioni dell'interfaccia).
• Alimentazione: In alcuni casi, l'alimentazione di Arduino tramite il cavo di programmazione non è sufficiente. Provare a utilizzare la presa CC con un alimentatore appropriato (7-12 V).
• Verificare la presenza di danni fisici: Verificare che il display OLED non presenti danni fisici, come la rottura di pin o tracce.
• Verifica del codice: Se si apportano modifiche al codice, verificare che siano state eseguite correttamente. Quando si utilizzano comandi specifici dalle tabelle dei comandi multipli, verificare che si ritorni alla tabella dei comandi principali (Set di comandi fondamentali) prima di tentare di inviare dati al display.
• Modelli diversi di Arduino: Se si sta cercando di implementare questo codice con un modello diverso di Arduino, verificare che il livello logico sia di 3,3V. Potrebbe anche essere necessario modificare le chiamate a porte specifiche all'interno del codice, poiché queste variano da modello a modello.

Conclusione

Il controller a chip singolo US2066 offre un modo semplice ed efficiente per integrare immagini di alta qualità con caratteristiche eccellenti per molte applicazioni OLED a carattere. Questa esercitazione ha offerto un modo semplice per iniziare, ma l'US2066 offre un'ampia gamma di funzioni che vanno al di là di quanto trattato in questa sede. Vi invitiamo a esplorare le capacità di questo controller per creare immagini sorprendenti per i vostri progetti.