Introduction to 8051 Programming in Assembly Language

The assembly language is a low-level programming language used to write program code in
terms of mnemonics. Even though there are many high-level languages that are currently in
demand, assembly programming language is popularly used in many applications. It can be
used for direct hardware manipulations. It is also used to write the 8051 programming
code efficiently with less number of clock cycles by consuming less memory compared to the
other high-level languages.

8051 Programming
8051 Programming in Assembly Language

The assembly language is a fully hardware related programming language. The embedded
designers must have sufficient knowledge on hardware of particular processor or controllers
before writing the program. The assembly language is developed by mnemonics; therefore,
users cannot understand it easily to modify the program.

8051 Programming in Assembly Language

 Assembly programming language is developed by various compilers and the ―keiluvison‖ is
best suitable for microcontroller programming development. Microcontrollers or
processors can understand only binary language in the form of ‗0s or 1s‘; An assembler
converts the assembly language to binary language, and then stores it in
the microcontroller memory to perform the specific task.
8051 Microcontroller Programs in Assembly Language

The assembly language is made up of elements which all are used to write the program
in sequential manner. Follow the given rules to write programming in assembly language.

Rules of Assembly Language

 The assembly code must be written in upper case letters

 The labels must be followed by a colon (label:)
 All symbols and labels must begin with a letter
 All comments are typed in lower case
 The last line of the program must be the END directive
The assembly language mnemonics are in the form of op-code, such as MOV, ADD, JMP,
and so on, which are used to perform the operations.

Op-code: The op-code is a single instruction that can be executed by the CPU. Here the op-
code is a MOV instruction.
Operands: The operands are a single piece of data that can be operated by the op-code.
Example, multiplication operation is performed by the operands that are multiplied by the
operand.
Syntax: MUL a,b;
The Elements of an Assembly Language Programming:

 Assembler Directives
 Instruction Set
 Addressing Modes
Assembler Directives:
The assembling directives give the directions to the CPU. The 8051 microcontroller consists
of various kinds of assembly directives to give the direction to the control unit. The most
useful directives are 8051 programming, such as:
 ORG
 DB
 EQU
 END
ORG(origin): This directive indicates the start of the program. This is used to set the register
address during assembly. For example; ORG 0000h tells the compiler all subsequent code
starting at address 0000h.
Syntax: ORG 0000h

DB(define byte): The define byte is used to allow a string of bytes. For example, print the
―EDGEFX‖ wherein each character is taken by the address and finally prints the ―string‖ by
the DB directly with double quotes.
Syntax:
ORG 0000h

MOV a, #00h
————-
————-
DB‖EDGEFX‖

EQU (equivalent): The equivalent directive is used to equate address of the variable.
Syntax:
reg equ,09h
—————–
—————–
MOV reg,#2h
END:The END directive is used to indicate the end of the program.
Syntax:
reg equ,09h
—————–
—————–
MOV reg,#2h
END
Addressing Modes:
 The way of accessing data is called addressing mode. The CPU can access the data in
different ways by using addressing modes. The 8051 microcontroller consists of five
addressing modes such as:
 Immediate Addressing Mode
 Register Addressing Mode
 Direct Addressing Mode
 Indirect Addressing Mode
 Base Index Addressing Mode
Immediate Addressing Mode:
In this addressing mode, the source must be a value that can be followed by the ‗#‘ and
destination must be SFR registers, general purpose registers and address. It is used for
immediately storing the value in the memory registers.
Syntax:
MOV A, #20h //A is an accumulator register, 20 is stored in the A//
MOV R0,#15 // R0 is a general purpose register; 15 is stored in the R0 register//
MOV P0, #07h //P0 is a SFR register;07 is stored in the P0//
MOV 20h,#05h //20h is the address of the register; 05 stored in the 20h//
Ex:
MOV R0, #1
MOV R0, #20 //R0 <—R0[15]+20, the final value is stored in R0//

Register Addressing Mode:

In this addressing mode, the source and destination must be a register, but not general
purpose registers. So the data is not moved within the general purpose bank registers.
Syntax:
MOV A, B; // A is a SFR register, B is a general purpose register//
MOV R0, R1 //Invalid instruction, GPR to GPR not possible//

EX:
MOV R0, #02h
MOV A, #30h
ADD R0, A //R0<—R0+A, the final value is stored in the R0 register//
Direct Addressing Mode
In this addressing mode, the source or destination (or both source and destination) must be an
address, but not value.

Syntax:
MOV A,20h // 20h is an address; A is a register//
MOV 00h, 07h // both are addressed of the GPS registers//
Ex:
MOV 07h,#01h
MOV A, #08h
ADD A,07h //A<—A+07h the final value is stored in A//

Indirect Addressing Mode:

In this addressing mode, the source or destination (or destination or source) must be a indirect
address, but not a value. This addressing mode supports the pointer concept. The pointer is a
variable that is used to store the address of the other variable. This pointer concept is only
used for R0 and R1 registers.
Syntax:
MOVR0, #01h //01 value is stored in the R0 register, R0 address is 08h//
MOV R1, #08h//R1 is the pointer variable that stores address (08h) of R0 //
MOV 20h,@R1 //01 value is stored in the 20h address of the GP register//
 Indirect Addressing Mode
Base Index Addressing Mode:
This addressing mode is used to read the data from the external memory or ROM memory.
All addressing modes cannot read the data from the code memory. The code must read
through the DPTR register. The DPTR is used to point the data in the code or external
memory.
Syntax:
MOVC A, @A+DPTR //C indicates code memory//
MOCX A, @A+DPTR // X indicate external memory//
EX: MOV A, #00H //00H is stored in the A register//
MOV DPTR, #0500H //DPTR points 0500h address in the memory//
MOVC A, @A+DPTR //send the value to the A register//
MOV P0, A //date of A send to the PO registrar//

Instruction Set:

The instruction set is the structure of the controller or processor that provides commands to
the controller to guide the controller for processing data. The instruction set consists of
instructions, native data types, addressing modes, interrupt registers, exceptional handling
and memory architecture. The 8051 microcontroller can follow CISC instructions with
Harvard architecture. In case of the 8051 programming different types of CISC instructions
include:
 Data Transfer Instruction set
 Sequential Instruction Set
 Arithmetic Instruction set
 Branching Instruction set
 Loop Instrcution Set
 Conditional Instruction set
 Unconditional Instruction set
 Logical Instruction set
 Boolean Instruction set
Arithmetic Instruction Set:

The arithmetic instructions perform the basic operations such as:

 Addition
 Multiplication
 Subtraction
 Division
Addition:
ORG 0000h
MOV R0, #03H // move the value 3 to the register R0//
MOV A, #05H // move the value 5 to accumulator A//
Add A, 00H // addA value with R0 value and stores the result inA//
END
Multiplication:
ORG 0000h
MOV R0, #03H // move the value 3 to the register R0//
MOV A, #05H // move the value 5 to accumulator A//
MUL A, 03H // Multiplied result is stored in the Accumulator A //
END
Subtraction:
ORG 0000h
MOV R0, #03H // move the value 3 to register R0//
MOV A, #05H // move the value 5 to accumulator A//
SUBB A, 03H // Result value is stored in the Accumulator A //
END

Division:
ORG 0000h
MOV R0, #03H // move the value 3 to register R0//
MOV A, #15H // move the value 5 to accumulator A//
DIV A, 03H // final value is stored in the Accumulator A //
END

Conditional Instructions
 The CPU executes the instructions based on the condition by checking the single bit status or
byte status. The 8051 microcontroller consists of various conditional instructions such as:
 JB —>Jump below
 JNB —> Jump if not below
 JC —> Jump if Carry
 JNC —>Jump if not Carry
 JZ —>Jump if Zero
 JNZ —> Jump if not Zero

Call and Jump Instructions:

The call and jump instructions are used to avoid the code replication of the program. When
some specific code used more than once in different places in the program, if we
mention specific name to code then we could use that name anywhere in the program without
entering a code for every time. This reduces the complexity of the program. The 8051
programming consists of call and jump instructions such as LCALL, SJMP.
 LCALL
 ACALL
 SJMP
 LJMP
1. Syntax:
ORG 0000h
– – – – – – – –
– – – – – – – –
ACALL, label
– – – – – – – –
– – – – – – – –
SJMP STOP
Label: – – – – – – – –
– – – – – – – –
– – – – – – – –
ret
STOP:NOP
2. Syntax:
ORG 0000h
––––––––
––––––––
LCALL, label
––––––––
––––––––
SJMP STOP
Label: – – – – – – – –
––––––––
––––––––
ret
STOP:NOP

Call and Jump Instructions

Loop Instructions:

The loop instructions are used to repeat the block each time while performing the increment
and decrement operations. The 8051 microcontroller consist two types of loop instructions:
 CJNE —> compare and jump if not equal
 DJNZ —> decrement and jump if not zero
1. Syntax:
of CJNE
MOV A, #00H
MOV B, #10H
Label:INC A
– – – – – –
– – – – – –
CJNE A, label
2. Syntax:
of DJNE
MOV R0, #10H
Label:– – – – – –
––––––
DJNE R0, label
––––––
––––––
END
Logical Instruction Set:
The 8051 microcontroller instruction set provides the AND, OR, XOR, TEST, NOT and
Boolean logic instructions for set and clears the bits based on the need in the program.

Logical Instruction Set

1. Syntax:
MOV A, #20H /00100000/
MOV R0, #03H /00000101/
ORL A, R0 //00100000/00000101=00000000//

2. Syntax:
MOV A, #20H /00100000/
MOV R0, #03H /00000101/
ANL A, R0

3. Syntax:
MOV A, #20H /00100000/
MOV R0, #03H /00000101/
XRL A, R0

Shifting Operators

The shift operators are used for sending and receiving the data efficiently. The
8051 microcontroller consist four shift operators:
 RR —> Rotate Right
 RRC —>Rotate Right through carry
 RL —> Rotate Left
 RLC —>Rotate Left through carry
Rotate Right (RR):
In this shifting operation, the MSB becomes LSB and all bits shift towards right side bit-by-
bit, serially.

Syntax:
MOV A, #25h
RR A

Rotate Left (RL):

In this shifting operation, the MSB becomes LSB and all bits shift towards Left side bit-by-
bit, serially.

Syntax:
MOV A, #25h
RL A

RRC Rotate Right through Carry:

In this shifting operation, the LSB moves to carry and the carry becomes MSB, and all the
bits are shift towards right side bit by bit position.

Syntax:
MOV A, #27h
RRC A

RLC Rotate Left through Carry:

In this shifting operation, the MSB moves to carry and the carry becomes LSB and all the bits
shift towards left side in a bit-by-bit position.

Syntax:
MOV A, #27h
RLC A

Basic Embedded C Programs:

The microcontroller programming differs for each type of operating system. There are many
operating systems such as Linux, Windows, RTOS and so on. However, RTOS has several
advantages for embedded system development. Some of the Assembly level programming
examples are given below.
 LED blinking using with 8051 microcontroller:
 Number Displaying on 7-segment display using 8051 microcontroller
 Timer/Counter calculations and program using 8051 microcontroller
 Serial Communication calculations and program using 8051 microcontroller
LED programs with 8051 Microcontrller
1. WAP to toggle the PORT1 LEDs
ORG 0000H
TOGLE: MOV P1, #01 //move 00000001 to the p1 register//
CALL DELAY //execute the delay//
MOV A, P1 //move p1 value to the accumulator//
CPL A //complement A value //
MOV P1, A //move 11111110 to the port1 register//
CALL DELAY //execute the delay//
SJMP TOGLE
DELAY: MOV R5, #10H //load register R5 with 10//
TWO: MOV R6, #200 //load register R6 with 200//
ONE: MOV R7, #200 //load register R7 with 200//
DJNZ R7, $ //decrement R7 till it is zero//
DJNZ R6, ONE //decrement R7 till it is zero//
DJNZ R5, TWO //decrement R7 till it is zero//
RET //go back to the main program //
END

Timer/Counter Calculations and Program using 8051 Microcontroller:

The delay is the one of the important factors in the application software development.
The timers and counters are hardware components of the microcontroller, that are used in
many applications to provide the accurate time delay with count pulses. Both the tasks are
implemented by the software technique.
1. WAP to calculate the 500us time delay.
MOV TMOD, #10H //select the timer mode by the registers//
MOV TH1, #0FEH // store the delay time in higher bit//
MOV TL1, #32H // store the delay time in low bit//
JNB TF1, $ //decrement the value of the timer till it is zero//
CLR TF1 //clear the timer flag bit//
CLR TR1 //OFF the timer//
2. WAP to toggle the LEDs withthe 5 sec time delay
ORG 0000H
RETURN: MOV PO, #00H
ACALL DELAY
MOV P0, #0FFH
ACALL DELAY
SJUMP RETURN
DELAY: MOV R5, #50H //load register R5 with 50//
DELAY1: MOV R6, #200 //load register R6 with 200//
DELAY2: MOV R7, #229 //load register R7 with 200//
DJNZ R7, $ //decrement R7 till it is zero//
DJNZ R6, DELAY2//decrement R6 till it is zero//
DJNZ R5, DELAY1//decrement R5 till it is zero//
RET //go back to the main program //
END
3. WAP to count the 250 pulses using mode0 count0
Syntax:
ORG 0000H
MOV TMOD, #50H //select the counter//
MOV TH0, #15 //move the counting pulses higher bit//
MOV TH1, #9FH //move the counting pulses, lower bit//
SET TR0 //ON the timer//
JNB $ //decrement the count value till zero//
CLR TF0 //clear the counter, flag bit//
CLR TR0 //stop the timer//
END