OLED I2C Display Arduino/NodeMCU Tutorial - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

Das allererste Programm, das Sie schreiben, wenn Sie anfangen zu lernen a

neue Programmiersprache ist: "Hello World!".

Das Programm selbst macht nichts weiter, als einen „Hello World“-Text auf den Bildschirm zu drucken.

Wie bringen wir also unser Arduino dazu, das "Hello World!" anzuzeigen?

In diesem Video zeige ich dir, wie du mit den kleinen 0,91 (128x32) und 0,96 (128x64) I2C OLED Displays loslegen kannst.

Es gibt Hunderte von Tutorials im Internet, die dasselbe auf unterschiedliche Weise erklären, aber ich konnte keins finden, das mir alles über das OLED-Display und seine Verwendung in verschiedenen Szenarien erklärt. Ich habe einige Zeit gebraucht, um das alles zu verarbeiten. Also dachte ich, ich sollte ein Tutorial zu dem, was ich gelernt habe, erstellen und alle Funktionen und Möglichkeiten kombinieren, die OLED-Displays in unseren Projekten verwenden können.

Schritt 1: Dinge, die wir heute lernen werden

In diesem Video sprechen wir über:

- Was ist ein OLED-Display?

- Dann schauen wir uns die 0,91 (128x32) und 0,96 (128x64) I2C OLED Displays genauer an

- Als nächstes werden wir über die Installation der Adafruit-Bibliothek in Ihrer Arduino-IDE sprechen

- Dann verbinden wir NodeMCU und Arduino mit einem OLED-Display

- Als nächstes schauen wir uns den Code an und zeigen einige Grafiken und Texte darauf an

- Wir werden auch über das Anwenden von benutzerdefinierten Schriftarten und das Anzeigen von Bildern sprechen

- Dann werden wir mehrere OLEDs mit einem I2C-Multiplexer an einen Mikrocontroller anschließen

- Schließlich werden wir über einige häufige Fehler sprechen, die Leute bei der Verwendung der OLED-Displays machen

Schritt 2: Hardware-Anforderung

Für dieses Tutorial benötigen wir:

- Ein Steckbrett

- Ein 0,91" (128x32) und 0,96" (128x64) I2C OLED-Display

- Arduino UNO/NANO (was auch immer praktisch ist)

- KnotenMCU

- TCA9548A I2C-Multiplexer

- Wenige Verbindungskabel

- und ein USB-Kabel zum Hochladen des Codes

Schritt 3: Was ist ein OLED-Display?

OLED oder organische Leuchtdiode ist eine lichtemittierende

Diode (LED), bei der die emittierende Elektrolumineszenzschicht ein Film aus einer organischen Verbindung (Millionen kleiner LED-Leuchten) ist, die als Reaktion auf einen elektrischen Strom Licht emittiert.

OLEDs werden verwendet, um digitale Anzeigen in Geräten wie Fernsehbildschirmen, Computermonitoren, tragbaren Systemen wie Mobiltelefonen, Handheld-Spielekonsolen und PDAs zu erstellen. Ein OLED-Display funktioniert ohne Hintergrundbeleuchtung, da es sichtbares Licht emittiert.

Schritt 4:

Es gibt viele Arten von OLED-Displays in der

Markt basierend auf ihrer

- Größen

- Farbe

- Marken

- Protokoll

- SPI (Serial Peripheral Interface) oder I2C

- Passiv-Matrix (PMOLED) oder Aktiv-Matrix (AMOLED) Steuerschema

In diesem Tutorial werde ich über das Verbinden der

blaue Farbe 0,91 (128x32 OLED) und 0,96 (128x64 OLED) I2C OLDE-Displays zu einem Arduino NANO und NodeMCU. Die I2C-Bus-Technologie verwendet nur 2 Pins der MCU, sodass wir Haufen für andere Sensoren zur Verfügung haben.

Schritt 5: Näherer Blick

Lassen Sie uns diese beiden Displays näher betrachten.

Auf der Rückseite dieser Displays sind haufenweise SMD-Kondensatoren und -Widerstände fest verlötet; Da es sich jedoch um ein I2C-Gerät handelt, kümmern wir uns nur um diese 2 Pins (SCL und SDA)

Das Display wird über nur vier Drähte mit Arduino verbunden – zwei für die Stromversorgung (VCC und GND) und zwei für die Daten (serielle Uhr SCL und

serielle Daten SDA), was die Verdrahtung sehr einfach macht. Die Datenverbindung ist I2C (I²C, IIC oder Inter-Integrated Circuit) und diese Schnittstelle wird auch TWI (Two Wire Interface) genannt.

- Die On-Board-Pins können in unterschiedlicher Reihenfolge sein, also immer dreifach überprüfen, bevor Sie es an Ihr Projekt anschließen.

- Die Betriebsspannung liegt zwischen 3 V und 5 V, am besten ist es jedoch, die Anleitung aus dem Datenblatt des Herstellers zu verwenden.

- Manchmal müssen wir in unseren Projekten 2 Displays verwenden. Wie können wir dies erreichen?

Der Trick besteht darin, eine konfigurierbare Adresse auf Ihrem Display zu haben. Dieses Gerät hat eine konfigurierbare Adresse zwischen 0x78 und 0x7A. Durch einfaches Ablöten des 0Ohm-Widerstands von einer Seite und Anschließen an die andere Seite oder durch Aufbringen eines globalen Lötmittels können wir die Adresse ändern. Wir werden ausführlich darüber sprechen, wenn wir im späteren Abschnitt dieses Tutorials mehrere Displays an ein Arduino anschließen.

Im Bild sehen diese Displays sehr groß aus. Aber praktisch gesehen sind sie winzig. Sie bestehen aus 128 x 32/64 einzelnen OLED-Pixeln und benötigen keine Hintergrundbeleuchtung. Schauen Sie sich das einfach an und sehen Sie, wie klein es ist. Obwohl sie klein sind, können sie in allen elektronischen Projekten sehr nützlich sein.

Schritt 6: Bibliothek

Es stehen mehrere Bibliotheken zur Verfügung, um diese zu steuern

zeigt an. In der Vergangenheit habe ich die "u8glib-Bibliothek" verwendet, aber ich finde die AdaFruit-Bibliothek sehr einfach zu verstehen und in unseren Projekten zu verwenden. Daher werde ich in diesem Tutorial die AdaFruit-Bibliothek verwenden.

Zur Steuerung des OLED-Displays benötigen Sie die Bibliothek "adafruit_GFX.h" und die Bibliothek "adafruit_SSD1306.h".

Es gibt zwei Möglichkeiten, die Bibliothek herunterzuladen und in Ihre Arduino-IDE zu installieren.

Methode 1

Gehen Sie zum "Bibliotheksmanager" und suchen Sie nach "adafruit_SSD1306" und "adafruit_gfx"

Wählen Sie die neueste Version aus und klicken Sie auf die Schaltfläche Installieren.

Nach der Installation können Sie diese Bibliotheken in Ihrem Programm verwenden.

Methode 2

Diese beiden Bibliotheken können auch von github heruntergeladen werden (Sie benötigen beide):

Ich werde die Links in der Beschreibung unten bereitstellen.

Die Display-Bibliothek:

Die GFX-Bibliothek:

Kopieren Sie nach dem Herunterladen den Ordner Adafruit_SSD1306-master aus der heruntergeladenen ZIP-Datei in den Arduino-Bibliotheksordner. Dieser Ordner befindet sich normalerweise unter Dokumente > Arduino > Bibliotheken auf Windows-Systemen. Unter Linux befindet es sich normalerweise im Home-Ordner > Arduino > Bibliotheken. Benennen Sie schließlich im Arduino-Bibliotheksordner den Ordner Adafruit_SSD1306-master in Adafruit_SSD1306 um. Auch wenn Sie nicht umbenennen, ist das in Ordnung.

Schritt 7:

Schauen wir uns nun die "Adafruit_SSD1306.h" an.

Datei

Zwei Dinge, die wir in dieser Bibliothek wissen müssen:

1. Wenn Sie die kleinere Anzeige verwenden möchten, verwenden Sie die Standardeinstellung 128_32, ansonsten kommentieren Sie für die größere Anzeige die 128_32 und entkommentieren Sie die 128_64

2. Wenn Sie die 0x7A-Adresse auf der Platine gelötet haben (über die wir später sprechen werden), dann verwenden Sie die 7-Bit 0x3D-Adresse für die größeren Displays, ansonsten verwenden Sie die Standardadresse 0x3C. Für die kleineren Displays lautet die Adresse 0x3C.

Schritt 8: Verdrahtung von 128 X 64/32 OLEDs

Beginnen wir mit dem Verbinden der NodeMCU mit dem Display.

Das erste und wichtigste zu beachten ist, dass bei einigen der Displays die GND- und VCC-Power-Pins vertauscht sein können. Überprüfen Sie Ihre Anzeige, um sicherzustellen, dass sie mit dem Bild übereinstimmt. Wenn die Pins vertauscht sind, stellen Sie sicher, dass Sie die Verbindungen zum Arduino oder NodeMCU ändern.

- NodeMCU OLED-Verkabelung

OLED VCC – NodeMCU 3.3V

OLED GND – NodeMCU GND

OLED SCL – NodeMCU D1

OLED-SDA – NodeMCU D2

- Arduino Uno OLED-Verkabelung

OLED-VCC – Arduino 5V

OLED GND – Arduino GND

OLED-SCL – Arduino Uno A5

OLED-SDA – Arduino Uno A4

- Arduino MEGA 2560 OLED-Verkabelung

OLED-VCC – Arduino 5V

OLED-GND – Arduino-GND

OLED SCL – Arduino MEGA 2560 Pin 21

OLED SDA – Arduino MEGA 2560 Pin 20

Schritt 9: Code

Die Adafruit-Bibliothek enthält wirklich gute Beispiele für beides

128x32- und 128x64-Anzeigen.

Die Bibliothek befindet sich unter Datei > Beispiele > Adafruit SSD1306 > und dann der Anzeigetyp in der Arduino IDE.

Wir werden das 128x32 I2C-Beispiel verwenden und es so modifizieren, dass es sowohl mit 128x64- als auch 128x32-Displays funktioniert, indem wir es zunächst an ein Arduino und dann an ein NodeMCU-Board anschließen.

Der Code beginnt mit der Einbeziehung beider Adafruit-Bibliotheken. In diesem Tutorial werde ich nur die Teile des Codes betonen, die für das Laden auf Boards und Displays erforderlich sind. Wenn Sie mehr über den Code erfahren möchten, hinterlassen Sie bitte einen Kommentar in meinem Blog oder im Kommentarbereich unten und ich bemühe mich, Sie zu kontaktieren.

- Zuerst werden wir den Code auf einen Arduino Nano laden, der mit einem 128x32-Display verbunden ist.

Wir können den Code unverändert verwenden.

128x32 verwendet die 0x3C-Adresse, also sieht dieses Bit hier gut aus. Lassen Sie uns die Header-Bibliothek überprüfen, ja, es wird auch die 0x3C-Adresse verwendet und der Anzeigetyp ist 128x32.

- Jetzt können wir das 128x64-Display anschließen. Wie wir wissen, verwendet es standardmäßig die 0x3C-Adresse, sodass wir die Adresse weder im Code noch in der Bibliothek aktualisieren müssen.

Wir müssen nur 128_32 kommentieren und 128_64 in der Header-Bibliothek auskommentieren und LCDHEIGHT in unserem Code auf 64 ändern.

- Um nun den gleichen Code auf einer NodeMCU auszuführen, müssen wir eine weitere Zeile in unserem Code ändern.

Der Rest des Codes "#define OLED_RESET 4"> "#define OLED_RESET LED_BUILTIN" ist derselbe wie bei Arduino

So ziemlich um alles anzuzeigen, was wir zuerst brauchen, um den vorherigen Bildschirm mit zu löschen

display.clearDisplay(); // Löschen Sie den Puffer

Dann zeichne das Objekt

testdrawline(); // Zeichne eine Linie

Zeigen Sie es auf der Hardware

display.display(); // Auf der Display-Hardware sichtbar machen!

Warten Sie einige Zeit, bevor Sie das nächste Element anzeigen.

Verzögerung (2000); // 2 Sekunden warten

In diesem Beispiel zeigen wir einige Elemente wie Text, Linien, Kreise, Lauftext, Dreiecke und mehr an. Lassen Sie Ihrer Fantasie freien Lauf und zeigen Sie auf diesen winzigen Displays, was immer Sie wollen.

Schritt 10: Text anpassen und Bilder hinzufügen

Manchmal muss Ihr Code benutzerdefinierte Schriftarten anzeigen und

Bilder. Wenn Sie sehr gut im Bit-Mapping sind, müssen Sie nur ein Byte-Array erstellen, indem Sie die winzigen LEDs des Displays ein- oder ausschalten, um benutzerdefinierte Schriftarten und Bilder zu erstellen.

Ich bin jedoch nicht sehr gut in diesen Zuordnungen und möchte nicht stundenlang damit verbringen, die Bitmap-Tabellen zu erstellen.

Also, was sind meine Optionen? Ich verwende im Allgemeinen zwei Websites, um benutzerdefinierte Schriftarten und Bilder zu generieren. Die Links sind in der Beschreibung unten angegeben.

Benutzerdefinierte Schriftarten

Gehen Sie zur Website des Schriftartkonverters, wählen Sie die Schriftartfamilie, den Stil, die Größe und die Bibliotheksversion als "Adafruit GFX Font" aus und klicken Sie dann auf die Schaltfläche "Erstellen". Auf der rechten Seite dieser Seite können Sie sehen, wie Ihre Schriftart auf dem tatsächlichen Display aussehen wird.

Basierend auf Ihrer Auswahl generiert die Webseite die Fonts-Header-Datei. Erstellen Sie eine Datei namens "modified_font.h" im selben Ordner, in dem sich Ihr Code befindet, und kopieren und speichern Sie den generierten Code darin. Dann müssen Sie nur die Header-Datei in Ihren Code einfügen, um die benutzerdefinierte Schriftart zu verwenden.

#include "modified_font.h"

Dann müssen Sie nur noch die Schriftart einstellen, bevor Sie den Text anzeigen, um die benutzerdefinierte Schriftart darauf anzuwenden.

display.setFont(&Ihr_Fonts_Name);

Sie können den Namen der Schriftart aus der Header-Datei abrufen, die Sie gerade zu Ihrem Projekt hinzugefügt haben. Das ist es, einfach.

Bei der Verwendung benutzerdefinierter Schriftarten ist der Arbeitsspeicher immer ein Problem. Berücksichtigen Sie daher immer die Bytes, die vom Arbeitsspeicher verbraucht werden. Denken Sie daran, dass Arduino UNO nur 32 KB Speicher hat.

Benutzerdefinierte Bilder

Um ein Bitmap-Bild auf Ihrem Bildschirm anzuzeigen, müssen Sie zunächst ein Bild in der Größe 128 x 64/32 erstellen.

Ich verwende das gute alte "MS Paint", um ein 128 x 64 Bitmap-Bild zu erstellen, das ich dann auf diese Bildkonverter-Website hochladen werde. Die Website wandelt Bilder in Byte-Strings um, die mit Arduino- und OLED-Displays verwendet werden können.

Beginnen Sie mit dem Hochladen des Bildes auf die Website. Aktivieren Sie dann das Kontrollkästchen "Bildfarben invertieren" und ändern Sie das "Ausgabecodeformat" in "Arduino-Code". Wählen Sie dann die Ausrichtung aus und klicken Sie auf die Schaltfläche "Code generieren", um das Byte-Array zu generieren. Der Abschnitt "Vorschau" zeigt Ihnen, wie Ihr Bild auf der tatsächlichen Anzeige aussehen wird.

Ich habe den Code zusammen mit diesem Tutorial eingefügt, mit dem Sie Ihre Bilder anzeigen können. Sie müssen nur das Array in meinem Code durch das gerade generierte ersetzen und dann auf Ihr Arduino laden.

Schritt 11: Anschließen von 2 Displays

Das Anschließen von zwei 128 x 64-Displays an Ihr Projekt ist einfach.

Sie müssen nur den 0Ohm-Widerstand von der 0x78-Adresse ablöten und auf 0x7A setzen und dann die 0x3D-Adresse in Ihrem Code anstelle des Standard 0x3C verwenden.

Sie fragen sich sicher, warum wir die 0x3C- und 0x3D-Adressen verwenden und nicht die tatsächlichen 0x78 und 0x7A. Arduino akzeptiert 7-Bit-Adressen und nicht die 8-Bit-Hardwareadressen. Wir müssen also zuerst die 8-Bit-Adresse in binär umwandeln und dann das niedrigstwertige Bit abschneiden, um die 7 Bits zu erhalten. Konvertieren Sie dann die 7 Bit in HEX, um die 0x3C- oder 0x3D-Adressen zu erhalten, die Sie in Ihren Code eingeben.

Initialisieren Sie zunächst die Anzeige, indem Sie ihr einen eindeutigen Namen geben:

Adafruit_SSD1306 display1(OLED_REST);

Adafruit_SSD1306 display2 (OLED_REST);

Verwenden Sie dann in Ihrem Code die Anzeige 1 und Anzeige 2, um die begin-Anweisungen mit den darin enthaltenen Geräteadressen aufzurufen:

display1.begin (SSD1306_SWITCHCAPVCC, 0x3C); // Anzeige 1 Op-Adresse 0x3C

display2.begin(SSD1306_SWITCHCAPVCC, 0x3D); // Anzeige 2 Op-Adresse 0x3D

Das war's, Sie können jetzt fortfahren und tun, was Sie wollen, indem Sie entweder Display 1 oder Display 2 im Rest Ihres Codes verwenden. Ich habe ein Beispiel mit diesem Tutorial bereitgestellt.

Die Verkabelung ist genau die gleiche wie zuvor, Sie müssen nur ein weiteres Display zu den gleichen I2C-Pins von Arduino oder NodeMCU hinzufügen. Basierend auf den Adressen sendet die MCU dann die Daten auf der I2C-Datenleitung.

Schritt 12: Anschließen von mehr als 2 Displays

Was ist nun, wenn Sie mehr als 2 Displays anschließen möchten?

Arduino hat eine begrenzte Anzahl von Pins und daher können Sie nicht mehr als eine bestimmte Anzahl von Abschirmungen daran befestigen. Außerdem hat es nur ein Paar I2C-Busse.

Wie können wir also mehr als 2 I2C-Displays an einen Arduino anschließen? Der Trick besteht darin, einen TCA9548-Multiplexer zu verwenden.

TCA9548 ermöglicht es einem einzelnen Mikrocontroller, mit bis zu '64 Sensoren' zu kommunizieren, die alle dieselbe oder eine andere I2C-Adresse haben, indem jedem Sensor-Slave-Subbus ein eindeutiger Kanal zugewiesen wird.

Wenn wir über das Senden von Daten über 2 Drähte an mehrere Geräte sprechen, müssen wir sie adressieren. Es ist das gleiche wie der Postbote, der auf einer einzigen Straße kommt und die Postpakete zu verschiedenen Häusern abgibt, weil sie unterschiedliche Adressen darauf haben.

Der Multiplexer wird an die 3V3-, GND-, SDA- und SCL-Leitungen des Mikrocontrollers angeschlossen. Die Slave-Sensoren werden an einen von acht SCL/SDA-Slave-Ports auf der Platine angeschlossen. Die Kanäle werden ausgewählt, indem dem TCA9548A seine I2C-Adresse (0x70 {default} - 0x77) gefolgt von der Kanalnummer (0b00000001 - 0b10000000) gesendet wird. Sie können maximal 8 dieser Multiplexer auf 0x70-0x77-Adressen miteinander verbunden haben, um 64 der gleichen I2C-adressierten Teile zu steuern. Durch Verbinden der drei Adressbits A0, A1 und A2 mit VIN können Sie verschiedene Kombinationen der Adressen erhalten. Ich werde dies in meinem nächsten Tutorial zum Breakout-Board TCA9548A ausführlich erklären. Lassen Sie uns für den Moment einfach 8 OLEDs an dieses Board anschließen und einen kurzen Blick auf den Code werfen.

Verbindung:

Fahrgestellnummer bis 5V (oder 3,3V)

GND an Masse

SCL zu I2C-Takt

SDA-zu-I2C-Daten

Verdrahten Sie dann die Sensoren mit VIN, GND und verwenden Sie einen der SCn / SDn-Multiplex-Busse

Nun beginnt der Code mit Int, indem die "Wire"-Bibliothek aufgenommen und die Multiplexer-Adresse definiert wird.

#include "Wire.h"

#enthalten

#define MUX_Address 0x70 // TCA9548A Encoder-Adresse

Dann müssen wir den Port auswählen, mit dem wir kommunizieren möchten, und die Daten mit dieser Funktion senden:

void tcaselect(uint8_t i) {

wenn (i > 7) Rückkehr;

Wire.beginTransmission(MUX_Address);

Wire.write(1 << i);

Wire.endTransmission();

}

Als nächstes initialisieren wir die Anzeige im Setup-Abschnitt, indem wir "u8g.begin();" aufrufen. für jede an den MUX angeschlossene Anzeige "tcaselect(i);"

Nach der Initialisierung können wir dann tun, was wir wollen, indem wir einfach die Funktion "tcaselect(i);" aufrufen. wobei "i" der Wert des gemultiplexten Busses ist und dann die Daten und der Takt entsprechend gesendet werden.

Schritt 13: Vor- und Nachteile

Das Bild einer OLED ist schön. OLEDs haben aber auch

Nachteile. Da OLED-Bildschirme organisches Material enthalten, ist ihre Lebensdauer kürzer als bei LCD-Displays. Darüber hinaus kommt es bei vielen OLED-Displays zu Einbrennvorgängen, wenn das gleiche Bild längere Zeit angezeigt wird. Nach einem Einbrennen bleibt das Bild auf dem Bildschirm, auch wenn ein anderes Bild angezeigt wird. Stellen Sie also sicher, dass Sie den Bildschirm alle paar Sekunden aktualisieren. Wasser kann die organischen Materialien dieser Displays sofort beschädigen.

Vorteile

Keine Hintergrundbeleuchtung erforderlich

Displays sind sehr dünn und leicht

Energieeffizient

Blickwinkel sind breiter als bei LCDs

Helligkeit und Kontrast sind super

Hohe Geschwindigkeit und geringe Reaktionszeit

Tiefschwarze Farbe

Nachteile

Kostspielige Technik

Kurzer Lebenszyklus

OLEDs brennen eher ein

Wasserschaden

Schritt 14: Häufige Fehler

Lassen Sie uns zum Abschluss des Tutorials über einige häufige Fehler sprechen

Menschen machen bei der Verwendung dieser Displays:

- Überprüfen Sie die Pins immer dreifach, bevor Sie sie in Ihrem Projekt verwenden

- Holen Sie sich die richtige Bibliotheksadresse in der Header-Datei und in Ihrem Code

#define SSD1306_I2C_ADDRESS 0x3C // in Adafruit_SSD1306.h

und

display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // in deinem Code

Wenn die Adresse falsch ist, zeigt das OLED nichts an

- Die Anzeigegröße muss im Treiber geändert werden, bevor sie verwendet werden kann. Wenn es nicht geändert wird, erhalten Sie beim Versuch, den Code zu überprüfen, eine Fehlermeldung

#error ("Höhe falsch, bitte Adafruit_SSD1306.h korrigieren!");

- Wenn Sie NodeMCU verwenden, stellen Sie sicher, dass Sie OLED_RESET von 4 auf LED_BUILTIN ersetzen

#define OLED_RESET LED_BUILTIN

Ich habe Szeneleute, die mit diesem OLED-Display alle möglichen Dinge machen. Einige haben sogar Videospiele und alle gemacht. Ich bin wirklich nicht daran interessiert, ein Videospiel mit diesem winzigen Display zu machen. Ich überlasse Sie jedoch jetzt, Ihrer Fantasie freien Lauf zu lassen und erstaunliche Ideen zu entwickeln.

Schritt 15: Links

- Blog:

- Bild hinzufügen:

- Benutzerdefinierter Text:

- Adafruit-Display-Bibliothek:

- Adafruit GFX-Bibliothek:

- u8glib-Bibliothek: https://code.google.com/archive/p/u8glib/ oder

Wenn Sie die kleinere Anzeige verwenden möchten, verwenden Sie die Standardeinstellung 128_32, ansonsten kommentieren Sie für die größere Anzeige die 128_32 und entkommentieren Sie die 128X64 NO_ACK in Ihrem Code (entkommentieren Sie einfach die Art des Bildschirms, den Sie verwenden) (Schriftarten sind in der Schriftartenbibliothek)