To display any character on LCD micro controller has to send its ASCII value to the data bus of LCD.

For e.g.
to display 'AB' microcontroller has to send two hex bytes 41h and 42h respectively.LCD display used here is
having 16x2 size. It means 2 lines each with 16 character.

Circuit Diagram

Pin Information of LCD:

Algorithm to send data to LCD:

1. Make R/W low
 2. Make RS=0 ;if data byte is command RS=1 ;if data byte is data (ASCII value)
3. Place data byte on data register
4. Pulse E (HIGH to LOW)
5. Repeat the steps to send another data byte
LCD Initialization:
This is the pit fall for beginners.Proper working of LCD depend on the how the LCD is initialized. We have to
send few command bytes to initialize the lcd. Simple steps to initialize the LCD
1. Specify function set:
Send 38H for 8-bit,double line and 5x7 dot character format.
2. Display On-Off control:
Send 0FH for display and blink cursor on.
3. Entry mode set:
Send 06H for cursor in increment position and shift is invisible.
4. Clear display:
Send 01H to clear display and return cursor to home position.
Addresses of cursor position for 16x2 HD44780 LCD

line1 80H  81H  82H  83H  84H  85H  86H  87H  88H  89H  8AH  8BH  8CH  8DH  8EH  8FH 
line2 C0H C1H C2H C3H C4H C5H C6H C7H C8H C9H CAH CBH CCH CDH CEH CFH 

Assembly Language Code

; Interfacing LCD 16x2 in 4-bit mode. MOV R7,#0H
; Port0 to higher nibble data pins of LCD CLR P2.0 ;RS COMMAND
; Crystal 3.579545 MHz NEXT: ;8-bit code is split into two 4-bit nibbles.
; AT89C51 INC R6
;P2.0 to RS pin MOVC A,@A+DPTR
;P2.1 to Enable Pin MOV R7,A
ORG 0000H ANL A,#0F0H
AJMP MAIN SWAP A
ORG 0030H ANL P0,#0F0H
MAIN: ORL P0,A
MOV SP,#60H ;STACK POINTER ACALL ENABLE ;PULSE E sending first nibble
ACALL LCD_INIT ;Initialize lcd MOV A,R7
MOV DPTR,#MESSAGE1 ANL A,#0FH
CALL LCD_STRING ;Display message on LCD ANL P0,#0F0H
CALL NEXT_LINE ;Place cursor to;second Line ORL P0,A
MOV DPTR,#MESSAGE2 ACALL ENABLE ;PULSE E sending second nibble
CALL LCD_STRING ;Display message on LCD MOV A,R6
HERE: AJMP HERE CJNE R6,#09H,NEXT
LCD_INIT: ;initialize LCD in 4-bit mode RET
ANL P0,#0F0H
CALL LOOP LCD_STRING:
MOV DPTR,#LCDCODE MOV P0,#00H
MOV A,#0H SETB P2.0 ;RS DATA
MOV R6,#0H MOV A,#00H
MOV R6,#00H RET
NC: ;checks the end of message string
MOVC A,@A+DPTR
CJNE A,#2FH,NC1 ;With respect to crystal frequency 3.579 MHz
RET DELAYL: ; 5ms DELAY
NC1: SETB PSW.4 ; SELECT BANK 2
LCALL LCD_WRITE MOV R7,#25
INC R6 HDH:
MOV A,R6 MOV R6,#60
AJMP NC DJNZ R6,$
LCD_WRITE: DJNZ R7,HDH
SETB P2.0 ;RS DATA CLR PSW.4 ;DEFAULT BANK
CALL LO RET
RET
NEXT_LINE: LOOP: ;1 SEC DELAY
MOV P0,#00H MOV R7,#100
CLR P2.0 ;RS COMMAND LOOP1:
MOV A,#0C0H CALL DELAYL
CALL LO CALL DELAYL
RET DJNZ R7,LOOP1
LCD_CLEAR: ;This Subroutine is used to clear LCD RET
CALL DELAYL
ANL P0,#00H ;LCD INITIALIZING CODE (DO NOT DISTURB THIS)
MOV A,#01H LCDCODE:
CLR P2.0 ; RS command DB 02H
LO: ;8-bit code is split into two 4-bit nibbles. DB 02H
MOV R7,A DB 02H
ANL A,#0F0H DB 28H
SWAP A DB 28H
ANL P0,#0F0H DB 28H
ORL P0,A DB 0CH
CALL ENABLE DB 06H
MOV A,R7 DB 01H
ANL A,#0FH
ANL P0,#0F0H ;DATA TO BE DISPLAYED
ORL P0,A ;Maximum message length = 16 characters.
CALL ENABLE ;To notify end of message place '/' at the end.
RET
ENABLE: ;Give High-to-low pulse at enable pin MESSAGE1: DB "LCD INTERFACING /" ;Change
SETB P2.1 Message1
CALL DELAYL MESSAGE2: DB " IT IS EASY /" ;Change Message2
CLR P2.1
CALL DELAYL END

Berbahasa C dengan MCS51

Bahasa Assembler merupakan bahasa pemrograman tingkat paling rendah, hanya mengenal instruksi-
instruksi paling dasar mikrokontroler, ditambah dengan beberapa perintah untuk mengatur memori secara
sederhana. Bahasa pemrograman ‘satu tingkat’ di atas Asembler adalah bahasa C yang sangat fleksible,
dipakai untuk membangun Windows, tapi bisa juga dipakai untuk rancang bangun peralatan dengan
mikrokontroler.
C asalnya dirancang sebagai bahasa pemrograman untuk membangun sistem operasi UNIX pada komputer
DEC PDP-11, sekitar awal tahun 1970-an. Bahasa ini berkembang secara pesat, pada tahun 1983, American
National Standards Institute (ANSI) membentuk komite kerja dengan tugas khusus membakukan bahasa C
sebagai bahasa pemrograman yang tidak tergantung pada jenis komputer. Hasil kerja komite tersebut
merupakan pedoman baku untuk bahasa C, dan C compiler yang dibangun atas dasar pedoman tersebut
disebut sebagai ANSI-C.
Semua C compiler yang ada kini kebanyakan adalah ANSI-C, tapi masing-masing mempunyai variasinya
tersendiri, dilengkapi dengan sarana-sarana untuk memudahkan pemakaian C pada komputer tertentu.
Dalam hal ini dikenal Turbo C, Borland C++, Visual C dan lain sebagainya, semuanya merupakan C Compiler
yang banyak dipakai pada IBM-PC, tentu saja hasil akhir dari semua C Compiler tadi adalah kode mesin
untuk prosesor IBM-PC (8086, 80286, 80386, 80486 dan Pentium).
Tapi bahasa C untuk keperluan rancang bangun peralatan yang memakai mikrokontroler tentu saja tidak
memerlukan sarana-sarana tambahan secanggih C Compiler yang dipakai dalam IBM-PC, dan hasil akhirnya
harus berupa kode mesin untuk masing-masing mikrokontroler/mikroprosesor. Artinya C Compiler untuk
mikrokontroler MCS51 harus menghasilkan kode mesin MCS51, C Compiler untuk MC68HC11 harus
menghasilkan kode mesin MC68HC11 pula.
Dengan pengertian di atas. C Compiler untuk IBM-PC tidak bisa dipakai untuk mikrokontroler, dan masing-
masing jenis mikrokontroler mempunyai C Compiler tersendiri.
C Compiler untuk MCS51
Sejak akhir tahun 1980-an, telah banyak dibuat C Cross-Compiler yang bekerja pada IBM-PC untuk MCS51,
artinya C Compiler tersebut bekerja di IBM-PC tapi kode mesin yang dihasilkan bukan untuk IBM-PC
melainkan untuk MCS51.
C Compiler untuk MCS51 yang cukup dikenal antara lain adalah Micro-C buatan Dunfield Development
Systems, Franklin C buatan Franklin Software Inc dan C51 buatan Keil Software, harga perangkat lunak
tersebut tidak murah. Yang menarik meskipun harganya mahal, Keil membagikan C51 produknya yang bisa
diminta lewat situs web http://www.keil.com, C51 gratis tersebut dibatasi hanya bisa menghasilkan kode
mesin MCS51 paling banyak 2 KiloByte. Tapi untuk keperluan projek kecil-kecil yang memakai AT89C2051
batasan memori tersebut tidak merupakan masalah, karena memori-program AT89C2051 memang hanya
sebesar 2 KiloByte.
Selain produk komersil tersebut di atas, ada pula C Compiler gratis, yang dikenal sebagai SDCC – Small
Device C Compiler.
Small Device C Compiler – SDCC
SDCC, buatan Sandeep Dutta (sandeep@users.sourceforge.net), sejak semula memang dibuat sebagai
software gratis (freeware), kemudian project mulia ini digabungkan dengan projek GNU, yakni projek
ramai-ramai insan Internet yang melahirkan Linux. Dengan demikian, kini program SDCC bisa diambil pada
situs http://sdcc.sourceforge.net.
Dalam rancangannya, SDCC dipersiapkan untuk berbagai macam mikroprosesor / mikrokontroler, hal ini
sesuai dengan sifat bahasa C yang mudah diadaptasikan ke berbagai macam prosesor. Sampai saat ini,
SDCC sudah bisa dipakai untuk mikroprosesor Z80, mikrokontroler MCS51, dalam waktu dekat akan segera
bisa dipakai untuk mikrokontroler AVR buatan Atmel, dan mikrokontroler PIC buatan MicroChip, dan
beberapa prosesor lainnya akan segera menyusul.
Hal ini membuat SDCC menjadi sangat menarik. Setelah terbiasa memakai SDCC untuk projek-projek
dengan MCS51, kelak satu saat bermaksud memakai mikrokontroler AVR karena memerlukan
mikrokontroler yang kemampuannya lebih, maka tidak banyak hambatan untuk beralih prosesor, bahkan
program-program yang sudah dikembangkan untuk MCS51 dengan SDCC, dengan sedikit perubahan bisa
dipakai di sistem yang memakai AVR.
Digital Clock dengan SDCC
Artikel ini tidak dimaksud untuk mengajarkan bahasa C, tapi hanya sekedar mengenalkan C untuk
mikrokontroler dengan contoh yang sesungguhnya.
Artikel Digital Clock – Ilhami Prinsip Dasar Microcontroller dalam Komputek edisi No. 175 Minggu ke IV Juli
2000 (http://alds.stts.edu/DIGITAL/DigitalClock.htm), merupakan contoh pemakaian AT89C2051 yang
sangat sederhana.

Gambar 1
Rangkaian Digital Clock
Program C berikut merupakan saduran langsung dari program CLOCK.ASM yang ditulis dalam bahasa
Assembler MCS51, dipakai untuk mengendalikan Digital Clock dengan rangkaian seperti terlihat dalam
Gambar 1, cara kerjanya dibahas dalam artikel di atas.
Program tersebut ditulis dengan program editor biasa, bisa pakai EDITOR.COM dalam DOS atau
NotePad.EXE dalam Windows, kemudian disimpan dalam file dengan nama CLOCK.C.
Selanjutnya pada DOS prompt diberikan perintah SDCC CLOCK.C, perintah ini akan menghasilkan banyak
file, semua dengan nama yang dimulai dengan CLOCK. Dari sekian banyak file tersebut terdapat CLOCK.IHX,
file ini merupakan file berisikan kode mesin MCS51 (object file) dengan format Intel Hex yang siap diisikan
ke dalam PEROM dari AT89C2051.
Program 1 – Digital Clock sederhana dengan C
01:/*************************************** 37:* Bagian Utama *
*********************\ 38:* Tugas Utama AT89C2051 menangani Sistem
02: Digital Clock Tampilan 7 ruas, dan *
03:\*************************************** 39:* menjalankan rutin ScanDisplay tanpa berhenti.
*********************/ *
04:#include <AT89X51.h> 40:* *
05:char Pencacah20; 41:* Interupsi Timer terjadi setiap 50 mili detik
06:char Detik; sekali, saat itu *
07:char Menit; 42:* AT89C2051 meninggalkan sebentar Bagian
08:char Jam; Utama ini, untuk mengu *
09:char Ruas[4]; 43:* rus untaian pencacah Menit dan pencacah
10:sbit at 0xB2 TombolJam; // P3.2 Jam. *
11:sbit at 0xB3 TombolMenit; // P3.3 44:\***************************************
12: ************************/
13:// ****** Membentuk ruas-ruas angka untuk 45:void main (void){
ditampilkan ****** 46: Pencacah20=20; //Nilai awal Pencacah20
14:void Ruas2Digit (unsigned char c, unsigned char 47: Jam=Menit=Detik=0; //Mulai dari Jam/Menit 0
pos){ 48: PerbaruiTampilan();
15: code char KombinasiRuas[] = 49:
{0xC0,0xF9,0xA4,0xB0,0×99, 50: //th0:tl0 diisi dengan -50000,
16: 0×92,0×82,0xF8,0×80,0×90}; 51: //sebagai pencacah count-up 50000 pulsa
17: Ruas[pos++] = KombinasiRuas[c/10]; kemudian
18: Ruas[pos] = KombinasiRuas[c%10]; 52: //(=50000 mikro-detik) pencacah melimpah
19: } menjadi 0 (TF0=1)
20:void PerbaruiTampilan (void){ 53: TH0 = (-50000/256)-1;
21: Ruas2Digit(Jam,0); 54: TL0 = (-50000%256);
22: Ruas2Digit(Menit,2); 55:
23: } 56: TMOD = 0×11; //Timer 0 & 1 sebagai 16 bit
24:// ****** Waktu tunda penyalaan 1 digit angka counter
****** 57: ET0 = 1; //Aktipkan interupsi Timer 0
25:void TungguSebentar() { // tunggu selama 1,5 58: EA = 1; //Aktipkan Sistem interupsi MCS51
mili-detik 59: TR0 = 1; //Jalankan Timer 0
26: //th0:tl0 diisi dengan -1500, 60:
27: //sebagai pencacah count-up 1500 pulsa 61: while(1) //4 baris berikut ini diulang tanpa henti
kemudian 62: {
28: //(=1500 mikro-detik) pencacah melimpah 63: P1 = Ruas[0]; //mengatur Ruas puluhan jam
menjadi 0 (TF1=1) 64: P3 = 0xF7; //menghidupkan angka puluhan jam
29: TH1 = (-1500/256)-1; 65: TungguSebentar();
30: TL1 = (-1500%256); 66: P1 = Ruas[1]; //mengatur Ruas satuan jam
31: 67: P3 = 0xFB; //menghidupkan angka satuan jam
32: TF1 = 0; //Timer Flag 1 di-nol-kan 68: TungguSebentar();
33: TR1 = 1; //Timer 1 mulai men-cacah 69: P1 = Ruas[2]; //mengatur Ruas puluhan menit
34: while (!TF1); //Tunggu sampai TF1 menjadi 1 70: P3 = 0xFD; //menghidupkan angka puluhan
35: } menit
36:/*************************************** 71: TungguSebentar();
************************\ 72: P1 = Ruas[3]; //mengatur Ruas satuan menit
73: P3 = 0xFE; //menghidupkan angka satuan menit 101: if (!TombolJam) GantiJam(); //ditekan, rubah
74: TungguSebentar(); angka Jam
75: } 102: else
76: } 103: if (!TombolMenit) GantiMenit(); //ditekan,
77:// ****** Melakukan perubahan angka Jam rubah angka Menit
****** 104: }
78:void GantiJam (void){ 105:
79: Jam += 1; //Jam sebagai ‘count-up counter’ /*****************************************
80: if (Jam==24) Jam=0; //Kembalikan ke 00 jika *******************\
sampai jam 24 106: Rutin Layanan Interupsi (ISR) untuk Timer 0
81: PerbaruiTampilan(); 107: Terjadi sekali setiap 50 mili detik (20 kali/detik)
82: } 108:
83:// ****** Melakukan perubahan angka Menit \*****************************************
****** *******************/
84:void GantiMenit(void){ 109: void TimerInterrupt(void) interrupt 1 using 1 {
85: Menit += 1; //Menit sebagai ‘count-up counter’ 110: //Perbaharui dulu nilai awal Timer 0
86: if (Menit==60) { //jika sudah sampai menit 60 … 111: //th0:tl0 diisi dengan -50000,
87: Menit = 0; //kembalikan menjadi menit 00 112: //sebagai pencacah count-up 50000 pulsa
88: GantiJam(); } //saatnya merubah angka Jam kemudian
89: PerbaruiTampilan(); 113: //(=50000 mikro-detik) pencacah melimpah
90: } menjadi 0 (TF0=1)
91:// ****** Melakukan perubahan angka Detik 114: TH0 = (-50000/256)-1;
****** 115: TL0 = (-50000%256);
92:void GantiDetik(void){ 116:
93: Detik += 1; //Detik sebagai ‘count-up counter’ 117: Pencacah20 -= 1; //Pencacah20 sebagai ‘count-
94: if (Detik==60) { //jika Detik menjadi 60 .. down counter’
95: Detik = 0; //Kembalikan menjadi detik 00 118: if (!Pencacah20) { //jika Pencacah20 menjadi 0
96: GantiMenit(); } …
97: PerbaruiTampilan(); 119: Pencacah20 = 20; //nilai awal Pencacah20
98: } 120: PeriksaTombol();
99:// ****** Melakukan pemeriksaan tombol 121: GantiDetik(); }
****** 122: }
100: void PeriksaTombol (void){
Materi Penunjang
Sandeep Dutta SDCC 2.3.0 (Small Device C Compiler) – for 8051/Z80 based MCUs
Budhy Sutanto