US2066 Tutorial: Zeichen-OLED mit Arduino

Wenn Sie daran interessiert sind, mit der Verwendung von Zeichen-OLED-Displays mit dem Controller-Chip US2066 zu beginnen, dann sind Sie hier genau richtig. Der All-in-One-Chip US2066 vereinfacht die Ansteuerung von OLED-Displays und macht den Einstieg für jedermann leicht, unabhängig vom Kenntnisstand. Ganz gleich, ob Sie an tragbaren Geräten, industriellen Instrumenten oder etwas dazwischen arbeiten, dieser Leitfaden vermittelt Ihnen das nötige Wissen, um das volle Potenzial von OLED-Displays mit dem US2066-Controller auszuschöpfen.

Übersicht über das Tutorial

In diesem Tutorial werden wir einige wichtige Funktionen des US2066-OLED-Controllers untersuchen und hervorheben. Wir werden auch die Verkabelung des Displays behandeln und Beispielcode bereitstellen, der Ihnen den Einstieg in die Einrichtung Ihres OLED mit Arduino erleichtert, einschließlich der Anzeige von Text, der Anpassung des Kontrasts und der Durchführung von Zeichenverschiebungen.

Der US2066-Controller ist das Herzstück einer Vielzahl unserer OLED-Displays. Derzeit bieten wir mehrere OLED-Displays mit dem US2066-Controller an, die in den Größen2x16,2x20 bis4x20 und in verschiedenen Monochrom-Farben erhältlich sind.

OLED-Displays bieten gegenüber herkömmlichen LCDs mehrere Vorteile, darunter:

• Scharfe, lebendige Bilder mit hohen Kontrastverhältnissen.
• Gleichbleibende Bildqualität aus weiten Blickwinkeln.
• Leistung in verschiedenen Umgebungen aufgrund ihres breiten Temperaturbereichs.
• Geringerer Stromverbrauch, insbesondere bei dunklen Farben.
• Überragende Bildwiederholraten für flüssigere Bilder mit minimaler Bewegungsunschärfe.
• Dünnes, leichtes Profil.
• Überragende Farbgenauigkeit und ein breiterer Farbraum für ein lebendiges Seherlebnis.

Was Sie benötigen

• Arduino UNO-Platine
• 4x20 Zeichen Slim OLED – NHD-0420CW-AB3 (kann mit vorverlöteten Pins erworben werden)
• Überbrückungsdrähte
• Arduino IDE-Software
• 1x20 einreihiger Stiftleistenverbinder (optional, wenn das OLED mit vorverlöteten Stiften gekauft wird)
• Steckbrett (optional)

Sie können diese Anleitung auch mit jedem ähnlichen OLED-Display befolgen, das über den US2066-Controller verfügt.

Tutorial-Ressourcen

• 4x20 Zeichen OLED Produktdetails
• 4x20 Zeichen OLED-Produktdatenblatt
• Datenblatt zum Controller US2066
• Arduino IDE herunterladen

Übersicht über den Controller US2066: Ein OLED-Display-IC-Controller

Der US2066 ist ein integrierter Ein-Chip-Schaltkreis (IC), der die Ansteuerung kleiner OLED-Displays vereinfacht. Diese kompakte und effiziente Lösung liefert scharfe Bilder mit hohem Kontrast bei minimalem Stromverbrauch – ideal für batteriebetriebene Geräte. Der US2066 bietet jedoch mehr als nur Mobilität. Seine Vielseitigkeit erstreckt sich auf eine Reihe von Auflösungen, Stromversorgungsoptionen und Schnittstellen (einschließlich I2C, SPI und Parallel). Dank dieser Flexibilität eignet er sich auch für Anwendungen außerhalb von Wearables und industriellen Displays.

US2066 Funktionen

• Ein-Chip-Design.
• Verfügt über einen integrierten Oszillator.
• Unterstützt verschiedene Bildschirmauflösungen: 1, 2, 3 oder 4 Zeilen mit 5x8 oder 6x8 Punktformat.
• Unterstützt mehrere Schnittstellen (I2C, SPI und 4/8-Bit-6800/8080-Parallel).
• Geringer Stromverbrauch und flexible Stromversorgungsoptionen.
• 256-stufige Kontrastregelung.
• Wählbarer Arbeitszyklus (1/8, 1/16, 1/24, 1/32).
• Unterstützt benutzerdefinierte Zeichen.
• Per Software wählbare Zeichensätze.
• Neuzuordnung von Zeilen und Spalten.
• Zeichen mit doppelter Höhe.
• Alle Zeichen werden seitenverkehrt angezeigt.
• Ermöglicht das Scrollen von Text sowohl nach links als auch nach rechts.
• Unabhängiges Zeilen-Scrollen.
• Bildschirmschoner-Ein-/Ausblendfunktion.
• Ermöglicht die Umkehrung aller Zeichen auf dem OLED-Display.
• Wenn die Stromversorgung eingeschaltet wird, wird es automatisch zurückgesetzt, um sicherzustellen, dass es sich immer in einem bekannten Zustand befindet.
• Unterstützt Bildschirmschoner-Ein-/Ausblendfunktionen.
• Verfügt über programmierbare Bildfrequenz.
• Enthält ein intelligentes Verfahren zur Kompensation von Übersprechen, um das Übersprechen zwischen Pixeln zu reduzieren.
• Arbeitet in einem breiten Betriebstemperaturbereich: -40 °C bis 85 °C.

US2066 Befehlstabellen

Der Controller US2066 verfügt über drei verschiedene Befehlssätze, die jeweils unterschiedliche Funktionen und Steuerungsoptionen für das OLED-Display bieten:

• Grundlegende Befehlssatz: Dieser Satz enthält grundlegende Befehle für die Steuerung der Anzeige, wie z. B. das Löschen der Anzeige, das Einstellen der Cursorposition und das Steuern des Ein-/Aus-Zustands der Anzeige.
• Erweiterter Befehlssatz: Diese Befehle erweitern die Funktionalität des Displays und ermöglichen Funktionen wie bidirektionales Verschieben und Anpassen von Anzeigemodi.
• OLED-Befehlssatz: Dieser Befehlssatz ist speziell für die OLED-Steuerung vorgesehen und umfasst Befehle zum Einstellen des Kontrasts, zum Aktivieren/Deaktivieren des Bildlaufs und zum Konfigurieren der Anzeigeeigenschaften.

Auf die Befehlssätze kann durch entsprechendes Setzen der Logikbits IS, RE und SD zugegriffen werden. Jeder Befehl in den Tabellen gibt an, wie diese Bits gesetzt werden müssen, um eine korrekte Konfiguration zu gewährleisten.

Schaltplan und Diagramm

Fangen wir mit der Verkabelung an!

• A0 bis A2 (Arduino) zu Pins 17 bis 19 (OLED): Schnittstellenauswahl (wir stellen sie per Code auf parallel ein).
• D0 bis D7 (Arduino) an Pins 7 bis 14 (OLED): Datenleitungen.
• D8 (Arduino) zu Pin 4 (OLED): Daten-/Befehlsauswahlsignal.
• D9 (Arduino) zu Pin 5 (OLED): Lese-/Schreib-Auswahlsignal.
• D10 (Arduino) zu Pin 6 (OLED): Aktivierungssignal.
• D11 (Arduino) zu Pin 15 (OLED): Chipauswahlsignal.
• D12 (Arduino) zu Pin 16 (OLED): Reset-Signal.

Stellen Sie sicher, dass Sie auch die Masse (GND) und die 3,3-V-Stromversorgung des OLED mit dem Arduino UNO verbinden.

OLED zu Arduino UNO Schaltplan

Charakter Slim OLED zu Arduino UNO Diagramm

Das folgende Tinkercad-Diagramm bietet eine anschaulichere Darstellung, die Ihnen bei den Verkabelungsanschlüssen hilft.

Zeichen-OLED – Arduino UNO Beispielcode

Unter Verwendung des US2066-Controllers im 8-Bit-8080-Parallelschnittstellenmodus initialisiert und verbindet der folgende Code einen Arduino Uno mit einem OLED-Display.

/*
* 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);
}
	

Obwohl die Kommentare im Code hilfreich sind, hier eine kurze Erklärung, was dieser Code bewirkt:

Pin-Definitionen: Der Code definiert die Pins, die für die Kommunikation zwischen dem Arduino und dem OLED-Display verwendet werden, darunter DC (Daten/Befehl), Schreiben, Lesen, Chipauswahl, Zurücksetzen und Bus-Schnittstellenauswahl-Pins.

OLED-Initialisierung: Das Init_OLED Die Funktion initialisiert das OLED-Display, indem sie eine Reihe von Befehlen sendet, um die Displayeinstellungen wie Kontrast, Anzeigemodus und Taktfrequenz zu konfigurieren.

Befehls- und Datenfunktionen: Das Befehl und Daten Funktionen werden verwendet, um Befehle und Daten an das OLED-Display zu senden.

Kontrastanpassung: Das Kontrast einstellen Die Funktion ermöglicht die Anpassung des Bildschirmkontrasts durch Senden der entsprechenden Befehle und Daten.

Text-Scrollen: Das Set_Scroll Die Funktion ermöglicht die Textverschiebung auf dem Display und bietet so eine Möglichkeit, Text über den Bildschirm zu scrollen.

Textanzeige: Das Text1 Die Funktion ist dafür verantwortlich, den Text „Newhaven Display!“ auf das OLED-Display zu schreiben, indem sie den Cursor mit Command(0xC0); an die Ausgangsposition bringt, den Bildschirm mit Command(0x80); löscht und mithilfe einer Schleife sicherstellt, dass der Text viermal geschrieben wird, einmal für jede Zeile des Displays.

Arduino-Einrichtung und Schleife: Das Einrichtung Die Funktion konfiguriert die Ports des Arduino und initialisiert das OLED-Display, während die Schleife Die Funktion demonstriert kontinuierlich die Funktionen zum Scrollen und zur Kontrasteinstellung.

OLED-Kontrastanpassungsprozess

Das folgende Flussdiagramm zeigt die Schritte zum Einstellen des Kontrasts auf einem OLED-Display mithilfe spezifischer Befehle. Der Vorgang umfasst das Umschalten auf einen erweiterten Befehlssatz, das Aktivieren von OLED-spezifischen Befehlen, das Einstellen der gewünschten Kontraststufe und das anschließende Zurücksetzen auf den Standardbefehlssatz.

OLED-Zeichenverschiebung/Bildlauf-Effekt

Das folgende Flussdiagramm veranschaulicht, wie die Zeichenverschiebung (Scroll-Effekt) auf dem OLED-Display aktiviert wird. Der Vorgang umfasst das Umschalten zwischen Befehlssätzen, das Aktivieren von Verschiebungsmodi, das Konfigurieren von Verschiebungsparametern und das Ausführen der Verschiebung mit kontrolliertem Timing.

Anweisungen zum Hochladen und Ausführen des Codes

1. Arduino IDE öffnen: Starten Sie die integrierte Entwicklungsumgebung (IDE) von Arduino auf Ihrem Computer.
2. Neue Skizze erstellen: Gehen Sie zu Datei > Neu um eine neue Skizze zu öffnen.
3. Kopieren und Einfügen des Codes: Kopieren Sie den gesamten obigen Code und fügen Sie ihn in den neuen Sketch ein.
4. Speichern Sie die SkizzeSpeichern Sie die Skizze, indem Sie zu Datei > Speichern.
5. Schließen Sie Ihr Arduino an: Verbinden Sie Ihr Arduino Uno über ein USB-Kabel mit Ihrem Computer.
6. Wählen Sie Ihr Board und Ihren Port aus:
   • Gehen Sie zu Werkzeuge > Tafel und wählen Sie „Arduino Uno“.
   • Gehen Sie zu Extras > Port und wählen Sie den Anschluss aus, an den Ihr Arduino angeschlossen ist.
7. Code hochladen: Klicken Sie auf die Schaltfläche „Hochladen“ (Pfeil-nach-rechts-Symbol) in der Symbolleiste der Arduino IDE, um den Code zu kompilieren und auf Ihren Arduino Uno hochzuladen.
8. Code ausführen: Sobald der Upload abgeschlossen ist, wird der Code automatisch auf Ihrem Arduino ausgeführt. Das OLED-Display sollte initialisiert werden und den Beispieltext anzeigen, zusammen mit den Funktionen zur Kontrasteinstellung und zum Scrollen des Textes.

Tipps zur Fehlerbehebung

• Überprüfen Sie Ihre Verkabelung: Eine falsche Verkabelung ist eines der häufigsten Probleme bei der Fehlersuche. Überprüfen Sie anhand des mitgelieferten Schaltplans, ob Ihre Überbrückungskabel an den richtigen Pins angeschlossen sind. Wenn Sie Zugang zu einem Multimeter haben, können Sie auch die Durchgängigkeit zwischen den Pins überprüfen (bei ausgeschaltetem Gerät). Überbrückungskabel können defekt sein, sodass selbst bei korrekter Verkabelung möglicherweise keine ordnungsgemäße Verbindung hergestellt werden kann.
• Arduino zurücksetzen oder neu flashen: Sie können auch versuchen, den Arduino mit der Reset-Taste zurückzusetzen oder einen Neustart durchzuführen. Beachten Sie, dass eine Unterbrechung des Arduino-Flash-Vorgangs zu einer Beschädigung des Programms führen kann. Wenn Sie ein Programm auf Ihren Arduino hochladen, ziehen Sie das Gerät nicht vom Stromnetz, bevor die Meldung „Done Uploading“ (Hochladen abgeschlossen) angezeigt wird.
• Pin-Spannungen überprüfen: Wenn Sie Zugang zu einem Multimeter haben, überprüfen Sie damit, ob Ihr VDD-Pin die richtige Spannung (3,3 V) erhält. Sie können auch Ihre Schnittstellen-Pins überprüfen, um sicherzustellen, dass diese richtig auf High oder Low gesetzt sind (verwenden Sie das Display-Datenblatt für Schnittstellenoptionen).
• Stromversorgung: In einigen Fällen reicht die Stromversorgung des Arduino über das Programmierkabel nicht aus. Versuchen Sie, den Gleichstromanschluss mit einer geeigneten Stromversorgung (7–12 V) zu verwenden.
• Auf physische Schäden prüfen: Untersuchen Sie das OLED-Display auf physische Schäden wie gebrochene Pins oder Leiterbahnen.
• Code überprüfen: Wenn Änderungen am Code vorgenommen werden, überprüfen Sie, ob diese korrekt ausgeführt wurden. Wenn Sie bestimmte Befehle aus den verschiedenen Befehlstabellen verwenden, überprüfen Sie, ob Sie zur Hauptbefehlstabelle (Fundamental Command Set) zurückkehren, bevor Sie versuchen, Daten an das Display zu senden.
• Verschiedene Arduino-Modelle: Wenn Sie versuchen, diesen Code mit einem anderen Arduino-Modell zu implementieren, überprüfen Sie, ob der Logikpegel 3,3 V beträgt. Möglicherweise müssen Sie auch alle Aufrufe bestimmter Ports innerhalb des Codes ändern, da diese von Modell zu Modell variieren.

Schlussfolgerung

Der Ein-Chip-Controller US2066 bietet eine einfache und effiziente Möglichkeit, hochwertige Grafiken mit hervorragenden Funktionen für viele OLED-Anwendungen mit Zeichen zu integrieren. Dieses Tutorial bot Ihnen einen einfachen Einstieg, aber der US2066 bietet eine Vielzahl von Funktionen, die über die hier behandelten hinausgehen. Wir empfehlen Ihnen, die Möglichkeiten dieses Controllers zu erkunden, um beeindruckende Grafiken für Ihre Projekte zu erstellen.