Bersenang-senang Dengan Layar OLED dan Arduino: 12 Langkah (dengan Gambar)

2024 Pengarang: John Day | [email protected]. Terakhir diubah: 2024-01-30 09:54

Saya cukup yakin Anda pasti pernah mendengar tentang teknologi layar OLED. Ini relatif baru dan menawarkan kualitas yang lebih baik daripada teknologi LCD lama. Dalam tutorial ini kami ingin meninjau langkah-langkah yang diperlukan untuk menampilkan data pada salah satu modul tampilan OLED satu warna paling umum yang tersedia di pasar. Saya akan mencoba menjelaskan fungsionalitas yang disediakan oleh perpustakaan Adafruit yang sesuai untuk menampilkan data pada modul ini.

Langkah 1: Modul OLED Apa yang Akan Kita Gunakan?

Modul OLED tersedia dalam berbagai ukuran dan fitur. Yang akan kita gunakan dalam tutorial ini adalah modul mono color 128x64 OLED. Jenis modul ini tersedia dalam ukuran berikut (Agar Anda melihat pada gambar):

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

Karena semua modul ini mendukung protokol I2C sebagai sarana komunikasi, kode dan pengkabelan semuanya sama persis. Satu-satunya perbedaan adalah Anda harus mempertimbangkan ukuran tampilan pada kode Anda sehingga konten yang akan Anda tampilkan, pas di dalamnya.

Langkah 2: I2C Singkatnya

Inter-integrated circuit (IIC) yang biasa disebut I2C (I squared C) dikembangkan oleh Philips pada tahun 80-an sebagai bus pertukaran data yang digunakan untuk mentransfer data antara central processing unit (CPU) atau unit mikrokontroler (MCU) suatu perangkat dan chip periferal. Itu pada dasarnya ditargetkan untuk aplikasi TV. Karena kesederhanaannya, ini menjadi sangat populer sehingga setelah beberapa saat menjadi salah satu mekanisme utama transfer data untuk CPU dan MCU dan perangkat periferal yang bukan merupakan bagian penting dari papan PCB yang sama dan terhubung melalui kabel (misalnya sensor, modul tampilan, dll.).

I2C terdiri dari bus komunikasi yang terbuat dari dua kabel yang mendukung transfer data dua arah antara master dan beberapa perangkat slave. Biasanya master node bertugas mengendalikan bus – yang sebenarnya dilakukan dengan membangkitkan sinyal sinkronisasi pada serial clock line (SCL). Ini adalah sinyal yang akan dikirim terus menerus oleh master selama transfer dan semua node lain yang terhubung ke bus akan menggunakannya untuk menyinkronkan komunikasi mereka dan mendeteksi kecepatan bus. Data ditransfer antara master dan slave melalui jalur data serial (SDA). Kecepatan transmisi bisa sampai 3,4 Mbps. Semua perangkat yang ingin mentransfer data melalui I2C harus memiliki alamat unik dan dapat beroperasi sebagai pemancar atau penerima tergantung pada fungsi perangkat. Misalnya modul tampilan OLED adalah penerima yang menerima beberapa data dan menampilkannya, sedangkan sensor suhu adalah transceiver yang mengirimkan suhu yang ditangkap melalui bus I2C. Biasanya perangkat master adalah perangkat yang memulai transfer data di bus dan menghasilkan sinyal clock untuk mengizinkan transfer. Selama transfer itu, perangkat apa pun yang ditangani oleh master ini dianggap sebagai budak dan membaca data itu.

Ketika sebuah node ingin mengirim beberapa data, byte pertama dari data harus menjadi alamat penerima dan kemudian data aktual datang setelahnya. Ini berarti bahwa untuk mengirim data ke perangkat output menggunakan I2C (misalnya modul tampilan OLED I2C) pertama-tama kita harus menemukan alamat I2C-nya dan inilah yang akan kita lakukan pertama kali pada langkah selanjutnya.

Jika Anda tertarik untuk mengetahui lebih dalam tentang detail dan teori tentang bus I2C, Anda dapat menggunakan referensi berikut:

www.i2c-bus.org

learn.sparkfun.com/tutorials/i2c

Langkah 3: Modul dan Komponen yang Diperlukan

Di sini Anda dapat menemukan daftar komponen yang Anda perlukan untuk menyelesaikan tutorial ini:

Tautan eBay:

• 1 x Arduino Uno:
• 1 x modul OLED 128x64:
• 4 x kabel Dupont:
• 1 x Mini papan tempat memotong roti solderless:

Link Amazon.com:

• 1 x Arduino Uno:
• 1 x modul OLED 128x64:
• 4 x kabel Dupont:
• 1 x Mini papan tempat memotong roti tanpa solder:

Langkah 4: Menghubungkan Modul Tampilan OLED ke Arduino

Catatan penting tentang perangkat yang mendukung I2C adalah cara Anda menghubungkannya ke Arduino semuanya sama. Ini karena Arduino menjalankan komunikasi I2C-nya hanya pada pin tertentu. Dalam tutorial ini saya menggunakan Arduino Uno. Arduino Uno menggunakan pin A5 sebagai SCK dan A4 sebagai SDA. Jadi kita bisa menghubungkan modul tampilan OLED ke Arduino Uno seperti yang ditunjukkan pada tampilan skema. Seperti yang mungkin Anda perhatikan pada gambar yang saya ambil dari modul tampilan OLED saya, konektor untuk VCC dan GND berbeda dari tampilan skematik. Ingatlah untuk memeriksa label pin pada modul Anda untuk memastikan Anda menghubungkannya dengan cara yang benar.

Kami hanya membutuhkan 4 pin yang harus terhubung seperti di bawah ini:

Arduino VCC -> Modul OLED VCC

Arduino GND -> Modul OLED GND

Arduino 4 -> Modul OLED SDA

Arduino 5 -> Modul OLED SCK

Langkah 5: Menemukan Alamat Modul Tampilan

Sebagai langkah pertama untuk menghubungkan ke perangkat berkemampuan I2C, Anda harus memiliki alamat modul. Untuk melakukannya, setelah memasang modul ke Arduino Anda, Anda hanya perlu mengunggah kode yang dilampirkan, ke Arduino Anda. Kode ini menggabungkan perpustakaan Wire yang merupakan perpustakaan yang disertakan dengan Arduino IDE yang menangani komunikasi I2C. Ia mencoba memindai perangkat I2C yang terhubung dan mengirimkan alamatnya melalui port serial ke komputer Anda. Jadi Anda dapat mengakses outputnya melalui alat Serial Monitor di Arduino IDE. Versi asli tersedia di Arduino Playground). Anda juga dapat melihatnya dengan cara yang lebih mudah dibaca di Editor Arduino online saya. Jangan berharap apa pun akan ditampilkan di layar saat kode ini berjalan.

Seperti yang Anda lihat pada gambar, modul saya diikat ke alamat 0x3C. Biasanya semua perangkat dalam lini produk tertentu (misalnya semua modul OLED 128x64) memiliki alamat yang sama.

Alamat perangkat I2C dibatasi dari 1 hingga 126. Kode ini hanya mencoba menghubungkan ke setiap perangkat secara berurutan (tanpa mentransmisikan data apa pun) dan kemudian memeriksa apakah ada kesalahan yang dilaporkan oleh pustaka yang mendasarinya saat menghubungkan ke alamat yang disediakan. Jika tidak ada kesalahan, maka cetak alamat sebagai modul yang tersedia untuk dihubungkan. Juga perlu dicatat bahwa 15 alamat pertama dicadangkan, jadi ia melompati mereka dan hanya mencetak yang di atas kisaran ini. Ingatlah bahwa alamat modul I2C ini dikodekan secara keras pada perangkat dan tidak dapat diubah. Jadi sebaiknya Anda menuliskannya di suatu tempat atau memberi label pada modul saat Anda akan meletakkannya kembali di rak lab Anda sehingga lain kali, menjalankan kode pemindai tidak diperlukan. Namun itu bukan prosedur yang rumit;)

Langkah 6: Menginstal Perpustakaan yang Diperlukan untuk Menampilkan Data pada Modul OLED

Pustaka Wire dapat menangani komunikasi tingkat rendah dengan perangkat I2C. Saat Anda ingin terhubung ke perangkat tertentu untuk membaca/menulis data dari/ke perangkat tersebut, biasanya Anda akan menggunakan perpustakaan yang disediakan oleh perusahaan yang awalnya membuat modul itu. Pustaka ini menangani semua detail komunikasi I2C dengan modul yang diberikan dan membiarkan kami lebih berkonsentrasi pada bisnis kami yang dalam hal ini menampilkan data dengan cara yang kami inginkan.

Adafruit, perusahaan yang memproduksi versi asli dari modul tampilan tersebut, menyediakan perpustakaan yang disebut Adafruit SSD1306 untuk menampilkan data pada tampilan monokrom ini. Jadi sebelum memulai coding, kita harus menginstal library ini melalui Library Manager (dapat diakses melalui menu Sketch > Include Library > Manage Libraries…) di Arduino IDE. Ada juga perpustakaan lain yang disebut Adafruit GFX Library yang menangani lebih banyak hal grafis tingkat rendah dan digunakan secara internal oleh Adafruit SSD1306. Anda harus menginstal keduanya di Arduino IDE Anda seperti yang Anda lihat pada gambar.

Langkah 7: Inisialisasi Modul Tampilan

Modul menggambar pada tampilan dibungkus dalam kelas bernama Adafruit_SSD1306. Definisi dari class ini ada pada library Adafruit, jadi kita harus memasukkan library tersebut terlebih dahulu. Kemudian kita harus membuat instance kelas ini terlebih dahulu. Konstruktor kelas ini mengambil nomor port di mana tampilan dapat diatur ulang yaitu pin 4 (terhubung ke SCK). Bagian kode ini harus ditempatkan di awal file (di luar fungsi setup() dan loop()).

#termasuk

Tampilan Adafruit_SSD1306(4);

Sekarang di dalam fungsi setup() kita harus memanggil fungsi begin dari objek tampilan dengan meneruskan alamat I2C kita seperti di bawah ini (SSD1306_SWITCHCAPVCC adalah nilai konstan yang menentukan jenis sumber daya ke perpustakaan):

batalkan pengaturan() {

display.begin(SSD1306_SWITCHCAPVCC, 0x3C); tampilan.tampilan(); } void loop() {} // loop bisa kosong untuk saat ini

Sekarang objek tampilan sudah siap dan kita dapat memanggil fungsinya (misalnya display.write(), display.drawLine, dll.). Catatan penting adalah bahwa setiap kali kita menggambar sesuatu dengan memanggil objek tampilan kita, kita perlu memanggil fungsi display.display() untuk membuat gambar yang sebenarnya terjadi pada tingkat perangkat keras. Hal ini terutama disebabkan oleh fakta bahwa fungsi menggambar yang kita panggil, hanya memperbarui representasi tampilan "dalam memori" untuk alasan kinerja. Ini sebenarnya men-cache perubahan dalam memori. Jadi kita harus selalu ingat untuk memanggil fungsi display() ketika kita selesai menggambar sesuatu di layar.

tampilan.tulis(…); // terus update di memori

display.drawLine(…); // terus memperbarui dalam memori. tampilan.tampilan(); // menghapus semua perubahan pada perangkat keras tampilan

Jika Anda mencoba mengunggah kode Anda pada langkah ini, Anda akan melihat bahwa logo Adafruit Industries akan ditampilkan. Anda mungkin bertanya-tanya siapa yang memintanya menggambar itu! Sebenarnya inilah yang dilakukan perpustakaan Adafruit. Ini menginisialisasi memori modul (representasi dalam memori dari perangkat keras tampilan) dengan logo perusahaan ini. Jika Anda tidak ingin melihatnya selama inisialisasi, Anda dapat mencoba memanggil fungsi display.clearDisplay() tepat sebelum memanggil display.display() dalam fungsi penyiapan Anda. Fungsi ini, seperti namanya, membersihkan layar sepenuhnya.

#termasuk

Tampilan Adafruit_SSD1306(4); void setup() { display.begin(SSD1306_SWITCHCAPVCC, 0x3C); tampilan.clearDisplay(); tampilan.tampilan(); } lingkaran kosong() {}

Berdasarkan dokumentasi pustaka Adafruit_SSD1306, Anda dapat menggunakan berbagai fungsi yang disediakan oleh kelas ini untuk menggambar di layar atau secara langsung memanipulasi piksel di dalamnya. Di bagian selanjutnya kami akan mencoba menyajikan contoh untuk masing-masing dari mereka sehingga Anda dapat memiliki gagasan tentang cara kerjanya. Sebagian besar contoh ini hanya akan menampilkan konten statis sederhana, jadi kita bisa meletakkannya di dalam fungsi setup() kita (setelah kode inisialisasi). Dengan demikian itu akan dijalankan hanya sekali dan tetap di sana.

Langkah 8: Tampilkan Teks Sederhana

Untuk menampilkan teks, kita dapat menggunakan fungsi sederhana display.println() dari library. Ia menerima teks sebagai string dan mencoba menampilkannya. Penting untuk diketahui bahwa kita harus memberi tahu perpustakaan di mana pada tampilan kita akan menyajikan teks. Setiap piksel pada tampilan memiliki koordinat yang ditentukan dengan X dan Y. X meningkat dari kiri ke kanan dan Y meningkat dari atas ke bawah. Sudut kiri atas layar adalah (X=0, Y=0) dan sudut kanan bawah adalah (X=127, Y=63). Saya mencatat koordinat sudut pada gambar pertama. Kita dapat menggunakan fungsi display.setCursor() untuk menentukan di mana pada tampilan kita akan menampilkan teks.

Properti lain dari teks adalah warnanya. Kita dapat menentukan warna menggunakan display.setTextColor() seperti yang ditampilkan pada contoh berikut.

tampilan.clearDisplay();

display.setTextColor(PUTIH); display.setCursor(35, 30); display.println("Halo Dunia!"); tampilan.tampilan();

Kita juga dapat menggunakan fungsi display.write() untuk menampilkan satu karakter. Ia menerima kode karakter sebagai tipe uint8_t dan menampilkan karakter yang sesuai dengan kode itu pada string. Sebagai contoh, jika kita ingin menampilkan string yang sama menggunakan fungsi ini, kita dapat menggunakan cuplikan berikut:

tampilan.clearDisplay();

display.setTextColor(PUTIH); display.setCursor(35, 30); tampilan.tulis(72); tampilan.tulis(101); tampilan.tulis(108); tampilan.tulis(108); tampilan.tulis(111); tampilan.tulis(32); tampilan.tulis(87); tampilan.tulis(111); tampilan.tulis(114); tampilan.tulis(108); tampilan.tulis(100); tampilan.tulis(33); tampilan.tampilan();

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

tampilan.clearDisplay();

// Mengatur warna menjadi hitam dengan tampilan latar belakang putih.setTextColor(BLACK, WHITE); display.setCursor(25, 30); display.println("Teks terbalik!"); tampilan.tampilan();

Anda juga memiliki pilihan untuk mengatur ukuran teks menggunakan fungsi display.setTextSize(). Ia menerima bilangan bulat sebagai ukuran. Semakin besar angkanya, semakin besar teksnya. Ukuran terkecil adalah 1 yang merupakan ukuran default teks. Kode berikut mencoba menulis huruf "A" dalam 6 ukuran berbeda:

tampilan.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"); tampilan.setTextSize(5); display.print("A"); display.setTextSize(6); display.print("A"); tampilan.tampilan();

Langkah 9: Menggambar Bentuk Dasar

Menggambar bentuk dasar seperti persegi panjang, lingkaran, segitiga, garis atau titik sangat mudah dan ada fungsi khusus untuk masing-masingnya.

Menggambar garis

Untuk menggambar garis, Anda dapat memanggil display.drawLine(startX, startY, endX, endY, color). Misalnya kode berikut menggambar garis diagonal di layar sehingga membentuk X besar:

tampilan.clearDisplay();

display.drawLine(0, 0, display.width() - 1, display.height() - 1, PUTIH); display.drawLine(display.width() - 1, 0, 0, display.height() - 1, PUTIH); tampilan.tampilan();

Anda dapat mengakses lebar dan tinggi tampilan menggunakan fungsi display.width() dan display.height(). Dengan demikian kode Anda akan independen dari ukuran layar.

Menggambar persegi panjang

Fungsi untuk menggambar persegi panjang adalah display.drawRect(upperLeftX, upperLeftY, width, height, color). Berikut adalah kode yang menggambar tiga persegi panjang di beberapa tempat acak:

tampilan.clearDisplay();

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

Dengan memanggil display.fillRect(upperLeftX, upperLeftY, width, height, WHITE) Anda dapat menggambar persegi panjang yang diisi dengan warna tertentu. Juga fungsi ketiga dalam contoh ini adalah display.drawRoundRect(upperLeftX, upperLeftY, width, height, cornerRadius, color) yang seperti yang Anda lihat pada gambar digunakan untuk menggambar persegi panjang dengan sudut bulat. Ia menerima parameter tambahan sebelum warna yang merupakan bilangan bulat yang menunjukkan radius sudut. Semakin besar nilainya semakin bulat sudutnya. Ini juga memiliki fungsi pengisian yang sesuai bernama display.drawFillRoundRect yang menurut saya Anda dapat menebak apa fungsinya.

Menggambar lingkaran

Fungsinya adalah display.drawCircle(centerX, centerY, radius, color). Berikut adalah contoh yang menggambar bentuk seperti smiley:

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

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

Seperti persegi panjang, Anda dapat menggunakan fungsi display.fillCircle untuk menggambar lingkaran yang diisi dengan warna yang diberikan.

Menggambar segitiga

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

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

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

Menggambar titik

Anda juga dapat mewarnai titik tertentu (yang disebut piksel) pada 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: Menggambar Gambar

Menggambar gambar berbeda dan sedikit rumit. Karena modul tampilan adalah monocolour, pertama-tama kita perlu mengonversi gambar kita ke format yang disebut bitmap warna mono (juga disebut hitam putih). Dalam format seperti itu, setiap piksel gambar disajikan dengan 0 atau 1. Angka 1 mewakili keberadaan warna dan 0 berarti ruang kosong. Anda dapat melihat contoh logo Arduino dalam format ini di atas bagian ini. Fungsi untuk menggambar gambar bitmap adalah display.drawBitmap(topLeftX, topLeftY, imageData, width, height, color). Parameter imageData adalah larik angka dalam byte. Setiap byte memiliki 8 bit, sehingga setiap byte berisi data 8 piksel gambar. Dengan menentukan lebar dan tinggi gambar, fungsi drawBitmap akan mengetahui dari bit mana baris piksel berikutnya dimulai.

Solusi yang saya pilih untuk mengonversi gambar saya ke format ini adalah pertama-tama menggunakan salah satu "konverter gambar ke ASCII" online (misalnya https://my.asciiart.club) untuk mengonversi gambar saya menjadi sekumpulan karakter ASCII dan kemudian menggantinya karakter yang digunakan untuk ruang kosong dengan 0 dan yang lainnya dengan 1. Itulah yang Anda lihat di bawah. Anda dapat menganggap masing-masing 0 dan 1 sebagai piksel pada layar. Jadi ukuran gambar tidak boleh melebihi ukuran tampilan kita yaitu 128x64.

Catatan: Menggunakan teknik ASCII ini bukanlah pendekatan yang disarankan karena karena rasio aspek karakter, gambar Anda akan berubah bentuk (karakter bukan persegi). Saya mencoba teknik ini hanya karena memudahkan untuk mengonversi gambar ke format yang diperlukan. Jika tidak, akan mungkin untuk mencapai hasil terbaik melalui beberapa pemrograman atau menggunakan beberapa aplikasi utilitas yang sepenuhnya berada di luar cakupan 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 membagi setiap baris dengan 8, mewakili satu byte dan menyimpannya dalam array seperti di bawah ini:

static const unsigned char PROGMEM arduino_logo ={

B00000000, B00000000, B00000111, B11111111, B111111111, B11100000, B00000000, B00000000, B00000000, B00000000, B01111111, B11111111, B111111111, B11111110, B00000000, B00000000, … // lanjutkan hingga akhir gambar };

Kemudian kita bisa menggambarnya di layar dengan memanggil fungsi drawBitmap.

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

Langkah 11: Pemecahan Masalah

Ini adalah tutorial yang panjang dan sangat mungkin terjadi kesalahan. Berikut adalah daftar beberapa kesalahan umum yang mungkin Anda temui saat menyiapkan modul tampilan OLED untuk proyek Anda (beberapa di antaranya terjadi pada saya saat menyiapkan tutorial ini).

Tidak ada yang ditampilkan sama sekali

Ini bisa terjadi karena berbagai alasan, jadi saya sarankan untuk memeriksa daftar berikut yang mungkin terjadi di proyek Anda:

Alamat I2C mungkin salah

Pastikan Anda telah menyetel alamat yang Anda dapatkan dalam kode i2c-scanner di fungsi display.begin() saat menyiapkan objek tampilan Anda.

SCL dan SDA terhubung dengan cara yang salah

Ini benar-benar terjadi pada saya. Jika Anda menggunakan Arduino Uno maka Anda harus memeriksa koneksi Anda lagi untuk memastikan mereka terhubung sama dengan milik saya. Jika Anda menggunakan edisi Arduino lain (mis. Mega, Leonardo, dll.), Anda harus tahu bahwa mereka mungkin memiliki I2C yang disetel ke pin lain. Anda dapat memeriksanya di dokumentasi perpustakaan Wire.

Anda menggambar sesuatu dari area yang terlihat

Ini adalah masalah perangkat lunak. Ini sangat umum ketika menggunakan fungsi gambar untuk salah menghitung beberapa koordinat sehingga gambar Anda akan berubah bentuk atau dalam skenario terburuk mungkin benar-benar keluar dari tempat kejadian. Tinjau perhitungan Anda dan coba lakukan gambar langkah demi langkah untuk melihat apa yang terjadi.

Teks tidak ditampilkan sama sekali

Anda lupa mengatur warna teks atau Anda telah menyetelnya ke nilai yang salah

Anda perlu memanggil setTextColor sebelum menggambar teks. Jika tidak, Anda tidak mendapatkan kesalahan, tetapi Anda tidak akan melihat apa pun di layar. Anda juga mungkin telah mengatur warna teks yang sama dengan warna latar belakang.

Anda menggunakan font yang sangat besar

Jika Anda mengatur ukuran teks ke nilai yang sangat besar, ada kemungkinan karakter keluar sepenuhnya dari area yang terlihat.

Ada kesalahan kompilasi tentang ukuran tampilan

Ini juga terjadi pada saya dan saya pikir itu akan terjadi pada sebagian besar dari Anda. Itu karena nilai konstanta ukuran tampilan yang didefinisikan di dalam file header Adafruit_SSD1306.h yang kami sertakan di atas skrip kami. File ini terletak di {your-project-folder}\libraries\Adafruit_SSD1306\Adafruit_SSD1306.h. Jika Anda membuka file ini, Anda akan melihat bahwa ada bagian komentar seperti di bawah ini yang menjelaskan bahwa Anda hanya perlu menghapus komentar pada konstanta yang mewakili ukuran modul tampilan OLED Anda. Untuk modul tampilan 128x64, baris #define SSD1306_128_64 harus tidak diberi komentar.

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

SSD1306 Menampilkan -------------------------------------------------- ---------------------- Driver digunakan dalam beberapa tampilan (128x64, 128x32, dll.). Pilih tampilan yang sesuai di bawah ini untuk membuat framebuffer berukuran tepat, dll. SSD1306_128_64 Layar 128x64 piksel SSD1306_128_32 Layar 128x32 piksel SSD1306_96_16 --------------------------- --------------------------------------------*/ #define SSD1306_128_64 / / #define SSD1306_128_32 // #define SSD1306_96_16 /*====================================== =================================*/

Langkah 12: Apa yang Harus Dilakukan Selanjutnya?

Layar OLED sebagai modul keluaran dapat memberi Anda peluang besar untuk menyediakan antarmuka yang terlihat profesional untuk proyek hobi Anda. Anda dapat mencoba mengikuti ide sebagai titik awal untuk menampilkan data yang berarti di dalamnya atau membantu pengguna mengetahui apa yang sedang terjadi atau apakah dia perlu melakukan sesuatu. Akan jauh lebih jelas bagi pengguna untuk membaca pesan di layar daripada menafsirkan status proyek/perangkat melalui beberapa LED.

Apa yang dapat Anda lakukan sebagai titik awal adalah:

• Baca nilai sensor suhu dan tampilkan di modul OLED. Anda dapat menambahkan sensor tekanan atau kelembaban ke dalamnya dan membuat proyek stasiun cuaca yang berfungsi penuh.
• Cobalah untuk menggambar sesuatu pada modul tampilan menggunakan modul joystick sebagai perangkat input.
• Cobalah untuk menggambar animasi di layar dengan urutan menggambar/menunda panggilan fungsi atau interupsi Arduino
• Tampilkan logo kustom Anda pada startup sistem Anda (bukan Adafruit Logo)

Jangan lupa beri tahu saya di komentar, apa yang akan Anda lakukan (atau sudah Anda lakukan) menggunakan modul tampilan OLED.