OLED I2C Display Arduino / NodeMCU Tutorial: 15 Hakbang

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

Ang kauna-unahang programa na sinusulat mo kapag nagsimula kang matuto a

bagong wika ng programa ay: "Hello World!".

Ang programa mismo ay wala nang ginagawa kundi ang pag-print ng isang teksto na "Hello World" sa screen.

Kaya, paano natin maipapakita ang aming Arduino na "Hello World!"?

Sa video na ito, ipapakita ko sa iyo kung paano magsimula sa maliit na 0.91 (128x32) at 0.96 (128x64) I2C OLED na ipinapakita.

Mayroong 100 ng mga tutorial sa web na nagpapaliwanag ng parehong bagay sa iba't ibang paraan, ngunit hindi ko makita ang isa na nagsasabi sa akin ng lahat tungkol sa OLED display at kung paano ito gamitin sa iba't ibang mga sitwasyon. Tumagal ako ng kaunting oras upang maisagawa ang lahat. Kaya, naisip ko na dapat akong lumikha ng isang tutorial sa kung ano ang natutunan ko at pagsamahin ang lahat ng mga tampok at paraan na maaaring magamit ang ipinapakita ng OLED sa aming mga proyekto.

Hakbang 1: Mga Bagay na Malalaman Natin Ngayon

Sa video na ito ay pag-uusapan natin:

- Ano ang isang OLED display?

- Pagkatapos ay titingnan natin nang mas malapit ang 0.91 (128x32) at 0.96 (128x64) I2C OLED na ipinapakita

- Susunod ay pag-uusapan natin ang tungkol sa pag-install ng Adafruit Library sa iyong Arduino IDE

- Pagkatapos ay ikonekta namin ang NodeMCU at Arduino sa isang OLED display

- Susunod magkakaroon kami ng isang pagtingin sa code at ipakita ang ilang mga graphic at teksto dito

- Pag-uusapan din namin ang tungkol sa paglalapat ng Mga Pasadyang Font at pagpapakita ng Mga Larawan

- Pagkatapos ay ikonekta namin ang Maramihang mga OLED sa isang micro-controller gamit ang I2C Multiplexer

- Panghuli, pag-uusapan natin ang ilang mga karaniwang pagkakamali na ginagawa ng mga tao habang ginagamit ang mga ipinapakita na OLED

Hakbang 2: Kinakailangan sa Hardware

Para sa tutorial na ito kailangan namin:

- Isang Breadboard

- Isang 0.91 "(128x32) at 0.96" (128x64) I2C OLED ay nagpapakita

- Arduino UNO / NANO (anuman ang madaling gamitin)

- NodeMCU

- TCA9548A I2C multiplexer

- Ilang mga Pagkonekta na Mga Kable

- at isang USB cable upang mai-upload ang code

Hakbang 3: Ano ang isang OLED Display?

Ang OLED o organikong light-emitting diode ay isang light-emitting

diode (LED) kung saan ang emissive electroluminescent layer ay isang pelikula ng organikong compound (milyon-milyong maliliit na ilaw na LED) na naglalabas ng ilaw bilang tugon sa isang kasalukuyang kuryente.

Ginagamit ang OLED upang lumikha ng mga digital display sa mga aparato tulad ng mga telebisyon, monitor ng computer, portable system tulad ng mga mobile phone, hand-hand game console at PDA. Gumagana ang isang OLED display nang walang backlight dahil naglalabas ito ng nakikitang ilaw.

Hakbang 4:

Maraming uri ng mga pagpapakita ng OLED na magagamit sa

merkado batay sa kanilang

- Mga Laki

- Kulay

- Mga tatak

- Protocol

- SPI (Serial Peripheral Interface) o I2C

- Passive-matrix (PMOLED) o scheme ng kontrol na aktibo-matrix (AMOLED)

Sa tutorial na ito, pag-uusapan ko ang tungkol sa pagkonekta sa

asul na kulay 0.91 (128x32 OLED) at 0.96 (128x64 OLED) I2C OLDE ay ipinapakita sa isang Arduino NANO at NodeMCU. Ang teknolohiya ng bus ng I2C ay gumagamit lamang ng 2 mga pin ng MCU kaya't mayroon kaming mga tambak na magagamit para sa iba pang mga sensor.

Hakbang 5: Mas Malapit na Pagtingin

Hinahayaan nating magkaroon ng isang malapit sa dalawang pagpapakita.

Sa likuran ng mga ipinapakitang ito ay may mga tambak ng SMD capacitor at resistors na solder on-board; ngunit, dahil ito ay isang aparato ng I2C nagmamalasakit lamang kami tungkol sa 2 mga pin (SCL at SDA)

Ang display ay kumokonekta sa Arduino gamit lamang ang apat na mga wire - dalawa para sa lakas (VCC at GND) at dalawa para sa data (serial clock SCL at

serial data SDA), ginagawang napaka-simple ang mga kable. Ang koneksyon ng data ay I2C (I²C, IIC o Inter-Integrated Circuit) at ang interface na ito ay tinatawag ding TWI (Two Wire Interface).

- Ang mga on-board na pin ay maaaring nasa magkakaibang pagkakasunud-sunod, kaya palaging triple check bago ito mai-hook sa iyong proyekto.

- Ang boltahe ng operasyon ay nasa pagitan ng 3v hanggang 5v ngunit, pinakamahusay na gamitin ang patnubay mula sa datasheet ng gumawa.

- Minsan kailangan nating gumamit ng 2 pagpapakita sa aming mga proyekto. Kaya, paano natin makakamit ito?

Ang trick ay ang pagkakaroon ng isang naka-configure na address sa iyong display. Ang yunit na ito ay may isang mai-configure na address sa pagitan ng 0x78 at 0x7A. Sa pamamagitan lamang ng pag-unsolding ng 0Ohm risistor mula sa isang gilid at hoking ito hanggang sa kabilang panig o sa pamamagitan lamang ng paglalagay ng isang pandaigdigang solder maaari nating baguhin ang address. Pag-uusapan natin ito nang malalim kapag nag-hook kami ng maraming pagpapakita sa isang Arduino sa susunod na seksyon ng tutorial na ito.

Sa larawan ang mga ipinakitang ito ay mukhang napakalaki. Ngunit, praktikal na pagsasalita sila ay maliit. Ang mga ito ay gawa sa 128 x 32/64 indibidwal na mga OLED pixel at hindi nangangailangan ng anumang back-light. Tingnan lamang ito at tingnan kung gaano ito kaliit. Kahit na sila ay maliit maaari silang maging napaka kapaki-pakinabang sa anumang mga elektronikong proyekto.

Hakbang 6: Library

Mayroong maraming mga aklatan na magagamit upang makontrol ang mga ito

ipinapakita. Noong nakaraan ginamit ko ang "u8glib library" ngunit mas madali kong maintindihan at magamit ang library ng AdaFruit sa aming mga proyekto. Kaya, gagamitin ko ang library ng AdaFruit sa tutorial na ito.

Upang makontrol ang pagpapakita ng OLED kakailanganin mo ang librong "adafruit_GFX.h" at ang librong "adafruit_SSD1306.h".

Mayroong dalawang paraan na maaari mong i-download at mai-install ang library sa iyong Arduino IDE.

Paraan 1

Pumunta sa "Library manager" at hanapin ang "adafruit_SSD1306" at "adafruit_gfx"

Piliin ang pinakabagong bersyon at pindutin ang pindutang I-install.

Kapag na-install na maaari mong gamitin ang mga aklatan na ito sa iyong programa.

Paraan 2

Ang dalawang aklatan na ito ay maaari ring mai-download mula sa github (kailangan mo pareho):

Ibibigay ko ang mga link sa paglalarawan sa ibaba.

Ang display library:

Ang GFX library:

Kapag na-download na, kopyahin ang Adafruit_SSD1306-master folder mula sa na-download na naka-zip na file sa folder ng Arduino libraries. Karaniwang matatagpuan ang folder na ito sa Mga Dokumento> Arduino> mga aklatan sa mga system ng Windows. Sa Linux kadalasang matatagpuan ito sa home folder> Arduino> mga aklatan. Panghuli sa folder ng Arduino library, palitan ang pangalan ng Adafruit_SSD1306-master folder sa Adafruit_SSD1306. Kahit na hindi mo palitan ang pangalan ayos lang.

Hakbang 7:

Ngayon, tingnan ang "Adafruit_SSD1306.h"

file

Dalawang bagay na kailangan nating malaman sa library na ito:

1. Kung nais mong gamitin ang mas maliit na display gamitin ang default na 128_32 kung hindi man para sa mas malaking display puna ang 128_32 at huwag paganahin ang 128_64

2. Kung na-solder mo ang 0x7A Address sa pisara (na pag-uusapan natin sa paglaon) pagkatapos ay gamitin ang 7 bit 0x3D address para sa mas malaking display, kung hindi man ay gamitin ang default na 0x3C address. Para sa mas maliit na ipinapakita ang address ay 0x3C.

Hakbang 8: Mga kable na 128 X 64/32 OLED

Magsisimula tayo sa pamamagitan ng pagkonekta sa NodeMCU sa display.

Ang una at pinakamahalagang bagay na dapat tandaan ay ang ilan sa mga ipinapakita ay maaaring magkaroon ng mga palitan ng kuryente ng GND at VCC. Suriin ang iyong display upang matiyak na ito ay pareho sa imahe. Kung napalitan ang mga pin, tiyaking baguhin ang mga koneksyon sa Arduino o NodeMCU.

- NodeMCU OLED Mga Kable

OLED VCC - NodeMCU 3.3V

OLED GND - NodeMCU GND

OLED SCL - NodeMCU D1

OLED SDA - NodeMCU D2

- Arduino Uno OLED Mga Kable

OLED VCC - Arduino 5V

OLED GND - Arduino GND

OLED SCL - Arduino Uno A5

OLED SDA - Arduino Uno A4

- Arduino MEGA 2560 OLED Mga Kable

OLED VCC - Arduino 5V

OLED GND - Arduino GND

OLED SCL - Arduino MEGA 2560 pin 21

OLED SDA - Arduino MEGA 2560 pin 20

Hakbang 9: Code

Ang library ng Adafruit ay mayroong talagang magagandang halimbawa para sa pareho

Lumilitaw ang 128x32 at 128x64.

Ang Library ay matatagpuan sa ilalim ng File> Mga Halimbawa> Adafruit SSD1306> at pagkatapos ang uri ng pagpapakita sa Arduino IDE.

Gagamitin namin ang halimbawa ng 128x32 I2C at babaguhin ito upang gumana kasama ang parehong 128x64 at 128x32 na nagpapakita ng kamao sa pamamagitan ng pag-hook sa isang Arduino at pagkatapos sa isang board ng NodeMCU.

Nagsisimula ang code sa pamamagitan ng pagsasama ng parehong mga aklatan ng Adafruit. Sa tutorial na ito ay bibigyang diin ko lamang ang mga bahagi ng code na kinakailangan para sa amin upang mai-load sa parehong mga board at display. Kung nais mong malaman ang tungkol sa code mangyaring mag-drop ng isang puna sa aking blog o sa seksyon ng mga komento sa ibaba at nagsusumikap akong bumalik sa iyo.

- Una naming mai-load ang code sa isang Arduino Nano na konektado sa isang 128x32 display.

Maaari naming gamitin ang code tulad ng walang anumang mga pagbabago.

Gumagamit ang 128x32 ng 0x3C address kaya't medyo maganda ang bit na ito dito, hinahayaan na i-double check ang header library, oo gumagamit din ito ng 0x3C address at ang display type ay 128x32.

- Hinahayaan ngayon ang ikonekta ang 128x64 display. Tulad ng alam naming ginagamit nito ang 0x3C address bilang default kaya hindi namin kailangang i-update ang address sa alinman sa code o library.

Kailangan lang namin na magkomento sa 128_32 at i-unsment ang 128_64 sa header library at baguhin ang LCDHEIGHT sa 64 sa aming code.

- Ngayon upang patakbuhin ang parehong code sa isang NodeMCU kailangan naming baguhin ang isa pang linya sa aming code.

Ang natitirang code na "#define OLED_RESET 4"> "#define OLED_RESET LED_BUILTIN" ng Arduino

Medyo maraming upang ipakita ang anumang kailangan muna namin upang limasin ang nakaraang screen gamit ang

display.clearDisplay (); // I-clear ang buffer

Pagkatapos iguhit ang bagay

testdrawline (); // Gumuhit ng linya

Ipakita ito sa hardware

display.display (); // Gawin silang nakikita sa display hardware!

Maghintay ng ilang oras bago ipakita ang susunod na item.

pagkaantala (2000); // Maghintay ng 2 segundo

Sa halimbawang ito ay nagpapakita kami ng ilang mga item tulad ng teksto, mga linya, mga bilog, pag-scroll ng teksto, mga tatsulok at marami pa. Sige at gamitin ang iyong imahinasyon at ipakita ang anumang gusto mo sa mga maliliit na ipinapakita.

Hakbang 10: Pagpapasadya ng Teksto at Pagdaragdag ng Mga Larawan

Minsan ang iyong code ay kailangang magpakita ng mga pasadyang font at

mga imahe Kung napakahusay mo sa kaunting pagmamapa pagkatapos ay kailangan mo lamang lumikha ng isang byte arrays sa pamamagitan ng pag-on o pag-off ng maliit na maliit na LED ng display upang lumikha ng mga pasadyang mga font at imahe.

Gayunpaman, hindi ako napakahusay sa paggawa ng mga pagmamapa na ito at hindi gugugol na gumugol ng oras sa paglikha ng mga talahanayan ng mapa ng bit.

Kaya, ano ang aking mga pagpipilian? Pangkalahatan ay gumagamit ako ng dalawang mga website upang makabuo ng mga pasadyang mga font at imahe. Ang mga link ay ibinigay sa paglalarawan sa ibaba.

Pasadyang Mga Font

Pumunta sa website ng font converter, piliin ang pamilya ng font, istilo, laki, Bersyon ng Library bilang "Adafruit GFX Font" at pagkatapos ay pindutin ang pindutang "Lumikha". Sa kanang bahagi ng pahinang ito makikita mo kung paano magiging hitsura ang iyong font sa aktwal na display.

Batay sa iyong pagpipilian ang webpage ay bumubuo ng mga font header file. Lumikha ng isang file na tinatawag na "binago_ font.h" sa parehong folder kung saan ang iyong code ay at kopyahin at i-save ang nabuong code dito. Pagkatapos ay kailangan mo lamang isama ang file ng header sa iyong code upang magamit ang pasadyang font.

# isama ang "binago_ font.h"

Pagkatapos, kailangan mo lamang itakda ang font bago ipakita ang teksto upang mailapat ang pasadyang font dito.

display.setFont (& Your_Fonts_Name);

Maaari mong makuha ang pangalan ng font mula sa header file na naidagdag mo lang sa iyong proyekto. Thats it, madali.

Ang memorya ay palaging isang pag-aalala habang gumagamit ng mga pasadyang mga font, kaya palaging isaalang-alang ang mga byte na natupok ng memorya. Tandaan lamang ang Arduino UNO ay mayroon lamang 32K ng memorya.

Pasadyang Mga Larawan

Upang maipakita ang isang bitmap na imahe sa iyong screen kailangan mo munang lumikha ng isang 128 x 64/32 laki ng imahe.

Gumagamit ako ng magandang lumang "MS Paint" upang lumikha ng isang 128 x 64 bitmap na imahe na pagkatapos ay mai-upload ko sa imahe ng website ng converter. Ang website ay nagko-convert ng mga imahe sa byte-strings, na maaaring magamit sa mga display ng Arduino at OLED.

Magsimula sa pamamagitan ng pag-upload ng imahe sa website. Pagkatapos ay maglagay ng tseke sa check-box na "Baligtarin ang mga kulay ng imahe" at baguhin ang format na "Output code" sa "Arduino Code" na susunod na piliin ang oryentasyon at pindutin ang pindutang "Bumuo ng Code" upang makabuo ng byte array. Ipinapakita sa iyo ng seksyong "Preview" kung paano magiging hitsura ang iyong imahe sa aktwal na display.

Isinama ko ang code kasama ang tutorial na ito na maaari mong gamitin upang ipakita ang iyong mga imahe. Kailangan mo lamang palitan ang array sa aking code sa isa na iyong nabuo at pagkatapos ay i-load ito sa iyong Arduino.

Hakbang 11: Pagkonekta sa 2 Ipinapakita

Ang pagkonekta ng dalawang 128 x 64 na ipinapakita sa iyong proyekto ay madali.

Kailangan mo lamang i-unslight ang resistor ng 0Ohm mula sa 0x78 address at ilagay ito sa 0x7A at pagkatapos ay gamitin ang 0x3D address sa iyong code sa halip na ang default 0x3C.

Dapat kang magtaka kung bakit ginagamit namin ang 0x3C at 0x3D address at hindi ang aktwal na 0x78 at 0x7A. Tumatanggap ang Arduino ng 7-bit address at hindi ang 8-bit na mga address sa hardware. Kaya, kailangan muna nating i-convert ang 8-bit na address sa binary, at pagkatapos ay i-chop ang hindi bababa sa makabuluhang piraso upang makuha ang 7 bits. Pagkatapos ay i-convert ang 7 bits sa HEX upang makuha ang 0x3C o 0x3D na mga address na ipinasok mo sa iyong code.

Una, simulan ang pagpapakita sa pamamagitan ng pagbibigay nito ng natatanging pangalan:

Adafruit_SSD1306 display1 (OLED_REST);

Adafruit_SSD1306 display2 (OLED_REST);

Pagkatapos sa iyong code gamitin ang display 1 at ipakita ang 2 upang tawagan ang mga pagsisimula ng pahayag na may mga address ng aparato sa kanila:

display1.begin (SSD1306_SWITCHCAPVCC, 0x3C); // display 1 op address 0x3C

display2.begin (SSD1306_SWITCHCAPVCC, 0x3D); // display 2 op address 0x3D

Iyon lang, maaari ka nang magpatuloy at gawin ang anumang nais mo gamit ang alinman sa Display 1 o Display 2 sa natitirang bahagi ng iyong code. Nagbigay ako ng isang halimbawa sa tutorial na ito.

Ang mga kable ay eksaktong kapareho ng kung ano ang nagawa namin dati, medyo kailangan mo lamang magdagdag ng isa pang display sa parehong mga I2C na pin ng alinman sa Arduino o NodeMCU. Batay sa mga address, ipinapadala ng MCU ang data sa linya ng data ng I2C.

Hakbang 12: Pagkonekta ng Higit sa 2 Ipinapakita

Ngayon, paano kung nais mong mag-hook ng higit sa 2 pagpapakita?

Ang Arduino ay may limitadong bilang ng mga pin at kaya't hindi ka maaaring magkaroon ng higit sa isang tiyak na halaga ng mga kalasag na nakakabit dito. Bukod dito, mayroon lamang itong isang pares ng mga I2C bus.

Kaya, paano namin mai-attach ang higit sa 2 ipinapakita na I2C sa isang Arduino? Ang trick ay ang paggamit ng isang TCA9548 Multiplexer.

Pinapayagan ng TCA9548 ang isang solong micro-controller na makipag-usap nang hanggang sa '64 sensor 'lahat na may pareho o magkakaibang I2C address sa pamamagitan ng pagtatalaga ng isang natatanging channel sa bawat sensor na sub-bus ng alipin.

Kapag pinag-uusapan natin ang tungkol sa pagpapadala ng data sa higit sa 2 mga wire sa maraming mga aparato kailangan namin ng isang paraan upang matugunan ang mga ito. Ito ay kapareho ng kartero na dumarating sa iisang kalsada at ihuhulog ang mga mail packet sa iba't ibang mga bahay dahil mayroon silang iba't ibang mga address na nakasulat sa kanila.

Ang Multiplexer ay kumokonekta sa mga linya ng 3V3, GND, SDA at SCL ng micro-controller. Ang mga sensor ng alipin ay konektado sa isa sa walong mga port ng alipin ng SCL / SDA sa pisara. Napili ang mga channel sa pamamagitan ng pagpapadala sa TCA9548A ng I2C address (0x70 {default} - 0x77) na sinusundan ng numero ng channel (0b00000001 - 0b10000000). Maaari kang magkaroon ng max 8 ng mga multiplexer na ito na nakakonekta sa 0x70-0x77 na mga address upang makontrol ang 64 ng parehong mga bahagi ng I2C na hinarap. Sa pamamagitan ng pagkonekta sa tatlong mga address bit A0, A1 at A2 sa VIN maaari kang makakuha ng iba't ibang kumbinasyon ng mga address. Ipapaliwanag ko ito nang malalim sa aking susunod na tutorial sa TCA9548A breakout board. Sa ngayon, hinahayaan lamang na ma-hook up ang 8 OLED sa board na ito at mabilis na tingnan ang code.

Koneksyon:

VIN hanggang 5V (o 3.3V)

GND sa lupa

SCL hanggang sa I2C na orasan

Data ng SDA hanggang I2C

Pagkatapos ay i-wire ang mga sensor sa VIN, GND at gamitin ang isa sa mga SCn / SDn multiplexed bus

Ngayon, Int magsisimula ang code sa pamamagitan ng pagsasama ng "Wire" library at sa pamamagitan ng pagtukoy sa multiplexers address.

# isama ang "Wire.h"

# isama

#define MUX_Address 0x70 // TCA9548A Encoders address

Pagkatapos ay kailangan naming piliin ang port na nais naming makipag-usap at ipadala ang data dito gamit ang pagpapaandar na ito:

walang bisa tcaselect (uint8_t i) {

kung (i> 7) bumalik;

Wire.beginTransmission (MUX_Address);

Wire.write (1 << i);

Wire.endTransmission ();

}

Susunod ay isisimulan namin ang pagpapakita sa seksyon ng pag-setup sa pamamagitan ng pagtawag sa "u8g.begin ();" para sa bawat display na nakakabit sa MUX "tcaselect (i);"

Kapag napasimulan, maaari na nating gawin ang nais natin sa pamamagitan lamang ng pagtawag sa pagpapaandar na "tcaselect (i);" kung saan ang "i" ay ang halaga ng multiplexed bus at pagkatapos ay pagpapadala ng data at orasan nang naaayon.

Hakbang 13: Mga Kalamangan at Kalamangan

Ang imahe ng isang OLED ay maganda. Gayunpaman, mayroon ding mga OLED

dehado Dahil ang mga OLED screen ay naglalaman ng organikong materyal, ang kanilang habang-buhay ay mas maikli kaysa sa mga ipinapakitang LCD. Bilang karagdagan, maraming mga pagpapakita ng OLED ang nakakakuha ng burn-in matapos ipakita ang mahabang imahe sa loob ng mahabang panahon. Pagkatapos ng burn-in, mananatili ang imahe sa screen kahit na nagpakita ng ibang imahe. Kaya siguraduhin na patuloy mong i-refresh ang screen bawat ilang segundo. Ang tubig ay maaaring agad na makapinsala sa mga organikong materyales ng mga ipinakitang ito.

Mga kalamangan

Hindi na kailangan para sa isang backlight

Ang mga display ay napaka payat at magaan

Mababang pagkonsumo ng kuryente

Ang mga anggulo ng pagtingin ay mas malawak kaysa sa mga LCD

Ang ningning at kaibahan ay mahusay

Mataas na bilis at may mababang oras ng pagtugon

Malalim na kulay itim

Mga Dehado

Magastos na teknolohiya

Maikling lifecycle

Ang mga OLED ay mas malamang na mag-burn-in

Pinsala sa tubig

Hakbang 14: Mga Karaniwang Error

Upang tapusin ang tutorial ay hinahayaan na pag-usapan ang tungkol sa ilang mga karaniwang error

ginagawa ng mga tao habang ginagamit ang mga ipinapakitang ito:

- Palaging triple suriin ang mga pin bago gamitin ito sa iyong proyekto

- Kunin ang tamang address ng library sa header file at sa iyong code

# tukuyin ang SSD1306_I2C_ADDRESS 0x3C // sa Adafruit_SSD1306.h

at

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); // sa iyong code

Kung ang address ay mali ang OLED ay hindi magpapakita ng anuman

- Dapat baguhin ang laki ng display sa driver bago ito magamit. Kung hindi ito binago makakakuha ka ng isang mensahe ng error kapag sinusubukang i-verify ang code

#error ("Hindi tama ang taas, mangyaring ayusin ang Adafruit_SSD1306.h!");

- Kung gumagamit ng NodeMCU tiyaking pinalitan mo ang OLED_RESET mula 4 hanggang LED_BUILTIN

# tukuyin ang OLED_RESET LED_BUILTIN

Mayroon akong mga taong eksena na gumagawa ng lahat ng mga uri ng bagay gamit ang OLED display na ito. Ang ilan ay nakagawa pa ng mga video game at lahat. Hindi talaga ako interesado na gumawa ng isang video game gamit ang maliit na display na ito. Gayunpaman, iiwan ko ka ngayon upang galugarin ang iyong mga imahinasyon at lumabas na may kamangha-manghang mga ideya.

Hakbang 15: Mga Link

- Blog:

- Magdagdag ng Larawan:

- Pasadyang Text:

- Adafruit display library:

- Adafruit GFX library:

- u8glib library: https://code.google.com/archive/p/u8glib/ o

Kung nais mong gamitin ang mas maliit na display gamitin ang default na 128_32 kung hindi man para sa mas malaking display na puna ang 128_32 at huwag paganahin ang 128X64 NO_ACK sa iyong code (huwag paganahin ang uri ng screen na iyong ginagamit) (ang mga font ay nasa library ng mga font)