Sjovt med OLED -skærm og Arduino: 12 trin (med billeder)

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:26

Jeg er ret sikker på, at du helt sikkert har hørt om OLED -skærmteknologi. Det er relativt nyt og tilbyder en bedre kvalitet end gammel LCD -teknologi. I denne vejledning vil vi gennemgå de trin, der er nødvendige for at vise data på et af de mest almindelige enkeltfarvede OLED -displaymoduler, der er tilgængelige på markedet. Jeg vil forsøge at forklare funktionaliteter fra det tilsvarende Adafruit -bibliotek for at vise data om dette modul.

Trin 1: Hvilke OLED -moduler skal vi bruge?

OLED -moduler fås i mange forskellige størrelser og funktioner. Den, vi skal bruge i denne vejledning, er et monofarvet 128x64 OLED -modul. Denne type modul er tilgængelig i følgende størrelser (For at du kan se på billederne):

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

Da alle disse moduler understøtter I2C -protokollen som middel til kommunikation, er koden og ledningerne til dem alle nøjagtig den samme. Den eneste forskel er, at du skal overveje størrelsen på skærmen på din kode, så det indhold, du vil vise, passer korrekt på den.

Trin 2: I2C i en nøddeskal

Det interintegrerede kredsløb (IIC), der normalt kaldes I2C (I squared C) udviklet af Philips på 80'erne som en dataudvekslingsbus, der bruges til at overføre data mellem den centrale behandlingsenhed (CPU) eller mikrokontrolenhed (MCU) på en enhed og perifere chips. Det var dybest set målrettet mod tv -applikationer. På grund af sin enkelhed blev den så populær, at den efter et stykke tid blev en af de primære mekanismer for dataoverførsel til CPU'er og MCU'er og perifere enheder, der ikke er en nødvendig del af det samme printkort og er forbundet til det via ledning (f.eks. Sensorer, displaymoduler osv.).

I2C består af en kommunikationsbus lavet af to ledninger, der understøtter tovejs dataoverførsel mellem en master og flere slaveenheder. Typisk er hovednoden ansvarlig for at styre bussen - hvilket faktisk gøres ved at generere et synkroniseringssignal på den serielle urlinje (SCL). Det er et signal, der ville blive sendt kontinuerligt af master under overførslen, og alle andre knuder, der er forbundet til bussen, vil bruge det til at synkronisere deres kommunikation og registrere busens hastighed. Data overføres mellem master og slave gennem en seriel data (SDA) linje. Overførselshastigheden kan være op til 3,4 Mbps. Alle enheder, der ønsker at overføre data via I2C, skal have en unik adresse og kan fungere som enten sender eller modtager afhængigt af enhedens funktion. For eksempel er et OLED -displaymodul en modtager, der accepterer nogle data og viser dem, mens en temperatursensor er en transceiver, der sender registreret temperatur via I2C -bus. Normalt er en master -enhed den enhed, der initierer en dataoverførsel på bussen og genererer urets signaler for at muliggøre overførsel. Under denne overførsel betragtes enhver enhed, der adresseres af denne master, som en slave og læser disse data.

Når en knude ønsker at sende nogle data, skal den allerførste byte af dataene være adressen på modtageren, og derefter kommer de faktiske data bagefter. Dette betyder, at for først at kunne sende en data til en outputenhed ved hjælp af I2C (f.eks. I2C OLED -displaymodul), skal vi først finde dens I2C -adresse, og det er det, vi skal gøre først i de næste trin.

Hvis du er interesseret i at vide mere om detaljerne og teorierne om I2C -bus, kan du bruge følgende referencer:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Trin 3: Påkrævede moduler og komponenter

Her kan du finde listen over komponenter, du skal bruge for at fuldføre denne vejledning:

eBay -links:

• 1 x Arduino Uno:
• 1 x OLED -modul 128x64:
• 4 x Dupont -kabel:
• 1 x Mini loddefrit brødbræt:

Amazon.com links:

• 1 x Arduino Uno:
• 1 x OLED -modul 128x64:
• 4 x Dupont -kabel:
• 1 x Mini loddefrit brødbræt:

Trin 4: Kabelføring af OLED -skærmmodul til Arduino

En vigtig bemærkning om I2C -aktiverede enheder er, at den måde, du skal forbinde dem til Arduino på, er den samme. Dette skyldes, at Arduino kun kører sin I2C -kommunikation på bestemte stifter. I denne vejledning bruger jeg Arduino Uno. Arduino Uno bruger pin A5 som SCK og A4 som SDA. Så vi kan forbinde OLED -displaymodulet til Arduino Uno som vist i den skematiske visning. Som du måske bemærker på det billede, jeg har taget fra mit OLED -displaymodul, er stikket til VCC og GND anderledes end den skematiske visning. Husk at tjekke etiketterne på benene på dine moduler for at sikre, at du forbinder det på den rigtige måde.

Vi mangler kun 4 ben, der skal tilsluttes som nedenfor:

Arduino VCC -> OLED -modul VCC

Arduino GND -> OLED -modul GND

Arduino 4 -> OLED -modul SDA

Arduino 5 -> OLED -modul SCK

Trin 5: Find adressen på displaymodulet

Som et første trin i forbindelse med tilslutning til en I2C -aktiveret enhed skal du have modulets adresse. For at gøre dette, efter at have koblet modulet til din Arduino, skal du bare uploade den vedhæftede kode til din Arduino. Denne kode inkorporerer Wire -biblioteket, som er et bibliotek, der følger med Arduino IDE, der håndterer I2C -kommunikation. Det forsøger at scanne tilsluttede I2C -enheder og sender deres adresse via seriel port til din computer. Så du kan få adgang til dens output via Serial Monitor -værktøj i Arduino IDE. Den originale version er tilgængelig på Arduino Playground). Du kan også se det på en mere læsbar måde i min online Arduino Editor. Forvent ikke, at der vises noget på skærmen, mens denne kode kører.

Som du kan se på billedet, er mit modul bundet til adressen 0x3C. Normalt har alle enhederne i en bestemt produktlinje (f.eks. Alle 128x64 OLED -moduler) samme adresse.

Adressen for I2C -enheder er begrænset fra 1 til 126. Denne kode forsøger simpelthen at oprette forbindelse til hver enhed i rækkefølge (uden at overføre data) og derefter kontrollere, om der var en fejl rapporteret af det underliggende bibliotek ved forbindelse til den angivne adresse. Hvis der ikke er nogen fejl, udskrives adressen som et tilgængeligt modul til tilslutning. Det skal også bemærkes, at de første 15 adresser er reserverede, så det hopper over dem og udskriver bare dem over dette område. Husk, at adressen på disse I2C-moduler er hårdt kodet på enheden, og den kan ikke ændres. Så det ville være en god idé at skrive det ned et sted eller sætte en etiket på modulet, når du skal lægge det tilbage på din laboratoriehylde, så næste gang ville det ikke være nødvendigt at køre scannerkoden. Det er dog ikke en kompliceret procedure;)

Trin 6: Installation af biblioteker, der kræves for at vise data på OLED -modul

Wire -biblioteket kan håndtere kommunikation på lavt niveau med I2C -enheder. Når du vil oprette forbindelse til en bestemt enhed for at læse/skrive data fra/til den, vil du normalt bruge et bibliotek leveret af virksomheden, der oprindeligt har bygget det modul. Dette bibliotek håndterer alle I2C -kommunikationsdetaljer med et givet modul og lader os koncentrere os mere om vores forretning, som i dette tilfælde viser dataene på den måde, vi ønsker.

Adafruit, virksomheden, der fremstiller den originale version af sådanne displaymoduler, leverer et bibliotek kaldet Adafruit SSD1306 for at vise data om disse monokrome skærme. Så før vi begynder at kode, skal vi installere dette bibliotek via Library Manager (tilgængeligt via Sketch> Include Library> Manage Libraries … menu) i Arduino IDE. Der er også et andet bibliotek kaldet Adafruit GFX Library, der håndterer flere grafiske ting på lavt niveau og bruges internt af Adafruit SSD1306. Du skal have dem begge installeret på din Arduino IDE, som du kan se på billederne.

Trin 7: Initialisering af displaymodulet

Tegning på displaymodul er pakket ind i en klasse ved navn Adafruit_SSD1306. Definitionen af denne klasse er på Adafruit bibliotek, så vi skal først inkludere det bibliotek. Så er vi nødt til at instantiere en forekomst af denne klasse først. Konstruktøren af denne klasse tager det portnummer, hvormed displayet kunne nulstilles, hvilket er pin 4 (forbundet til SCK). Denne del af koden skal være placeret i begyndelsen af filen (uden for setup () og loop () funktioner).

#omfatte

Adafruit_SSD1306 display (4);

Nu inde i opsætningsfunktionen () skal vi kalde skærmobjektets startfunktion ved at sende vores I2C -adresse som nedenfor (SSD1306_SWITCHCAPVCC er en konstant værdi, der angiver typen af strømkilde til biblioteket):

ugyldig opsætning () {

display.begynder (SSD1306_SWITCHCAPVCC, 0x3C); display.display (); } void loop () {} // loop kan være tom for nu

Nu er visningsobjektet klar, og vi kan kalde dets funktioner (f.eks. Display.write (), display.drawLine osv.). Den vigtige bemærkning er, at når vi trækker noget på ved at kalde på vores displayobjekt, skal vi ringe til display.display () -funktionen for at få den faktiske tegning til at ske på hardwareniveau. Dette skyldes hovedsageligt det faktum, at de tegnefunktioner, vi kalder, bare opdaterer "i hukommelsen" -repræsentationen af displayet af præstationsmæssige årsager. Det gemmer faktisk ændringer i hukommelsen. Så vi skal altid huske at kalde display () -funktionen, når vi var færdige med at tegne noget på skærmen.

display.write (…); // bliver ved med at opdatere i hukommelsen

display.drawLine (…); // bliver ved med at opdatere i hukommelsen. display.display (); // skyller alle ændringer af skærmens hardware

Hvis du prøver at uploade din kode i dette trin, vil du bemærke, at Adafruit Industries -logoet vises. Du kan undre dig over, hvem der har bedt det om at tegne det! Det er faktisk det, Adafruit -biblioteket gør. Det initialiserer modulets hukommelse (repræsentationen i hukommelsen af skærmens hardware) med dette firmas logo. Hvis du ikke vil se det under initialiseringen, kan du prøve at kalde display.clearDisplay () -funktionen lige før du kalder display.display () i din opsætningsfunktion. Denne funktion, som navnet antyder, sletter displayet fuldstændigt.

#omfatte

Adafruit_SSD1306 display (4); ugyldig opsætning () {display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); display.display (); } void loop () {}

Baseret på dokumentation af Adafruit_SSD1306 -biblioteket kan du bruge forskellige funktioner fra denne klasse til at tegne på displayet eller direkte manipulere pixelerne på det. I de næste afsnit prøver vi at præsentere et eksempel for hver enkelt af dem, så du kan få en idé om, hvordan det fungerer. De fleste af disse eksempler viser bare et simpelt statisk indhold, så vi kan bare sætte dem inde i vores setup () -funktion (efter initialiseringskoden). Ved at gøre det ville det kun blive kørt en gang og forbliver der.

Trin 8: Vis en enkel tekst

For at vise en tekst kan vi bruge bibliotekets simple display.println () -funktion. Den accepterer teksten som en streng og forsøger at vise den. Det er vigtigt at vide, at vi skal fortælle biblioteket, hvor vi på displayet skal præsentere teksten. Hver pixel på displayet har en koordinat, der er angivet med et X og Y. X stiger fra venstre mod højre og Y stiger fra top til bund. Skærmens øverste venstre hjørne er (X = 0, Y = 0) og nederste højre hjørne er (X = 127, Y = 63). Jeg noterede mig koordinaterne for hjørnerne på det første billede. Vi kan bruge funktionen display.setCursor () til at angive, hvor på displayet vi skal vise teksten.

En anden egenskab ved teksten er dens farve. Vi kan angive farven ved hjælp af display.setTextColor () som vist på følgende prøve.

display.clearDisplay ();

display.setTextColor (HVID); display.setCursor (35, 30); display.println ("Hej verden!"); display.display ();

Vi kan også bruge funktionen display.write () til at vise et enkelt tegn. Det accepterer en tegnkode som en uint8_t -type og viser tegnet, der svarer til den kode, på strengen. Som et eksempel, hvis vi vil vise den samme streng ved hjælp af denne funktion, kan vi bruge følgende uddrag:

display.clearDisplay ();

display.setTextColor (HVID); 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 ();

Det er også muligt at tegne tekster i sort farve med en hvid baggrund. For at gøre dette skal du ringe til display.setTextColor -funktionen som nedenfor:

display.clearDisplay ();

// Indstiller farven til sort med en hvid baggrundsvisning. SetTextColor (SORT, HVID); display.setCursor (25, 30); display.println ("Omvendt tekst!"); display.display ();

Du har også mulighed for at indstille tekstens størrelse ved hjælp af funktionen display.setTextSize (). Det accepterer et heltal som en størrelse. Jo større tal, jo større ville teksten være. Mindste størrelse er 1, som er standardstørrelsen på tekster. Følgende kode forsøger at skrive bogstavet "A" i 6 forskellige størrelser:

display.clearDisplay ();

display.setTextColor (HVID); 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 ();

Trin 9: Tegning af grundlæggende former

Tegning af grundformer som rektangel, cirkel, trekant, linje eller punkt er meget let, og der er en dedikeret funktion til hver enkelt.

Tegningslinje

For at tegne en linje kan du kalde display.drawLine (startX, startY, endX, endY, farve). For eksempel tegner følgende kode en diagonale linjer på skærmen, så de former et stort X:

display.clearDisplay ();

display.drawLine (0, 0, display.width () - 1, display.height () - 1, WHITE); display.drawLine (display.width () - 1, 0, 0, display.height () - 1, WHITE); display.display ();

Du kan få adgang til bredden og højden på displayet ved hjælp af display.width () og display.height () funktioner. Ved at gøre det ville din kode være uafhængig af skærmstørrelsen.

Tegning rektangel

Funktionen til at tegne et rektangel er display.drawRect (upperLeftX, upperLeftY, bredde, højde, farve). Her er koden, der tegner tre rektangler på nogle tilfældige steder:

display.clearDisplay ();

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

Ved at kalde display.fillRect (upperLeftX, upperLeftY, bredde, højde, HVID) kan du tegne et rektangel fyldt med den angivne farve. Den tredje funktion i dette eksempel er også display.drawRoundRect (upperLeftX, upperLeftY, bredde, højde, cornerRadius, farve), der som du kan se på billedet bruges til at tegne et rektangel med runde hjørner. Det accepterer en ekstra parameter før farve, der er et helt tal, der angiver hjørneradius. Jo større værdi jo rundere hjørne. Det har også en tilsvarende udfyldningsfunktion ved navn display.drawFillRoundRect, som jeg tror, du kan gætte, hvad det gør.

Tegningscirkel

Funktionen er display.drawCircle (centerX, centerY, radius, farve). Her er et eksempel, der tegner en smiley-lignende form:

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

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

Ligesom rektangler kan du bruge funktionen display.fillCircle til at tegne en cirkel fyldt med den givne farve.

Tegning trekant

Ahh, igen en funktion kaldet display.drawTriangle (poin1X, point1Y, point2X, point2Y, point3X, point3Y, color) og tilsvarende display.fillTriangle, der tegner en fyldt trekant.

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

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

Tegn et punkt

Du kan også farve et bestemt punkt (som kaldes pixel) på skærmen via display.drawPixel (pixelX, pixelY, farve) funktion.

display.drawPixel (20, 35, WHITE);

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

Trin 10: Tegning af billede

At tegne et billede er anderledes og lidt kompliceret. Da skærmmodulet er monokulært, skal vi først konvertere vores billede til et format kaldet monofarve bitmap (også kaldet sort og hvid). I et sådant format præsenteres hver pixel i billedet med enten 0 eller 1. 1'erne repræsenterer eksistensen af farven, og 0'erne betyder et tomt mellemrum. Du kan se et eksempel på Arduino -logoet i dette format oven på dette afsnit. Funktionen til at tegne et bitmapbillede er display.drawBitmap (topLeftX, topLeftY, imageData, bredde, højde, farve). Parameteren imageData er en række tal i bytes. Hver byte har 8 bits, så hver byte indeholder dataene fra 8 pixel i billedet. Ved at angive bredden og højden på billedet ved drawBitmap -funktionen, fra hvilken bit den næste række pixels begynder.

Løsningen, som jeg valgte at konvertere mit billede til dette format, var først at bruge en af online "image til ASCII -konvertere" (f.eks. Http://my.asciiart.club) til at konvertere mit billede til et sæt ASCII -tegn og derefter erstatte tegnene, der bruges til tomrum med 0 og andre med 1. Det er det, du ser nedenfor. Du kan tænke på hver 0 og 1 som en pixel på displayet. Så billedets størrelse bør ikke overstige vores skærmstørrelse, som er 128x64.

Bemærk: Brug af denne ASCII -teknik er ikke en anbefalet fremgangsmåde, fordi billedets aspektforhold vil blive deformeret (tegn er ikke en firkant). Jeg prøvede denne teknik, bare fordi det gør det lettere at konvertere billedet til det nødvendige format. Ellers ville det være muligt at opnå det bedste resultat via programmering eller ved hjælp af nogle hjælpeprogrammer, der er helt uden for denne teksts anvendelsesområde.

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

Nu skal vi dividere hver linje med 8, der repræsenterer en byte og gemme dem i et array som nedenfor:

statisk const unsigned char PROGMEM arduino_logo = {

B00000000, B00000000, B00000111, B11111111, B11111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B11111111, B11111111, B11111110, B00000000, B00000000,… // fortsætte op til slutningen af billedet};

Derefter kan vi tegne det på skærmen ved at kalde drawBitmap -funktionen.

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

Trin 11: Fejlfinding

Dette var en lang vejledning, og det er derfor meget sandsynligt, at noget går galt. Her er listen over nogle almindelige fejl, du kan støde på, når du konfigurerer OLED -displaymodul til dit projekt (nogle af dem skete for mig under forberedelsen af denne vejledning).

Intet vises overhovedet

Dette kan ske af mange grunde, så jeg foreslår at tjekke følgende liste, som er i orden, der kan forekomme i dit projekt:

I2C -adressen er sandsynligvis forkert

Sørg for, at du har angivet den adresse, du fik i i2c-scannerkoden i display.begin () -funktionen, når du konfigurerer dit displayobjekt.

SCL og SDA er forbundet på en forkert måde

Dette skete faktisk for mig. Hvis du bruger Arduino Uno, skal du kontrollere dine forbindelser igen for at sikre, at de er forbundet på samme måde som mine. Hvis du bruger en anden Arduino -udgave (f.eks. Mega, Leonardo osv.), Skal du vide, at de muligvis har deres I2C indstillet til andre pins. Du kan kontrollere det i dokumentationen til Wire -biblioteket.

Du trækker noget ud af det synlige område

Dette er et softwareproblem. Det er meget almindeligt, når du bruger en tegningsfunktion til at fejlberegne nogle koordinater, så din tegning ville blive deformeret, eller i værste fald kan den være helt ude af scenen. Gennemgå dine beregninger, og prøv at tegne trin for trin for at se, hvad der foregår.

Tekst vises slet ikke

Du har glemt at angive tekstens farve, eller du har indstillet den til en forkert værdi

Du skal ringe til setTextColor, før du tegner tekster. Ellers har du ingen fejl, men du kan ikke se noget på skærmen. Du har muligvis også indstillet tekstfarven på samme måde som baggrundsfarven.

Du bruger en meget stor skrifttype

Hvis du indstiller tekststørrelsen til en meget stor værdi, kan det være muligt, at tegn kommer helt ud af det synlige område.

Der er en kompileringsfejl om skærmstørrelse

Dette skete også for mig, og jeg tror, det ville ske for de fleste af jer. Det er på grund af de konstante værdier i displaystørrelsen, der er defineret inde i header -filen Adafruit_SSD1306.h, som vi inkluderer oven på vores script. Denne fil findes på {din-projekt-mappe} biblioteker / Adafruit_SSD1306 / Adafruit_SSD1306.h. Hvis du åbner denne fil, vil du bemærke, at der er et kommentarsektion som nedenfor, hvor det beskriver, at du kun skal fjerne en kommentar fra den konstant, der repræsenterer din OLED -skærmmodulstørrelse. For et 128x64 -skærmmodul bør linjen #define SSD1306_128_64 være uden kommentarer.

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

SSD1306-skærme ------------------------------------------------- ---------------------- Driveren bruges på flere skærme (128x64, 128x32 osv.). Vælg den relevante skærm herunder for at oprette en passende størrelse framebuffer osv. SSD1306_128_64 128x64 pixel display SSD1306_128_32 128x32 pixel display SSD1306_96_16 --------------------------- --------------------------------------------* / #define SSD1306_128_64 / / #define SSD1306_128_32 // #define SSD1306_96_16 /*========================================= =================================*/

Trin 12: Hvad skal jeg gøre derefter?

OLED -displayet som outputmodul kan give dig en fantastisk mulighed for at give et professionelt udseende interface til dine hobbyprojekter. Du kan prøve at følge ideer som udgangspunkt for at vise meningsfulde data om det eller hjælpe brugeren med at vide, hvad der foregår, eller hvis han/hun havde brug for at gøre noget. Det ville være meget klarere for en bruger at læse en meddelelse på et display end at fortolke tilstanden af et projekt/enheden via nogle lysdioder.

Hvad du kan gøre som udgangspunkt kan være:

• Læs en temperatursensorværdi, og vis den på OLED -modulet. Du kan tilføje tryk- eller fugtighedsføler til den og oprette et fuldt funktionelt vejrstationsprojekt.
• Prøv at tegne noget på displaymodulet ved hjælp af et joystick -modul som inputenhed.
• Prøv at tegne en animation på displayet ved hjælp af en sekvens af tegne/forsinke funktionsopkald eller Arduino -afbrydelse
• Vis dit brugerdefinerede logo ved din systemstart (i stedet for Adafruit Logo)

Glem ikke at fortælle mig om kommentarer, hvad ville du gøre (eller du har allerede gjort) ved hjælp af OLED -displaymodul.