Moro med OLED -skjerm og Arduino: 12 trinn (med bilder)

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:21

Jeg er ganske sikker på at du definitivt har hørt om OLED -skjermteknologi. Det er relativt nytt og tilbyr en bedre kvalitet enn gammel LCD -teknologi. I denne opplæringen ønsker vi å gå gjennom trinnene som kreves for å vise data på en av de vanligste OLED -skjermmodulene i en farge som er tilgjengelig på markedet. Jeg skal prøve å forklare funksjonalitetene fra det tilsvarende Adafruit -biblioteket for å vise data om denne modulen.

Trinn 1: Hvilke OLED -moduler skal vi bruke?

OLED -moduler er tilgjengelige i mange forskjellige størrelser og funksjoner. Den vi skal bruke i denne opplæringen er en monofarge 128x64 OLED -modul. Denne modulen er tilgjengelig i følgende størrelser (slik du ser på bildene):

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

Siden alle disse modulene støtter I2C -protokollen som et middel for kommunikasjon, er koden og ledningene til dem alle nøyaktig det samme. Den eneste forskjellen er at du må vurdere størrelsen på skjermen på koden din slik at innholdet du skal vise, passer riktig på den.

Trinn 2: I2C i et nøtteskall

Den interintegrerte kretsen (IIC) som vanligvis kalles I2C (I squared C) utviklet av Philips på 80-tallet som en datautvekslingsbuss som brukes til å overføre data mellom den sentrale behandlingsenheten (CPU) eller mikrokontrollerenheten (MCU) på en enhet og perifere chips. Det var i utgangspunktet rettet mot TV -applikasjoner. På grunn av sin enkelhet ble den så populær at den etter en stund ble en av de viktigste mekanismene for dataoverføring for CPUer og MCUer og eksterne enheter som ikke er en nødvendig del av det samme kretskortet og er koblet til det via ledning (f.eks. Sensorer, displaymoduler, etc.).

I2C består av en kommunikasjonsbuss laget av to ledninger som støtter toveis dataoverføring mellom en master og flere slaveenheter. Vanligvis er hovednoden ansvarlig for å kontrollere bussen - noe som faktisk gjøres ved å generere et synkroniseringssignal på den serielle klokkelinjen (SCL). Det er et signal som vil bli sendt kontinuerlig av master under overføringen, og alle andre noder som er koblet til bussen, vil bruke det til å synkronisere kommunikasjonen og oppdage bussens hastighet. Data overføres mellom master og slave gjennom en seriell data (SDA) linje. Overføringshastigheten kan være opptil 3,4 Mbps. Alle enheter som ønsker å overføre data via I2C bør ha en unik adresse og kan fungere som enten sender eller mottaker avhengig av enhetens funksjon. For eksempel er en OLED -skjermmodul en mottaker som godtar noen data og viser dem, mens en temperatursensor er en transceiver som sender fanget temperatur via I2C -buss. Normalt er en hovedenhet enheten som starter en dataoverføring på bussen og genererer klokkesignalene for å tillate overføring. Under denne overføringen regnes enhver enhet som adresseres av denne mesteren som en slave og leser disse dataene.

Når en node vil sende noen data, bør den aller første byten av dataene være adressen til mottakeren, og deretter kommer faktiske data etterpå. Dette betyr at for å sende data til en utdataenhet ved hjelp av I2C (f.eks. I2C OLED -skjermmodul), bør vi først finne I2C -adressen, og dette er hva vi først skal gjøre i neste trinn.

Hvis du er interessert i å vite mer om detaljene og teoriene om I2C -buss, kan du bruke følgende referanser:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Trinn 3: Nødvendige moduler og komponenter

Her finner du listen over komponenter du trenger for å fullføre denne opplæringen:

eBay lenker:

• 1 x Arduino Uno:
• 1 x OLED -modul 128x64:
• 4 x Dupont -kabel:
• 1 x Mini loddetfritt brødbrett:

Amazon.com lenker:

• 1 x Arduino Uno:
• 1 x OLED -modul 128x64:
• 4 x Dupont -kabel:
• 1 x Mini loddetfritt brødbrett:

Trinn 4: Kabling av OLED -skjermmodul til Arduino

En viktig merknad om I2C -aktiverte enheter er at måten du bør koble dem til Arduino på er den samme. Dette er fordi Arduino bare kjører sin I2C -kommunikasjon på spesifikke pinner. I denne opplæringen bruker jeg Arduino Uno. Arduino Uno bruker pin A5 som SCK og A4 som SDA. Så vi kan koble OLED -skjermmodulen til Arduino Uno som vist i skjematisk visning. Som du kanskje merker på bildet jeg har tatt fra min OLED -skjermmodul, er kontakten for VCC og GND annerledes enn den skjematiske visningen. Husk å sjekke etikettene på pinnene på modulene dine for å sikre at du kobler den til på en riktig måte.

Vi trenger bare 4 pinner som skal kobles til som nedenfor:

Arduino VCC -> OLED -modul VCC

Arduino GND -> OLED -modul GND

Arduino 4 -> OLED -modul SDA

Arduino 5 -> OLED -modul SCK

Trinn 5: Finne adressen til skjermmodulen

Som et første trinn for å koble til en I2C -aktivert enhet, må du ha adressen til modulen. For å gjøre det, etter at du har koblet modulen til Arduino, bør du bare laste opp koden som er vedlagt, til din Arduino. Denne koden inneholder Wire -biblioteket, som er et bibliotek som følger med Arduino IDE som håndterer I2C -kommunikasjon. Den prøver å skanne tilkoblede I2C -enheter og sender adressen via seriell port til datamaskinen. Så du kan få tilgang til utgangen via Serial Monitor -verktøyet i Arduino IDE. Den originale versjonen er tilgjengelig på Arduino Playground). Du kan også se den på en mer lesbar måte i min online Arduino Editor. Ikke forvent at noe skal vises på skjermen mens denne koden kjører.

Som du kan se på bildet, er modulen min bundet til adressen 0x3C. Normalt har alle enhetene i en bestemt produktlinje (for eksempel alle 128 x 64 OLED -moduler) samme adresse.

Adressen til I2C -enheter er begrenset fra 1 til 126. Denne koden prøver ganske enkelt å koble til hver enhet i rekkefølge (uten å overføre data) og deretter kontrollere om det var noen feil rapportert av det underliggende biblioteket ved tilkobling til den oppgitte adressen. Hvis det ikke er noen feil, skriver du ut adressen som en tilgjengelig modul for tilkobling. Det bør også bemerkes at de første 15 adressene er reservert, så det hopper over dem og skriver ut de over dette området. Husk at adressen til disse I2C-modulene er hardkodet på enheten, og den kan ikke endres. Så det ville være en god idé å skrive det ned et sted eller sette en etikett på modulen når du skal legge den tilbake på labhyllen, slik at det ikke er nødvendig å kjøre skannerkoden neste gang. Det er imidlertid ikke en komplisert prosedyre;)

Trinn 6: Installere biblioteker som kreves for å vise data på OLED -modulen

Wire -biblioteket kan håndtere kommunikasjon på lavt nivå med I2C -enheter. Når du vil koble til en bestemt enhet for å lese/skrive data fra/til den, vil du normalt bruke et bibliotek levert av selskapet som opprinnelig har bygd den modulen. Dette biblioteket håndterer alle I2C -kommunikasjonsdetaljer med den gitte modulen og lar oss konsentrere oss mer om virksomheten vår, som i dette tilfellet viser dataene på den måten vi ønsker.

Adafruit, selskapet som produserer den opprinnelige versjonen av slike skjermmoduler, tilbyr et bibliotek kalt Adafruit SSD1306 for å vise data på disse monokrome skjermene. Så før vi begynner å kode, må vi installere dette biblioteket via Library Manager (tilgjengelig via Sketch> Include Library> Manage Libraries … -menyen) i Arduino IDE. Det er også et annet bibliotek kalt Adafruit GFX Library som håndterer flere grafiske ting på lavt nivå og brukes internt av Adafruit SSD1306. Du må ha begge installert på Arduino IDE som du kan se på bildene.

Trinn 7: Initialiserer skjermmodulen

Tegning på displaymodul er pakket inn i en klasse som heter Adafruit_SSD1306. Definisjonen av denne klassen er på Adafruit bibliotek, så vi må først inkludere det biblioteket. Da må vi først instansere en forekomst av denne klassen. Konstruktøren av denne klassen tar portnummeret der skjermen kan tilbakestilles, som er pin 4 (koblet til SCK). Denne delen av koden skal være plassert i begynnelsen av filen (ut av oppsett () og loop () funksjoner).

#inkludere

Adafruit_SSD1306 display (4);

Nå inne i setup () -funksjonen bør vi kalle startfunksjonen til displayobjektet ved å sende I2C -adressen vår som nedenfor (SSD1306_SWITCHCAPVCC er en konstant verdi som spesifiserer typen strømkilde til biblioteket):

ugyldig oppsett () {

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

Nå er visningsobjektet klart, og vi kan kalle funksjonene (f.eks. Display.write (), display.drawLine, etc.). Den viktige merknaden er at hver gang vi trekker på noe ved å ringe til skjermobjektet vårt, må vi ringe funksjonen display.display () for å få den faktiske tegningen til å skje på maskinvarenivå. Dette skyldes hovedsakelig det faktum at tegningsfunksjonene vi kaller, bare oppdaterer "i minnet" -representasjonen av displayet av ytelsesmessige årsaker. Det lagrer faktisk endringene i minnet. Så vi bør alltid huske å ringe display () -funksjonen når vi var ferdige med å tegne noe på skjermen.

display.write (…); // fortsetter å oppdatere i minnet

display.drawLine (…); // fortsetter å oppdatere i minnet. display.display (); // skyller alle endringer i skjermens maskinvare

Hvis du prøver å laste opp koden din i dette trinnet, vil du legge merke til at Adafruit Industries -logoen vises. Du lurer kanskje på hvem som har bedt den om å tegne det! Dette er faktisk det Adafruit -biblioteket gjør. Det initialiserer minnet til modulen (representasjonen i skjermens maskinvare) med logoen til dette selskapet. Hvis du ikke vil se det under initialiseringen, kan du prøve å ringe display.clearDisplay () rett før du ringer display.display () i oppsettsfunksjonen. Denne funksjonen, som navnet antyder, sletter skjermen helt.

#inkludere

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

Basert på dokumentasjon av Adafruit_SSD1306 -biblioteket, kan du bruke forskjellige funksjoner fra denne klassen til å tegne på displayet eller manipulere pikslene direkte på det. I de neste avsnittene prøver vi å presentere et eksempel på hver av dem, slik at du kan ha en ide om hvordan det fungerer. De fleste av disse eksemplene vil bare vise et enkelt statisk innhold, så vi kan bare sette dem inne i vår setup () -funksjon (etter initialiseringskoden). Ved å gjøre det ville det bare bli kjørt en gang og forbli der.

Trinn 8: Vis en enkel tekst

For å vise en tekst kan vi bruke bibliotekets enkle display.println () -funksjon. Den godtar teksten som en streng og prøver å vise den. Det er viktig å vite at vi må fortelle biblioteket hvor vi skal presentere teksten på skjermen. Hver piksel på displayet har en koordinat som er spesifisert med X og Y. X øker fra venstre til høyre og Y øker fra topp til bunn. Øvre venstre hjørne av skjermen er (X = 0, Y = 0) og nedre høyre hjørne er (X = 127, Y = 63). Jeg noterte koordinatene til hjørnene på det første bildet. Vi kan bruke funksjonen display.setCursor () til å angi hvor på displayet vi skal vise teksten.

En annen egenskap ved teksten er fargen. Vi kan spesifisere fargen ved hjelp av display.setTextColor () som vist på følgende prøve.

display.clearDisplay ();

display.setTextColor (HVIT); display.setCursor (35, 30); display.println ("Hei verden!"); display.display ();

Vi kan også bruke display.write () -funksjonen til å vise et enkelt tegn. Den godtar en tegnkode som en uint8_t -type og viser tegnet som tilsvarer den koden på strengen. Som et eksempel, hvis vi ønsker å vise den samme strengen ved hjelp av denne funksjonen, kan vi bruke følgende kodebit:

display.clearDisplay ();

display.setTextColor (HVIT); 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å mulig å tegne tekster i svart farge med hvit bakgrunn. For å gjøre dette må du ringe display.setTextColor -funksjonen som nedenfor:

display.clearDisplay ();

// Angir fargen til svart med en hvit bakgrunnsdisplay.setTextColor (SVART, HVIT); display.setCursor (25, 30); display.println ("Omvendt tekst!"); display.display ();

Du har også muligheten til å angi størrelsen på teksten ved hjelp av funksjonen display.setTextSize (). Den godtar et heltall som en størrelse. Jo større tallet er, desto større blir teksten. Den minste størrelsen er 1, som er standardstørrelsen på tekster. Følgende kode prøver å skrive bokstaven "A" i 6 forskjellige størrelser:

display.clearDisplay ();

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

Trinn 9: Tegne grunnleggende former

Å tegne grunnleggende former som rektangel, sirkel, trekant, linje eller punkt er veldig enkelt, og det er en egen funksjon for hver enkelt.

Tegningslinje

For å tegne en linje kan du ringe display.drawLine (startX, startY, endX, endY, farge). For eksempel tegner følgende kode en diagonale linjer på skjermen slik at 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 får tilgang til bredden og høyden på skjermen ved hjelp av funksjonene display.width () og display.height (). Ved å gjøre dette vil koden din være uavhengig av skjermstørrelsen.

Tegning rektangel

Funksjonen for å tegne et rektangel er display.drawRect (upperLeftX, upperLeftY, bredde, høyde, farge). Her er koden som tegner tre rektangler på noen tilfeldige steder:

display.clearDisplay ();

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

Ved å ringe display.fillRect (upperLeftX, upperLeftY, bredde, høyde, HVIT) kan du tegne et rektangel fylt med spesifisert farge. Den tredje funksjonen i dette eksemplet er også display.drawRoundRect (upperLeftX, upperLeftY, bredde, høyde, cornerRadius, farge) som du kan se på bildet brukes til å tegne et rektangel med runde hjørner. Den godtar en ekstra parameter før farge som er et heltall som angir hjørneradius. Jo større verdi, jo rundere hjørne. Den har også en tilsvarende fyllfunksjon som heter display.drawFillRoundRect som jeg tror du kan gjette hva den gjør.

Tegningssirkel

Funksjonen er display.drawCircle (centerX, centerY, radius, farge). Her er et eksempel som tegner en smiley-lignende form:

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

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

Som rektangler kan du bruke display.fillCircle -funksjonen til å tegne en sirkel fylt med den angitte fargen.

Tegning trekant

Ahh, igjen en funksjon som kalles display.drawTriangle (poin1X, point1Y, point2X, point2Y, point3X, point3Y, color) og tilsvarende display.fillTriangle som tegner en fylt trekant.

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

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

Trekk et poeng

Du kan også farge et bestemt punkt (som kalles piksel) på skjermen via display.drawPixel (pixelX, pixelY, farge) -funksjonen.

display.drawPixel (20, 35, WHITE);

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

Trinn 10: Tegne bilde

Å tegne et bilde er annerledes og litt komplisert. Siden skjermmodulen er monokolor, må vi først konvertere bildet vårt til et format som kalles monofarge -bitmap (også kalt svart og hvitt). I et slikt format blir hver piksel i bildet presentert med enten 0 eller 1. 1ene representerer eksistensen av fargen og 0s betyr et tomt mellomrom. Du kan se et eksempel på Arduino -logoen i dette formatet på toppen av denne delen. Funksjonen for å tegne et punktgrafikkbilde er display.drawBitmap (topLeftX, topLeftY, imageData, bredde, høyde, farge). ImageData -parameteren er en rekke tall i byte. Hver byte har 8 bits, så hver byte inneholder dataene til 8 piksler i bildet. Ved å spesifisere bredden og høyden på bildet, vil drawBitmap -funksjonen vite fra hvilken bit neste rad med piksler begynner.

Løsningen jeg valgte å konvertere bildet mitt til dette formatet var å først bruke en av online "image to ASCII -omformere" (f.eks. Http://my.asciiart.club) for å konvertere bildet mitt til et sett med ASCII -tegn og deretter erstatte det tegnene som brukes for tomrom med 0 og andre med 1. Det er det du ser nedenfor. Du kan tenke på hver 0 og 1 som en piksel på skjermen. Så størrelsen på bildet bør ikke overstige skjermstørrelsen vår som er 128x64.

Merk: Å bruke denne ASCII -teknikken er ikke en anbefalt tilnærming, fordi bildet ditt blir deformert på grunn av størrelsesforholdet mellom tegn (tegn er ikke en firkant). Jeg prøvde denne teknikken bare fordi det gjør det lettere å konvertere bildet til ønsket format. Ellers ville det være mulig å oppnå det beste resultatet via programmering eller bruk av noen verktøy som er helt utenfor omfanget av denne teksten.

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

Nå skal vi dele hver linje med 8, som representerer en byte og lagre dem i en matrise 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,… // fortsette til slutten av bildet};

Deretter kan vi tegne det på skjermen ved å ringe drawBitmap -funksjonen.

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

Trinn 11: Feilsøking

Dette var en lang opplæring, og det er derfor svært sannsynlig at noe går galt. Her er listen over noen vanlige feil du kan støte på når du konfigurerer OLED -skjermmodul for prosjektet ditt (noen av dem skjedde for meg mens du forberedte denne opplæringen).

Ingenting vises i det hele tatt

Dette kan skje av mange grunner, så jeg foreslår at du sjekker følgende liste som er i orden som kan forekomme i prosjektet ditt:

I2C -adressen er sannsynligvis feil

Sørg for at du har angitt adressen du fikk i i2c-skannerkoden i display.begin () -funksjonen når du konfigurerer skjermobjektet.

SCL og SDA er tilkoblet på en feil måte

Dette skjedde faktisk for meg. Hvis du bruker Arduino Uno, må du sjekke tilkoblingene igjen for å sikre at de er koblet til det samme som mine. Hvis du bruker en annen Arduino -utgave (f.eks. Mega, Leonardo, etc.), må du vite at de kan ha I2C satt til andre pins. Du kan sjekke det i dokumentasjonen til Wire -biblioteket.

Du trekker noe ut av det synlige området

Dette er et programvareproblem. Det er veldig vanlig når du bruker tegnefunksjoner for å feilberegne noen koordinater, så tegningen din blir deformert, eller i verste fall kan den være helt ute av scenen. Gjennomgå beregningene dine og prøv å lage en trinnvis tegning for å se hva som skjer.

Tekst vises ikke i det hele tatt

Du glemte å angi fargen på teksten, eller du har satt den til en feil verdi

Du må ringe setTextColor før du tegner tekster. Ellers har du ingen feil, men du ser ingenting på skjermen. Du kan også ha angitt tekstfargen på samme måte som bakgrunnsfargen.

Du bruker en veldig stor skrift

Hvis du setter tekststørrelsen til en veldig stor verdi, kan det være mulig at tegn kommer helt ut av det synlige området.

Det er en kompileringsfeil om skjermstørrelsen

Dette skjedde også for meg, og jeg tror det ville skje for de fleste av dere. Det er på grunn av visningsstørrelsens konstante verdier som er definert inne i toppfilen Adafruit_SSD1306.h som vi tar med på toppen av skriptet vårt. Denne filen ligger i {your-project-folder} libraries / Adafruit_SSD1306 / Adafruit_SSD1306.h. Hvis du åpner denne filen vil du legge merke til at det er en kommentarseksjon som nedenfor der den beskriver at du bare trenger å kommentere konstanten som representerer OLED -skjermmodulstørrelsen. For en 128x64 skjermmoduler, bør linjen #define SSD1306_128_64 være uten kommentar.

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

SSD1306-skjermer ------------------------------------------------- ---------------------- Driveren brukes på flere skjermer (128x64, 128x32, etc.). Velg riktig skjerm nedenfor for å lage en passende størrelse rammebuffer, etc. 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 /*========================================= ================================*/

Trinn 12: Hva skal jeg gjøre videre?

OLED -skjermen som utgangsmodul kan gi deg en flott mulighet til å tilby et profesjonelt grensesnitt til hobbyprosjektene dine. Du kan prøve å følge ideer som utgangspunkt for å vise meningsfylte data om det, eller hjelpe brukeren å vite hva som skjer eller om han/hun trengte å gjøre noe. Det ville være mye tydeligere for en bruker å lese en melding på en skjerm enn å tolke tilstanden til et prosjekt/enhet via noen lysdioder.

Det du kan gjøre som utgangspunkt kan være:

• Les en temperatursensorverdi og vis den på OLED -modulen. Du kan legge til trykk- eller fuktighetssensor til den og lage et fullt funksjonelt værstasjonsprosjekt.
• Prøv å tegne noe på skjermmodulen ved hjelp av en joystick -modul som inndataenhet.
• Prøv å tegne en animasjon på skjermen med en sekvens med tegning/forsinkelse av funksjonsanrop eller Arduino -avbrudd
• Vis din tilpassede logo ved systemoppstart (i stedet for Adafruit -logo)

Ikke glem å fortelle meg om kommentarer, hva ville du gjort (eller du har allerede gjort) ved hjelp av OLED -skjermmodul.