Spaß mit OLED-Display und Arduino - Gunook

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

Ich bin mir ziemlich sicher, dass Sie definitiv von der OLED-Display-Technologie gehört haben. Es ist relativ neu und bietet eine bessere Qualität als die alte LCD-Technologie. In diesem Tutorial möchten wir uns die Schritte ansehen, die zum Anzeigen von Daten auf einem der gängigsten einfarbigen OLED-Display-Module auf dem Markt erforderlich sind. Ich werde versuchen, die Funktionalitäten der entsprechenden Adafruit-Bibliothek zu erklären, um Daten in diesem Modul anzuzeigen.

Schritt 1: Welche OLED-Module werden wir verwenden?

OLED-Module sind in einer Vielzahl von Größen und Funktionen erhältlich. Das, was wir in diesem Tutorial verwenden werden, ist ein einfarbiges 128x64-OLED-Modul. Dieser Modultyp ist in folgenden Größen erhältlich (Damit Sie auf den Bildern sehen):

• 128x64
• 128x32
• 96x16
• 64x48
• 64x32

Da alle diese Module das I2C-Protokoll als Kommunikationsmittel unterstützen, sind der Code und die Verdrahtung bei allen exakt gleich. Der einzige Unterschied besteht darin, dass Sie die Größe der Anzeige in Ihrem Code berücksichtigen müssen, damit die Inhalte, die Sie anzeigen möchten, richtig darauf passen.

Schritt 2: I2C in Kürze

Die inter-integrierte Schaltung (IIC), die normalerweise als I2C (I squared C) bezeichnet wird, wurde in den 80er Jahren von Philips als Datenaustauschbus entwickelt, der verwendet wird, um Daten zwischen der Zentraleinheit (CPU) oder Mikrocontrollereinheit (MCU) eines Geräts und periphere Chips. Es war im Wesentlichen für TV-Anwendungen bestimmt. Aufgrund seiner Einfachheit wurde es so populär, dass es nach einiger Zeit zu einem der primären Mechanismen der Datenübertragung für CPUs und MCUs und Peripheriegeräte wurde, die nicht notwendigerweise Teil derselben Leiterplatte sind und mit dieser über Kabel verbunden sind (z. Anzeigemodule usw.).

I2C besteht aus einem zweiadrigen Kommunikationsbus, der die bidirektionale Datenübertragung zwischen einem Master und mehreren Slave-Geräten unterstützt. Normalerweise ist der Master-Knoten für die Steuerung des Busses verantwortlich – was tatsächlich durch die Erzeugung eines Synchronisationssignals auf der seriellen Taktleitung (SCL) geschieht. Es ist ein Signal, das während der Übertragung kontinuierlich vom Master gesendet wird und alle anderen an den Bus angeschlossenen Knoten verwenden es, um ihre Kommunikation zu synchronisieren und die Geschwindigkeit des Busses zu erkennen. Die Daten werden zwischen Master und Slave über eine serielle Datenleitung (SDA) übertragen. Die Übertragungsgeschwindigkeit kann bis zu 3,4 Mbit/s betragen. Alle Geräte, die Daten über I2C übertragen möchten, sollten eine eindeutige Adresse haben und können je nach Funktion des Gerätes als Sender oder Empfänger fungieren. Zum Beispiel ist ein OLED-Anzeigemodul ein Empfänger, der einige Daten akzeptiert und anzeigt, während ein Temperatursensor ein Transceiver ist, der die erfasste Temperatur über den I2C-Bus sendet. Normalerweise ist ein Master-Gerät das Gerät, das eine Datenübertragung auf dem Bus initiiert und die Taktsignale erzeugt, um die Übertragung zu ermöglichen. Während dieser Übertragung wird jedes von diesem Master adressierte Gerät als Slave betrachtet und liest diese Daten.

Wenn ein Knoten Daten senden möchte, sollte das allererste Byte der Daten die Adresse des Empfängers sein und danach kommen die eigentlichen Daten. Das bedeutet, dass wir zum Senden von Daten an ein Ausgabegerät mit I2C (z.

Wenn Sie mehr über die Details und Theorien zum I2C-Bus erfahren möchten, können Sie folgende Referenzen verwenden:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Schritt 3: Erforderliche Module und Komponenten

Hier finden Sie die Liste der Komponenten, die Sie für dieses Tutorial benötigen:

eBay-Links:

• 1 x Arduino Uno:
• 1 x OLED-Modul 128x64:
• 4 x Dupont-Kabel:
• 1 x Mini lötfreies Steckbrett:

Amazon.com-Links:

• 1 x Arduino Uno:
• 1 x OLED-Modul 128x64:
• 4 x Dupont-Kabel:
• 1 x Mini lötfreies Steckbrett:

Schritt 4: Verkabelung des OLED-Anzeigemoduls mit Arduino

Ein wichtiger Hinweis zu I2C-fähigen Geräten ist, dass die Art und Weise, wie Sie sie mit Arduino verbinden sollten, gleich ist. Dies liegt daran, dass Arduino seine I2C-Kommunikation nur auf bestimmten Pins ausführt. In diesem Tutorial verwende ich Arduino Uno. Der Arduino Uno verwendet Pin A5 als SCK und A4 als SDA. So können wir das OLED-Anzeigemodul wie in der schematischen Ansicht gezeigt an Arduino Uno anschließen. Wie Sie auf dem Bild, das ich von meinem OLED-Display-Modul aufgenommen habe, vielleicht feststellen können, unterscheiden sich die Anschlüsse für VCC und GND von der schematischen Ansicht. Denken Sie daran, die Beschriftungen der Pins an Ihren Modulen zu überprüfen, um sicherzustellen, dass Sie sie richtig anschließen.

Wir benötigen nur 4 Pins, die wie folgt verbunden werden sollten:

Arduino VCC -> OLED-Modul VCC

Arduino GND -> OLED-Modul GND

Arduino 4 -> OLED-Modul SDA

Arduino 5 -> OLED-Modul SCK

Schritt 5: Finden der Adresse des Anzeigemoduls

Als ersten Schritt zum Verbinden mit einem I2C-fähigen Gerät benötigen Sie die Adresse des Moduls. Um dies zu tun, sollten Sie nach dem Verdrahten des Moduls mit Ihrem Arduino einfach den beigefügten Code auf Ihren Arduino hochladen. Dieser Code enthält die Wire-Bibliothek, eine Bibliothek, die in der Arduino IDE enthalten ist und die I2C-Kommunikation verarbeitet. Es versucht, angeschlossene I2C-Geräte zu scannen und sendet deren Adresse über die serielle Schnittstelle an Ihren Computer. Sie können also über das Serial Monitor-Tool in der Arduino IDE auf die Ausgabe zugreifen. Die Originalversion ist bei Arduino Playground erhältlich). Sie können es auch in meinem Online-Arduino-Editor besser lesbar anzeigen. Erwarten Sie nicht, dass etwas auf dem Bildschirm angezeigt wird, während dieser Code ausgeführt wird.

Wie Sie auf dem Bild sehen können, ist mein Modul an die Adresse 0x3C gebunden. Normalerweise haben alle Geräte einer bestimmten Produktlinie (zB alle 128x64 OLED-Module) dieselbe Adresse.

Die Adresse von I2C-Geräten ist auf 1 bis 126 begrenzt. Dieser Code versucht einfach, sich der Reihe nach mit jedem Gerät zu verbinden (ohne Daten zu übertragen) und dann zu überprüfen, ob von der zugrunde liegenden Bibliothek beim Verbinden mit der angegebenen Adresse ein Fehler gemeldet wurde. Wenn kein Fehler auftritt, wird die Adresse als verfügbares Modul zum Verbinden gedruckt. Es sollte auch beachtet werden, dass die ersten 15 Adressen reserviert sind, also überspringt es und druckt nur diejenigen über diesem Bereich. Denken Sie daran, dass die Adresse dieser I2C-Module auf dem Gerät fest codiert ist und nicht geändert werden kann. Es wäre also eine gute Idee, es irgendwo aufzuschreiben oder das Modul zu beschriften, wenn Sie es wieder in Ihr Laborregal stellen, damit das nächste Mal nicht der Scannercode ausgeführt werden muss. Es ist jedoch kein kompliziertes Verfahren;)

Schritt 6: Installieren von Bibliotheken, die zum Anzeigen von Daten auf dem OLED-Modul erforderlich sind

Die Wire-Bibliothek kann die Kommunikation auf niedriger Ebene mit I2C-Geräten verarbeiten. Wenn Sie eine Verbindung zu einem bestimmten Gerät herstellen möchten, um Daten von diesem zu lesen/zu schreiben, verwenden Sie normalerweise eine Bibliothek, die von der Firma bereitgestellt wird, die dieses Modul ursprünglich entwickelt hat. Diese Bibliothek verarbeitet alle I2C-Kommunikationsdetails mit dem gegebenen Modul und lässt uns uns mehr auf unser Geschäft konzentrieren, das in diesem Fall die Daten so anzeigt, wie wir es wollen.

Adafruit, das Unternehmen, das die Originalversion solcher Displaymodule herstellt, bietet eine Bibliothek namens Adafruit SSD1306 an, um Daten auf diesen monochromen Displays anzuzeigen. Bevor wir mit dem Codieren beginnen, müssen wir diese Bibliothek über den Bibliotheksmanager (zugänglich über das Menü Sketch> Include Library> Manage Libraries…) in der Arduino IDE installieren. Es gibt auch eine andere Bibliothek namens Adafruit GFX Library, die mehr grafische Dinge auf niedriger Ebene verarbeitet und intern von Adafruit SSD1306 verwendet wird. Sie müssen beide auf Ihrer Arduino IDE installiert haben, wie Sie auf den Bildern sehen können.

Schritt 7: Initialisieren des Anzeigemoduls

Das Drawing-on-Display-Modul ist in eine Klasse namens Adafruit_SSD1306 eingeschlossen. Die Definition dieser Klasse befindet sich in der Adafruit-Bibliothek, daher müssen wir diese Bibliothek zuerst einschließen. Dann müssen wir zuerst eine Instanz dieser Klasse instanziieren. Der Konstruktor dieser Klasse nimmt die Portnummer, an der die Anzeige zurückgesetzt werden könnte, nämlich Pin 4 (verbunden mit SCK). Dieser Teil des Codes sollte sich am Anfang der Datei befinden (außerhalb der Funktionen setup() und loop()).

#enthalten

Adafruit_SSD1306-Anzeige (4);

Nun sollten wir innerhalb der setup()-Funktion die begin-Funktion des Anzeigeobjekts aufrufen, indem wir unsere I2C-Adresse wie unten angegeben übergeben (der SSD1306_SWITCHCAPVCC ist ein konstanter Wert, der den Typ der Stromquelle an die Bibliothek angibt):

Leere Einrichtung () {

display.begin(SSD1306_SWITCHCAPVCC, 0x3C); display.display(); } void loop() {} // Schleife kann vorerst leer sein

Nun ist das Anzeigeobjekt fertig und wir können seine Funktionen aufrufen (z. B. display.write(), display.drawLine, etc.). Der wichtige Hinweis ist, dass wir jedes Mal, wenn wir etwas zeichnen, indem wir unser Anzeigeobjekt aufrufen, die Funktion display.display() aufrufen müssen, damit das eigentliche Zeichnen auf Hardwareebene erfolgt. Dies liegt hauptsächlich daran, dass die von uns aufgerufenen Zeichenfunktionen aus Performancegründen nur die "im Speicher"-Darstellung der Anzeige aktualisieren. Es speichert tatsächlich die Änderungen im Speicher. Wir sollten also immer daran denken, die Funktion display() aufzurufen, wenn wir mit dem Zeichnen auf dem Bildschirm fertig sind.

anzeigen.schreiben(…); // aktualisiert sich ständig im Speicher

display.drawLine(…); // wird im Speicher ständig aktualisiert. display.display(); // löscht alle Änderungen an der Display-Hardware

Wenn Sie in diesem Schritt versuchen, Ihren Code hochzuladen, werden Sie feststellen, dass das Logo von Adafruit Industries angezeigt wird. Sie fragen sich vielleicht, wer es gebeten hat, das zu zeichnen! Genau das macht die Adafruit-Bibliothek. Es initialisiert den Speicher des Moduls (die In-Memory-Darstellung der Display-Hardware) mit dem Logo dieser Firma. Wenn Sie das während der Initialisierung nicht sehen möchten, können Sie versuchen, die Funktion display.clearDisplay() direkt vor dem Aufrufen von display.display() in Ihrer Setup-Funktion aufzurufen. Diese Funktion löscht, wie der Name schon sagt, das Display komplett.

#enthalten

Adafruit_SSD1306-Anzeige (4); Void setup () {display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay(); display.display(); } Leere Schleife () { }

Basierend auf der Dokumentation der Adafruit_SSD1306-Bibliothek können Sie verschiedene Funktionen dieser Klasse verwenden, um auf dem Display zu zeichnen oder die Pixel darauf direkt zu manipulieren. In den nächsten Abschnitten werden wir versuchen, für jeden von ihnen ein Beispiel zu präsentieren, damit Sie eine Vorstellung davon bekommen, wie es funktioniert. Die meisten dieser Beispiele zeigen nur einen einfachen statischen Inhalt an, sodass wir sie einfach in unsere setup()-Funktion (nach dem Initialisierungscode) einfügen können. Dadurch würde es nur einmal ausgeführt und verbleibt dort.

Schritt 8: Zeigen Sie einen einfachen Text an

Um einen Text anzuzeigen, können wir die einfache Funktion display.println() der Bibliothek verwenden. Es akzeptiert den Text als String und versucht ihn anzuzeigen. Es ist wichtig zu wissen, dass wir der Bibliothek mitteilen müssen, wo auf dem Display der Text präsentiert werden soll. Jedes Pixel auf dem Display hat eine Koordinate, die mit einem X und Y angegeben wird. Das X nimmt von links nach rechts zu und Y von oben nach unten. Die obere linke Ecke des Bildschirms ist (X=0, Y=0) und die untere rechte Ecke ist (X=127, Y=63). Ich habe mir die Koordinaten der Ecken auf dem ersten Bild notiert. Wir können die Funktion display.setCursor() verwenden, um anzugeben, wo auf dem Display der Text angezeigt werden soll.

Eine weitere Eigenschaft des Textes ist seine Farbe. Wir können die Farbe mit display.setTextColor() angeben, wie im folgenden Beispiel gezeigt.

display.clearDisplay();

display.setTextColor (WEISS); display.setCursor(35, 30); display.println("Hallo Welt!"); display.display();

Wir können auch die Funktion display.write() verwenden, um ein einzelnes Zeichen anzuzeigen. Es akzeptiert einen Zeichencode vom Typ uint8_t und zeigt das diesem Code entsprechende Zeichen in der Zeichenfolge an. Wenn wir beispielsweise mit dieser Funktion dieselbe Zeichenfolge anzeigen möchten, können wir das folgende Snippet verwenden:

display.clearDisplay();

display.setTextColor (WEISS); display.setCursor(35, 30); display.write(72); display.write(101); display.write(108); display.write(108); display.write(111); display.write(32); display.write(87); display.write(111); display.write(114); display.write(108); display.write (100); display.write(33); display.display();

Es ist auch möglich, Texte in schwarzer Farbe mit weißem Hintergrund zu zeichnen. Dazu müssen Sie die Funktion display.setTextColor wie folgt aufrufen:

display.clearDisplay();

// Setzt die Farbe auf Schwarz mit weißem Hintergrund display.setTextColor(BLACK, WHITE); display.setCursor(25, 30); display.println("Invertierter Text!"); display.display();

Sie haben auch die Möglichkeit, die Größe des Textes mit der Funktion display.setTextSize() einzustellen. Es akzeptiert eine ganze Zahl als Größe. Je größer die Zahl, desto größer wäre der Text. Die kleinste Größe ist 1, was die Standardgröße von Texten ist. Der folgende Code versucht, den Buchstaben "A" in 6 verschiedenen Größen zu schreiben:

display.clearDisplay();

display.setTextColor (WEISS); display.setCursor(0, 0); display.setTextSize(1); display.print("A"); display.setTextSize(2); display.print("A"); display.setTextSize(3); display.print("A"); display.setTextSize(4); display.print("A"); display.setTextSize(5); display.print("A"); display.setTextSize(6); display.print("A"); display.display();

Schritt 9: Zeichnen von Grundformen

Das Zeichnen von Grundformen wie Rechteck, Kreis, Dreieck, Linie oder Punkt ist sehr einfach und für jede gibt es eine eigene Funktion.

Linie zeichnen

Um eine Linie zu zeichnen, können Sie display.drawLine(startX, startY, endX, endY, color) aufrufen. Der folgende Code zeichnet beispielsweise diagonale Linien auf dem Bildschirm, sodass sie ein großes X bilden:

display.clearDisplay();

display.drawLine(0, 0, display.width() – 1, display.height() – 1, WEISS); display.drawLine(display.width() – 1, 0, 0, display.height() – 1, WEISS); display.display();

Auf Breite und Höhe der Anzeige können Sie mit den Funktionen display.width() und display.height() zugreifen. Auf diese Weise wäre Ihr Code unabhängig von der Bildschirmgröße.

Rechteck zeichnen

Die Funktion zum Zeichnen eines Rechtecks ist display.drawRect(upperLeftX, upperLeftY, width, height, color). Hier ist der Code, der an einigen zufälligen Stellen drei Rechtecke zeichnet:

display.clearDisplay();

display.drawRect(100, 10, 20, 20, WEISS); display.fillRect(10, 10, 45, 15, WEISS); display.drawRoundRect(60, 20, 35, 35, 8, WEISS); display.display();

Durch Aufrufen von display.fillRect(upperLeftX, upperLeftY, width, height, WHITE) können Sie ein Rechteck zeichnen, das mit der angegebenen Farbe gefüllt ist. Auch die dritte Funktion in diesem Beispiel ist display.drawRoundRect(upperLeftX, upperLeftY, width, height, cornerRadius, color), die, wie Sie im Bild sehen können, verwendet wird, um ein Rechteck mit runden Ecken zu zeichnen. Es akzeptiert einen zusätzlichen Parameter vor Farbe, der eine ganze Zahl ist, die den Eckenradius angibt. Je größer der Wert, desto runder die Ecke. Es hat auch eine entsprechende Füllfunktion namens display.drawFillRoundRect, von der ich denke, dass Sie erraten können, was sie tut.

Kreis zeichnen

Die Funktion ist display.drawCircle(centerX, centerY, radius, color). Hier ist ein Beispiel, das eine Smiley-ähnliche Form zeichnet:

display.drawCircle(60, 30, 30, WEISS);

display.fillCircle(50, 20, 5, WEISS); display.fillCircle(70, 20, 5, WEISS);

Wie bei Rechtecken können Sie mit der Funktion display.fillCircle einen Kreis zeichnen, der mit der angegebenen Farbe gefüllt ist.

Dreieck zeichnen

Ahh, wieder eine Funktion namens display.drawTriangle(poin1X, point1Y, point2X, point2Y, point3X, point3Y, color) und das entsprechende display.fillTriangle, die ein gefülltes Dreieck zeichnen.

display.drawTriangle (24, 1, 3, 55, 45, 55, WEISS);

display.fillTriangle(104, 62, 125, 9, 83, 9, WEISS);

Zeichne einen Punkt

Sie können auch einen bestimmten Punkt (der als Pixel bezeichnet wird) auf dem Bildschirm über die Funktion display.drawPixel(pixelX, pixelY, color) einfärben.

display.drawPixel(20, 35, WEISS);

display.drawPixel(45, 12, WEISS); display.drawPixel (120, 59, WEISS); display.drawPixel(97, 20, WEISS); display.drawPixel (35, 36, WEISS); display.drawPixel(72, 19, WEISS); display.drawPixel(90, 7, WEISS); display.drawPixel(11, 29, WEISS); display.drawPixel (57, 42, WEISS); display.drawPixel(69, 34, WEISS); display.drawPixel(108, 12, WEISS);

Schritt 10: Bild zeichnen

Ein Bild zu zeichnen ist anders und ein bisschen kompliziert. Da das Anzeigemodul einfarbig ist, müssen wir unser Bild zuerst in ein Format namens Monocolor Bitmap (auch Schwarzweiß genannt) konvertieren. In einem solchen Format wird jedem Pixel des Bildes entweder 0 oder 1 angezeigt. Die 1 steht für die Existenz der Farbe und 0 bedeutet einen leeren Raum. Ein Beispiel für das Arduino-Logo in diesem Format finden Sie oben in diesem Abschnitt. Die Funktion zum Zeichnen eines Bitmap-Bildes ist display.drawBitmap(topLeftX, topLeftY, imageData, width, height, color). Der Parameter imageData ist ein Array von Zahlen in Bytes. Jedes Byte hat 8 Bits, also enthält jedes Byte die Daten von 8 Pixeln des Bildes. Durch Angabe der Breite und Höhe des Bildes weiß die drawBitmap-Funktion, ab welchem Bit die nächste Pixelzeile beginnt.

Die Lösung, die ich gewählt habe, um mein Bild in dieses Format zu konvertieren, bestand darin, zuerst einen der Online-"Bild-zu-ASCII-Konverter" (zB https://my.asciiart.club) zu verwenden, um mein Bild in einen Satz von ASCII-Zeichen zu konvertieren und dann zu ersetzen die Zeichen für Leerzeichen mit 0 und andere mit 1. Das sehen Sie unten. Sie können sich jede 0 und 1 als Pixel auf dem Display vorstellen. Daher sollte die Größe des Bildes unsere Anzeigegröße von 128x64 nicht überschreiten.

Hinweis: Die Verwendung dieser ASCII-Technik wird nicht empfohlen, da Ihr Bild aufgrund des Seitenverhältnisses der Zeichen verformt wird (Zeichen sind keine Quadrate). Ich habe diese Technik ausprobiert, nur weil sie es einfacher macht, das Bild in das erforderliche Format zu konvertieren. Andernfalls wäre es möglich, das beste Ergebnis durch einige Programmierungen oder die Verwendung einiger Dienstprogramme zu erzielen, die vollständig den Rahmen dieses Textes sprengen würden.

00000000000000000000011111111111111111111110000000000000000000000000000000000000011111111111111111111111111111100000000000000000 0000000000000111111111111111111111111111111111111110000000000000 0000000000011111111111111111111111111111111111111111100000000000 0000000001111111111111111111111111111111111111111111111000000000 0000000111111111111111111111111111111111111111111111111110000000 0000011111111111111111111111111111111111111111111111111111100000 0000111111111111111111111111111111111111111111111111111111110000 0001111111111111111111111111111111111111111111111111111111111000 0011111111111111111111111111111111111111111111111111111111111100 0111111111111111000000011111111111111111100000001111111111111110 0111111111110000000000000001111111111000000000000000111111111110 1111111111000000001111000000001111000000001111000000001111111111 1111111110000011111111111100000110000011111111111100000111111111 1111111100000111111111111111000000001111111001111110000011111111 1111111100001111100000011111100000011111100000011111000011111111 1111111100001111100000011111100000011111100000011111000011111111 1111111100000111111111111111000000001111111001111110000011111111 1111111110000011111111111100000110000011111111111100000111111111 1111111111000000001111000000001111000000001111100000001111111111 0111111111110000000000000000111111110000000000000000111111111110 0111111111111111000000001111111111111111000000001111111111111110 0011111111111111111111111111111111111111111111111111111111111100 0001111111111111111111111111111111111111111111111111111111111000 0000111111111111111111111111111111111111111111111111111111110000 0000011111111111111111111111111111111111111111111111111111100000 0000000111111111111111111111111111111111111111111111111110000000 0000000011111111111111111111111111111111111111111111111100000000 0000000000011111111111111111111111111111111111111111100000000000 0000000000000111111111111111111111111111111111111110000000000000 0000000000000000111111111111111111111111111111110000000000000000 0000000000000000000001111111111111111111111000000000000000000000

Jetzt sollten wir jede Zeile durch 8 teilen, die ein Byte darstellt, und sie wie folgt in einem Array speichern:

static const unsigned char PROGMEM arduino_logo ={

B00000000, B00000000, B00000111, B111111, B11111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B11111111, B11111111, B11111110, B00000000, B00000000, … // weiter bis zum Ende des Bildes };

Dann können wir es auf dem Display zeichnen, indem wir die drawBitmap-Funktion aufrufen.

display.drawBitmap (32, 16, arduino_logo, 64, 32, WEISS);

Schritt 11: Fehlerbehebung

Dies war ein langes Tutorial und daher ist es sehr wahrscheinlich, dass etwas schief geht. Hier ist die Liste einiger häufiger Fehler, die beim Einrichten des OLED-Anzeigemoduls für Ihr Projekt auftreten können (einige davon sind mir bei der Vorbereitung dieses Tutorials passiert).

Es wird gar nichts angezeigt

Dies kann aus vielen Gründen passieren, daher schlage ich vor, die folgende Liste zu überprüfen, die in Ihrem Projekt in der richtigen Reihenfolge auftreten kann:

I2C-Adresse ist wahrscheinlich falsch

Stellen Sie sicher, dass Sie die Adresse, die Sie im i2c-Scanner-Code in der Funktion display.begin() erhalten haben, beim Einrichten Ihres Anzeigeobjekts eingestellt haben.

SCL und SDA sind falsch verbunden

Bei mir ist das tatsächlich passiert. Wenn Sie Arduino Uno verwenden, müssen Sie Ihre Verbindungen erneut überprüfen, um sicherzustellen, dass sie mit meinen identisch sind. Wenn Sie eine andere Arduino-Edition verwenden (z. B. Mega, Leonardo usw.), müssen Sie wissen, dass ihr I2C möglicherweise auf andere Pins eingestellt ist. Sie können es in der Dokumentation der Wire-Bibliothek überprüfen.

Sie zeichnen etwas aus dem sichtbaren Bereich

Dies ist ein Softwareproblem. Es kommt sehr häufig vor, dass bei der Verwendung einer Zeichnungsfunktion einige Koordinaten falsch berechnet werden, sodass Ihre Zeichnung verformt wird oder im schlimmsten Fall vollständig aus der Szene verschwindet. Überprüfen Sie Ihre Berechnungen und versuchen Sie, Schritt für Schritt zu zeichnen, um zu sehen, was los ist.

Text wird gar nicht angezeigt

Sie haben vergessen, die Textfarbe einzustellen, oder Sie haben einen falschen Wert eingestellt

Sie müssen setTextColor aufrufen, bevor Sie Texte zeichnen. Andernfalls erhalten Sie keine Fehler, aber Sie sehen nichts auf dem Display. Möglicherweise haben Sie auch die Textfarbe wie die Hintergrundfarbe eingestellt.

Sie verwenden eine sehr große Schriftart

Wenn Sie die Textgröße auf einen sehr großen Wert einstellen, kann es sein, dass Zeichen vollständig aus dem sichtbaren Bereich herauskommen.

Es gibt einen Kompilierungsfehler bezüglich der Anzeigegröße

Das ist mir auch passiert und ich denke, es würde den meisten von euch passieren. Dies liegt an den konstanten Werten für die Anzeigegröße, die in der Header-Datei Adafruit_SSD1306.h definiert sind, die wir oben in unser Skript einfügen. Diese Datei befindet sich unter {Ihr-Projektordner}\libraries\Adafruit_SSD1306\Adafruit_SSD1306.h. Wenn Sie diese Datei öffnen, werden Sie feststellen, dass es einen Kommentarabschnitt wie unten gibt, in dem beschrieben wird, dass Sie nur die Konstante auskommentieren müssen, die die Größe Ihres OLED-Displaymoduls darstellt. Bei einem 128x64-Displaymodul sollte die Zeile #define SSD1306_128_64 unkommentiert werden.

/*=====================================================================

SSD1306-Anzeigen ------------------------------------------------ ---------------------- Der Treiber wird in mehreren Displays verwendet (128x64, 128x32 usw.). Wählen Sie unten die entsprechende Anzeige aus, um einen Framebuffer mit entsprechender Größe usw. zu erstellen. SSD1306_128_64 128x64-Pixel-Anzeige SSD1306_128_32 128x32-Pixel-Anzeige SSD1306_96_16 -------------------------- --------------------------------------------------------*/ #define SSD1306_128_64 / / #define SSD1306_128_32 // #define SSD1306_96_16 /*====================================== ===============================*/

Schritt 12: Was ist als nächstes zu tun?

Das OLED-Display als Ausgabemodul bietet Ihnen eine großartige Möglichkeit, Ihren Hobbyprojekten eine professionell aussehende Schnittstelle zu bieten. Sie können versuchen, den Ideen als Ausgangspunkt zu folgen, um aussagekräftige Daten anzuzeigen oder dem Benutzer zu helfen, zu wissen, was vor sich geht oder ob er / sie etwas tun muss. Es wäre für einen Benutzer viel übersichtlicher, eine Meldung auf einem Display zu lesen, als den Zustand eines Projekts/Geräts über einige LEDs zu interpretieren.

Was Sie als Ausgangspunkt tun können, könnte sein:

• Lesen Sie einen Temperatursensorwert aus und zeigen Sie ihn auf dem OLED-Modul an. Sie können einen Druck- oder Feuchtigkeitssensor hinzufügen und ein voll funktionsfähiges Wetterstationsprojekt erstellen.
• Versuchen Sie, mit einem Joystick-Modul als Eingabegerät etwas auf das Anzeigemodul zu zeichnen.
• Versuchen Sie, eine Animation auf dem Display zu zeichnen, indem Sie eine Folge von Funktionsaufrufen zeichnen/verzögern oder einen Arduino-Interrupt
• Zeigen Sie Ihr benutzerdefiniertes Logo beim Systemstart an (anstelle des Adafruit-Logos)

Vergessen Sie nicht, mir in den Kommentaren mitzuteilen, was Sie mit dem OLED-Displaymodul tun würden (oder bereits getan haben).