Seronok Dengan Paparan OLED dan Arduino: 12 Langkah (dengan Gambar)

2024 Pengarang: John Day | [email protected]. Diubah suai terakhir: 2024-01-30 11:07

Saya cukup pasti anda pernah mendengar mengenai teknologi paparan OLED. Ia agak baru dan menawarkan kualiti yang lebih baik daripada teknologi LCD lama. Dalam tutorial ini kami ingin mengkaji langkah-langkah yang diperlukan untuk memaparkan data pada salah satu modul paparan OLED warna tunggal yang paling umum yang terdapat di pasaran. Saya akan cuba menerangkan fungsi yang disediakan oleh perpustakaan Adafruit yang sesuai untuk memaparkan data pada modul ini.

Langkah 1: Modul OLED Apa Yang Akan Kami Gunakan?

Modul OLED tersedia dalam pelbagai saiz dan ciri. Yang akan kita gunakan dalam tutorial ini adalah modul OLED 128x64 mono warna. Jenis modul ini tersedia dalam ukuran berikut (Agar anda dapat melihat gambar):

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

Oleh kerana semua modul ini menyokong protokol I2C sebagai alat komunikasi, kod dan pendawaian semuanya sama. Satu-satunya perbezaan ialah anda harus mempertimbangkan ukuran paparan pada kod anda sehingga kandungan yang akan anda paparkan, sesuai dengan yang sesuai.

Langkah 2: I2C secara ringkas

Litar inter-bersepadu (IIC) yang biasanya disebut I2C (I kuadrat C) yang dikembangkan oleh Philips pada tahun 80-an sebagai bus pertukaran data yang digunakan untuk memindahkan data antara unit pemprosesan pusat (CPU) atau unit mikrokontroler (MCU) suatu peranti dan cip periferal. Pada dasarnya disasarkan untuk aplikasi TV. Kerana kesederhanaannya, ia menjadi sangat popular sehingga setelah sekian lama ia menjadi salah satu mekanisme utama pemindahan data untuk CPU dan MCU dan peranti periferal yang bukan merupakan bahagian penting dari papan PCB yang sama dan disambungkan kepadanya melalui wayar (contohnya sensor, modul paparan, dll.).

I2C terdiri daripada bus komunikasi yang terbuat dari dua wayar yang menyokong pemindahan data dua arah antara master dan beberapa peranti hamba. Biasanya simpul induk berperanan mengendalikan bas - yang sebenarnya dilakukan dengan menghasilkan isyarat penyegerakan pada garis jam bersiri (SCL). Ini adalah isyarat yang akan dihantar terus oleh tuan semasa pemindahan dan semua nod lain yang disambungkan ke bas akan menggunakannya untuk menyegerakkan komunikasi mereka dan mengesan kelajuan bas. Data dipindahkan antara tuan dan hamba melalui garis data bersiri (SDA). Kelajuan penghantaran boleh mencapai 3.4 Mbps. Semua peranti yang ingin memindahkan data melalui I2C harus mempunyai alamat yang unik dan dapat beroperasi sebagai pemancar atau penerima bergantung pada fungsi perangkat. Sebagai contoh modul paparan OLED adalah penerima yang menerima beberapa data dan memaparkannya, sementara sensor suhu adalah transceiver yang menghantar suhu yang ditangkap melalui bus I2C. Biasanya peranti induk adalah peranti yang memulakan pemindahan data di bus dan menghasilkan isyarat jam untuk membenarkan pemindahan. Semasa pemindahan itu, sebarang peranti yang ditujukan oleh tuan ini dianggap sebagai hamba dan membaca data tersebut.

Apabila nod ingin menghantar beberapa data, bait pertama dari data tersebut mestilah alamat penerima dan kemudian data sebenar datang selepas itu. Ini bermaksud bahawa untuk menghantar data ke peranti output menggunakan I2C (mis. Modul paparan OLED I2C) kita harus terlebih dahulu mencari alamat I2Cnya dan inilah yang akan kita lakukan terlebih dahulu pada langkah seterusnya.

Sekiranya anda berminat untuk mengetahui lebih lanjut mengenai butiran dan teori mengenai bas I2C, anda boleh menggunakan rujukan berikut:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Langkah 3: Modul dan Komponen yang Diperlukan

Di sini anda dapat mencari senarai komponen yang anda perlukan untuk menyelesaikan tutorial ini:

pautan eBay:

• 1 x Arduino Uno:
• 1 x modul OLED 128x64:
• 4 x Kabel Dupont:
• 1 x Papan roti tanpa solder mini:

Pautan Amazon.com:

• 1 x Arduino Uno:
• 1 x modul OLED 128x64:
• 4 x Kabel Dupont:
• 1 x Papan roti tanpa solder mini:

Langkah 4: Memasang Modul Paparan OLED ke Arduino

Nota penting mengenai peranti berkemampuan I2C adalah cara anda menyambungkannya ke Arduino semuanya sama. Ini kerana Arduino menjalankan komunikasi I2Cnya hanya pada pin tertentu. Dalam tutorial ini saya menggunakan Arduino Uno. Arduino Uno menggunakan pin A5 sebagai SCK dan A4 sebagai SDA. Oleh itu, kita dapat menyambungkan modul paparan OLED ke Arduino Uno seperti yang ditunjukkan dalam paparan skematik. Seperti yang anda perhatikan dalam gambar yang saya ambil dari modul paparan OLED saya, penyambung untuk VCC dan GND berbeza daripada pandangan skematik. Ingatlah untuk memeriksa label pin pada modul anda untuk memastikan anda menyambungkannya dengan cara yang betul.

Kami hanya memerlukan 4 pin yang harus dihubungkan seperti di bawah:

Arduino VCC -> Modul OLED VCC

Arduino GND -> Modul OLED GND

Arduino 4 -> Modul OLED SDA

Arduino 5 -> Modul OLED SCK

Langkah 5: Mencari Alamat Modul Paparan

Sebagai langkah pertama untuk menyambung ke peranti berkemampuan I2C, anda perlu mempunyai alamat modul. Untuk melakukannya, setelah memasang modul ke Arduino anda, anda hanya perlu memuat naik kod yang dilampirkan ke Arduino anda. Kod ini menggabungkan perpustakaan Wire yang merupakan perpustakaan yang disertakan dengan Arduino IDE yang mengendalikan komunikasi I2C. Ia cuba mengimbas peranti I2C yang disambungkan dan menghantar alamatnya melalui port bersiri ke komputer anda. Oleh itu, anda boleh mengakses outputnya melalui alat Monitor Serial di Arduino IDE. Versi asal boleh didapati di Arduino Playground). Anda juga boleh melihatnya dengan cara yang lebih mudah dibaca di Editor Arduino dalam talian saya. Jangan mengharapkan apa-apa dipaparkan di skrin semasa kod ini sedang berjalan.

Seperti yang anda lihat pada gambar, modul saya terikat pada alamat 0x3C. Biasanya semua peranti dalam barisan produk tertentu (contohnya semua modul OLED 128x64) mempunyai alamat yang sama.

Alamat peranti I2C adalah terhad dari 1 hingga 126. Kod ini hanya cuba menyambung ke setiap peranti dengan teratur (tanpa menghantar data) dan kemudian periksa sama ada terdapat sebarang kesilapan yang dilaporkan oleh perpustakaan yang mendasari semasa menyambung ke alamat yang disediakan. Sekiranya tidak ada ralat, maka cetak alamat sebagai modul yang tersedia untuk disambungkan. Juga harus diperhatikan bahawa 15 alamat pertama disediakan, jadi ia melompati alamatnya dan hanya mencetak alamat di atas julat ini. Ingat bahawa alamat modul I2C ini dikodkan keras pada peranti dan tidak boleh diubah. Oleh itu, adalah idea yang baik untuk menuliskannya di suatu tempat atau meletakkan label pada modul apabila anda akan meletakkannya kembali di rak makmal anda sehingga pada masa berikutnya, menjalankan kod pengimbas tidak diperlukan. Walau bagaimanapun, ini bukan prosedur yang rumit;)

Langkah 6: Memasang Perpustakaan Diperlukan untuk Memaparkan Data pada Modul OLED

Perpustakaan Wire dapat menangani komunikasi tahap rendah dengan peranti I2C. Apabila anda ingin menyambung ke peranti tertentu untuk membaca / menulis data dari / ke dalamnya, biasanya anda akan menggunakan perpustakaan yang disediakan oleh syarikat yang pada awalnya membina modul tersebut. Perpustakaan ini menangani semua butir-butir komunikasi I2C dengan modul yang diberikan dan biarkan kami lebih fokus pada perniagaan kami yang dalam hal ini menampilkan data dengan cara yang kami mahukan.

Adafruit, syarikat yang menghasilkan versi asal modul paparan seperti itu, menyediakan perpustakaan yang bernama Adafruit SSD1306 untuk memaparkan data pada paparan monokrom ini. Oleh itu sebelum memulakan pengekodan, kita harus memasang perpustakaan ini melalui Pengurus Perpustakaan (diakses melalui Sketsa> Sertakan Perpustakaan> Urus menu Perpustakaan…) di Arduino IDE. Terdapat juga perpustakaan lain yang disebut Adafruit GFX Library yang mengendalikan lebih banyak barang grafik tahap rendah dan digunakan secara dalaman oleh Adafruit SSD1306. Anda mesti memasang kedua-duanya pada IDE Arduino anda seperti yang anda lihat pada gambar.

Langkah 7: Memulakan Modul Paparan

Melukis modul paparan dibungkus dalam kelas bernama Adafruit_SSD1306. Definisi kelas ini terdapat di perpustakaan Adafruit, jadi pertama-tama kita perlu memasukkan perpustakaan itu. Maka kita harus membuat contoh kelas ini terlebih dahulu. Konstruktor kelas ini mengambil nombor port di mana paparan dapat diset semula iaitu pin 4 (disambungkan ke SCK). Bahagian kod ini harus berada di awal fail (di luar fungsi setup () dan loop ()).

#sertakan

Paparan Adafruit_SSD1306 (4);

Sekarang di dalam fungsi setup () kita harus memanggil fungsi mula dari objek paparan dengan menyampaikan alamat I2C kami seperti di bawah (SSD1306_SWITCHCAPVCC adalah nilai tetap yang menentukan jenis sumber kuasa ke perpustakaan):

batal persediaan () {

display.begin (SSD1306_SWITCHCAPVCC, 0x3C); paparan.display (); } gelung void () {} // gelung boleh kosong buat masa ini

Sekarang objek paparan sudah siap dan kita dapat memanggil fungsinya (mis. Display.write (), display.drawLine, dll.). Catatan penting adalah bahawa setiap kali kita menarik sesuatu dengan memanggil objek paparan kita, kita perlu memanggil fungsi display.display () untuk membuat gambar sebenar berlaku pada tahap perkakasan. Ini terutama disebabkan oleh fakta bahawa fungsi menggambar yang kita sebut, hanya kemas kini representasi paparan "dalam memori" untuk alasan prestasi. Ini sebenarnya menyimpan perubahan dalam ingatan. Oleh itu, kita harus selalu ingat untuk memanggil fungsi display () ketika kita selesai melukis sesuatu di skrin.

display.write (…); // terus dikemas kini dalam memori

display.drawLine (…); // terus dikemas kini dalam memori. paparan.display (); // mengalihkan semua perubahan pada perkakasan paparan

Sekiranya anda cuba memuat naik kod anda dalam langkah ini, anda akan melihat bahawa logo Adafruit Industries akan dipaparkan. Anda mungkin tertanya-tanya siapa yang memintanya untuk menariknya! Sebenarnya inilah yang dilakukan oleh perpustakaan Adafruit. Ia menginisialisasi memori modul (dalam memori perwakilan perkakasan paparan) dengan logo syarikat ini. Sekiranya anda tidak ingin melihatnya semasa inisialisasi, anda boleh memanggil fungsi display.clearDisplay () tepat sebelum memanggil display.display () dalam fungsi persediaan anda. Fungsi ini, seperti namanya, membersihkan paparan sepenuhnya.

#sertakan

Paparan Adafruit_SSD1306 (4); batal persediaan () {display.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); paparan.display (); } gelung kosong () {}

Berdasarkan dokumentasi perpustakaan Adafruit_SSD1306, anda boleh menggunakan pelbagai fungsi yang disediakan oleh kelas ini untuk menarik paparan atau memanipulasi piksel di atasnya secara langsung. Pada bahagian seterusnya, kami akan cuba memberikan contoh bagi setiap satu daripadanya supaya anda dapat mempunyai idea mengenai cara kerjanya. Sebilangan besar contoh ini hanya akan memaparkan kandungan statik yang sederhana, jadi kita boleh memasukkannya ke dalam fungsi persediaan () (setelah kod inisialisasi). Dengan berbuat demikian, ia akan dijalankan sekali sahaja dan kekal di sana.

Langkah 8: Paparkan Teks Ringkas

Untuk memaparkan teks, kita dapat menggunakan fungsi display.println () yang mudah di perpustakaan. Ia menerima teks sebagai rentetan dan berusaha memaparkannya. Penting untuk mengetahui bahawa kita harus memberitahu perpustakaan di mana di paparan kita akan menyampaikan teksnya. Setiap piksel pada paparan mempunyai koordinat yang ditentukan dengan X dan Y. X meningkat dari kiri ke kanan dan Y meningkat dari atas ke bawah. Sudut kiri atas skrin adalah (X = 0, Y = 0) dan sudut kanan bawah adalah (X = 127, Y = 63). Saya perhatikan koordinat sudut pada gambar pertama. Kita dapat menggunakan fungsi display.setCursor () untuk menentukan di mana pada layar kita akan memaparkan teks.

Satu lagi sifat teks adalah warnanya. Kita dapat menentukan warna menggunakan display.setTextColor () seperti yang ditunjukkan pada contoh berikut.

display.clearDisplay ();

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

Kita juga dapat menggunakan fungsi display.write () untuk memaparkan satu watak. Ia menerima kod aksara sebagai jenis uint8_t dan memaparkan watak yang sesuai dengan kod tersebut pada rentetan. Sebagai contoh, jika kita ingin menampilkan rentetan yang sama menggunakan fungsi ini, kita dapat menggunakan potongan berikut:

display.clearDisplay ();

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

Anda juga boleh menggambar teks dengan warna hitam dengan latar belakang putih. Untuk melakukannya, anda harus memanggil fungsi display.setTextColor seperti di bawah:

display.clearDisplay ();

// Menetapkan warna menjadi hitam dengan paparan latar belakang putih.setTextColor (HITAM, PUTIH); display.setCursor (25, 30); display.println ("Teks terbalik!"); paparan.display ();

Anda juga mempunyai pilihan untuk menetapkan ukuran teks menggunakan fungsi display.setTextSize (). Ia menerima nombor bulat sebagai ukuran. Semakin besar bilangannya, semakin besar teksnya. Ukuran terkecil adalah 1 yang merupakan ukuran teks lalai. Kod berikut cuba menulis huruf "A" dalam 6 saiz yang berbeza:

display.clearDisplay ();

display.setTextColor (PUTIH); 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"); paparan.display ();

Langkah 9: Melukis Bentuk Asas

Melukis bentuk asas seperti segi empat tepat, bulatan, segitiga, garis atau titik sangat mudah dan terdapat fungsi khusus untuk setiap satu.

Garisan melukis

Untuk melukis garis, anda boleh memanggil display.drawLine (startX, startY, endX, endY, color). Contohnya, kod berikut melukis garis pepenjuru di skrin sehingga membentuk X yang besar:

display.clearDisplay ();

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

Anda dapat mengakses lebar dan tinggi layar menggunakan fungsi display.width () dan display.height (). Dengan berbuat demikian kod anda akan bebas dari ukuran skrin.

Melukis segi empat tepat

Fungsi untuk melukis sebuah segi empat tepat adalah display.drawRect (upperLeftX, upperLeftY, lebar, tinggi, warna). Berikut adalah kod yang melukis tiga segi empat tepat di beberapa tempat rawak:

display.clearDisplay ();

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

Dengan memanggil display.fillRect (upperLeftX, upperLeftY, lebar, tinggi, PUTIH) anda boleh melukis sebuah segi empat tepat yang diisi dengan warna yang ditentukan. Fungsi ketiga dalam contoh ini adalah display.drawRoundRect (upperLeftX, upperLeftY, lebar, tinggi, sudutRadius, warna) yang seperti yang anda lihat dalam gambar digunakan untuk melukis sebuah segi empat tepat dengan sudut bulat. Ia menerima parameter tambahan sebelum warna yang merupakan nombor bulat yang menunjukkan jejari sudut. Semakin besar nilainya semakin bulat. Ia juga mempunyai fungsi pengisian yang sesuai bernama display.drawFillRoundRect yang saya rasa anda dapat meneka apa yang dilakukannya.

Lukisan bulatan

Fungsinya adalah display.drawCircle (centerX, centerY, radius, colour). Berikut adalah contoh yang melukis bentuk seperti senyuman:

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

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

Seperti segi empat tepat, anda boleh menggunakan fungsi display.fillCircle untuk melukis bulatan yang dipenuhi dengan warna yang diberikan.

Melukis segitiga

Ahh, sekali lagi fungsi yang disebut display.drawTriangle (poin1X, point1Y, point2X, point2Y, point3X, point3Y, color) dan display.fillTriangle yang sesuai yang melukis segitiga penuh.

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

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

Lukiskan satu titik

Anda juga dapat mewarnai titik tertentu (yang disebut piksel) di layar melalui fungsi display.drawPixel (pixelX, pixelY, color).

display.drawPixel (20, 35, PUTIH);

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

Langkah 10: Melukis Gambar

Melukis gambar adalah berbeza dan agak rumit. Oleh kerana modul paparan berwarna monokol, pertama-tama kita perlu menukar gambar kita ke format yang disebut bitmap warna mono (juga disebut hitam dan putih). Dalam format seperti itu, setiap piksel gambar disajikan dengan 0 atau 1. The 1s mewakili keberadaan warna dan 0s bermaksud ruang kosong. Anda dapat melihat contoh logo Arduino dalam format ini di bahagian atas bahagian ini. Fungsi untuk melukis gambar bitmap adalah display.drawBitmap (topLeftX, topLeftY, imageData, lebar, tinggi, warna). Parameter imageData adalah susunan nombor dalam bait. Setiap bait mempunyai 8 bit, jadi setiap bait mengandungi data 8 piksel gambar. Dengan menentukan lebar dan ketinggian gambar, fungsi drawBitmap akan mengetahui dari mana bit piksel seterusnya bermula.

Penyelesaian yang saya pilih untuk menukar gambar saya ke format ini adalah dengan menggunakan salah satu "penukar gambar ke ASCII" dalam talian (mis. Http://my.asciiart.club) untuk menukar gambar saya ke sekumpulan watak ASCII dan kemudian ganti watak yang digunakan untuk ruang kosong sebanyak 0 dan yang lain sebanyak 1. Itulah yang anda lihat di bawah. Anda boleh menganggap setiap 0 dan 1 sebagai piksel pada paparan. Jadi ukuran gambar tidak boleh melebihi ukuran paparan kita iaitu 128x64.

Catatan: Menggunakan teknik ASCII ini bukanlah pendekatan yang disarankan kerana kerana aspek aspek karakter gambar anda akan cacat (watak tidak segi empat sama). Saya mencuba teknik ini hanya kerana memudahkan untuk menukar gambar ke format yang diperlukan. Jika tidak, dapat mencapai hasil terbaik melalui beberapa pengaturcaraan atau menggunakan beberapa aplikasi utiliti yang benar-benar berada di luar ruang lingkup teks ini.

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

Sekarang kita harus membahagikan setiap baris dengan 8, mewakili bait dan menyimpannya dalam pelbagai seperti di bawah:

PROGMEM ar statino_logo char tidak bertanda stat stat = {

B00000000, B00000000, B00000111, B11111111, B11111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B11111111, B11111111, B11111110, B00000000, B00000000; // terus …

Kemudian kita dapat melukisnya di paparan dengan memanggil fungsi drawBitmap.

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

Langkah 11: Penyelesaian masalah

Ini adalah tutorial yang panjang dan jadi kemungkinan ada sesuatu yang tidak kena. Berikut adalah senarai beberapa kesilapan biasa yang mungkin anda hadapi semasa menyiapkan modul paparan OLED untuk projek anda (sebahagiannya berlaku untuk saya semasa menyiapkan tutorial ini).

Tidak ada yang dipaparkan sama sekali

Ini boleh berlaku kerana banyak sebab jadi saya cadangkan untuk melihat senarai berikut yang sesuai yang mungkin berlaku dalam projek anda:

Alamat I2C mungkin salah

Pastikan bahawa anda telah menetapkan alamat yang anda dapatkan dalam kod pengimbas i2c dalam fungsi display.begin () ketika menyiapkan objek paparan anda.

SCL dan SDA dihubungkan dengan cara yang salah

Ini sebenarnya berlaku untuk saya. Sekiranya anda menggunakan Arduino Uno, maka anda perlu menyemak semula sambungan anda untuk memastikan sambungannya sama seperti saya. Sekiranya anda menggunakan edisi Arduino yang lain (mis. Mega, Leonardo, dll.), Anda harus tahu bahawa mereka mungkin menetapkan I2C mereka ke pin lain. Anda boleh menyemaknya di dokumentasi perpustakaan Wire.

Anda menarik sesuatu dari kawasan yang kelihatan

Ini adalah masalah perisian. Sangat biasa apabila menggunakan fungsi gambar untuk salah mengira beberapa koordinat dan jadi gambar anda akan cacat atau dalam keadaan terburuk, ia benar-benar di luar tempat kejadian. Kaji pengiraan anda dan cuba buat gambar langkah demi langkah untuk melihat apa yang berlaku.

Teks sama sekali tidak dipaparkan

Anda lupa untuk menetapkan warna teks atau anda menetapkannya ke nilai yang salah

Anda perlu memanggil setTextColor sebelum melukis teks. Jika tidak, anda tidak mendapat kesilapan, tetapi anda tidak akan melihat apa-apa yang dipamerkan. Anda juga mungkin menetapkan warna teks sama dengan warna latar belakang.

Anda menggunakan fon yang sangat besar

Sekiranya anda menetapkan ukuran teks ke nilai yang sangat besar, ada kemungkinan watak keluar sepenuhnya dari kawasan yang kelihatan.

Terdapat ralat kompilasi mengenai ukuran paparan

Ini juga berlaku untuk saya dan saya rasa ia akan berlaku bagi kebanyakan anda. Ini kerana nilai pemalar ukuran paparan yang ditentukan dalam fail tajuk Adafruit_SSD1306.h yang kami sertakan di atas skrip kami. Fail ini terletak di {library-projek-anda} perpustakaan / Adafruit_SSD1306 / Adafruit_SSD1306.h. Sekiranya anda membuka fail ini, anda akan melihat bahawa ada bahagian komen seperti di bawah ini di mana ia menjelaskan bahawa anda hanya perlu melepaskan pemalar yang mewakili ukuran modul paparan OLED anda. Untuk modul paparan 128x64, baris #define SSD1306_128_64 harus dibahas.

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

Paparan SSD1306 ------------------------------------------------ ---------------------- Pemacu digunakan dalam pelbagai paparan (128x64, 128x32, dll.). Pilih paparan yang sesuai di bawah untuk membuat framebuffer bersaiz yang sesuai, dsb. SSD1306_128_64 paparan 128x64 piksel SSD1306_128_32 paparan 128x32 piksel SSD1306_96_16 --------------------------- -------------------------------------------- * / #tentukan SSD1306_128_64 / / #tentukan SSD1306_128_32 // #tentukan SSD1306_96_16 / * ======================================= =============================== * /

Langkah 12: Apa yang Perlu Dilakukan Selanjutnya?

Paparan OLED sebagai modul output dapat memberi anda peluang besar untuk menyediakan antara muka profesional untuk projek hobi anda. Anda boleh mencuba idea berikut sebagai titik permulaan untuk memaparkan data yang bermakna di dalamnya atau membantu pengguna mengetahui apa yang sedang berlaku atau jika dia perlu melakukan sesuatu. Akan lebih jelas bagi pengguna untuk membaca mesej pada paparan daripada menafsirkan keadaan projek / peranti melalui beberapa LED.

Apa yang boleh anda lakukan sebagai titik permulaan ialah:

• Baca nilai sensor suhu dan paparkan pada modul OLED. Anda boleh menambahkan sensor tekanan atau kelembapan ke dalamnya dan membuat projek stesen cuaca yang berfungsi sepenuhnya.
• Cuba lukis sesuatu pada modul paparan menggunakan modul kayu bedik sebagai alat input.
• Cuba lukiskan animasi pada paparan dengan urutan menggambar / menunda panggilan fungsi atau gangguan Arduino
• Paparkan logo tersuai anda pada permulaan sistem anda (bukannya Logo Adafruit)

Jangan lupa beritahu saya mengenai komen, apa yang akan anda lakukan (atau sudah anda lakukan) menggunakan modul paparan OLED.