Kasayahan Sa OLED Display at Arduino: 12 Hakbang (na may Mga Larawan)

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:11

Sigurado akong sigurado na narinig mo ang tungkol sa OLED display technology. Medyo bago ito at nag-aalok ng isang mas mahusay na kalidad kaysa sa lumang teknolohiya ng LCD. Sa tutorial na ito nais naming suriin ang mga hakbang na kinakailangan upang maipakita ang data sa isa sa mga pinaka-karaniwang solong kulay na OLED display module na magagamit sa merkado. Susubukan kong ipaliwanag ang mga pagpapaandar na ibinigay ng kaukulang library ng Adafruit upang maipakita ang data sa modyul na ito.

Hakbang 1: Ano ang Mga Modelo ng OLED na Gagamitin Namin?

Ang mga module ng OLED ay magagamit sa iba't ibang mga laki at tampok. Ang gagamitin namin sa tutorial na ito ay isang mono color 128x64 OLED module. Ang uri ng modyul na ito ay magagamit sa mga sumusunod na laki (Upang makita mo ang mga larawan):

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

Tulad ng lahat ng mga modyul na ito ay sumusuporta sa I2C protocol bilang isang ibig sabihin para sa komunikasyon, ang code at mga kable ng lahat ng mga ito ay eksaktong pareho. Ang pagkakaiba lamang ay kailangan mong isaalang-alang ang laki ng display sa iyong code upang ang mga nilalaman na ipapakita mo, magkasya nang maayos dito.

Hakbang 2: I2C sa isang Nutshell

Ang inter-integrated circuit (IIC) na karaniwang tinatawag na I2C (I squared C) na binuo ng Philips noong 80s bilang isang data exchange bus na ginamit upang ilipat ang data sa pagitan ng central processing unit (CPU) o microcontroller unit (MCU) ng isang aparato at peripheral chips. Karaniwan itong naka-target para sa aplikasyon sa TV. Dahil sa pagiging simple nito, naging tanyag ito at pagkatapos nito ay naging isa sa mga pangunahing mekanismo ng paglipat ng data para sa mga CPU at MCU at mga peripheral na aparato na hindi kinakailangang bahagi ng parehong PCB board at konektado dito sa pamamagitan ng wire (hal. Sensor, ipakita ang mga module, atbp.).

Ang I2C ay binubuo ng isang bus ng komunikasyon na gawa sa dalawang kawad na sumusuporta sa paglipat ng dalawang data na data sa pagitan ng isang master at maraming mga aparato ng alipin. Kadalasan ang master node ay namamahala sa pagkontrol sa bus - na aktwal na ginagawa sa pamamagitan ng pagbuo ng isang signal ng pagsabay sa serial line line (SCL). Ito ay isang senyas na patuloy na ipapadala ng master sa panahon ng paglipat at ang lahat ng iba pang mga node na konektado sa bus ay gagamitin ito upang i-sync ang kanilang komunikasyon at makita ang bilis ng bus. Ang data ay inililipat sa pagitan ng master at alipin sa pamamagitan ng isang linya ng serial data (SDA). Ang bilis ng paghahatid ay maaaring hanggang sa 3.4 Mbps. Ang lahat ng mga aparato na nais maglipat ng data sa pamamagitan ng I2C ay dapat magkaroon ng isang natatanging address at maaaring gumana bilang alinman sa transmiter o tatanggap depende sa pagpapaandar ng aparato. Halimbawa ang isang OLED display module ay isang tatanggap na tumatanggap ng ilang data at ipinapakita ang mga ito, habang ang isang sensor ng temperatura ay isang transceiver na nagpapadala ng nakunan ng temperatura sa pamamagitan ng I2C bus. Karaniwan ang isang master aparato ay ang aparato na nagpasimula ng isang data transfer sa bus at bumubuo ng mga signal ng orasan upang payagan ang paglipat. Sa panahon ng paglipat na iyon, ang anumang aparato na hinarap ng master na ito ay itinuturing na isang alipin at binabasa ang data na iyon.

Kapag nais ng isang node na magpadala ng ilang data, ang unang byte ng data ay dapat na ang address ng tatanggap at pagkatapos ay ang aktwal na data ay darating pagkatapos. Nangangahulugan ito na upang makapagpadala ng isang data sa isang output aparato gamit ang I2C (hal. I2C OLED display module) dapat muna nating hanapin ang I2C address nito at ito ang una naming gagawin sa mga susunod na hakbang.

Kung interesado kang malaman ang tungkol sa mga detalye at teorya tungkol sa I2C bus, maaari mong gamitin ang mga sumusunod na sanggunian:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Hakbang 3: Mga Kinakailangan na Modyul at Mga Bahagi

Mahahanap mo rito ang listahan ng mga bahagi na kakailanganin mong makumpleto ang tutorial na ito:

Mga link sa eBay:

• 1 x Arduino Uno:
• 1 x OLED module 128x64:
• 4 x Dupont cable:
• 1 x Mini na solderless breadboard:

Mga link ng Amazon.com:

• 1 x Arduino Uno:
• 1 x OLED module 128x64:
• 4 x Dupont cable:
• 1 x Mini na solderless breadboard:

Hakbang 4: Mga Modelo ng Display ng OLED sa Arduino

Ang isang mahalagang tala tungkol sa mga aparato na pinagana ng I2C ay ang paraan na dapat mong ikonekta ang mga ito sa Arduino ay pareho ang lahat. Ito ay dahil ang Arduino ay nagpapatakbo ng komunikasyon ng I2C lamang sa mga tukoy na pin. Sa tutorial na ito ginagamit ko ang Arduino Uno. Ang Arduino Uno ay gumagamit ng pin A5 bilang SCK at A4 bilang SDA. Kaya maaari naming ikonekta ang module ng pagpapakita ng OLED sa Arduino Uno tulad ng ipinakita sa pananaw sa eskematiko. Tulad ng napansin mo sa larawan na nakuha ko mula sa aking OLED display module, ang konektor para sa VCC at GND ay naiiba kaysa sa iskemikong pagtingin. Tandaan na suriin ang mga label ng mga pin sa iyong mga module upang matiyak na ikonekta mo ito sa isang tamang paraan.

Kailangan lamang namin ng 4 na mga pin na dapat na konektado sa ibaba:

Arduino VCC -> OLED Module VCC

Arduino GND -> OLED Module GND

Arduino 4 -> OLED Module SDA

Arduino 5 -> OLED Module SCK

Hakbang 5: Paghahanap ng Address ng Display Module

Bilang unang hakbang sa pagkonekta sa isang aparato na pinagana ng I2C, kailangan mong magkaroon ng address ng module. Upang magawa ito, pagkatapos i-wire ang module sa iyong Arduino, dapat mo lamang i-upload ang naka-attach na code, sa iyong Arduino. Ang code na ito ay isinasama ang Wire library na isang library na kasama ng Arduino IDE na humahawak sa komunikasyon ng I2C. Sinusubukan nitong i-scan ang mga konektadong aparato ng I2C at ipinapadala ang kanilang address sa pamamagitan ng serial port sa iyong computer. Kaya maaari mong ma-access ang output nito sa pamamagitan ng tool ng Serial Monitor sa Arduino IDE. Magagamit ang orihinal na bersyon sa Arduino Playground). Gayundin maaari mo itong tingnan sa isang mas nababasa na paraan sa aking online Arduino Editor. Huwag asahan ang anumang ipapakita sa screen habang tumatakbo ang code na ito.

Tulad ng nakikita mo sa larawan, ang aking module ay nakagapos upang tugunan ang 0x3C. Karaniwan ang lahat ng mga aparato sa isang tukoy na linya ng produkto (halimbawa lahat ng 128x64 OLED modules) ay may parehong address.

Ang addresse ng mga aparatong I2C ay limitado mula 1 hanggang 126. Sinusubukan lamang ng code na ito na kumonekta sa bawat aparato nang maayos (nang hindi nagpapadala ng anumang data) at pagkatapos ay suriin kung mayroong anumang error na naiulat ng napapailalim na library sa pagkonekta sa ibinigay na address. Kung walang error, pagkatapos ay i-print ang address bilang isang magagamit na module upang kumonekta. Gayundin dapat pansinin na ang unang 15 mga address ay nakalaan, kaya't tumatalon ito at inililimbag lamang ang mga nasa itaas ng saklaw na ito. Tandaan na ang address ng mga modyul na I2C na ito ay hard-code sa aparato at hindi ito mababago. Kaya magandang ideya na isulat ito sa kung saan o maglagay ng isang label sa module kapag ibabalik mo ito sa iyong istante ng lab upang sa susunod, ang pagpapatakbo ng scanner code ay hindi kinakailangan. Gayunpaman hindi ito isang kumplikadong pamamaraan;)

Hakbang 6: Pag-install ng Mga Aklatan na Kinakailangan upang Maipakita ang Data sa OLED Module

Ang Wire library ay maaaring hawakan ang mababang antas ng komunikasyon sa mga aparato ng I2C. Kung nais mong kumonekta sa isang tukoy na aparato upang mabasa / isulat ang data mula sa / papunta rito, karaniwang gagamitin mo ang isang silid-aklatan na ibinigay ng kumpanya na orihinal na nagtayo ng modyul na iyon. Hinahawakan ng library na ito ang lahat ng mga detalye ng komunikasyon ng I2C na may naibigay na module at hayaan kaming higit na magtuon sa aming negosyo na sa kasong ito ay ipinapakita ang data sa paraang nais namin.

Ang Adafruit, ang kumpanya na gumagawa ng orihinal na bersyon ng mga naturang display module, ay nagbibigay ng isang aklatan na tinatawag na Adafruit SSD1306 upang maipakita ang data sa mga monochrome display na ito. Kaya bago simulang mag-coding, kailangan naming i-install ang library na ito sa pamamagitan ng Library Manager (maa-access sa pamamagitan ng Sketch> Isama ang Library> Pamahalaan ang Mga Library … menu) sa Arduino IDE. Mayroon ding isa pang silid-aklatan na tinatawag na Adafruit GFX Library na humahawak ng mas mababang antas ng graphic na bagay at ginagamit sa loob ng Adafruit SSD1306. Kailangan mong i-install ang pareho sa mga ito sa iyong Arduino IDE tulad ng nakikita mo sa mga larawan.

Hakbang 7: Inisialisa ang Modyul ng Display

Ang pagguhit sa display module ay nakabalot sa isang klase na nagngangalang Adafruit_SSD1306. Ang kahulugan ng klase na ito ay nasa Adafruit library, kaya kailangan muna nating isama ang library na iyon. Pagkatapos ay kailangan muna nating pasimulan ang isang halimbawa ng klase na ito. Kinukuha ng tagabuo ng klase na ito ang numero ng port kung saan maaaring ma-reset ang display na kung saan ay ang pin 4 (konektado sa SCK). Ang bahaging ito ng code ay dapat na matatagpuan sa simula ng pag-andar ng file (wala sa pag-setup () at loop ()).

# isama

Adafruit_SSD1306 display (4);

Ngayon sa loob ng pag-andar ng () pag-andar dapat nating tawagan ang simulang pag-andar ng display object sa pamamagitan ng pagpasa sa aming I2C address tulad ng nasa ibaba (ang SSD1306_SWITCHCAPVCC ay isang pare-pareho na halaga na tumutukoy sa uri ng mapagkukunan ng kuryente sa library):

walang bisa ang pag-setup () {

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.display (); } void loop () {} // loop ay maaaring walang laman sa ngayon

Ngayon ang display object ay handa na at maaari nating tawagan ang mga pagpapaandar nito (hal. Display.write (), display.drawLine, atbp.). Ang mahalagang tala ay tuwing gumuhit tayo ng isang bagay sa pamamagitan ng pagtawag sa aming display object, kailangan naming tawagan ang display.display () na function upang mangyari ang aktwal na pagguhit sa antas ng hardware. Pangunahin ito dahil sa ang katunayan na ang paggana ng pagguhit na tinatawag namin, i-update lamang ang "sa memorya" na representasyon ng display para sa mga kadahilanan sa pagganap. Talagang cache nito ang mga pagbabago sa memorya. Kaya dapat nating laging tandaan na tawagan ang display () na pag-andar kapag natapos namin ang pagguhit ng isang bagay sa screen.

display.write (…); // ay patuloy na nag-a-update sa memorya

display.drawLine (…); // ay patuloy na nag-a-update sa memorya. display.display (); // flushes lahat ng mga pagbabago sa display hardware

Kung susubukan mong i-upload ang iyong code sa hakbang na ito, mapapansin mong maipakita ang logo ng Adafruit Industries. Maaari kang magtaka kung sino ang nagtanong dito upang iguhit iyon! Sa totoo lang ito ang ginagawa ng Adafruit library. Pinasimulan nito ang memorya ng module (ang sa representasyon ng memorya ng display hardware) na may logo ng kumpanyang ito. Kung hindi mo nais na makita iyon sa panahon ng pagsisimula, maaari mong subukang tawagan ang function ng display.clearDisplay () bago tumawag sa display.display () sa iyong pag-andar ng pag-setup. Ang pagpapaandar na ito, tulad ng iminumungkahi ng pangalan nito, ganap na nililimas ang display.

# isama

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

Batay sa dokumentasyon ng Adafruit_SSD1306 library, maaari mong gamitin ang iba't ibang mga pagpapaandar na ibinigay ng klase na ito upang gumuhit sa display o direktang manipulahin ang mga pixel dito. Sa mga susunod na seksyon susubukan naming magpakita ng isang halimbawa para sa bawat isa sa kanila upang magkaroon ka ng ideya tungkol sa kung paano ito gumagana. Karamihan sa mga halimbawang ito ay magpapakita lamang ng isang simpleng mga static na nilalaman, upang mailagay lamang namin ang mga ito sa loob ng aming pag-setup () na pag-andar (pagkatapos ng code ng pagsisimula). Sa pamamagitan nito, tatakbo ito nang isang beses lamang at mananatili doon.

Hakbang 8: Magpakita ng isang Simpleng Teksto

Upang maipakita ang isang teksto, maaari naming gamitin ang simpleng display.println () na pagpapaandar ng library. Tumatanggap ito ng teksto bilang isang string at sinusubukang ipakita ito. Mahalagang malaman na kailangan nating sabihin sa library kung saan sa display ipapakita natin ang teksto. Ang bawat pixel sa display ay mayroong isang coordinate na tinukoy sa isang X at Y. Ang X ay tumataas mula kaliwa hanggang kanan at tumataas ang Y mula sa itaas hanggang sa ibaba. Ang kaliwang sulok sa itaas ng screen ay (X = 0, Y = 0) at ang kanang ibabang sulok ay (X = 127, Y = 63). Nabanggit ko ang mga coordinate ng mga sulok sa unang larawan. Maaari naming gamitin ang display.setCursor () function upang tukuyin kung saan sa display ipapakita namin ang teksto.

Ang isa pang pag-aari ng teksto ay ang kulay nito. Maaari naming tukuyin ang kulay gamit ang display.setTextColor () tulad ng ipinakita sa sumusunod na sample.

display.clearDisplay ();

display.setTextColor (PUTI); display.setCursor (35, 30); display.println ("Hello World!"); display.display ();

Maaari din naming gamitin ang pagpapakita ng display.write () upang maipakita ang isang solong character. Tumatanggap ito ng isang character code bilang isang uri ng uint8_t at ipinapakita ang character na naaayon sa code na iyon sa string. Bilang isang halimbawa, kung nais naming ipakita ang parehong string gamit ang pagpapaandar na ito, maaari naming gamitin ang sumusunod na snippet:

display.clearDisplay ();

display.setTextColor (PUTI); display.setCursor (35, 30); ipakita. sumulat (72); display.write (101); display.write (108); display.write (108); ipakita. sumulat (111); ipakita. sumulat (32); ipakita. sumulat (87); ipakita. sumulat (111); display.write (114); display.write (108); display.write (100); ipakita. sumulat (33); display.display ();

Posible ring gumuhit ng mga teksto sa itim na kulay na may puting background. Upang magawa ito, kailangan mong tawagan ang display.setTextColor function tulad ng sa ibaba:

display.clearDisplay ();

// Itinatakda ang kulay sa itim na may puting background display.setTextColor (BLACK, WHITE); display.setCursor (25, 30); display.println ("Inverted text!"); display.display ();

Mayroon ka ring pagpipilian ng pagtatakda ng laki ng teksto gamit ang display.setTextSize () function. Tumatanggap ito ng isang bilang ng integer bilang isang sukat. Kung mas malaki ang bilang, mas malaki ang teksto. Ang pinakamaliit na laki ay 1 na kung saan ay ang default na laki ng mga teksto. Sinusubukan ng sumusunod na code na isulat ang titik na "A" sa 6 na magkakaibang laki:

display.clearDisplay ();

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

Hakbang 9: Pagguhit ng Pangunahing Mga Hugis

Ang pagguhit ng mga pangunahing hugis tulad ng rektanggulo, bilog, tatsulok, linya o point ay napakadali at mayroong isang nakatuong pag-andar para sa bawat isa.

Linya ng pagguhit

Upang gumuhit ng isang linya maaari kang tumawag sa display.drawLine (startX, startY, endX, endY, kulay). Halimbawa ang sumusunod na code ay gumuhit ng mga linya ng dayagonal sa screen upang hugis nila ang isang malaking X:

display.clearDisplay ();

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

Maaari mong ma-access ang lapad at taas ng display gamit ang display.width () at display.height () na mga function. Sa pamamagitan nito, ang iyong code ay magiging malaya mula sa laki ng screen.

Pagguhit ng rektanggulo

Ang pagpapaandar upang gumuhit ng isang rektanggulo ay ipinapakita.drawRect (upperLeftX, upperLeftY, lapad, taas, kulay). Narito ang code na kumukuha ng tatlong rektanggulo sa ilang mga random na lugar:

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 ();

Sa pamamagitan ng pagtawag sa display.fillRect (upperLeftX, upperLeftY, lapad, taas, WHITE) maaari kang gumuhit ng isang rektanggulo na puno ng tinukoy na kulay. Gayundin ang pangatlong pagpapaandar sa halimbawang ito ay ang display.drawRoundRect (upperLeftX, upperLeftY, lapad, taas, sulok ng Radio, kulay) na tulad ng nakikita mo sa larawan ay ginagamit upang gumuhit ng isang rektanggulo na may mga bilog na sulok. Tumatanggap ito ng dagdag na parameter bago ang kulay na isang numero ng integer na nagpapahiwatig ng radius ng sulok. Ang mas malaki ang halaga ng bilugan ang sulok. Mayroon din itong kaukulang function ng pagpuno na pinangalanang display.drawFillRoundRect na sa palagay ko mahuhulaan mo kung ano ang ginagawa nito.

Guhit ng bilog

Ang pagpapaandar ay ipinapakita.drawCircle (centerX, centerY, radius, kulay). Narito ang isang halimbawa kung saan kumukuha ng mala-nakangiting hugis:

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

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

Tulad ng mga parihaba, maaari mong gamitin ang display.fillCircle function upang gumuhit ng isang bilog na puno ng ibinigay na kulay.

Tatsulok na guhit

Ahh, muli ang isang pagpapaandar na tinatawag na display.drawTriangle (poin1X, point1Y, point2X, point2Y, point3X, point3Y, kulay) at kaukulang display.fillTriangle na gumuhit ng isang napuno na tatsulok.

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

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

Gumuhit ng isang punto

Maaari mo ring kulayan ang isang tukoy na point (na kung tawagin ay pixel) sa screen sa pamamagitan ng pagpapakita ng function.drawPixel (pixelX, pixelY, color).

display.drawPixel (20, 35, WHITE);

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

Hakbang 10: Larawan ng Guhit

Ang pagguhit ng isang imahe ay naiiba at medyo kumplikado. Dahil ang display module ay monocolour, kailangan muna nating baguhin ang aming imahe sa isang format na tinatawag na mono color bitmap (tinatawag ding itim at puti). Sa ganitong format, ang bawat pixel ng imahe ay ipinakita sa alinman sa 0 o 1. Ang mga 1 ay kumakatawan sa pagkakaroon ng kulay at 0 ay nangangahulugang isang walang laman na puwang. Maaari kang makakita ng isang halimbawa ng Arduino logo sa format na ito sa tuktok ng seksyong ito. Ang pagpapaandar upang gumuhit ng isang bitmap na imahe ay ipinapakita.drawBitmap (topLeftX, topLeftY, imageData, lapad, taas, kulay). Ang parameter ng imageData ay isang hanay ng mga numero sa mga byte. Ang bawat byte ay may 8 bits, kaya't ang bawat byte ay naglalaman ng data ng 8 pixel ng imahe. Sa pamamagitan ng pagtukoy ng lapad at taas ng imahe, malalaman ng paggana ng drawBitmap mula sa kung aling kagat ang nagsisimula ang susunod na hilera ng mga pixel.

Ang solusyon na pinili ko upang mai-convert ang aking imahe sa format na ito ay ang unang paggamit ng isa sa online na "imahe sa mga converter ng ASCII" (hal. Http://my.asciiart.club) upang mai-convert ang aking larawan sa isang hanay ng mga ASCII character at pagkatapos ay palitan ang mga tauhang ginamit para sa walang laman na puwang ng 0 at iba pa bago ang 1. Iyon ang nakikita mo sa ibaba. Maaari mong isipin ang bawat 0 at 1 bilang isang pixel sa display. Kaya't ang laki ng larawan ay hindi dapat lumagpas sa laki ng aming display na 128x64.

Tandaan: Ang paggamit ng diskarteng ASCII na ito ay hindi isang inirekumendang diskarte dahil dahil sa aspeto ng ratio ng mga character ang iyong imahe ay magiging deformed (ang mga character ay hindi isang parisukat). Sinubukan ko ang diskarteng ito dahil lamang sa ginagawang mas madali nitong mai-convert ang imahe sa kinakailangang format. Kung hindi posible na makamit ang pinakamahusay na resulta sa pamamagitan ng ilang mga programa o paggamit ng ilang mga aplikasyon ng utility na ganap na wala sa saklaw ng teksto na ito.

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

Ngayon dapat nating hatiin ang bawat linya sa 8, na kumakatawan sa isang byte at iimbak ang mga ito sa isang array tulad ng sa ibaba:

static Const unsigned char PROGMEM arduino_logo = {

B00000000, B00000000, B00000111, B11111111, B11111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B11111111, B11111111, B11111110, B00000000, B00000000,… // magpatuloy hanggang sa dulo ng larawan};

Pagkatapos ay maaari nating iguhit ito sa display sa pamamagitan ng pagtawag sa drawBitmap function.

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

Hakbang 11: Pag-troubleshoot

Ito ay isang mahabang tutorial at kaya't malamang na may mali. Narito ang listahan ng ilang mga karaniwang error na maaari mong makasalamuha habang nagse-set up ng OLED display module para sa iyong proyekto (ang ilan sa mga ito ay nangyari para sa akin habang inihahanda ang tutorial na ito).

Wala namang ipinapakita

Maaaring mangyari ito sa maraming kadahilanan kaya iminumungkahi kong suriin ang sumusunod na listahan kung alin ang maaaring mangyari sa iyong proyekto:

Malamang mali ang I2C address

Siguraduhin na naitakda mo ang address na nakuha mo sa i2c-scanner code sa display.begin () function kapag na-set up ang iyong display object.

Ang SCL at SDA ay konektado sa maling paraan

Ito talaga ang nangyari sa akin. Kung gumagamit ka ng Arduino Uno pagkatapos ay kailangan mong suriin muli ang iyong mga koneksyon upang matiyak na konektado ang mga ito katulad ng sa akin. Kung gumagamit ka ng isa pang edisyon ng Arduino (hal. Mega, Leonardo, atbp.), Dapat mong malaman na maaaring maitakda nila ang kanilang I2C sa iba pang mga pin. Maaari mo itong suriin sa dokumentasyon ng Wire library.

Gumuhit ka ng isang bagay sa nakikitang lugar

Ito ay isang isyu sa software. Ito ay napaka-pangkaraniwan kapag gumagamit ng pagguhit ng paggana upang maling kalkulahin ang ilang mga coordinate at sa gayon ang iyong pagguhit ay magiging deformed o sa pinakamasamang senaryo maaari itong ganap na wala sa eksena. Suriin ang iyong mga kalkulasyon at subukang gumawa ng isang hakbang-hakbang na pagguhit upang makita kung ano ang nangyayari.

Ang teksto ay hindi ipinapakita sa lahat

Nakalimutan mong itakda ang kulay ng teksto o itinakda mo ito sa isang maling halaga

Kailangan mong tawagan ang setTextColor bago ang pagguhit ng mga teksto. Kung hindi man wala kang mga error, ngunit wala kang makikitang ipinapakita. Gayundin maaari mong itakda ang kulay ng teksto pareho sa kulay ng background.

Gumagamit ka ng napakalaking font

Kung itinakda mo ang laki ng teksto sa isang napakalaking halaga, maaaring posible na ang mga character ay ganap na makalabas sa nakikitang lugar.

Mayroong isang error sa pag-ipon tungkol sa laki ng display

Nangyari din ito para sa akin at sa palagay ko ito ang mangyayari para sa karamihan sa iyo. Dahil sa laki ng display na pare-pareho ang mga halaga na tinukoy sa loob ng header file na Adafruit_SSD1306.h na isinasama namin sa tuktok ng aming script. Ang file na ito ay matatagpuan sa {your-project-folder} libraries / Adafruit_SSD1306 / Adafruit_SSD1306.h. Kung buksan mo ang file na ito ay mapapansin mo na mayroong isang seksyon ng komento tulad ng sa ibaba kung saan inilalarawan nito na kailangan mo lamang na i-kompromiso ang palagiang kumakatawan sa iyong laki ng display na OLED. Para sa isang 128x64 display module, ang linya na #define SSD1306_128_64 ay dapat na hindi kumpleto.

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

Nagpapakita ang SSD1306 ----------------- ----------------- Ginamit ang driver sa maraming pagpapakita (128x64, 128x32, atbp.). Piliin ang naaangkop na display sa ibaba upang lumikha ng isang naaangkop na laki ng framebuffer, atbp. SSD1306_128_64 128x64 pixel display SSD1306_128_32 128x32 pixel display SSD1306_96_16 --------------------------- -------------------------------------------- * / # tukuyin ang SSD1306_128_64 / / # tukuyin ang SSD1306_128_32 // # tukuyin ang SSD1306_96_16 / * =_ =_ * /

Hakbang 12: Ano ang Susunod na Gawin?

Ang OLED display bilang isang output module ay maaaring magbigay sa iyo ng isang mahusay na pagkakataon upang magbigay ng isang propesyonal na naghahanap interface sa iyong mga proyekto sa libangan. Maaari mong subukang sundin ang mga ideya bilang isang panimulang punto upang maipakita ang isang makabuluhang data dito o matulungan ang gumagamit na malaman kung ano ang nangyayari o kung kailangan niyang gumawa ng isang bagay. Mas magiging malinaw para sa isang gumagamit na basahin ang isang mensahe sa isang display kaysa sa bigyang kahulugan ang estado ng isang proyekto / aparato sa pamamagitan ng ilang mga LED.

Ang maaari mong gawin bilang isang panimulang punto ay maaaring:

• Basahin ang isang halaga ng sensor ng temperatura at ipakita ito sa module ng OLED. Maaari kang magdagdag ng presyon o sensor ng kahalumigmigan dito at lumikha ng isang ganap na gumaganang proyekto ng istasyon ng panahon.
• Subukang gumuhit ng isang bagay sa display module gamit ang isang module ng Joystick bilang isang input device.
• Subukang gumuhit ng isang animation sa display sa pamamagitan ng isang pagkakasunud-sunod ng pagguhit / pagkaantala ng mga tawag sa pag-andar o makagambala ng Arduino
• Ipakita ang iyong pasadyang logo sa pagsisimula ng iyong system (sa halip na Adafruit Logo)

Huwag kalimutan na sabihin sa akin sa mga komento, ano ang gagawin mo (o nagawa mo na) gamit ang OLED display module.