Apakah Anda sering mengandalkan serial monitor untuk memantau keluaran dari proyek ESP8266 Anda? Jika ya, menambahkan layar LCD berbasis antarmuka I2C bisa menjadi solusi yang lebih efisien. Berbeda dengan LCD paralel konvensional yang memerlukan banyak jalur data, LCD I2C hanya membutuhkan dua pin komunikasi, yaitu SDA (data) dan SCL (clock). Keunggulan lainnya, kedua pin tersebut dapat digunakan bersama dengan perangkat I2C lainnya tanpa menyebabkan konflik alamat, sehingga pengkabelan menjadi jauh lebih sederhana dan penggunaan pin mikrokontroler menjadi lebih efisien. Hal ini memberikan ruang bagi Anda untuk menambahkan lebih banyak sensor atau modul tambahan dalam satu proyek. Dalam artikel ini, Anda akan mempelajari cara menghubungkan LCD I2C ke papan ESP8266, menemukan alamat I2C perangkat, serta menulis program untuk menampilkan teks, angka hingga karakter khusus. Setelah memahami langkah-langkah ini, Anda akan memiliki dasar yang kuat untuk meningkatkan tampilan data pada proyek ESP8266 Anda tanpa bergantung pada Serial Monitor lagi.
Gambaran Umum Perangkat Keras
Pada umumnya, layar LCD I2C terdiri dari dua bagian utama, yaitu layar LCD karakter berbasis HD44780 dan adaptor LCD I2C. Berikut ini pembahasan detail dari kedua komponen tersebut:
1. Layar LCD Karakter
LCD karakter dirancang khusus untuk menampilkan huruf, angka, dan simbol. LCD karakter 16×2, misalnya, dapat menampilkan 16 karakter di setiap baris, dengan total dua baris.
Jika Anda perhatikan layar dengan saksama, Anda akan melihat kotak-kotak persegi panjang kecil untuk setiap posisi karakter. Di dalam setiap kotak ini terdapat kisi-kisi 5x8 titik atau piksel kecil. Piksel-piksel ini menyala dalam berbagai pola untuk membentuk huruf, angka, atau simbol yang berbeda.
2. Adaptor LCD I2C
Komponen utama adaptor ini adalah chip ekspander I/O 8-bit yang disebut PCF8574. Chip pintar ini mengubah data I2C dari ESP8266 Anda menjadi data paralel yang dibutuhkan layar LCD agar berfungsi.
Papan adaptor juga mencakup trimpot kecil yang memungkinkan Anda membuat penyesuaian halus pada kontras tampilan.
Anda akan melihat adanya jumper pada papan yang memasok daya ke lampu latar. Jika Anda ingin mengontrol tingkat kecerahan lampu latar, Anda cukup melepas jumper ini dan menghubungkan sumber tegangan eksternal ke pin header bertanda 'LED'.
Baca juga: Cara Mengonfigurasi dan Menggunakan Interrupt GPIO ESP8266 di Arduino IDE
Alamat I2C LCD
Jika Anda mengoperasikan beberapa perangkat pada bus I2C yang sama, Anda perlu memastikan bahwa setiap perangkat memiliki alamat I2C unik untuk mencegah terjadinya konflik alamat (address collision). Hal ini berlaku juga untuk I2C LCD backpack/adaptor.
Adaptor LCD umumnya dilengkapi dengan tiga pad konfigurasi alamat (A0, A1, A2) dalam bentuk jumper atau solder pads. Secara default, seluruh pad berada dalam kondisi open, sehingga adaptor menggunakan alamat bawaan. Untuk sistem dengan satu LCD, konfigurasi default ini sudah memadai.
Namun, ketika beberapa modul I2C dihubungkan secara bersamaan, Anda harus memodifikasi kombinasi A0–A2 untuk menghasilkan alamat alternatif yang tidak digunakan perangkat lain. Perubahan alamat dilakukan dengan men-short pad yang diperlukan menggunakan sedikit solder, sehingga bit alamat terkait berubah status dari 0 ke 1 sesuai tabel alamat yang berlaku untuk chip I2C expander (misalnya PCF8574 atau PCF8574A).
Hal penting yang perlu diketahui adalah bahwa perusahaan yang berbeda, seperti Texas Instruments dan NXP Semiconductors, memproduksi chip PCF8574 yang sama. Alamat I2C LCD Anda bergantung pada perusahaan pembuat chip tersebut.
Jika LCD Anda menggunakan chip PCF8574 dari Texas Instruments:
Menurut 'datasheet Texas Instruments', tiga bit pemilihan alamat (A0, A1, dan A2) dipetakan pada tiga bit LSB dari ruang alamat I2C 7-bit, yang digunakan untuk menentukan variasi alamat perangkat pada bus.
Karena modul menyediakan tiga pin pemilihan alamat yang dapat dikonfigurasi sebagai level logika HIGH atau LOW, tersedia delapan kombinasi alamat (2³ = 8) yang memungkinkan. Secara default, ketiga pin alamat tersebut berada pada kondisi HIGH melalui resistor pull-up internal, sehingga alamat I2C default PCF8574 adalah 0x27. Ketika sebuah jumper solder di-short, pin alamat terkait ditarik ke logika LOW. Jika ketiga jumper disingkat sekaligus, maka seluruh bit alamat berada pada kondisi LOW, menghasilkan alamat I2C sebesar 0x20. Dengan demikian, rentang alamat valid untuk perangkat ini berada pada interval 0x20 hingga 0x27.
Jika LCD Anda menggunakan chip PCF8574 NXP:
Berdasarkan lembar data NXP Semiconductors, tiga bit pemilihan alamat (A0, A1, dan A2) juga dipetakan pada tiga bit paling rendah dari register alamat I²C 7-bit. Namun, struktur bit yang tersisa dalam register alamat tersebut memiliki perbedaan dibandingkan implementasi pada varian Texas Instruments, sehingga format alamat efektif yang dihasilkan tidak identik antara kedua produsen.
Sama seperti varian Texas Instruments, konfigurasi tiga bit alamat (A0, A1, A2) pada chip ini menghasilkan delapan kombinasi alamat yang mungkin karena masing-masing bit dapat berada pada level HIGH atau LOW. Secara default, ketiga input alamat tersebut ditarik ke kondisi HIGH melalui resistor pull-up internal, sehingga modul PCF8574 menggunakan alamat I²C default 0x3F.
Melakukan short pada salah satu jumper solder akan memaksa bit alamat terkait ke level LOW. Apabila seluruh jumper disingkat, ketiga bit berubah menjadi LOW, dan perangkat akan menggunakan alamat dasar 0x38. Dengan demikian, rentang alamat I²C yang valid berada pada kisaran 0x38 hingga 0x3F.
Jadi, alamat I2C LCD Anda kemungkinan besar adalah 0x27 atau 0x3F. Jika Anda tidak yakin alamat I2C LCD Anda, jangan khawatir! Ada cara mudah untuk mengetahuinya, yang akan Anda pelajari nanti di tutorial ini.
Pinout Layar LCD I2C
Layar LCD I2C hanya memiliki empat pin. Berikut pinout-nya:
1. GND adalah pin ground.
2. VCC adalah pin catu daya. Hubungkan ke output 5V Arduino atau catu daya eksternal 5V.
3. SDA adalah pin data I2C.
4. SCL adalah pin clock I2C.
Menghubungkan Layar LCD I2C ke ESP8266
Menghubungkan LCD I2C ke ESP8266 sangat mudah karena Anda hanya perlu menghubungkan empat pin. Mulailah dengan menghubungkan pin VCC pada LCD ke pin VIN pada ESP8266, dan pin GND ke salah satu pin GND (ground) pada ESP8266. Selanjutnya, hubungkan kedua pin yang digunakan untuk komunikasi I2C. Hubungkan pin SCL pada LCD ke D1 (GPIO#5) pada ESP8266, dan pin SDA ke D2 (GPIO#4) pada ESP8266. Diagram ini menunjukkan kepada Anda secara tepat cara menghubungkan semuanya:
.png)
Menyesuaikan Kontras LCD
Setelah Anda selesai menghubungkan LCD ke ESP8266, Anda perlu menyesuaikan kontras layar LCD. Cari trimpot biru kecil pada papan adaptor I2C – ini mengontrol kontras LCD. Sekarang, nyalakan ESP8266 Anda. Anda akan melihat lampu latar menyala dengan segera. Ambil obeng kecil dan putar kenop potensiometer secara perlahan. Saat Anda menyesuaikannya, Anda akan mulai melihat baris persegi panjang pertama muncul di layar. Persegi panjang inilah tempat karakter akan muncul. Jika Anda dapat melihat persegi panjang tersebut dengan jelas. Selamat! LCD Anda berfungsi dengan sempurna dan siap untuk menampilkan teks!
Menentukan Alamat I2C
Sebelum kita masuk ke contoh kode, Anda perlu mengetahui alamat I2C LCD Anda agar dapat berkomunikasi dengan benar. Seperti yang telah disebutkan sebelumnya, alamat I2C LCD Anda kemungkinan besar adalah 0x27 atau 0x3F. Anda mungkin menemukan alamat ini tercetak pada stiker yang disertakan dengan LCD Anda atau tercantum dalam informasi produk. Namun, jangan khawatir jika Anda tidak dapat menemukan informasi ini di mana pun! Ada solusi mudah – Anda dapat menjalankan sketsa pemindai I2C sederhana yang akan membantu Anda menemukan alamat yang benar secara otomatis. Muat sketsa di bawah ini ke dalam Arduino IDE Anda.
#include <Wire.h>
void setup() {
Serial.begin(115200);
// Leonardo: wait for serial port to connect
while (!Serial) {
}
Serial.println();
Serial.println("I2C scanner. Scanning ...");
byte count = 0;
Wire.begin();
for (byte i = 8; i < 120; i++) {
Wire.beginTransmission(i);
if (Wire.endTransmission() == 0) {
Serial.print("Found address: ");
Serial.print(i, DEC);
Serial.print(" (0x");
Serial.print(i, HEX);
Serial.println(")");
count++;
delay(1); // maybe unneeded?
} // end of good response
} // end of for loop
Serial.println("Done.");
Serial.print("Found ");
Serial.print(count, DEC);
Serial.println(" device(s).");
} // end of setup
void loop() {
}
Setelah mengunggah sketsa ke ESP8266 Anda, buka monitor serial dengan laju baud 115200 dan tekan tombol EN pada ESP8266. Dalam beberapa saat, Anda akan melihat alamat I2C layar LCD Anda muncul di layar.
Pastikan untuk mencatat alamat ini di tempat yang aman. Anda akan membutuhkannya saat kita bekerja dengan LCD pada contoh selanjutnya.
Instalasi Library
Untuk mengontrol LCD I2C, kita akan menggunakan pustaka LiquidCrystal_I2C. Pustaka ini membuat penulisan ke LCD jauh lebih mudah karena menangani semua komunikasi I2C yang rumit di latar belakang. Ada beberapa versi pustaka ini yang tersedia, tetapi salah satu yang paling andal adalah versi yang dibuat oleh Frank de Brabander. Untuk menginstal pustaka:
1. Pertama, buka program Arduino IDE Anda. Kemudian klik ikon Pengelola Pustaka di bilah sisi kiri.
2. Ketik "liquidcrystal" di kotak pencarian untuk memfilter hasil Anda.
3. Cari pustaka "LiquidCrystal I2C library" yang dibuat oleh Frank de Brabander.
4. Klik tombol Instal untuk menambahkannya ke Arduino IDE Anda.
Contoh Kode Dasar – Hello World!
Dengan perangkat keras yang terhubung dan pustaka yang terpasang, kita dapat menulis sketsa Arduino sederhana untuk menampilkan teks pada LCD. Dalam contoh ini, kita akan mencetak 'Halo Dunia!' pada baris pertama LCD dan 'Tutorial LCD' pada baris kedua.
Sebelum mengunggah sketsa, Anda perlu membuat dua perubahan penting agar sketsa berfungsi dengan LCD spesifik Anda. Anda harus memasukkan alamat I2C LCD yang benar (yang telah kita temukan sebelumnya) dan menentukan dimensi tampilan dalam konstruktor LiquidCrystal_I2C(). Jika Anda menggunakan LCD karakter 16×2, masukkan 16 dan 2; jika Anda menggunakan LCD karakter 20×4, masukkan 20 dan 4.
// enter the I2C address and the dimensions of your LCD here
LiquidCrystal_I2C lcd(0x3F, 16, 2);
Setelah Anda membuat perubahan ini, Anda siap untuk mencoba sketsa lengkapnya:
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F, 16, 2); // set the LCD address to 0x3F for a 16 chars and 2 line display
void setup() {
lcd.init();
lcd.clear();
lcd.backlight(); // Make sure backlight is on
// Print a message on both lines of the LCD.
lcd.setCursor(2, 0); //Set cursor to character 2 on line 0
lcd.print("Hello world!");
lcd.setCursor(2, 1); //Move cursor to character 2 on line 1
lcd.print("LCD Tutorial");
}
void loop() {
}
Setelah mengunggah kode ini ke ESP8266 Anda, inilah yang akan Anda lihat di layar:
Penjelasan Kode:
Sketsa dimulai dengan menyertakan pustaka LiquidCrystal_I2C, yang menyediakan semua fungsi yang kita butuhkan untuk mengendalikan LCD.
#include <LiquidCrystal_I2C.h>
Selanjutnya, kita buat objek kelas LiquidCrystal_I2C. Konstruktor LiquidCrystal_I2C membutuhkan tiga informasi: alamat I2C, jumlah kolom, dan jumlah baris tampilan Anda.
LiquidCrystal_I2C lcd(0x3F,16,2);
Dalam fungsi setup, kita memanggil tiga fungsi penting. Pertama, fungsi init() menginisialisasi antarmuka ke LCD. Kedua, fungsi clear() menghapus apa pun di layar LCD dan memindahkan kursor ke pojok kiri atas. Ketiga, fungsi backlight() menyalakan lampu latar LCD agar kita dapat melihat teks.
lcd.init();
lcd.clear();
lcd.backlight();
Fungsi setCursor(2, 0) memindahkan kursor ke kolom ketiga pada baris pertama. (Ingat bahwa penghitungan dimulai dari 0, jadi kolom 2 sebenarnya adalah kolom ketiga.) Posisi kursor memberi tahu LCD di mana teks baru harus ditempatkan di layar. Sudut kiri atas dianggap sebagai posisi (0,0).
lcd.setCursor(2,0);
Berikutnya, kita menggunakan fungsi print() untuk menampilkan teks “Halo dunia!” pada LCD.
lcd.print("Hello world!");
Demikian pula, dua baris kode berikutnya memindahkan kursor ke kolom ketiga baris kedua dan mencetak ‘Tutorial LCD’ pada LCD.
lcd.setCursor(2,1);
lcd.print("LCD Tutorial");
Contoh Teks Bergulir
Jika Anda memiliki pesan yang lebih panjang dari 16 karakter, atau ingin membuat efek marquee bergulir, Anda dapat menggunakan fungsi scrollDisplayLeft() atau scrollDisplayRight() dalam satu putaran untuk menggerakkan teks di layar. Sketsa di bawah ini menunjukkan cara menggulir pesan secara terus-menerus ke kiri:
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F,16,2); // set the LCD address to 0x3F for a 16 chars and 2 line display
void setup() {
lcd.init();
lcd.clear();
lcd.backlight(); // Make sure backlight is on
// Print a message
lcd.print("Scrolling Text Demo");
delay(1000); // pause to read the message initially
}
void loop() {
lcd.scrollDisplayLeft(); // scroll everything to the left by one position
delay(300); // small delay for visible scrolling speed
}
Saat Anda mengunggah kode ini ke ESP8266 Anda, LCD Anda akan menampilkan sesuatu seperti ini:
Penjelasan Kode:
Dalam contoh ini, kami mencetak pesan sepanjang 19 karakter ("Demo Teks Bergulir") ke LCD. Karena layar hanya dapat menampilkan 16 karakter sekaligus, hanya 16 karakter pertama yang akan ditampilkan pada awalnya.
// Print a message to the LCD
lcd.print("Scrolling Text Demo");
Dalam fungsi loop(), kita memanggil lcd.scrollDisplayLeft(), yang memindahkan seluruh konten tampilan satu spasi ke kiri. Dengan mengulangi fungsi ini dengan jeda singkat di antara setiap pengguliran, pesan tampak bergerak mulus di layar.
void loop() {
lcd.scrollDisplayLeft(); // scroll everything to the left by one position
delay(300); // small delay for visible scrolling speed
}
Saat teks bergulir, karakter yang bergeser dari tepi kiri menghilang, dan spasi kosong muncul di sisi kanan layar. Jika Anda ingin pesan terus berulang, Anda perlu menambahkan kode yang mencetak ulang pesan secara berkala. Untuk menggulir ke arah sebaliknya (kanan ke kiri), Anda dapat menggunakan lcd.scrollDisplayRight().
Fungsi lain yang bermanfaat dari Pustaka LiquidCrystal_I2C
Objek LiquidCrystal_I2C menyediakan banyak fungsi bermanfaat untuk mengontrol LCD Anda. Berikut beberapa yang paling bermanfaat:
1. lcd.home() memindahkan kursor kembali ke pojok kiri atas LCD (posisi pertama pada baris pertama). Tidak seperti clear(), fungsi ini tidak menghapus apa yang sudah ada di layar – hanya memindahkan kursor ke posisi awal.
2. lcd.blink() dan lcd.noBlink() mengaktifkan atau menonaktifkan kursor blok yang berkedip. Saat diaktifkan dengan blink(), Anda akan melihat blok padat yang berkedip-kedip pada posisi kursor saat ini. Ini bagus untuk menarik perhatian pengguna atau menunjukkan di mana teks akan muncul selanjutnya. Jika Anda tidak menginginkan blok yang berkedip ini, gunakan noBlink() untuk menonaktifkannya.
3. lcd.cursor() dan lcd.noCursor() mengontrol apakah garis garis bawah (_) muncul di posisi di mana karakter berikutnya akan ditulis. Fungsi cursor() menampilkan garis ini, sementara noCursor() menyembunyikannya. Ini berbeda dari blok yang berkedip – ini hanyalah garis sederhana yang menunjukkan di mana karakter berikutnya akan berada.
4. lcd.display() dan lcd.noDisplay() memungkinkan Anda menyalakan atau mematikan seluruh layar tanpa menghapus apa pun. Saat Anda menggunakan noDisplay(), layar menjadi kosong, tetapi semua teks tetap tersimpan di memori LCD. Saat Anda memanggil display() lagi, semuanya akan muncul kembali! Ini sempurna untuk menciptakan efek kedipan atau menghemat daya saat layar tidak diperlukan.
Cobalah bereksperimen dengan fungsi-fungsi ini dalam kode Anda sendiri untuk melihat cara kerjanya. Fungsi-fungsi ini akan membantu Anda menciptakan tampilan yang lebih interaktif dan dinamis untuk proyek Anda!
Membuat dan Menampilkan Karakter Kustom
Terkadang Anda mungkin ingin menampilkan karakter khusus yang bukan bagian dari alfabet atau angka standar – misalnya, simbol seperti wajah tersenyum, simbol derajat (°) untuk pembacaan suhu, atau ikon-ikon menarik seperti hati, not musik, atau panah.
Kabar baiknya, LCD HD44780 memungkinkan Anda membuat hingga 8 karakter kustom dengan desain Anda sendiri! Seperti yang telah kita pelajari sebelumnya dalam tutorial ini, setiap karakter pada LCD ditampilkan menggunakan kisi-kisi kecil piksel yang tersusun dalam pola 5×8 (lebar 5 piksel dan tinggi 8 piksel). Untuk membuat karakter Anda sendiri, Anda perlu menentukan titik-titik kecil mana yang harus diaktifkan dan mana yang harus dinonaktifkan.
Untuk membuat karakter kustom Anda, pertama-tama Anda perlu membuat array 8-byte dalam kode Anda. Setiap byte dalam array ini mewakili satu baris horizontal dalam karakter Anda, dimulai dari baris atas hingga baris bawah. Untuk setiap byte, Anda akan menggunakan bit (1 dan 0 dalam biner) untuk menunjukkan piksel mana yang harus AKTIF (1) dan mana yang harus NONAKTIF (0). Hanya 5 bit pertama dari setiap byte yang digunakan karena karakter tersebut memiliki lebar 5 piksel.
Setelah Anda mendesain karakter dengan menyiapkan array ini, Anda dapat menggunakan fungsi createChar() untuk menyimpan karakter kustom Anda ke dalam CGRAM (Character Generator RAM) LCD, yang merupakan area memori khusus yang dirancang khusus untuk menampung karakter kustom.
Sekarang, mari kita lanjutkan dan buat beberapa karakter kustom keren untuk proyek Anda!
CGROM vs. CGRAM
Semua LCD berbasis driver Hitachi HD44780 memiliki dua jenis memori: CGROM (Memori Hanya-Baca Pembangkit Karakter) dan CGRAM (Memori Akses Acak Pembangkit Karakter). CGROM adalah memori non-volatil, yang berarti datanya tetap tersimpan meskipun daya dimatikan. CGROM menyimpan pola titik yang telah ditentukan sebelumnya untuk karakter ASCII standar, seperti huruf, angka, dan simbol umum. Ketika Anda ingin menampilkan "A" di layar, Anda mengirimkan kode untuk "A" (yang merupakan 0x41 dalam heksadesimal), dan pengontrol LCD akan mencari pola titik untuk "A" di CGROM-nya dan menampilkannya. Hal ini membuat menampilkan karakter biasa menjadi sangat cepat dan mudah!
Namun, CGRAM adalah memori volatil, sehingga datanya akan hilang ketika daya dimatikan. Memori ini fleksibel dan memungkinkan Anda menyimpan pola titik khusus yang tidak termasuk dalam set bawaan. Misalnya, Anda dapat mendesain simbol, ikon, atau karakter unik Anda sendiri untuk proyek Anda. Namun, CGRAM memiliki ruang terbatas – totalnya hanya 64 byte. Pada LCD 5×8 piksel standar, ini berarti Anda hanya dapat menyimpan 8 karakter khusus (karena setiap karakter membutuhkan 8 byte). Jika Anda menggunakan LCD 5×10 piksel, Anda hanya dapat menyimpan 4 karakter khusus karena masing-masing membutuhkan lebih banyak memori.
Singkatnya, CGROM bersifat baca-saja dengan pola karakter tetap yang tidak dapat diubah, sementara CGRAM dapat ditulis, memungkinkan Anda membuat dan menyimpan karakter kustom kapan pun dibutuhkan.
Generator Karakter Kustom
Membuat karakter kustom kini semakin mudah! Kami telah mengembangkan alat bermanfaat bernama Generator Karakter Kustom. Lihat kotak biru di bawah ini? Anda dapat mengeklik piksel mana pun untuk mengaktifkan atau menonaktifkannya, dan saat Anda melakukannya, kode untuk karakter Anda akan otomatis dibuat tepat di sebelah kotak tersebut. Anda dapat menyalin kode ini langsung ke sketsa Arduino Anda.
Kemungkinan untuk berkreasi hampir tak terbatas! Anda bisa membuat panah, hewan sederhana, karakter game, simbol cuaca, atau ikon kecil apa pun yang muat di kotak 5×8. Satu-satunya batasan adalah pustaka LiquidCrystal_I2C hanya memungkinkan Anda menggunakan delapan karakter kustom sekaligus. Tapi jangan khawatir – delapan karakter kustom yang berbeda masih cukup untuk membuat proyek Anda unik dan menarik!
Contoh Kode ESP8266
Sketsa di bawah ini menunjukkan cara menampilkan karakter kustom Anda di LCD:
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F, 16, 2); // set the LCD address to 0x3F for a 16 chars and 2 line display
// make some custom characters:
byte Heart[8] = {
0b00000,
0b01010,
0b11111,
0b11111,
0b01110,
0b00100,
0b00000,
0b00000
};
byte Bell[8] = {
0b00100,
0b01110,
0b01110,
0b01110,
0b11111,
0b00000,
0b00100,
0b00000
};
byte Alien[8] = {
0b11111,
0b10101,
0b11111,
0b11111,
0b01110,
0b01010,
0b11011,
0b00000
};
byte Check[8] = {
0b00000,
0b00001,
0b00011,
0b10110,
0b11100,
0b01000,
0b00000,
0b00000
};
byte Speaker[8] = {
0b00001,
0b00011,
0b01111,
0b01111,
0b01111,
0b00011,
0b00001,
0b00000
};
byte Sound[8] = {
0b00001,
0b00011,
0b00101,
0b01001,
0b01001,
0b01011,
0b11011,
0b11000
};
byte Skull[8] = {
0b00000,
0b01110,
0b10101,
0b11011,
0b01110,
0b01110,
0b00000,
0b00000
};
byte Lock[8] = {
0b01110,
0b10001,
0b10001,
0b11111,
0b11011,
0b11011,
0b11111,
0b00000
};
void setup() {
lcd.init();
// Make sure backlight is on
lcd.backlight();
// create a new characters
lcd.createChar(0, Heart);
lcd.createChar(1, Bell);
lcd.createChar(2, Alien);
lcd.createChar(3, Check);
lcd.createChar(4, Speaker);
lcd.createChar(5, Sound);
lcd.createChar(6, Skull);
lcd.createChar(7, Lock);
// Clears the LCD screen
lcd.clear();
// Print a message to the lcd.
lcd.print("Custom Character");
}
// Print All the custom characters
void loop() {
lcd.setCursor(0, 1);
lcd.write(0);
lcd.setCursor(2, 1);
lcd.write(1);
lcd.setCursor(4, 1);
lcd.write(2);
lcd.setCursor(6, 1);
lcd.write(3);
lcd.setCursor(8, 1);
lcd.write(4);
lcd.setCursor(10, 1);
lcd.write(5);
lcd.setCursor(12, 1);
lcd.write(6);
lcd.setCursor(14, 1);
lcd.write(7);
}
Saat Anda mengunggah kode ini ke ESP8266 Anda, LCD Anda akan menampilkan sesuatu seperti ini:
Cobalah dan bereksperimenlah dengan membuat karakter unik Anda sendiri!
Penjelasan Kode:
Setelah menyertakan pustaka LiquidCrystal_I2C dan menyiapkan objek LCD, kode tersebut mendefinisikan array khusus untuk karakter kustom kita. Setiap array memiliki tepat 8 byte, dan setiap byte mengontrol satu baris titik dalam kisi karakter 5×8 kita.
Contoh ini mencakup delapan karakter kustom yang berbeda. Mari kita lihat array Heart[8] sebagai contoh:
byte Heart[8] = {
0b00000,
0b01010,
0b11111,
0b11111,
0b01110,
0b00100,
0b00000,
0b00000
};
Setiap baris mewakili satu baris piksel, dimulai dari atas karakter. Angka "0b" di awal memberi tahu Arduino bahwa ini adalah angka biner (terdiri dari 0 dan 1). Setiap angka 0 berarti "piksel mati" dan setiap angka 1 berarti "piksel menyala". Jika Anda perhatikan polanya dengan saksama, Anda dapat melihat bagaimana angka 1 membentuk hati!
Di bagian pengaturan kode, kita menggunakan fungsi createChar() untuk menyimpan karakter kustom kita di memori LCD. Fungsi ini membutuhkan dua informasi: Angka antara 0 dan 7 (yang memberi tahu LCD slot memori mana dari delapan slot yang tersedia untuk digunakan) dan nama larik yang berisi desain karakter kita.
Kode di bawah ini menyimpan desain hati kita di slot 0 memori CGRAM LCD.
// create a new character
lcd.createChar(0, Heart);
Terakhir, di bagian loop, kita menampilkan karakter kustom kita menggunakan fungsi write(). Kita menentukan karakter mana yang akan ditampilkan dengan meneruskan nomor slot memori:
// byte(0) represents Heart character.
lcd.write(byte(0));
Siap Untuk Membuat Proyek Impianmu Menjadi Kenyataan?
Klik di sini untuk chat langsung via WhatsApp dan dapatkan dukungan langsung dari tim ahli kami!
0 Komentar