Hvordan grensesnitt OLED -skjerm med Arduino Nano

Arduino Nano er et lite mikrokontrollertavle som bruker ATmega328p for å behandle instruksjoner. Det ligner på Arduino UNO, men den er mye mindre i størrelse og har et lavere prispunkt. Arduino Nano brukes ofte i prosjekter der plass er en begrensning, for eksempel i bærbar elektronikk eller småskala robotikk. Arduino Nano kan brukes til å kontrollere OLED -displayet og proses -sensordataene. Denne artikkelen vil dekke grensesnitt til en OLED -skjerm med Arduino Nano.

Denne leksjonen inkluderer følgende emner:

• 1: Introduksjon til OLED -skjerm
• 2: Wiring OLED -skjermmodul til Arduino Nano
• 3: Installere nødvendige biblioteker
• 4: Kontroller OLED Display I2C -adresse
• 5: OLED Display Arduino IDE Eksempel
• 5.1: Kode
• 5.2: Output
• 6: Statisk tekstutskrift på OLED -skjerm ved hjelp av Arduino Nano
• 6.1: Kode
• 6.2: Output

1: Introduksjon til OLED -skjerm

En I2C OLED-skjerm er en organisk lysemitterende diodeskjerm som bruker den inter-integrerte krets (I2C) -protokollen for kommunikasjon. OLED-skjermer har høy kontrastforhold og større synsvinkel som gjør dem godt egnet for en rekke visningsapplikasjoner.

En I2C OLED -skjerm består vanligvis av en liten OLED -skjerm og en førerkrets som konverterer I2C -signalene til passende spenning og strømmer som trengs for å kjøre OLED -piksler.

Lysdioder inne i OLED -skjermen lyser opp pikslene som viser oss forskjellige bilder og tekst. Mens på den andre siden bruker LCD -skjermen en bakgrunnsbelysning for å belyse piksler. Disse pikslene lysstyrken kan kontrolleres separat.

Nå vil vi grensesnitt Arduino Nano med en OLED -skjerm.

2: Wiring OLED -skjermmodul til Arduino Nano

OLED -skjermer jobber hovedsakelig med to kommunikasjonsprotokoller. Disse er I2C og SPI. Blant disse to SPI (seriell perifert grensesnitt) er raskere sammenlignet med I2C, men mesteparten av tiden er I2C OLED -skjerm foretrukket på grunn av et mindre antall ledninger.

I2C er en to-ledet seriell kommunikasjonsprotokoll som lar flere enheter dele et enkelt sett med data og klokkelinjer, noe som gjør det til et praktisk valg for å koble OLED-skjermer til mikrokontrollere og andre enheter

Å bruke I2C OLED To pinner SDA og SCL er nok til å vise bilder og tekst. Det gitte bildet viser Arduino nano med 0.96-tommers (128 × 64 piksler) OLED-skjerm.

Nedenfor er tabellen PIN -tilkobling:

Siden vi har koblet sammen Arduino Nano med en OLED -skjerm, vil vi nå installere de nødvendige bibliotekene i Arduino IDE slik at vi kan komme videre med former som vises på OLED -skjermen.

3: Installere nødvendige biblioteker

For å vise bilder, må vi installere de nødvendige bibliotekene for OLED -skjerm i Arduino IDE. Uten å bruke disse bibliotekene kan Arduino Nano ikke vise grafikk på OLED.

Hovedsakelig brukes to biblioteker fra Adafruit: SSD1306 og GFX Library.

Åpne Arduino Integrated Environment (IDE) og søk SSD1306 -biblioteket. Installer Adafruit SSD1306 bibliotek.

En annen måte å installere på kommer til å: Skisse> Inkluder bibliotek> Administrer biblioteker:

Nå installer GFX Bibliotek av Adafruit:

Som vi har installert begge bibliotekene, så nå kan vi enkelt programmere Arduino Nano med en OLED -skjerm.

4: Kontroller OLED Display I2C -adresse

I2C, eller inter-integrert krets, er en kommunikasjonsprotokoll som gjør at flere enheter kan kobles til og kommunisere med hverandre over et to-trådsgrensesnitt. Hver I2C -enhet må ha en unik adresse, fra 0 til 127, for å sikre at den kan identifiseres og kommuniseres med I2C -linjen. Flere enheter med samme I2C -adresse kan ikke bruke den samme I2C -bussen.

Koble OLED -skjermen med Arduino Nano og etter valg av brett og port i Arduino IDE, last opp nedenfor gitt kode til Nano -brettet for å sjekke I2C -adressen til OLED -skjermen.

#include /*Inkluder ledning.H bibliotek for OLED -skjerm*/
ugyldig oppsett ()

Metalltråd.begynne(); /*I2c kommunikasjon med OLED starter*/
Serie.Begynn (9600); /*baudfrekvens definert for seriell kommunikasjon*/
samtidig som (!Seriell); /*Vent på serieutgang*/
Serie.println ("\ ni2c skanner");

ugyldig sløyfe ()

byte feil, adr; /*Variabel feil er definert med adresse på I2C*/
int number_of_devices;
Serie.println ("skanning.");
number_of_devices = 0;
for (ADR = 1; ADR < 127; adr++)

Metalltråd.BeginTransmission (ADR);
feil = ledning.EndTransmission ();
if (err == 0)

Serie.print ("I2C -enhet på adresse 0x");
hvis (adr < 16)
Serie.print ("0");
Serie.trykk (ADR, Hex);
Serie.Println (" !");
NUMMER_OF_DEVICES ++;

ellers hvis (err == 4)

Serie.print ("ukjent feil på adresse 0x");
hvis (adr < 16)
Serie.print ("0");
Serie.Println (ADR, Hex);


if (number_of_devices == 0)
Serie.println ("NO I2C -enheter vedlagt \ n");
ellers
Serie.println ("gjort \ n");
forsinkelse (5000); /*Vent 5 sek for neste I2C -skanning*/

Etter å ha lastet opp kode til Arduino Nano etter nevnte output, vises på Serial Monitor. OLED -en vår er koblet til 0x3c adresse.

De 0x3C I2C -adresse vil bli brukt i Arduino nano -kode for grensesnitt.

5: OLED Display Arduino IDE Eksempel

Når OLED -visningsbibliotekene er installert i Arduino IDE, kan vi se noen forhåndsritten eksempelkode i IDE. For å teste Arduino Nano -grensesnitt, vil vi laste opp en SSD1306 -eksempelkode i Arduino Nano.

Gå til: Fil> Eksempler> Adafruit SSD1306> SSD1306_128x64_I2C

Merk: Husk å velge riktig størrelse og kommunikasjonsprotokoll mens du åpner eksempelkode. Her i vårt tilfelle bruker vi I2C OLED med 128x64 størrelse.

1: Kode

Et nytt IDE -vindu vil åpne der vi kan se Adafruit OLED -eksemplet kode. Denne koden vil vise forskjellige mønstre på OLED som stjerner, sirkler, rulle tekst og animert tekst.

Merk: Husk å oppdatere I2C -adressen med din egen skjerm.

2: Output

Etter å ha lastet opp kode til Arduino Nano, kan vi se forskjellige mønstre på OLED -skjermen:

Nå har vi med hell koblet OLED -displayet med Arduino Nano ved hjelp av den forhåndsbestemte bibliotekskoden. Nå vil vi vise litt tekst på en OLED -skjerm ved hjelp av Arduino Nano.

6: Statisk tekstutskrift på OLED -skjerm ved hjelp av Arduino Nano

Adafruit GFX -biblioteket lar oss vise tekst på en OLED -skjerm. Nå skal vi skrive en enkel kode for å vise tekst på OLED.

1: Kode

Åpne Arduino IDE og laste opp kode til Arduino Nano Board:

#inkludere
#inkludere
#inkludere
#Define Screen_Width 128 /*128 Bredde på OLED i piksler* /
#defineskjerm_height 64 /*64 høyde av OLED i piksler* /
Adafruit_ssd1306 display (screen_width, screen_height, & wire, -1); /*OLED -skjerm koblet til i2c -pinner (SDA, SCL)*/
void setup ()
Serie.Begin (115200); / *Baud rate uart kommunikasjon */
hvis(!vise.Begynn (SSD1306_switchcapvcc, 0x3c)) /*i2c adresse som OLED vil kommunisere* /
Serie.Println (F ("SSD1306 tildeling mislyktes"));
til(;;);

forsinkelse (2000);
vise.clearDisplay (); /*Klar skjerm*/
vise.SettExtSize (2); /*OLED -skjermtekststørrelse definert*/
vise.setTextColor (hvit); /*OLED -skjermtekstfarge*/
vise.setcursor (0, 10); /*Vis statisk tekst*/
vise.Println ("Linuxhint.com "); /*streng for å representere på OLED -skjerm* /
vise.vise();

void loop ()

I starten av koden først importerte vi de to bibliotekene som inkluderer Wire og Adafruit Library. Ledningen.H -biblioteket lar oss bruke I2C -kommunikasjonsprotokollen mens det andre Adafruit -biblioteket hjelper til med å vise tekst på en OLED -skjerm.

Neste i kode er definert nedenfor visningsfunksjon:

Adafruit -skjermkommandoene tar 4 parametere som inkluderer Screen_width og screen_height variabler. Disse to variablene vil ta størrelsen på OLED -skjermen. Vi bruker en OLED med størrelse 128x64. Og den tredje parameteren er &Metalltråd.

Den siste parameteren er -1 som indikerer at OLED -skjermen ikke har noen ekstern tilbakestillingsknapp. Hvis vi har en OLED -skjerm med en tilbakestillingsknapp, vil vi sende denne parameteren til GPIO -pinnen. Hvis tilbakestillingsknappen trykkes, vil OLED vise tekst.

Neste I2C -adresse (0x3c) er definert som vi fikk ved å bruke Arduino I2C skannerkode.

Til slutt er strengen som skal vises på OLED -skjermen definert sammen med skriftstørrelse og farge.

Nå vil vi observere utdata på OLED -skjermen.

2: Output

I utgangen kan vi se en streng "Linuxhint.com”Vises på en OLED -skjerm med en skriftstørrelse på 2.

Vi har fullført I2C OLED -skjermgrensesnitt med Arduino Nano Board.

Konklusjon

I2C OLED (organisk lysemitterende diode) er en type OLED-skjerm som kommuniserer med en mikrokontroller eller annen enhet ved hjelp av I2C-protokollen. Denne artikkelen dekket koden til grensesnittet Arduino Nano med I2C OLED -skjerm ved bruk av Arduino IDE. Bruke den gitte metoden Enhver OLED -skjerm kan kobles sammen med Arduino Nano Board.