Pret met OLED -skerm en Arduino: 12 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:24

Ek is redelik seker dat u beslis van OLED -skermtegnologie gehoor het. Dit is relatief nuut en bied 'n beter kwaliteit as ou LCD -tegnologie. In hierdie tutoriaal wil ons die stappe hersien wat nodig is om data oor een van die mees algemene OLED -skermmodules wat op die mark beskikbaar is, te vertoon. Ek sal probeer om die funksies van die ooreenstemmende Adafruit -biblioteek te verduidelik om data oor hierdie module te vertoon.

Stap 1: Watter OLED -modules gaan ons gebruik?

OLED -modules is beskikbaar in 'n wye verskeidenheid groottes en funksies. Die een wat ons in hierdie tutoriaal gaan gebruik, is 'n monokleur 128x64 OLED -module. Hierdie tipe module is beskikbaar in die volgende groottes (sodat u dit op die foto's kan sien):

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

Aangesien al hierdie modules I2C -protokol as kommunikasiemiddel ondersteun, is die kode en bedrading van almal presies dieselfde. Die enigste verskil is dat u die grootte van die skerm op u kode moet oorweeg, sodat die inhoud wat u gaan vertoon, behoorlik daarop pas.

Stap 2: I2C in 'n neutedop

Die inter-geïntegreerde stroombaan (IIC) wat normaalweg I2C (I squared C) genoem word, ontwikkel deur Philips op die 80's as 'n data-uitruilbus wat gebruik word om data oor te dra tussen die sentrale verwerkingseenheid (SVE) of mikrobeheereenheid (MCU) van 'n toestel en perifere skyfies. Dit was basies gemik op TV -toepassings. Vanweë die eenvoud daarvan, het dit so gewild geword dat dit na 'n rukkie een van die belangrikste meganismes geword het vir die oordrag van data vir SVE's en MCU's en randapparatuur wat nie 'n noodsaaklike deel van dieselfde PCB -kaart is nie en via draad daaraan gekoppel is (bv. vertoonmodules, ens.).

I2C bestaan uit 'n kommunikasiebus van twee drade wat tweerigting -data -oordrag tussen 'n meester en verskeie slawe -toestelle ondersteun. Die hoofknooppunt is gewoonlik verantwoordelik vir die bestuur van die bus - wat eintlik gedoen word deur 'n sinchronisasie sein op die seriële kloklyn (SCL) te genereer. Dit is 'n sein wat voortdurend deur die meester tydens die oordrag gestuur sal word, en alle ander nodusse wat aan die bus gekoppel is, sal dit gebruik om hul kommunikasie te sinchroniseer en die snelheid van die bus op te spoor. Data word tussen die meester en slaaf oorgedra deur middel van 'n reeks data (SDA) lyn. Die transmissiesnelheid kan tot 3,4 Mbps wees. Alle toestelle wat data via I2C wil oordra, moet 'n unieke adres hê en kan as sender of ontvanger werk, afhangende van die funksie van die toestel. 'N OLED -vertoningsmodule is byvoorbeeld 'n ontvanger wat 'n paar data aanvaar en dit vertoon, terwyl 'n temperatuursensor 'n sender is wat die vasgestelde temperatuur via die I2C -bus stuur. Normaalweg is 'n meesterapparaat die toestel wat 'n data -oordrag op die bus begin en die klokseine genereer om die oordrag moontlik te maak. Tydens die oordrag word enige toestel wat deur hierdie meester aangespreek word, as 'n slaaf beskou en lees die data.

As 'n knoop 'n paar data wil stuur, moet die heel eerste byte van die data die adres van die ontvanger wees, en dan kom die werklike data daarna. Dit beteken dat ons eers die I2C -adres moet vind om 'n data met 'n I2C (bv.

As u belangstel om meer te wete te kom oor die besonderhede en teorieë oor die I2C -bus, kan u die volgende verwysings gebruik:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Stap 3: Vereiste modules en komponente

Hier vind u die lys van komponente wat u benodig om hierdie tutoriaal te voltooi:

eBay -skakels:

• 1 x Arduino Uno:
• 1 x OLED -module 128x64:
• 4 x Dupont -kabel:
• 1 x Mini soldeerlose broodbord:

Amazon.com -skakels:

• 1 x Arduino Uno:
• 1 x OLED -module 128x64:
• 4 x Dupont -kabel:
• 1 x Mini soldeerlose broodbord:

Stap 4: Bedraad OLED -skermmodule na Arduino

'N Belangrike opmerking oor toestelle met I2C is dat die manier waarop u dit met Arduino moet koppel, dieselfde is. Dit is omdat Arduino sy I2C -kommunikasie slegs op spesifieke penne voer. In hierdie tutoriaal gebruik ek Arduino Uno. Die Arduino Uno gebruik pen A5 as SCK en A4 as SDA. Ons kan dus die OLED -skermmodule aan die Arduino Uno koppel soos in die skematiese aansig getoon. Soos u dalk sien op die foto wat ek uit my OLED -skermmodule geneem het, is die aansluiting vir VCC en GND anders as die skematiese aansig. Onthou om die etikette van die penne op u modules na te gaan om seker te maak dat u dit op die regte manier verbind.

Ons benodig slegs 4 penne wat soos hieronder verbind moet word:

Arduino VCC -> OLED -module VCC

Arduino GND -> OLED -module GND

Arduino 4 -> OLED -module SDA

Arduino 5 -> OLED -module SCK

Stap 5: Soek die adres van die skermmodule

As 'n eerste stap om aan te sluit op 'n I2C -toestel, moet u die adres van die module hê. Om dit te kan doen, moet u net die aangehegte kode na u Arduino laai nadat u die module na u Arduino gekoppel het. Hierdie kode bevat die Wire -biblioteek, 'n biblioteek wat by Arduino IDE ingesluit is en I2C -kommunikasie hanteer. Dit probeer om gekoppelde I2C -toestelle te skandeer en stuur hul adres via die seriële poort na u rekenaar. U kan dus toegang tot die uitvoer verkry via die Serial Monitor -instrument in Arduino IDE. Die oorspronklike weergawe is beskikbaar by Arduino Playground). U kan dit ook op 'n meer leesbare manier sien in my aanlyn Arduino Editor. Moenie verwag dat iets op die skerm verskyn terwyl hierdie kode werk nie.

Soos u op die foto kan sien, is my module gebind aan die adres 0x3C. Gewoonlik het alle toestelle in 'n spesifieke produkreeks (byvoorbeeld alle 128x64 OLED -modules) dieselfde adres.

Die adres van I2C -toestelle is beperk van 1 tot 126. Hierdie kode probeer eenvoudig om in verbinding te tree met elke toestel (sonder om data oor te dra) en kyk dan of daar 'n fout is deur die onderliggende biblioteek tydens die verbinding met die gegewe adres. As daar geen fout is nie, druk die adres af as 'n beskikbare module om aan te sluit. Daar moet ook op gelet word dat die eerste 15 adresse voorbehou is, sodat dit oor hulle spring en net die bo die reeks afdruk. Onthou dat die adres van hierdie I2C-modules hardgekodeer is op die toestel en dat dit nie verander kan word nie. Dit is dus 'n goeie idee om dit êrens neer te skryf of 'n etiket op die module te plaas as u dit weer op u laboratoriumrak gaan neersit, sodat dit nie nodig is om die skandeerderkode te gebruik nie. Dit is egter nie 'n ingewikkelde prosedure nie;)

Stap 6: Die installering van biblioteke wat benodig word om data op die OLED -module te vertoon

Die Wire -biblioteek kan lae vlak kommunikasie met I2C -toestelle hanteer. As u aan 'n spesifieke toestel wil koppel om data van/na dit te lees/skryf, gebruik u gewoonlik 'n biblioteek wat deur die onderneming verskaf is wat die module oorspronklik gebou het. Hierdie biblioteek hanteer alle I2C -kommunikasiebesonderhede met die gegewe module en laat ons meer konsentreer op ons besigheid, wat in hierdie geval die data op die manier wys wat ons wil.

Adafruit, die onderneming wat die oorspronklike weergawe van sulke skermmodules vervaardig, bied 'n biblioteek met die naam Adafruit SSD1306 om data oor hierdie monochrome skerms te vertoon. Dus, voordat ons begin met kodering, moet ons hierdie biblioteek installeer via Library Manager (toeganklik via Sketch> Include Library> Manage Libraries … menu) in Arduino IDE. Daar is ook 'n ander biblioteek genaamd Adafruit GFX Library wat meer grafiese dinge op 'n lae vlak hanteer en intern deur Adafruit SSD1306 gebruik word. Beide moet op u Arduino IDE geïnstalleer word, soos u op die foto's kan sien.

Stap 7: Initialiseer die skermmodule

Die teken op die vertoonmodule is toegedraai in 'n klas genaamd Adafruit_SSD1306. Die definisie van hierdie klas is op die Adafruit -biblioteek, dus moet ons eers die biblioteek insluit. Dan moet ons eers 'n voorbeeld van hierdie klas instansieer. Die konstrukteur van hierdie klas neem die poortnommer waarop die skerm herstel kan word, wat pin 4 is (gekoppel aan SCK). Hierdie deel van die kode moet aan die begin van die lêer geleë wees (buite die opset () en lus () funksies).

#insluit

Adafruit_SSD1306 vertoon (4);

Binne die setup () -funksie moet ons die beginfunksie van die vertoonobjek noem deur ons I2C -adres soos hieronder deur te gee (die SSD1306_SWITCHCAPVCC is 'n konstante waarde wat die tipe kragbron aan die biblioteek spesifiseer):

ongeldige opstelling () {

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); vertoon.display (); } leemte lus () {} // lus kan vir eers leeg wees

Nou is die vertoonvoorwerp gereed en kan ons die funksies daarvan noem (bv. Display.write (), display.drawLine, ens.). Die belangrike opmerking is dat elke keer as ons iets aantrek deur ons skermvoorwerp aan te roep, ons die funksie display.display () moet skakel om die werklike tekening op die hardeware -vlak te laat gebeur. Dit is hoofsaaklik te wyte aan die feit dat die tekenfunksies wat ons noem, net die weergawe "in geheue" van die skerm opdateer om prestasie -redes. Dit lê eintlik die veranderinge in die geheue in die kas. Ons moet dus altyd onthou om die display () -funksie te bel wanneer ons iets op die skerm geteken het.

vertoon.skryf (…); // hou aan om in die geheue op te dateer

display.drawLine (…); // hou aan om in die geheue op te dateer. vertoon.display (); // spoel alle veranderinge aan die hardeware van die skerm af

As u probeer om u kode in hierdie stap op te laai, sal u sien dat die Adafruit Industries -logo vertoon word. U wonder miskien wie dit gevra het om dit te teken! Dit is eintlik wat die Adafruit -biblioteek doen. Dit initialiseer die geheue van die module (die weergawe in die geheue van die skermhardeware) met die logo van hierdie onderneming. As u dit nie tydens die inisialisering wil sien nie, kan u probeer om die funksie display.clearDisplay () te skakel net voordat u display.display () in u opstelfunksie bel. Hierdie funksie, soos die naam aandui, maak die skerm heeltemal skoon.

#insluit

Adafruit_SSD1306 vertoon (4); ongeldige opstelling () {display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); vertoon.display (); } leemte lus () {}

Op grond van die dokumentasie van die Adafruit_SSD1306 -biblioteek, kan u verskillende funksies van hierdie klas gebruik om op die skerm te teken of die pixels daarop direk te manipuleer. In die volgende afdelings sal ons 'n voorbeeld vir elkeen van hulle aanbied, sodat u 'n idee kan kry van hoe dit werk. Die meeste van hierdie voorbeelde bevat slegs 'n eenvoudige statiese inhoud, sodat ons dit net binne ons opset () funksie kan plaas (na die inisialiseringskode). Deur dit te doen, word dit slegs een keer uitgevoer en bly dit daar.

Stap 8: Vertoon 'n eenvoudige teks

Om 'n teks te vertoon, kan ons die eenvoudige display.println () funksie van die biblioteek gebruik. Dit aanvaar die teks as 'n string en probeer dit vertoon. Dit is belangrik om te weet dat ons die biblioteek moet vertel waar ons die teks op die skerm gaan aanbied. Elke pixel op die skerm het 'n koördinaat wat met 'n X en Y gespesifiseer word. Die X neem van links na regs toe en Y styg van bo na onder. Die boonste linkerhoek van die skerm is (X = 0, Y = 0) en die regter onderste hoek (X = 127, Y = 63). Ek het die koördinate van die hoeke op die eerste foto aangeteken. Ons kan die display.setCursor () -funksie gebruik om aan te dui waar ons die teks op die skerm sal vertoon.

'N Ander eienskap van die teks is die kleur daarvan. Ons kan die kleur spesifiseer met behulp van display.setTextColor () soos op die volgende voorbeeld vertoon.

display.clearDisplay ();

display.setTextColor (WIT); display.setCursor (35, 30); display.println ("Hallo wêreld!"); vertoon.display ();

Ons kan ook die display.write () -funksie gebruik om 'n enkele karakter te vertoon. Dit aanvaar 'n karakterkode as 'n uint8_t -tipe en vertoon die karakter wat ooreenstem met die kode op die string. As 'n voorbeeld, as ons dieselfde string met hierdie funksie wil vertoon, kan ons die volgende greep gebruik:

display.clearDisplay ();

display.setTextColor (WIT); display.setCursor (35, 30); vertoon.skryf (72); vertoon.skryf (101); vertoon.skryf (108); vertoon.skryf (108); vertoon.skryf (111); vertoon.skryf (32); vertoon.skryf (87); vertoon.skryf (111); vertoon.skryf (114); vertoon.skryf (108); vertoon.skryf (100); vertoon.skryf (33); vertoon.display ();

Dit is ook moontlik om tekste in swart kleur met 'n wit agtergrond te teken. Om dit te kan doen, moet u die display.setTextColor -funksie soos hieronder bel:

display.clearDisplay ();

// Stel die kleur in op swart met 'n wit agtergrond.setTextColor (SWART, WIT); display.setCursor (25, 30); display.println ("Omgekeerde teks!"); vertoon.display ();

U het ook die opsie om die grootte van die teks in te stel met die display.setTextSize () -funksie. Dit aanvaar 'n heelgetalgetal as 'n grootte. Hoe groter die getal, hoe groter sal die teks wees. Die kleinste grootte is 1, wat die standaard grootte van tekste is. Die volgende kode probeer om die letter "A" in 6 verskillende groottes te skryf:

display.clearDisplay ();

display.setTextColor (WIT); 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"); vertoon.display ();

Stap 9: Teken basiese vorms

Dit is baie maklik om basiese vorms soos reghoek, sirkel, driehoek, lyn of punt te teken, en daar is 'n spesiale funksie vir elkeen.

Tekenlyn

Om 'n lyn te trek, kan u display.drawLine (startX, startY, endX, endY, kleur) noem. Byvoorbeeld, die volgende kode trek 'n diagonale lyne in die skerm sodat hulle 'n groot X vorm:

display.clearDisplay ();

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

U het toegang tot die breedte en hoogte van die skerm met die funksies display.width () en display.height (). Deur dit te doen, is u kode onafhanklik van die skermgrootte.

Reghoek teken

Die funksie om 'n reghoek te teken, is display.drawRect (upperLeftX, upperLeftY, breedte, hoogte, kleur). Hier is die kode wat drie reghoeke op 'n paar ewekansige plekke teken:

display.clearDisplay ();

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

Deur display.fillRect (upperLeftX, upperLeftY, breedte, hoogte, WIT) te roep, kan u 'n reghoek teken wat deur die gespesifiseerde kleur gevul is. Die derde funksie in hierdie voorbeeld is ook display.drawRoundRect (upperLeftX, upperLeftY, breedte, hoogte, cornerRadius, kleur) wat, soos u op die foto kan sien, gebruik word om 'n reghoek met ronde hoeke te teken. Dit aanvaar 'n ekstra parameter voor kleur, 'n heelgetalgetal wat die hoekradius aandui. Hoe groter die waarde, hoe rondter is die hoek. Dit het ook 'n ooreenstemmende vulfunksie met die naam display.drawFillRoundRect, wat ek dink u kan raai wat dit doen.

Teken sirkel

Die funksie is display.drawCircle (centerX, centerY, radius, kleur). Hier is 'n voorbeeld wat 'n smiley-agtige vorm teken:

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

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

Net soos reghoeke, kan u die display.fillCircle -funksie gebruik om 'n sirkel met die gegewe kleur te teken.

Teken driehoek

Ahh, weer 'n funksie genaamd display.drawTriangle (punt1X, punt1Y, punt2X, punt2Y, punt3X, punt3Y, kleur) en ooreenstemmende display.fillTriangle wat 'n gevulde driehoek teken.

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

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

Trek 'n punt

U kan ook 'n spesifieke punt (wat pixel genoem word) op die skerm inkleur via display.drawPixel (pixelX, pixelY, kleur) funksie.

display.drawPixel (20, 35, WIT);

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

Stap 10: Teken prentjie

Om 'n prent te teken is anders en 'n bietjie ingewikkeld. Aangesien die vertoningsmodule monokleur is, moet ons ons beeld eers omskakel in 'n formaat met die naam monokleur -bitmap (ook swart en wit genoem). In so 'n formaat word elke pixel van die prent met 0 óf 1. Die 1s verteenwoordig die bestaan van die kleur en 0s beteken 'n leë spasie. U kan bo -op hierdie afdeling 'n voorbeeld van die Arduino -logo in hierdie formaat sien. Die funksie om 'n bitmap -prent te teken, is display.drawBitmap (topLeftX, topLeftY, imageData, breedte, hoogte, kleur). Die parameter imageData is 'n verskeidenheid getalle in grepe. Elke greep het 8 bisse, so elke greep bevat die data van 8 pixels van die beeld. Deur die breedte en hoogte van die prent te spesifiseer, sal die drawBitmap -funksie weet van watter bit die volgende ry pixels begin.

Die oplossing wat ek gekies het om my beeld na hierdie formaat te omskep, was om eers een van die aanlyn "image to ASCII -omsetters" (bv. Http://my.asciiart.club) te gebruik om my prent na 'n stel ASCII -karakters om te skakel en dan te vervang die karakters wat gebruik word vir leë spasie met 0 en ander met 1. Dit is wat u hieronder sien. U kan elke 0 en 1 as 'n pixel op die skerm beskou. Die grootte van die prent mag dus nie die skermgrootte van 128x64 oorskry nie.

Let wel: die gebruik van hierdie ASCII -tegniek word nie aanbeveel nie, want as gevolg van die aspekverhouding van karakters, word u beeld vervorm (karakters is nie 'n vierkant nie). Ek het hierdie tegniek probeer net omdat dit dit makliker maak om die beeld na die vereiste formaat te omskep. Anders sou dit moontlik wees om die beste resultaat te behaal deur middel van programmering of met behulp van nutsprogramme wat heeltemal buite die omvang van hierdie teks val.

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

Nou moet ons elke reël met 8 deel, wat 'n byte verteenwoordig en dit in 'n skikking soos hieronder stoor:

statiese konst ongetekende char PROGMEEM arduino_logo = {

B00000000, B00000000, B00000111, B11111111, B11111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B11111111, B11111111, B11111110, B00000000, B00000000,… // hou aan tot aan die einde van die prentjie};

Dan kan ons dit op die skerm teken deur die drawBitmap -funksie te skakel.

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

Stap 11: Probleemoplossing

Dit was 'n lang tutoriaal en daarom is dit baie waarskynlik dat iets verkeerd loop. Hier is 'n lys van 'n paar algemene foute wat u kan ondervind tydens die opstel van 'n OLED -skermmodule vir u projek (sommige het met my gebeur tydens die voorbereiding van hierdie tutoriaal).

Niks word enigsins vertoon nie

Dit kan om baie redes gebeur, dus stel ek voor dat u die volgende lys nagaan wat in u projek voorkom:

I2C -adres is waarskynlik verkeerd

Maak seker dat u die adres wat u in die i2c-skandeerderkode gekry het, in die display.begin () -funksie gestel het tydens die opstel van u skermvoorwerp.

SCL en SDA is op 'n verkeerde manier verbind

Dit het eintlik vir my gebeur. As u Arduino Uno gebruik, moet u u verbindings weer kontroleer om seker te maak dat hulle dieselfde as myne is. As u 'n ander Arduino -uitgawe gebruik (bv. Mega, Leonardo, ens.), Moet u weet dat hulle I2C moontlik op ander penne kan stel. U kan dit nagaan by die dokumentasie van die Wire -biblioteek.

U trek iets uit die sigbare gebied

Dit is 'n sagtewarekwessie. Dit is baie algemeen as u 'n tekenfunksie gebruik om 'n paar koördinate verkeerd te bereken, en u tekening sou vervorm word, of in die ergste geval kan dit heeltemal buite die toneel wees. Hersien u berekeninge en probeer 'n stap -vir -stap teken om te sien wat aangaan.

Teks word glad nie vertoon nie

U het vergeet om die kleur van die teks in te stel, of u het dit op 'n verkeerde waarde gestel

U moet setTextColor bel voordat u tekste teken. Andersins het u geen foute nie, maar u sien niks op die skerm nie. U het moontlik ook die tekskleur dieselfde as die agtergrondkleur gestel.

U gebruik 'n baie groot lettertipe

As u die teksgrootte op 'n baie groot waarde stel, is dit moontlik dat karakters heeltemal uit die sigbare gebied kom.

Daar is 'n opstelfout oor die skermgrootte

Dit het ook met my gebeur en ek dink dit sou met die meeste van julle gebeur. Dit is vanweë die konstante waardes van die skermgrootte wat in die koplêer Adafruit_SSD1306.h gedefinieer word, wat ons bo -op ons script insluit. Hierdie lêer is geleë op {your-project-folder} libraries / Adafruit_SSD1306 / Adafruit_SSD1306.h. As u hierdie lêer oopmaak, sal u opmerk dat daar 'n kommentaarafdeling soos hieronder is waarin dit beskryf dat u slegs die konstante wat u grootte van die OLED -skermmodule verteenwoordig, moet oplos. Vir 'n 128x64 -skermmodules, moet die reël #define SSD1306_128_64 ongekommenteer word.

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

SSD1306-skerms ------------------------------------------------- ---------------------- Die bestuurder word gebruik in verskeie skerms (128x64, 128x32, ens.). Kies die toepaslike skerm hieronder om 'n raambuffer van die regte grootte te maak, ens. SSD1306_128_64 128x64 pixel skerm SSD1306_128_32 128x32 pixel skerm SSD1306_96_16 --------------------------- --------------------------------------------* / #defineer SSD1306_128_64 / / #define SSD1306_128_32 // #define SSD1306_96_16 /*========================================= =================================//

Stap 12: Wat om verder te doen?

Die OLED -skerm as uitsetmodule kan u 'n uitstekende geleentheid bied om 'n professionele koppelvlak vir u stokperdjieprojekte te bied. U kan probeer om idees as uitgangspunt te volg om betekenisvolle gegewens daaroor te vertoon, of om die gebruiker te help om te weet wat aan die gang is, of as hy/sy iets moes doen. Dit sou baie duideliker wees vir 'n gebruiker om 'n boodskap op die skerm te lees as om die toestand van 'n projek/toestel via 'n paar LED's te interpreteer.

Wat u as uitgangspunt kan doen, kan wees:

• Lees 'n temperatuur sensor waarde en vertoon dit op OLED module. U kan druk- of humiditeitsensor daarby voeg en 'n volledig funksionele weerstasieprojek skep.
• Probeer om iets op die vertoonmodule te teken deur 'n joystick -module as invoertoestel te gebruik.
• Probeer 'n animasie op die skerm teken deur 'n reeks tekenoproepe/vertraagde funksieoproepe of Arduino -onderbreking
• Vertoon u pasgemaakte logo tydens die opstart van u stelsel (in plaas van Adafruit -logo)

Moenie vergeet om my met kommentaar te vertel wat u sou doen (of wat u al gedoen het) met behulp van die OLED -skermmodule nie.