Layar adalah bagian penting dari sebuah mesin apakah itu peralatan rumah tangga atau mesin industri. Tampilan tidak hanya menunjukkan opsi kontrol untuk mengoperasikan mesin tetapi juga menunjukkan status dan keluaran tugas yang dilakukan oleh mesin itu. Ada banyak jenis tampilan yang digunakan dalam elektronik seperti tampilan 7-segmen, tampilan LCD, tampilan layar sentuh TFT, tampilan LED, dll. Layar LCD 16x2 adalah yang paling dasar dan juga tampilan yang digunakan di beberapa peralatan elektronik kecil, kami telah melakukan banyak hal proyek menggunakan LCD 16x2 termasuk antarmuka dasar dengan mikrokontroler lain:
- Antarmuka LCD dengan Mikrokontroler 8051
- Antarmuka LCD dengan Mikrokontroler ATmega32
- Antarmuka LCD dengan Mikrokontroler PIC
- Menghubungkan LCD 16x2 dengan Arduino
- 16x2 LCD Interfacing dengan Raspberry Pi menggunakan Python
Dalam tutorial ini, kita akan melihat bagaimana antarmuka LCD 16x2 dengan mikrokontroler ARM7-LPC2148 dan menampilkan pesan selamat datang yang sederhana. Jika Anda baru mengenal ARM7, mulailah dengan dasar-dasar ARM7 LPC2148 dan pelajari cara memprogramnya menggunakan Keil uVision
Bahan yang Dibutuhkan
Perangkat keras
- Papan mikrokontroler ARM7-LPC2148
- LCD (16X2)
- Potensiometer
- IC pengatur tegangan 5V
- Papan tempat memotong roti
- Menghubungkan Kabel
- Baterai 9V
- Kabel USB mikro
Perangkat lunak
- Keil uVision 5
- Alat Flash Ajaib
Sebelum masuk ke proyek kita harus mengetahui beberapa hal tentang mode operasi LCD dan tentang kode Hex LCD.
Modul Layar LCD 16X2
Sebuah LCD 16X2 mengatakan bahwa ia memiliki 16 Kolom dan 2 Baris. LCD ini memiliki 16 pin. Gambar dan tabel di bawah ini menunjukkan nama pin layar LCD dan fungsinya.
|
NAMA |
FUNGSI |
|
VSS |
Pin Tanah |
|
VDD |
+ 5V Input Pin |
|
VEE |
Contrast Adjust Pin |
|
RS |
Daftar Pilih |
|
R / W |
Baca / Tulis Pin |
|
E |
Aktifkan Pin |
|
D0-D7 |
Pin Data (8 Pin) |
|
LED A |
Pin Anoda (+ 5V) |
|
LED K |
Pin Katoda (GND) |
LCD dapat bekerja dalam dua mode berbeda, yaitu mode 4-bit dan mode 8-bit. Dalam mode 4 bit kami mengirim data nibble dengan nibble, nibble atas pertama dan kemudian nibble bawah. Bagi Anda yang belum tahu apa itu nibble: nibble adalah sekelompok empat bit, jadi empat bit yang lebih rendah (D0-D3) dari sebuah byte membentuk nibble yang lebih rendah sedangkan empat bit teratas (D4-D7) dari satu byte membentuk camilan yang lebih tinggi. Ini memungkinkan kami mengirim data 8 bit.
Sedangkan pada mode 8 bit kita dapat mengirimkan data 8-bit secara langsung dalam satu goresan karena kita menggunakan 8 jalur data tersebut.
Di sini, di proyek ini kita akan menggunakan mode yang paling umum digunakan yaitu mode 4-bit. Dalam mode empat bit kita dapat menghemat 4 pin mikrokontroler dan juga mengurangi overhead kabel.
16x2 juga menggunakan kode HEX untuk mengambil perintah apa pun, ada banyak perintah hex untuk LCD seperti untuk memindahkan kursor, pilih mode, geser kontrol ke baris kedua dll. Untuk mengetahui lebih lanjut tentang Modul Layar LCD 16X2 dan perintah hex, ikuti tautan.
Diagram Sirkuit dan Koneksi
Tabel di bawah ini menunjukkan koneksi sirkuit antara LCD & ARM7-LPC2148.
|
ARM7-LPC2148 |
LCD (16x2) |
|
P0.4 |
RS (Pilih Daftar) |
|
P0.6 |
E (Aktifkan) |
|
P0.12 |
D4 (Data pin 4) |
|
P0.13 |
D5 (Data pin 5) |
|
P0.14 |
D6 (Data pin 6) |
|
P0.15 |
D7 (Data pin 7) |
Koneksi Regulator Tegangan dengan LCD & ARM7 Stick
Tabel di bawah ini menunjukkan hubungan antara ARM7 & LCD dengan pengatur tegangan.
|
IC Regulator Tegangan |
Fungsi pin |
LCD & ARM-7 LPC2148 |
|
1. Pin Kiri |
+ Ve dari baterai 9V Input |
NC |
|
2. Pin Pusat |
- Ve dari baterai |
VSS, R / W, K LCD GND dari ARM7 |
|
3. Pin Kanan |
Teratur + 5V Output |
VDD, A LCD + 5V dari ARM7 |
Potensiometer dengan LCD
Potensiometer digunakan untuk memvariasikan kontras layar LCD. Sebuah pot memiliki tiga pin, pin kiri (1) terhubung ke + 5V dan tengah (2) ke VEE atau V0 modul LCD dan pin kanan (3) terhubung ke GND. Kita bisa mengatur kontras dengan memutar kenop.
Pengaturan Jumper
Pin jumper ada di ARM7-Stick sehingga kita dapat memberi daya & mengunggah kode dengan menggunakan USB atau dengan menggunakan input 5V DC untuk daya saja. Anda bisa melihat gambar di bawah ini.
Gambar di bawah ini menunjukkan bahwa jumper berada pada posisi DC. Itu berarti kita harus menyalakan papan dari catu daya 5V eksternal.
Dan gambar ini menunjukkan bahwa jumper terhubung dalam mode USB. Di sini daya dan kode disediakan melalui port micro usb.
CATATAN: Di sini, di tutorial ini kami telah mengunggah kode dengan menggunakan USB dengan mengatur jumper ke USB dan kemudian mengubah jumper ke mode DC ke daya LPC2148 dari input 5v regulator. Anda dapat melihat ini di video yang diberikan di bagian akhir.
Rangkaian terakhir untuk menghubungkan LCD 16x2 dengan Mikrokontroler ARM7 akan terlihat seperti ini:
Pemrograman ARM7-LPC2148
Untuk memprogram ARM7-LPC2148 kita membutuhkan alat keil uVision & Flash Magic. Kami menggunakan Kabel USB untuk memprogram ARM7 Stick melalui port micro USB. Kami menulis kode menggunakan Keil dan membuat file hex dan kemudian file HEX di-flash ke tongkat ARM7 menggunakan Flash Magic. Untuk mengetahui lebih lanjut tentang menginstal keil uVision dan Flash Magic dan bagaimana menggunakannya ikuti link Memulai Dengan Mikrokontroler ARM7 LPC2148 dan Program itu menggunakan Keil uVision.
Kode lengkap untuk antarmuka LCD dengan ARM 7 diberikan di akhir tutorial ini, di sini kami menjelaskan beberapa bagiannya.
Pertama-tama kita perlu menyertakan file header yang diperlukan
#include
Menginisialisasi modul LCD adalah langkah yang sangat penting. Di sini kami menggunakan kode HEX tertentu, yang sebenarnya adalah perintah, untuk memberi tahu LCD tentang mode operasi (4-bit), jenis LCD (16x2), garis start, dll.
void LCD_INITILIZE (void) // Berfungsi untuk menyiapkan LCD { IO0DIR = 0x0000FFF0; // Set pin P0.4, P0.6, P0.12, P0.13, P0.14, P0.15 sebagai OUTPUT delay_ms (20); LCD_SEND (0x02); // Inisialisasi lcd dalam mode operasi 4-bit LCD_SEND (0x28); // 2 baris (16X2) LCD_SEND (0x0C); // Menampilkan kursor pada LCD_SEND (0x06); // Kursor kenaikan otomatis LCD_SEND (0x01); // Tampilkan LCD_SEND yang jelas (0x80); // baris pertama posisi pertama }
Untuk mode 4-Bit kita memiliki jenis fungsi tulis yang berbeda untuk pinnya, yaitu dengan menggunakan upper & lower nibble. Mari kita lihat, bagaimana caranya
void LCD_SEND (perintah char) // Berfungsi untuk mengirim perintah hex nibble dengan nibble { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((command & 0xF0) << 8)); // Kirim bagian atas perintah IO0SET = 0x00000040; // Mengaktifkan HIGH IO0CLR = 0x00000030; // Membuat delay_ms RS & RW RENDAH (5); IO0CLR = 0x00000040; // Mengaktifkan LOW delay_ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((perintah & 0x0F) << 12)); // Send nibble perintah yang lebih rendah IO0SET = 0x00000040; // AKTIFKAN TINGGI IO0CLR = 0x00000030; // RS & RW RENDAH delay_ms (5); IO0CLR = 0x00000040; // AKTIFKAN RENDAH delay_ms (5); }
Nibble Sending Logic
IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((perintah & 0x0F) << 12)); // Kirim nibble perintah yang lebih rendah IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((command & 0xF0) << 8)); // Kirim perintah bagian atas
Dua pernyataan di atas memainkan peran penting dalam program ini. Perintah pertama mengirim camilan bawah & kedua mengirim camilan atas. Itu tanpa mempengaruhi pin lain yang kami lakukan. Mari kita lihat bagaimana hal itu terjadi sebelum itu mengenal logika ini terlebih dahulu
ORing- (A-0 = A), (A-1 = 1) ANDing- (A & 0 = 0), (A & 1 = A)
Jadi kami menggunakan konsep masking dan operasi pergeseran logis tanpa mempengaruhi pin lainnya. Berarti hanya pin (P0.12-P0.15) yang digunakan dan tidak ada pin lain seperti P0.4, P0.6 yang terpengaruh. Ini akan dilakukan dengan menggeser data dalam empat bit dan membuat gigitan atas menggantikan gigitan bawah dan menutupi gigitan atas. Dan kemudian kami membuat bit bawah nol (0XF0) dan ORed dengan data nibble untuk mendapatkan data nibble atas pada output.
Proses serupa digunakan untuk data nibble yang lebih rendah tetapi di sini kita tidak perlu menggeser data.
Saat menulis data ke output, yaitu dalam mode perintah RS harus RENDAH dan untuk menjalankan mengaktifkan harus TINGGI, dan dalam mode data RS harus TINGGI dan untuk menjalankan pengaktifan harus TINGGI.
Sekarang untuk mengirimkan data string yang akan dicetak pada keluaran, prinsip yang sama digunakan nibble by nibble. Langkah penting disini adalah REGISTER SELECT (RS) harus HIGH untuk mode data.
void LCD_DISPLAY (char * msg) // Berfungsi untuk mencetak karakter yang dikirim satu persatu { uint8_t i = 0; sementara (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Mengirimkan nibble IO0SET = 0x00000050; // RS TINGGI & AKTIFKAN TINGGI untuk mencetak data IO0CLR = 0x00000020; // RW RENDAH Penundaan mode tulis ms (2); IO0CLR = 0x00000040; // EN = 0, RS dan RW tidak berubah (yaitu RS = 1, RW = 0) delay ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Mengirimkan nibble IO0SET = 0x00000050 lebih rendah; // RS & EN TINGGI IO0CLR = 0x00000020; tunda ms (2); IO0CLR = 0x00000040; tunda ms (5); i ++; }
Video Coding & Demonstrasi lengkap diberikan di bawah ini.