OLED I2C Display Arduino/NodeMCU Handledning: 15 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:45

Det allra första programmet du skriver när du börjar lära dig a

nytt programmeringsspråk är: "Hej världen!".

Själva programmet gör inget mer än att skriva ut en "Hello World" -text på skärmen.

Så hur får vi vår Arduino att visa "Hej världen!"?

I den här videon kommer jag att visa dig hur du kommer igång med de små 0,91 (128x32) och 0,96 (128x64) I2C OLED -skärmarna.

Det finns 100 -tal handledning på webben som förklarar samma sak på olika sätt, men jag kunde inte hitta en som berättar allt om OLED -skärmen och hur man använder den i olika scenarier. Det tog mig lite tid att fixa det hela. Så jag tänkte att jag skulle skapa en handledning om vad jag har lärt mig och kombinera alla funktioner och sätt som OLED -skärmarna kan användas i våra projekt.

Steg 1: Saker vi ska lära oss idag

I den här videon kommer vi att prata om:

- Vad är en OLED -skärm?

- Då kommer vi att titta närmare på 0,91 (128x32) och 0,96 (128x64) I2C OLED -skärmar

- Därefter kommer vi att prata om att installera Adafruit -biblioteket i din Arduino IDE

- Sedan kommer vi att ansluta NodeMCU och Arduino till en OLED -skärm

- Därefter kommer vi att titta på koden och visa lite grafik och text på den

- Vi kommer också att prata om att använda anpassade teckensnitt och visa bilder

- Sedan kommer vi att ansluta flera OLED-enheter till en mikrokontroller med I2C Multiplexer

- Slutligen kommer vi att prata om några vanliga fel som människor gör när de använder OLED -skärmarna

Steg 2: Hårdvarukrav

För denna handledning behöver vi:

- Ett brödbräda

- En 0,91 "(128x32) och 0,96" (128x64) I2C OLED -skärmar

- Arduino UNO/NANO (vad som helst är praktiskt)

- NodeMCU

- TCA9548A I2C multiplexer

- Några anslutningskablar

- och en USB -kabel för att ladda upp koden

Steg 3: Vad är en OLED -skärm?

OLED eller organisk ljusemitterande diod är en ljusemitterande

diod (LED) där det emissiva elektroluminescerande skiktet är en film av organisk förening (miljontals små LED -lampor) som avger ljus som svar på en elektrisk ström.

OLED används för att skapa digitala skärmar i enheter som tv-skärmar, datorskärmar, bärbara system som mobiltelefoner, handhållna spelkonsoler och handdatorer. En OLED -skärm fungerar utan bakgrundsbelysning eftersom den avger synligt ljus.

Steg 4:

Det finns många typer av OLED -skärmar tillgängliga i

marknaden baserad på deras

- Storlekar

- Färg

- Varumärken

- Protokoll

- SPI (Serial Peripheral Interface) eller I2C

-Passiv-matris (PMOLED) eller aktiv-matris (AMOLED) kontrollschema

I den här självstudien kommer jag att prata om att ansluta

blå färg 0,91 (128x32 OLED) och 0,96 (128x64 OLED) I2C OLDE -skärmar till en Arduino NANO och NodeMCU. I2C -bussteknologi använder bara 2 stift på MCU så vi har massor tillgängliga för andra sensorer.

Steg 5: Närmare titt

Låt oss närmare dessa två skärmar.

På baksidan av dessa skärmar finns massor av SMD-kondensatorer och motstånd lödda ombord; men eftersom det är en I2C -enhet bryr vi oss bara om dessa två stift (SCL och SDA)

Displayen ansluts till Arduino med endast fyra ledningar - två för ström (VCC och GND) och två för data (seriell klocka SCL och

seriell data SDA), vilket gör ledningarna mycket enkla. Dataförbindelsen är I2C (I²C, IIC eller Inter-Integrated Circuit) och detta gränssnitt kallas också TWI (Two Wire Interface).

- Inbyggda stiften kan vara i olika ordning, så kontrollera alltid tre gånger innan du ansluter det till ditt projekt.

- Driftspänning är mellan 3v och 5v, men det är bäst att använda vägledningen från tillverkarens datablad.

- Ibland behöver vi använda två skärmar i våra projekt. Så hur kan vi uppnå detta?

Tricket är att ha en konfigurerbar adress på skärmen. Denna enhet har en konfigurerbar adress mellan 0x78 och 0x7A. Bara genom att lödda 0Ohm -motståndet från ena sidan och haka upp det på andra sidan eller bara genom att sätta ett globalt löd kan vi ändra adressen. Vi kommer att prata om det på djupet när vi ansluter flera bildskärmar till en Arduino i det senare avsnittet av denna handledning.

På bild ser dessa skärmar väldigt stora ut. Men praktiskt taget är de små. De är gjorda av 128 x 32/64 enskilda OLED-pixlar och kräver inget motljus. Titta bara på det här och se hur liten det är. Även om de är små kan de vara mycket användbara i alla elektroniska projekt.

Steg 6: Bibliotek

Det finns flera bibliotek tillgängliga för att styra dessa

visar. Tidigare har jag använt "u8glib -biblioteket" men jag tycker att AdaFruit -biblioteket är mycket lätt att förstå och använda i våra projekt. Så jag kommer att använda AdaFruit -biblioteket i den här självstudien.

För att styra OLED -skärmen behöver du "adafruit_GFX.h" -biblioteket och "adafruit_SSD1306.h" -biblioteket.

Det finns två sätt att ladda ner och installera biblioteket till din Arduino IDE.

Metod 1

Gå till "Library manager" och sök "adafruit_SSD1306" och "adafruit_gfx"

Välj den senaste versionen och tryck på knappen Installera.

Efter installationen kan du använda dessa bibliotek i ditt program.

Metod 2

Dessa två bibliotek kan också laddas ner från github (du behöver båda):

Jag kommer att tillhandahålla länkarna i beskrivningen nedan.

Displaybiblioteket:

GFX-biblioteket:

När du har laddat ner kopierar du mappen Adafruit_SSD1306-master från den nedladdade zippade filen till mappen Arduino bibliotek. Denna mapp finns vanligtvis på Dokument> Arduino> bibliotek på Windows -system. På Linux finns det vanligtvis hemmapp> Arduino> bibliotek. Slutligen i Arduino biblioteksmapp, byt namn på mappen Adafruit_SSD1306-master till Adafruit_SSD1306. Även om du inte byter namn är det bra.

Steg 7:

Låt oss nu titta på "Adafruit_SSD1306.h"

fil

Två saker vi behöver veta i det här biblioteket:

1. Om du vill använda den mindre skärmen använder du standard 128_32 annars för den större skärmkommentaren 128_32 och avmarkerar 128_64

2. Om du har lödt 0x7A -adressen på kortet (som vi kommer att prata om senare) använder du 7 -bitars 0x3D -adressen för de större skärmarna, annars använder du standard 0x3C -adressen. För de mindre skärmarna är adressen 0x3C.

Steg 8: Anslut 128 x 64/32 OLED -enheter

Låt oss börja med att ansluta NodeMCU till displayen.

Det första och viktigaste att notera är att vissa av skärmarna kan ha GND- och VCC -stiften utbytta. Kontrollera att skärmen är densamma som bilden. Om stiften byts ut, se till att du ändrar anslutningarna till Arduino eller NodeMCU.

- NodeMCU OLED -kablar

OLED VCC - NodeMCU 3.3V

OLED GND - NodeMCU GND

OLED SCL - NodeMCU D1

OLED SDA - NodeMCU D2

- Arduino Uno OLED -ledningar

OLED VCC - Arduino 5V

OLED GND - Arduino GND

OLED SCL - Arduino Uno A5

OLED SDA - Arduino Uno A4

- Arduino MEGA 2560 OLED -ledningar

OLED VCC - Arduino 5V

OLED GND - Arduino GND

OLED SCL - Arduino MEGA 2560 pin 21

OLED SDA - Arduino MEGA 2560 pin 20

Steg 9: Kod

Adafruit bibliotek kommer med riktigt bra exempel för båda

128x32 och 128x64 skärmar.

Biblioteket finns under Arkiv> Exempel> Adafruit SSD1306> och sedan visningstypen i Arduino IDE.

Vi kommer att använda 128x32 I2C -exemplet och kommer att modifiera det för att fungera med både 128x64 och 128x32 bildskärmar genom att ansluta det till en Arduino och sedan till ett NodeMCU -kort.

Koden börjar med att inkludera båda Adafruit -biblioteken. I den här handledningen kommer jag bara att betona de delar av koden som är nödvändiga för att vi ska kunna ladda på både kort och skärmar. Om du vill veta mer om koden kan du lämna en kommentar på min blogg eller i kommentarfältet nedan så försöker jag återkomma till dig.

- Först ska vi ladda koden till en Arduino Nano ansluten till en 128x32 -skärm.

Vi kan använda koden som den är utan några ändringar.

128x32 använder 0x3C -adress så den här biten ser bra ut här, låter dubbelkolla rubrikbiblioteket, ja den använder också 0x3C -adressen och visningstypen är 128x32.

- Nu kan vi ansluta 128x64 -skärmen. Som vi vet använder den 0x3C -adressen som standard så vi behöver inte uppdatera adressen i varken koden eller biblioteket.

Vi behöver bara kommentera 128_32 och avmarkera 128_64 i rubrikbiblioteket och ändra LCDHEIGHT till 64 i vår kod.

- Nu för att köra samma kod på en NodeMCU måste vi ändra en rad till i vår kod.

Resten av "#define OLED_RESET 4"> "#define OLED_RESET LED_BUILTIN" är samma som Arduino

Ganska mycket för att visa allt vi först behöver för att rensa föregående skärm med

display.clearDisplay (); // Rensa bufferten

Rita sedan föremålet

testdrawline (); // Dra ett streck

Visa det på hårdvaran

display.display (); // Gör dem synliga på skärmens hårdvara!

Vänta en stund innan nästa objekt visas.

fördröjning (2000); // Vänta i 2 sekunder

I det här exemplet visar vi få objekt som text, linjer, cirklar, rullande text, trianglar och mer. Fortsätt och använd din fantasi och visa vad du vill på dessa små skärmar.

Steg 10: Anpassa text och lägga till bilder

Ibland måste din kod visa anpassade teckensnitt och

bilder. Om du är mycket bra på bitmappning behöver du bara skapa en byte -matris genom att slå på eller stänga av de små lysdioderna på displayen för att skapa anpassade teckensnitt och bilder.

Jag är dock inte särskilt bra på att göra dessa mappningar och vill inte lägga timmar på att skapa bitkarttabellerna.

Så, vad är mina alternativ? Jag använder vanligtvis två webbplatser för att skapa anpassade teckensnitt och bilder. Länkarna finns i beskrivningen nedan.

Anpassade teckensnitt

Gå till fontkonverteringswebbplatsen, välj teckensnittsfamilj, stil, storlek, biblioteksversion som "Adafruit GFX Font" och tryck sedan på "Skapa" -knappen. På höger sida av denna sida kan du se hur ditt teckensnitt kommer att se ut på själva displayen.

Baserat på ditt val genererar webbsidan teckensnitthuvudfilen. Skapa en fil som heter "modified_font.h" i samma mapp där koden finns och kopiera och spara den genererade koden i den. Då behöver du bara inkludera rubrikfilen i din kod för att använda det anpassade teckensnittet.

#include "modified_font.h"

Sedan behöver du bara ställa in teckensnittet innan du visar texten för att använda det anpassade teckensnittet på det.

display.setFont (& Your_Fonts_Name);

Du kan få namnet på teckensnittet från rubrikfilen du just lagt till i ditt projekt. Det är det, lätt.

Minnet är alltid ett problem när du använder anpassade teckensnitt, så tänk alltid på de byte som kommer att förbrukas av minnet. Kom bara ihåg att Arduino UNO bara har 32K minne.

Anpassade bilder

För att visa en bitmappsbild på skärmen måste du först skapa en bild på 128 x 64/32.

Jag använder den gamla gamla "MS Paint" för att skapa en 128 x 64 bitmappsbild som jag sedan kommer att ladda upp till denna bildkonverteringswebbplats. Webbplatsen konverterar bilder till byte-strängar, som kan användas med Arduino och OLED-skärmar.

Börja med att ladda upp bilden till webbplatsen. Markera sedan kryssrutan "Invertera bildfärger" och ändra "Utmatningskodformat" till "Arduino-kod", välj sedan orienteringen och tryck på "Generera kod" -knappen för att generera byte-arrayen. Avsnittet "Förhandsgranskning" visar hur din bild kommer att se ut på själva skärmen.

Jag har inkluderat koden tillsammans med denna handledning som du kan använda för att visa dina bilder. Du behöver bara ersätta matrisen i min kod med den du just skapade och sedan ladda den till din Arduino.

Steg 11: Ansluta 2 bildskärmar

Det är enkelt att ansluta två 128 x 64 bildskärmar till ditt projekt.

Du behöver bara avlasta 0Ohm -motståndet från 0x78 -adressen och sätta det på 0x7A och sedan använda 0x3D -adressen i din kod istället för standard 0x3C.

Du måste undra varför vi använder 0x3C- och 0x3D -adressen och inte själva 0x78 och 0x7A. Arduino accepterar 7-bitars adress och inte 8-bitars hårdvaruadresser. Så vi måste först konvertera 8-bitarsadressen till binär och sedan hugga av den minst signifikanta biten för att få de 7 bitarna. Konvertera sedan de 7 bitarna till HEX för att få de 0x3C- eller 0x3D -adresser som du anger i din kod.

Initiera först skärmen genom att ge den ett unikt namn:

Adafruit_SSD1306 display1 (OLED_REST);

Adafruit_SSD1306 display2 (OLED_REST);

Använd sedan displayen 1 och display 2 i din kod för att ringa start -satserna med enhetsadresserna i dem:

display1.start (SSD1306_SWITCHCAPVCC, 0x3C); // visa 1 op -adress 0x3C

display2.start (SSD1306_SWITCHCAPVCC, 0x3D); // visa 2 op -adress 0x3D

Det är det, du kan nu fortsätta och göra vad du vill med antingen Display 1 eller Display 2 i resten av din kod. Jag har gett ett exempel med denna handledning.

Kabeldragning är exakt samma som vad vi har gjort tidigare, i stort sett behöver du bara lägga till en annan skärm till samma I2C -stift på antingen Arduino eller NodeMCU. Baserat på adresserna skickar MCU sedan data på I2C -dataraden.

Steg 12: Anslut mer än 2 skärmar

Vad händer nu om du vill ansluta mer än 2 skärmar?

Arduino har ett begränsat antal stift och därför kan du inte ha mer än en viss mängd sköldar fästa vid den. Dessutom har den bara ett par I2C -bussar.

Så hur kan vi fästa mer än 2 I2C -skärmar till en Arduino? Tricket är att använda en TCA9548 Multiplexer.

TCA9548 tillåter en enda mikrokontroller att kommunicera med upp till '64 sensorer 'alla med samma eller olika I2C-adress genom att tilldela varje sensorslavsubus en unik kanal.

När vi pratar om att skicka data över två ledningar till flera enheter behöver vi sedan ett sätt att ta itu med dem. Det är samma sak som brevbäraren som kommer på en enda väg och tappar postpaketen till olika hus eftersom de har olika adresser skrivna på dem.

Multiplexern ansluter till 3V3-, GND-, SDA- och SCL-linjer på mikrokontrollern. Slavsensorerna är anslutna till en av åtta SCL/SDA -slavportar på kortet. Kanalerna väljs genom att skicka TCA9548A dess I2C -adress (0x70 {default} - 0x77) följt av kanalnummer (0b00000001 - 0b10000000). Du kan ha max 8 av dessa multiplexrar anslutna ihop på 0x70-0x77 adresser för att styra 64 av samma I2C adresserade delar. Genom att ansluta de tre adressbitarna A0, A1 och A2 till VIN kan du få olika kombinationer av adresserna. Jag kommer att förklara detta på djupet i min nästa handledning om TCA9548A breakout board. För tillfället kan vi bara ansluta 8 OLED -enheter till detta kort och ta en snabb titt på koden.

Förbindelse:

VIN till 5V (eller 3.3V)

GND till jord

SCL till I2C klocka

SDA till I2C data

Anslut sedan sensorerna till VIN, GND och använd en av SCn / SDn -multiplexbussarna

Nu kan Int -koden börja med att inkludera "Wire" -biblioteket och genom att definiera multiplexeradressen.

#inkludera "Wire.h"

#omfatta

#define MUX_Address 0x70 // TCA9548A Kodares adress

Då måste vi välja porten vi vill kommunicera till och skicka data på den med denna funktion:

void tcaselect (uint8_t i) {

om (i> 7) återgår;

Wire.beginTransmission (MUX_Address);

Wire.write (1 << i);

Wire.endTransmission ();

}

Därefter initierar vi displayen i installationsdelen genom att ringa "u8g.begin ();" för varje bildskärm ansluten till MUX "tcaselect (i);"

När vi väl initierats kan vi göra vad vi vill bara genom att kalla funktionen "tcaselect (i);" där "i" är värdet på den multiplexerade bussen och sedan skicka data och klocka därefter.

Steg 13: Fördelar och nackdelar

Bilden på en OLED är vacker. Det har dock OLED också

nackdelar. Eftersom OLED -skärmar innehåller organiskt material är deras livslängd kortare än LCD -skärmar. Dessutom blir många OLED-skärmar inbrända efter att ha visat samma bild länge. Efter en inbränning förblir bilden på skärmen även efter att ha visat en annan bild. Så se till att du uppdaterar skärmen med några sekunders mellanrum. Vatten kan omedelbart skada de organiska materialen på dessa skärmar.

Fördelar

Inget behov av bakgrundsbelysning

Skärmarna är mycket tunna och lätta

Låg energiförbrukning

Betraktningsvinklarna är bredare än LCD -skärmar

Ljusstyrka och kontrast är bra

Hög hastighet och låg responstid

Djupt svart färg

Nackdelar

Dyr teknik

Kort livscykel

OLEDS är mer benägna att bränna sig

Vattenskada

Steg 14: Vanliga fel

För att avsluta handledningen kan vi prata om några vanliga fel

människor gör när de använder dessa skärmar:

- Kontrollera alltid stiften tre gånger innan du använder dem i ditt projekt

- Hämta rätt biblioteksadress i rubrikfilen och i din kod

#define SSD1306_I2C_ADDRESS 0x3C // i Adafruit_SSD1306.h

och

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); // i din kod

Om adressen är fel visar OLED ingenting

- Displayens storlek måste ändras i drivrutinen innan den kan användas. Om den inte ändras får du ett felmeddelande när du försöker verifiera koden

#error ("Felaktig höjd, korrigera Adafruit_SSD1306.h!");

- Om du använder NodeMCU, se till att du byter ut OLED_RESET från 4 till LED_BUILTIN

#define OLED_RESET LED_BUILTIN

Jag har scenmänniskor som gör alla möjliga saker med denna OLED -skärm. Vissa har till och med gjort videospel och allt. Jag är verkligen inte intresserad av att göra ett tv -spel med denna lilla display. Men nu ska jag låta dig utforska din fantasi och komma med fantastiska idéer.

Steg 15: Länkar

- Blogg:

- Lägg till bild:

- Anpassad text:

- Adafruit displaybibliotek:

-Adafruit GFX-bibliotek:

- u8glib -bibliotek: https://code.google.com/archive/p/u8glib/ eller

Om du vill använda den mindre skärmen använder du standard 128_32 annars för den större skärmkommentaren 128_32 och avmarkerar 128X64 NO_ACK i din kod (avmarkera bara vilken typ av skärm du använder) (teckensnitt finns i teckensnittsbiblioteket)