Szórakozás az OLED kijelzővel és az Arduino -val: 12 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:39

Biztos vagyok benne, hogy biztosan hallott már az OLED kijelzőtechnológiáról. Viszonylag új, és jobb minőséget kínál, mint a régi LCD technológia. Ebben az oktatóanyagban át akarjuk tekinteni azokat a lépéseket, amelyek szükségesek az adatok megjelenítéséhez a piacon elérhető egyik leggyakoribb egyszínű OLED kijelzőmodulon. Megpróbálom elmagyarázni a funkciókat, amelyeket a megfelelő Adafruit könyvtár biztosít az adatok megjelenítéséhez ezen a modulon.

1. lépés: Milyen OLED modulokat fogunk használni?

Az OLED modulok sokféle méretben és funkcióban kaphatók. Ebben az oktatóanyagban egy mono színes 128x64 OLED modult fogunk használni. Ez a típusú modul a következő méretekben kapható (a képeken látható módon):

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

Mivel ezek a modulok kommunikációs eszközként támogatják az I2C protokollt, mindegyik kódja és kábelezése pontosan ugyanaz. Az egyetlen különbség az, hogy figyelembe kell vennie a kód méretét a kijelzőn, hogy a megjeleníteni kívánt tartalom megfelelően illeszkedjen rá.

2. lépés: I2C dióhéjban

Az integrált áramkör (IIC), amelyet általában I2C-nek (I négyzet C) neveznek, a Philips fejlesztette ki a 80-as években, mint adatcsere busz, amelyet az adatok központi processzor (CPU) vagy mikrovezérlő egység (MCU) közötti adatátvitelre használnak, és perifériás chipek. Alapvetően TV -alkalmazásra irányult. Egyszerűsége miatt annyira népszerűvé vált, hogy egy idő után ez lett az egyik elsődleges adatátviteli mechanizmus a CPU -k, MCU -k és perifériás eszközök számára, amelyek nem szükségesek ugyanannak a PCB -kártyának, és amelyek vezetéken keresztül csatlakoznak hozzá (pl. kijelző modulok stb.).

Az I2C két vezetékből álló kommunikációs buszból áll, amely támogatja a kétirányú adatátvitelt a master és több slave eszköz között. Általában a főcsomópont felelős a busz vezérléséért - ami valójában szinkronizációs jel generálásával történik a soros óra vonalon (SCL). Ez egy olyan jel, amelyet a mester folyamatosan küld az átvitel során, és a buszhoz csatlakoztatott összes többi csomópont ezt fogja használni a kommunikáció szinkronizálásához és a busz sebességének észleléséhez. Az adatok továbbítása a master és a slave között soros adat (SDA) vonalon keresztül történik. Az átviteli sebesség akár 3,4 Mbps is lehet. Minden eszköznek, amely adatokat szeretne továbbítani az I2C -n keresztül, egyedi címmel kell rendelkeznie, és az eszköz funkciójától függően adóként vagy vevőként is működhet. Például egy OLED kijelzőmodul egy vevő, amely bizonyos adatokat fogad és megjelenít, míg a hőmérséklet -érzékelő egy adó -vevő, amely az I2C buszon keresztül küldi a rögzített hőmérsékletet. Általában a master eszköz az az eszköz, amely adatátvitelt kezdeményez a buszon, és generálja az órajeleket, amelyek lehetővé teszik az átvitelt. Az átvitel során a master által címzett bármely eszköz slave -nek minősül, és beolvassa az adatokat.

Amikor egy csomópont bizonyos adatokat akar küldeni, akkor az adatok legelső bájtjának a vevő címének kell lennie, majd a tényleges adatok jönnek utána. Ez azt jelenti, hogy ahhoz, hogy adatokat küldhessünk egy kimeneti eszközre az I2C használatával (pl. I2C OLED kijelzőmodul), először meg kell találnunk annak I2C címét, és ezt fogjuk tenni a következő lépésekben.

Ha többet szeretne megtudni az I2C busz részleteiről és elméleteiről, használhatja a következő referenciákat:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

3. lépés: Szükséges modulok és alkatrészek

Itt megtalálja az oktatóanyag elvégzéséhez szükséges összetevők listáját:

eBay linkek:

• 1 x Arduino Uno:
• 1 x 128x64 OLED modul:
• 4 x Dupont kábel:
• 1 x Mini forrasztás nélküli kenyérlap:

Amazon.com linkek:

• 1 x Arduino Uno:
• 1 x 128x64 OLED modul:
• 4 x Dupont kábel:
• 1 x Mini forrasztás nélküli kenyeretábla:

4. lépés: Az OLED kijelzőmodul csatlakoztatása Arduino -hoz

Fontos megjegyzés az I2C -kompatibilis eszközökről, hogy az Arduino -hoz való csatlakoztatás módja ugyanaz. Ennek oka az, hogy az Arduino csak meghatározott csapokon futtatja I2C kommunikációját. Ebben az oktatóanyagban az Arduino Uno -t használom. Az Arduino Uno az A5 -ös tűt használja SCK -ként, és az A4 -et SDA -ként. Tehát csatlakoztathatjuk az OLED kijelzőmodult az Arduino Uno -hoz, ahogy az a sematikus nézetben látható. Amint észreveheti az OLED kijelzőmodulról készített képen, a VCC és a GND csatlakozója eltér a sematikus nézettől. Ne felejtse el ellenőrizni a modulok csapjainak címkéit, hogy megbizonyosodjon arról, hogy megfelelően csatlakoztatja.

Csak 4 csapra van szükségünk, amelyeket az alábbiak szerint kell csatlakoztatni:

Arduino VCC -> OLED modul VCC

Arduino GND -> OLED GND modul

Arduino 4 -> OLED modul SDA

Arduino 5 -> OLED modul SCK

5. lépés: Keresse meg a megjelenítő modul címét

Az I2C -kompatibilis eszközhöz való csatlakozás első lépéseként meg kell adnia a modul címét. Ehhez, miután csatlakoztatta a modult az Arduino -hoz, csak töltse fel a mellékelt kódot az Arduino -ra. Ez a kód magában foglalja a Wire könyvtárat, amely az Arduino IDE -hez tartozó könyvtár, amely kezeli az I2C kommunikációt. Megpróbálja beolvasni a csatlakoztatott I2C eszközöket, és a címüket soros porton keresztül elküldi a számítógépnek. Így a kimenetét az Arduino IDE Serial Monitor eszközén keresztül érheti el. Az eredeti verzió az Arduino Playground -on érhető el). Olvashatóbb módon is megtekintheti az online Arduino szerkesztőmben. Ne várja el, hogy bármi is megjelenjen a képernyőn, amíg ez a kód fut.

Amint a képen látható, a modulom 0x3C címhez van kötve. Általában egy adott termékcsalád összes eszközének (például az összes 128x64 OLED modulnak) ugyanaz a címe.

Az I2C eszközök címe 1 és 126 között van. Ez a kód egyszerűen megpróbál sorrendben csatlakozni az egyes eszközökhöz (adatátvitel nélkül), majd ellenőrizze, hogy az alapkönyvtár nem jelentett -e hibát a megadott címhez való csatlakozáskor. Ha nincs hiba, akkor a címet kinyomtatja elérhető modulként a csatlakozáshoz. Azt is meg kell jegyezni, hogy az első 15 cím le van foglalva, így átugrik rajtuk, és csak kinyomtatja ezeket a tartományokat. Ne feledje, hogy ezen I2C modulok címe hardveresen van kódolva az eszközön, és nem módosítható. Tehát jó ötlet lenne leírni valahol, vagy feliratozni a modult, amikor visszahelyezi a laboratóriumi polcára, hogy legközelebb ne legyen szükség a szkenner kód futtatására. Ez azonban nem bonyolult eljárás;)

6. lépés: Az adatok OLED -modulon való megjelenítéséhez szükséges könyvtárak telepítése

A Wire könyvtár képes kezelni az alacsony szintű kommunikációt az I2C eszközökkel. Ha egy adott eszközhöz szeretne csatlakozni, hogy adatokat tudjon olvasni/írni abból/abba, akkor általában a modult eredetileg építő cég által biztosított könyvtárat használja. Ez a könyvtár kezeli az I2C kommunikáció minden részletét az adott modullal, és koncentráljunk inkább az üzletünkre, amely ebben az esetben az adatokat a kívánt módon jeleníti meg.

Az Adafruit, az ilyen kijelzőmodulok eredeti verzióját gyártó cég, az Adafruit SSD1306 nevű könyvtárat biztosítja az adatok megjelenítésére ezeken a monokróm kijelzőkön. Tehát mielőtt elkezdenénk kódolni, telepítenünk kell ezt a könyvtárat a Library Manager segítségével (elérhető a Vázlat> Könyvtár bevonása> Könyvtárak kezelése … menüben) az Arduino IDE -ben. Van még egy másik könyvtár, az Adafruit GFX Library, amely több alacsony szintű grafikai dolgot kezel, és amelyet az Adafruit SSD1306 használ belsőleg. Mindkettőt telepítenie kell az Arduino IDE -re, amint a képeken is látható.

7. lépés: A kijelzőmodul inicializálása

A kijelzőmodul rajza Adafruit_SSD1306 nevű osztályba van csomagolva. Ennek az osztálynak a meghatározása az Adafruit könyvtárban található, ezért először fel kell vennünk ezt a könyvtárat. Ezután először példát kell mutatnunk ennek az osztálynak. Ennek az osztálynak a konstruktőre azt a portszámot veszi fel, amelyen a kijelzőt vissza lehet állítani, ami a 4. érintkező (SCK -hoz csatlakoztatva). A kódnak ezt a részét a fájl elején kell elhelyezni (out of setup () és loop () függvények).

#befoglalni

Adafruit_SSD1306 kijelző (4);

Most a setup () függvényben meg kell hívnunk a megjelenítési objektum start függvényét az alábbiakban megadott I2C -címünk átadásával (az SSD1306_SWITCHCAPVCC egy állandó érték, amely meghatározza a könyvtár áramforrásának típusát):

void setup () {

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.display (); } void loop () {} // a ciklus egyelőre üres lehet

Most a megjelenített objektum készen áll, és meghívhatjuk annak funkcióit (pl. Display.write (), display.drawLine stb.). A fontos megjegyzés az, hogy valahányszor felhívunk valamit a megjelenítő objektumunk meghívásával, meg kell hívnunk a display.display () függvényt, hogy a tényleges rajzolás hardveres szinten történjen. Ez elsősorban annak a ténynek köszönhető, hogy az általunk meghívott rajzolási funkciók csak teljesítménybeli okokból frissítik a kijelző "memóriában" ábrázolását. Valójában tárolja a memória változásait. Ezért mindig emlékeznünk kell a display () függvény meghívására, amikor befejeztük a rajzolás valamit a képernyőn.

display.write (…); // folyamatosan frissül a memóriában

display.drawLine (…); // folyamatosan frissül a memóriában. display.display (); // átöblíti a kijelző hardverének minden módosítását

Ha ebben a lépésben megpróbálja feltölteni a kódot, észre fogja venni, hogy megjelenik az Adafruit Industries logója. Kíváncsi lehet, hogy ki kérte fel ezt a rajzot! Valójában ezt teszi az Adafruit könyvtár. Ez a cég logójával inicializálja a modul memóriáját (a kijelző hardver memóriában történő megjelenítését). Ha nem szeretné látni, hogy az inicializálás során megpróbálhatja meghívni a display.clearDisplay () függvényt közvetlenül a display.display () hívása előtt a beállítási funkcióban. Ez a funkció, ahogy a neve is sugallja, teljesen törli a kijelzőt.

#befoglalni

Adafruit_SSD1306 kijelző (4); void setup () {display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); display.display (); } void loop () {}

Az Adafruit_SSD1306 könyvtár dokumentációja alapján az osztály különböző funkcióit használhatja a kijelzőn történő rajzoláshoz vagy a rajta lévő képpontok közvetlen kezeléséhez. A következő szakaszokban megpróbálunk példát mutatni mindegyikre, hogy elképzelése legyen a működéséről. A legtöbb ilyen példa csak egy egyszerű statikus tartalmat jelenít meg, így ezeket csak a setup () függvényünkbe tehetjük (az inicializáló kód után). Ezzel csak egyszer futna, és ott is maradna.

8. lépés: Egyszerű szöveg megjelenítése

Szöveg megjelenítéséhez használhatjuk a könyvtár egyszerű display.println () függvényét. Elfogadja a szöveget karakterláncként, és megpróbálja megjeleníteni. Fontos tudni, hogy meg kell mondanunk a könyvtárnak, hogy a kijelzőn hol mutatjuk be a szöveget. A kijelző minden pixelének van egy koordinátája, amelyet X és Y jelöl. Az X balról jobbra nő, Y pedig felülről lefelé. A képernyő bal felső sarka (X = 0, Y = 0), a jobb alsó sarok pedig (X = 127, Y = 63). Megjegyeztem az első képen a sarkok koordinátáit. A display.setCursor () függvénnyel meghatározhatjuk, hogy a kijelzőn hol jelenítsük meg a szöveget.

A szöveg másik tulajdonsága a színe. A színt a display.setTextColor () segítségével adhatjuk meg a következő mintán látható módon.

display.clearDisplay ();

display.setTextColor (FEHÉR); display.setCursor (35, 30); display.println ("Hello World!"); display.display ();

A display.write () függvény segítségével egyetlen karaktert is megjeleníthetünk. Elfogad egy karakterkódot uint8_t típusként, és megjeleníti a kódnak megfelelő karaktert a karakterláncon. Például, ha ugyanazt a karakterláncot szeretnénk megjeleníteni ezzel a függvénnyel, akkor a következő részletet használhatjuk:

display.clearDisplay ();

display.setTextColor (FEHÉR); 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 ();

Lehetőség van arra is, hogy fekete háttérrel fehér háttérrel szövegeket rajzoljon. Ehhez meg kell hívnia a display.setTextColor függvényt az alábbiak szerint:

display.clearDisplay ();

// A színt feketére állítja fehér háttérrel. SetTextColor (BLACK, WHITE); display.setCursor (25, 30); display.println ("Fordított szöveg!"); display.display ();

Lehetőség van a szöveg méretének beállítására is a display.setTextSize () függvénnyel. Egész számot fogad el méretként. Minél nagyobb a szám, annál nagyobb lesz a szöveg. A legkisebb méret 1, ami a szövegek alapértelmezett mérete. A következő kód megpróbálja az A betűt 6 különböző méretben írni:

display.clearDisplay ();

display.setTextColor (FEHÉR); 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 ();

9. lépés: Alapformák rajzolása

Az alapvető formák, például téglalap, kör, háromszög, egyenes vagy pont rajzolása nagyon egyszerű, és mindegyikhez külön funkció tartozik.

Rajzvonal

Ha vonalat szeretne húzni, hívja a display.drawLine (startX, startY, endX, endY, color). Például a következő kód átlós vonalakat rajzol a képernyőre, hogy nagy X -et formáljanak:

display.clearDisplay ();

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

A kijelző szélességét és magasságát a display.width () és display.height () függvények segítségével érheti el. Ezzel a kód független lenne a képernyő méretétől.

Rajz téglalap

A téglalap rajzolásának funkciója a display.drawRect (felsőLeftX, felsőLeftY, szélesség, magasság, szín). Íme a kód, amely három téglalapot rajzol néhány véletlenszerű helyre:

display.clearDisplay ();

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

A display.fillRect (felsőLeftX, felsőLeftY, szélesség, magasság, FEHÉR) meghívásával rajzolhat egy meghatározott színnel kitöltött téglalapot. Ebben a példában a harmadik függvény is a display.drawRoundRect (felsőLeftX, felsőLeftY, szélesség, magasság, sarkRádius, szín), amelyet a képen látható módon kerek sarkú téglalap rajzolására használnak. A szín előtt egy további paramétert fogad el, amely a sarok sugarát jelző egész szám. Minél nagyobb az érték, annál sarkosabb a sarok. Ezenkívül rendelkezik egy megfelelő kitöltési függvénnyel, display.drawFillRoundRect néven, és azt hiszem, kitalálhatja, mit csinál.

Rajzoló kör

A függvény display.drawCircle (centerX, centerY, sugár, szín). Íme egy példa, amely mosolygó alakot rajzol:

display.drawCircle (60, 30, 30, FEHÉR);

display.fillCircle (50, 20, 5, FEHÉR); display.fillCircle (70, 20, 5, FEHÉR);

A téglalapokhoz hasonlóan a display.fillCircle függvénnyel rajzolhat egy kört az adott színnel.

Rajz háromszög

Ahh, megint egy display.drawTriangle (poin1X, point1Y, point2X, point2Y, point3X, point3Y, color) nevű függvény és a megfelelő display.fillTriangle, amely egy kitöltött háromszöget rajzol.

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

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

Rajzolj egy pontot

A kijelzőn egy adott pontot (amelyet pixelnek is nevezhetünk) a display.drawPixel (pixelX, pixelY, color) függvénnyel.

display.drawPixel (20, 35, FEHÉR);

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

10. lépés: Kép rajzolása

A kép rajzolása más és kissé bonyolult. Mivel a kijelzőmodul egyszínű, először át kell alakítanunk a képünket mono color bitmap (más néven fekete -fehér) formátumba. Ilyen formátumban a kép minden képpontja 0 -val vagy 1 -gyel jelenik meg. Az 1 -es a szín létezését jelenti, a 0 -as pedig egy üres teret. Láthat egy példát az Arduino logóra ebben a formátumban a szakasz tetején. A bitképes rajzolás funkciója a display.drawBitmap (topLeftX, topLeftY, imageData, szélesség, magasság, szín). Az imageData paraméter egy bájtos számtömb. Minden bájt 8 bites, tehát minden bájt a kép 8 pixelének adatait tartalmazza. A kép szélességének és magasságának megadásával a drawBitmap függvény tudni fogja, hogy melyik bitből indul a következő képpontsor.

A megoldás, amellyel a képemet ebbe a formátumba konvertáltam, az volt, hogy először használtam egy online "image to ASCII converter" -t (pl. Http://my.asciiart.club), hogy a képemet ASCII karakterkészletté alakítsam, majd az üres helyre használt karaktereket 0, a többi karaktert pedig 1. Ezt látja alább. A 0 -t és az 1 -et úgy tekintheti, mint egy pixelt a kijelzőn. Tehát a kép mérete nem haladhatja meg a megjelenítési méretünket, amely 128x64.

Megjegyzés: Ennek az ASCII technikának a használata nem ajánlott, mert a karakterek képaránya miatt a kép deformálódik (a karakterek nem négyzetek). Ezt a technikát csak azért próbáltam ki, mert megkönnyíti a kép kívánt formátumba konvertálását. Ellenkező esetben lehetséges lenne a legjobb eredmény elérése valamilyen programozással vagy olyan segédprogramokkal, amelyek teljesen kívül esnek a szöveg hatályán.

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

Most el kell osztanunk minden sort 8 -mal, ami egy bájtot jelent, és tároljuk őket az alábbi tömbben:

static const unsigned char PROGMEM arduino_logo = {

B00000000, B00000000, B00000111, B11111111, B11111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B11111111, B11111111, B11111110, B00000000, B00000000, vége …

Ezután a drawBitmap függvény meghívásával rajzolhatjuk a kijelzőn.

display.drawBitmap (32, 16, arduino_logo, 64, 32, FEHÉR);

11. lépés: Hibaelhárítás

Ez egy hosszú oktatóanyag volt, ezért nagyon valószínű, hogy valami baj van. Az alábbiakban felsoroljuk azokat a gyakori hibákat, amelyekkel találkozhat az OLED kijelzőmodul beállítása során a projekthez (ezek közül néhány az oktatóanyag előkészítése során történt).

Egyáltalán nem jelenik meg semmi

Ennek számos oka lehet, ezért azt javaslom, hogy ellenőrizze az alábbi listát, amely sorrendben előfordulhat a projektben:

Az I2C cím valószínűleg rossz

Győződjön meg arról, hogy a megjelenítési objektum beállításakor beállította az i2c-szkenner kódban megadott címet a display.begin () függvényben.

Az SCL és az SDA rossz módon van csatlakoztatva

Ez valójában velem történt. Ha az Arduino Uno -t használja, akkor újra ellenőriznie kell a kapcsolatait, hogy megbizonyosodjon arról, hogy ugyanazok, mint az enyém. Ha másik Arduino kiadást használ (pl. Mega, Leonardo stb.), Akkor tudnia kell, hogy az I2C -t más tűkre lehet állítani. A Wire könyvtár dokumentációjában ellenőrizheti.

Rajzol valamit a látható területről

Ez szoftver probléma. Nagyon gyakori, amikor rajzfunkciókat használnak egyes koordináták rossz kiszámításához, és így a rajz deformálódik, vagy a legrosszabb esetben teljesen kimaradhat a jelenetből. Tekintse át számításait, és próbáljon lépésről lépésre rajzolni, hogy lássa, mi történik.

A szöveg egyáltalán nem jelenik meg

Elfelejtette beállítani a szöveg színét, vagy rossz értékre állította be

Szövegek rajzolása előtt meg kell hívnia a setTextColor parancsot. Ellenkező esetben nem lesz hiba, de nem fog látni semmit a kijelzőn. Lehet, hogy a szöveg színét a háttérszínnel azonosnak állította be.

Nagyon nagy betűtípust használ

Ha nagyon nagy értékre állítja be a szövegméretet, előfordulhat, hogy a karakterek teljesen kikerülnek a látható területről.

Fordítási hiba történt a kijelző méretével kapcsolatban

Ez nálam is megtörtént, és azt hiszem, a legtöbben meg fognak történni. Ez az Adafruit_SSD1306.h fejlécfájlban megadott megjelenítési méretállandó értékek miatt szerepel a szkriptünk tetején. Ez a fájl a {your-project-folder} libraries / Adafruit_SSD1306 / Adafruit_SSD1306.h címen található. Ha megnyitja ezt a fájlt, észre fogja venni, hogy az alábbiakban található egy megjegyzés szakasz, amelyben leírja, hogy csak az OLED kijelzőmodul méretét jelző állandó értékét kell megszüntetnie. 128x64 -es kijelzőmodulok esetén a #define SSD1306_128_64 sort nem kell megjegyezni.

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

SSD1306 kijelzők ------------------------------------------------ ---------------------- Az illesztőprogramot több kijelzőn (128x64, 128x32 stb.) Használják. Válassza ki a megfelelő kijelzőt a megfelelő méretű keretbuffer stb. Létrehozásához stb. --------------------------------------------* / #define SSD1306_128_64 / / #define SSD1306_128_32 // #define SSD1306_96_16 /*======================================= ===============================*/

12. lépés: Mi a következő teendő?

Az OLED kijelző kimeneti modulként nagyszerű lehetőséget kínál arra, hogy professzionális megjelenésű felületet biztosítson hobbiprojektjeihez. Kipróbálhatja a következő ötleteket kiindulópontként, hogy tartalmas adatokat jelenítsen meg rajtuk, vagy segítsen a felhasználónak megtudni, mi történik, vagy ha valamit tennie kell. Sokkal világosabb lenne, ha a felhasználó üzenetet olvasna a kijelzőn, mint hogy egy projekt/eszköz állapotát értelmezze néhány LED -en keresztül.

Kiindulópontként a következőket teheti:

• Olvassa le a hőmérséklet -érzékelő értékét, és jelenítse meg az OLED modulon. Hozzáadhat nyomás- vagy páratartalom -érzékelőt, és létrehozhat egy teljesen működőképes időjárás -állomás projektet.
• Próbáljon valamit rajzolni a kijelzőmodulra a joystick modul használatával, mint beviteli eszköz.
• Próbáljon rajzot rajzolni/késleltetni, vagy Arduino megszakítással rajzolni egy animációt a kijelzőre
• Az egyéni logó megjelenítése a rendszer indításakor (az Adafruit logó helyett)

Ne felejtse el elmondani a megjegyzésekben, hogy mit tenne (vagy már tett) az OLED kijelzőmodul használatával.