UNIT I

8-BIT EMBEDDED PROCESSOR

1.1. 8051 Microcontroller

8051 microcontroller is an 8-bit microcontroller created in 1981 by Intel Corporation. It has an 8-
bit processor that simply means that it operates on 8-bit data at a time. It is among the most
popular and commonly used microcontroller.
As it is an 8-bit microcontroller thus has 8-bit data bus, 16-bit address bus. Along with that, it
holds 4 KB ROM with 128 bytes RAM.

1.1.1. What a Microcontroller is?

A microcontroller is an integrated chip designed under Very Large Scale Integration technique
that consists of a processor with other peripheral units like memory, I/O port, timer, decoder,
ADC etc. A microcontroller is basically designed in such a way that all the working peripherals
are embedded in a single chip with the processor.

Any programmable device holds a processor, memory, I/O ports and timer within it. But a
microcontroller contains all these components embedded in a single chip. This single-chip
manages the overall operation of the device.
A microprocessor simply contains a CPU that processes the operations with the help of other
peripheral units. Microprocessors are used where huge space is present to inbuilt a large
motherboard like in PCs.

1.2. Architecture of 8051 Microcontroller

The figure below represents the architectural block diagram of 8051 microcontroller:
As we can see that several units are present in the above architecture. And every unit is
embedded to execute the desired operation. Let us now discuss the operation of each unit present
in the architecture.

1.2.1. Central processing unit (CPU): 8051 uses the 8-bit processor. This unit carries out the
operation on 8-bit data. A processor is the heart of microcontroller. As the execution of the
program stored in the memory is performed by the processor.
The unit performs arithmetic and logical operations on 8-bit data as it has ALU, with internal
registers and program counters.
Several logical operations are performed by the ALU according to the program stored in the
memory.
The processor of 8051 microcontrollers possesses a special feature by which it can process single
bit or 8-bit data. This simply means that it has the ability to access each single bit data either to
clear, set or move etc. for any logical computation.
1.2.2. Memory: Basically 8051 microcontroller consists of on-chip program memory i.e., ROM
and on-chip data memory i.e., RAM.
Let us first understand
• ROM
8051 microcontroller has 4 KB ROM with 0000H to 0FFFH as the addressable space. It is
completely a program or code memory that means used by the programmer to store the
programs that are to be executed by the microcontroller.
• The operations that are executed by the device in which the microcontroller is present are
stored in the ROM of the memory at the time of fabrication. Hence cannot be changed or
modified.

• RAM
8051 holds a 128 bytes RAM. Basically, RAM is used to store data or operands for only a
small time duration. It can be altered anytime according to the need of the user. It is also
known as the data memory as it stores the data temporarily.
•
Out of the 128-byte RAM, first, 32 bytes is held by the working registers. Basically, these are
4 banks which separately has 8 registers. These registers are accessed either by its name or
address. It is to be noted here that at a particular time only a single register bank can be used.

• As in 8051, the data and program memory i.e., RAM and ROM hold a definite memory
space. However, for some applications there exist the need for external memory to enhance
the memory space, thus external RAM, ROM/EPROM is used by the 8051 microcontrollers.
1.2.3. Input/ Output port: 8051 consists of 4 parallel ports of 8 bit each thereby providing 32
input-output pins. All the 4 ports function bidirectional i.e., either input or output according to
the software control.

1.2.4. Timer and Control Unit: Timers are used to create a time gap or delay between 2 events.
8051 microcontroller consists of 2 timers of 16 bit each by which the system can produce two
delays simultaneously in order to generate the appropriate delay.

1.2.5. 8051 Flag Bits and PSW Register

The program status word (PSW) register is an 8-bit register, also known as flag register. It is of
8-bit wide but only 6-bit of it is used. The two unused bits are user-defined flags.

1.2.6. The Data Pointer (DPTR) is the 8051's only user-accessible 16-bit (2-byte) register. The
Accumulator, R0–R7 registers and B registers are 1 Byte value registers. DPTR is meant for
pointing to data. It is used by the 8051 to access external memory using the address indicated by
DPTR.

Basically, microcontrollers use hardware delays in which a physical device is used by the
processor to produce the respective delay. And this physical device is known as a timer.
The timer produces the delay according to the demand of the processor and sends the signal to
the processor once the respective delay gets produced.

1.2.7. Pin diagram of 8051 Microcontroller

Introduction :
The 8051 microcontroller is a popular 8-bit microcontroller widely used in embedded systems. It
is a single-chip microcontroller with a Harvard architecture that includes a CPU, RAM, ROM,
and several peripherals. The 8051 microcontroller has a 40-pin dual in-line package (DIP) that
provides various inputs and outputs for communication with external devices.
8051 microcontroller is a 40 pin Dual Inline Package (DIP). These 40 pins serve different
functions like read, write, I/O operations, interrupts etc. 8051 has four I/O ports wherein each
port has 8 pins which can be configured as input or output depending upon the logic state of the
pins. Therefore, 32 out of these 40 pins are dedicated to I/O ports. The rest of the pins are
dedicated to VCC, GND, XTAL1, XTAL2, RST, ALE, EA‘ and PSEN‘. Pin diagram of 8051.

Description of the Pins :

• Pin 1 to Pin 8 (Port 1) – Pin 1 to Pin 8 are assigned to Port 1 for simple I/O operations. They
can be configured as input or output pins depending on the logic control i.e. if logic zero (0)
is applied to the I/O port it will act as an output pin and if logic one (1) is applied the pin will
act as an input pin. These pins are also referred to as P1.0 to P1.7 (where P1 indicates that it
is a pin in port 1 and the number after ‗.‘ tells the pin number i.e. 0 indicates first pin of the
port. So, P1.0 means first pin of port 1, P1.1 means second pin of the port 1 and so on). These
pins are bidirectional pins.
• Pin 9 (RST) – Reset pin. It is an active-high, input pin. Therefore if the RST pin is high for a
minimum of 2 machine cycles, the microcontroller will reset i.e. it will close and terminate
all activities. It is often referred as ―power-on-reset‖ pin because it is used to reset the
microcontroller to it‘s initial values when power is on (high).
• Pin 10 to Pin 17 (Port 3) – Pin 10 to pin 17 are port 3 pins which are also referred to as P3.0
to P3.7. These pins are similar to port 1 and can be used as universal input or output pins.
These pins are bidirectional pins. These pins also have some additional functions which are
as follows:

• P3.0 (RXD) : 10th pin is RXD (serial data receive pin) which is for serial input. Through this
input signal microcontroller receives data for serial communication.
• P3.1 (TXD) : 11th pin is TXD (serial data transmit pin) which is serial output pin. Through
this output signal microcontroller transmits data for serial communication.
• P3.2 and P3.3 (INT0′, INT1′ ) : 12th and 13th pins are for External Hardware Interrupt 0
and Interrupt 1 respectively. When this interrupt is activated(i.e. when it is low), 8051 gets
interrupted in whatever it is doing and jumps to the vector value of the interrupt (0003H for
INT0 and 0013H for INT1) and starts performing Interrupt Service Routine (ISR) from that
vector location.
• P3.4 and P3.5 (T0 and T1) : 14th and 15th pin are for Timer 0 and Timer 1 external input.
They can be connected with 16 bit timer/counter.
• P3.6 (WR’) : 16th pin is for external memory write i.e. writing data to the external memory.
• P3.7 (RD’) : 17th pin is for external memory read i.e. reading data from external memory.
• Pin 18 and Pin 19 (XTAL2 And XTAL1) – These pins are connected to an external
oscillator which is generally a quartz crystal oscillator. They are used to provide an external
clock frequency of 4MHz to 30MHz.
• Pin 20 (GND) – This pin is connected to the ground. It has to be provided with 0V power
supply. Hence it is connected to the negative terminal of the power supply.
 • Pin 21 to Pin 28 (Port 2) – Pin 21 to pin 28 are port 2 pins also referred to as P2.0 to P2.7.
When additional external memory is interfaced with the 8051 microcontroller, pins of port 2
act as higher-order address bytes. These pins are bidirectional.
• Pin 29 (PSEN) – PSEN stands for Program Store Enable. It is output, active-low pin. This is
used to read external memory. In 8031 based system where external ROM holds the program
code, this pin is connected to the OE pin of the ROM.
• Pin 30 (ALE/ PROG) – ALE stands for Address Latch Enable. It is input, active-high pin.
This pin is used to distinguish between memory chips when multiple memory chips are used.
It is also used to de-multiplex the multiplexed address and data signals available at port 0.
During flash programming i.e. Programming of EPROM, this pin acts as program pulse input
(PROG).
• Pin 31 (EA/ VPP) – EA stands for External Access input. It is used to enable/disable
external memory interfacing. In 8051, EA is connected to Vcc as it comes with on-chip ROM
to store programs. For other family members such as 8031 and 8032 in which there is no on-
chip ROM, the EA pin is connected to the GND.
• Pin 32 to Pin 39 (Port 0) – Pin 32 to pin 39 are port 0 pins also referred to as P0.0 to P0.7.
They are bidirectional input/output pins. They don‘t have any internal pull-ups. Hence, 10 K?
pull-up registers are used as external pull-ups. Port 0 is also designated as AD0-AD7 because
8051 multiplexes address and data through port 0 to save pins.
• Pin 40 (VCC) – This pin provides power supply voltage i.e. +5 Volts to the circuit.

Uses of pin diagram of the 8051 microcontroller :

The pin diagram of the 8051 microcontroller is used for various purposes in embedded systems.
Some of the main uses of the pin diagram are:
1. Interfacing with external devices: The 8051 microcontroller has several input/output pins
that can be used for interfacing with external devices such as sensors, actuators, displays, and
communication modules. The pin diagram provides the information about the location of
these pins, their functionalities, and their electrical characteristics.
2. Programming the microcontroller: The 8051 microcontroller can be programmed using
various programming languages such as Assembly, C, and BASIC. The pin diagram provides
the information about the pins that are used for programming the microcontroller, such as the
PSEN pin and the ALE pin.
3. Debugging and testing: The pin diagram provides access to the internal signals of the
microcontroller, such as the address and data buses, which can be used for debugging and
testing the microcontroller. Special hardware tools such as logic analyzers and oscilloscopes
can be connected to the pins to monitor the signals and diagnose any issues in the system.
4. Expansion and customization: The pin diagram provides the flexibility to expand and
customize the functionality of the microcontroller by connecting external devices and
peripherals. For example, additional memory can be added by connecting external RAM or
ROM chips to the address and data buses.

Characteristics of 8051 microcontroller

1. An 8-bit processor.
2. Data memory or RAM of 128 bytes.
3. Program memory or ROM of 4 KB.
4. 2 timers of 16 bit each.
5. 8-bit data bus.
6. 16-bit address bus.
7. Offers bit addressable format.
8. Special function registers and serial port.
9. 32 input/output lines.

1.3. 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.

1.3.1. 8051 Programming in Assembly Language

8051 Programming in Assembly Language

Assembly programming language is developed by the 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.

1.3.2. 8051 Microcontroller Architecture

The 8051 microcontroller is the CISC based Harvard architecture, and it has peripherals like 32
I/O, timers/counters, serial communication and memories. The microcontroller requires a
program to perform the operations that require a memory for saving and to read the functions.
The 8051 microcontroller consists of RAM and ROM memories to store instructions.
 8051 Microcontroller Block diagram

A Register is the main part in the processors and microcontrollers which is contained in the
memory that provides a faster way of collecting and storing the data. The 8051 assembly
language programming is based on the memory registers. If we want to manipulate data to a
processor or controller by performing subtraction, addition, etc., we cannot do that directly in the
memory, but it needs registers to process and to store the data. Microcontrollers contain several
types of registers that can be classified according to their instructions or content that operate in
them.

1.3.3. 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.

1.3.3.1. 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;

1.3.4. The Elements of an Assembly Language Programming

• Assembler Directives
• Instruction Set
• Addressing Modes

1.3.4.1. 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

(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

Equate address of the variable.
used to

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

1.3.4.2. Embedded Systems - Addressing Modes

An addressing mode refers to how you are addressing a given memory location. There are five
different ways or five addressing modes to execute this instruction which are as follows −
• Immediate addressing mode
• Direct addressing mode
• Register direct addressing mode
• Register indirect addressing mode
• Indexed addressing mode

Immediate Addressing Mode

Let's begin with an example.
MOV A, #6AH
In general, we can write,
MOV A, #data
It is termed as immediate because 8-bit data is transferred immediately to the accumulator
(destination operand).
 The above instruction and its execution. The opcode 74H is saved at 0202 address. The data
6AH is saved at 0203 address in the program memory. After reading the opcode 74H, the data at
the next program memory address is transferred to accumulator A (E0H is the address of
accumulator). Since the instruction is of 2-bytes and is executed in one cycle, the program
counter will be incremented by 2 and will point to 0204 of the program memory.
Note − The '#' symbol before 6AH indicates that the operand is a data (8 bit). In the absence of
'#', the hexadecimal number would be taken as an address.
Direct Addressing Mode
This is another way of addressing an operand. Here, the address of the data (source data) is given
as an operand. Let‘s take an example.
MOV A, 04H
The register bank#0 (4th register) has the address 04H. When the MOV instruction is executed,
the data stored in register 04H is moved to the accumulator. As the register 04H holds the data
1FH, 1FH is moved to the accumulator.
Note − We have not used '#' in direct addressing mode, unlike immediate mode. If we had used
'#', the data value 04H would have been transferred to the accumulator instead of 1FH.
Now, take a look at the following illustration. It shows how the instruction gets executed.
 As shown in the above illustration, this is a 2-byte instruction which requires 1 cycle to
complete. The PC will be incremented by 2 and will point to 0204. The opcode for the
instruction MOV A, address is E5H. When the instruction at 0202 is executed (E5H), the
accumulator is made active and ready to receive data. Then the PC goes to the next a ddress as
0203 and looks up the address of the location of 04H where the source data (to be transferred to
accumulator) is located. At 04H, the control finds the data 1F and transfers it to the accumulator
and hence the execution is completed.

Register Direct Addressing Mode

In this addressing mode, we use the register name directly (as source operand). Let us try to
understand with the help of an example.
MOV A, R4
At a time, the registers can take values from R0 to R7. There are 32 such registers. In order to
use 32 registers with just 8 variables to address registers, register banks are used. There are 4
register banks named from 0 to 3. Each bank comprises of 8 registers named from R0 to R7.
 At a time, a single register bank can be selected. Selection of a register bank is made possible
through a Special Function Register (SFR) named Processor Status Word (PSW). PSW is an
8-bit SFR where each bit can be programmed as required. Bits are designated from PSW.0 to
PSW.7. PSW.3 and PSW.4 are used to select register banks.
Now, take a look at the following illustration to get a clear understanding of how it works.
Opcode EC is used for MOV A, R4. The opcode is stored at the address 0202 and when it is
executed, the control goes directly to R4 of the respected register bank (that is selected in PSW).
If register bank #0 is selected, then the data from R4 of register bank #0 will be moved to the
accumulator. Here 2F is stored at 04H. 04H represents the address of R4 of register bank #0.
Data (2F) movement is highlighted in bold. 2F is getting transferred to the accumulator from data
memory location 0C H and is shown as dotted line. 0CH is the address location of Register 4
(R4) of register bank #1. The instruction above is 1 byte and requires 1 cycle for complete
execution. What it means is, you can save program memory by using register direct addressing
mode.
Register Indirect Addressing Mode
In this addressing mode, the address of the data is stored in the register as operand.
MOV A, @R0
 Here the value inside R0 is considered as an address, which holds the data to be transferred to the
accumulator. Example: If R0 has the value 20H, and data 2FH is stored at the address 20H, then
the value 2FH will get transferred to the accumulator after executing this instruction. See the
following illustration.
So the opcode for MOV A, @R0 is E6H. Assuming that the register bank #0 is selected, the R0
of register bank #0 holds the data 20H. Program control moves to 20H where it locates the data
2FH and it transfers 2FH to the accumulator. This is a 1-byte instruction and the program counter
increments by 1 and moves to 0203 of the program memory.
Note − Only R0 and R1 are allowed to form a register indirect addressing instruction. In other
words, the programmer can create an instruction either using @R0 or @R1. All register banks
are allowed.

Indexed Addressing Mode

We will take two examples to understand the concept of indexed addressing mode. Take a look
at the following instructions −
MOVC A, @A+DPTR
and
MOVC A, @A+PC

where DPTR is the data pointer and PC is the program counter (both are 16 -bit registers).
Consider the first example.
MOVC A, @A+DPTR
The source operand is @A+DPTR. It contains the source data from this location. Here we are
adding the contents of DPTR with the current content of the accumulator. This addition will give
a new address which is the address of the source data. The data pointed by this address is then
 transferred to the accumulator.
The opcode is 93H. DPTR has the value 01FE, where 01 is located in DPH (higher 8 bits) and
FE is located in DPL (lower 8 bits). Accumulator has the value 02H. Then a 16-bit addition is
performed and 01FE H+02H results in 0200 H. Data at the location 0200H will get transferred to

the accumulator. The previous value inside the accumulator (02H) will be replaced with the new
data from 0200H. The new data in the accumulator is highlighted in the illustration.
This is a 1-byte instruction with 2 cycles needed for execution and the execution time required
for this instruction is high compared to previous instructions (which were all 1 cycle each).
The other example MOVC A, @A+PC works the same way as the above example. Instead of
adding DPTR with the accumulator, here the data inside the program counter (PC) is added with
the accumulator to obtain the target address.
1.3.4.3. Instruction Set

In the sequence of instructions to be executed, it is often necessary to transfer program control to

a different location. There are many instructions in the 8051 to achieve this. This chapter covers
the control transfer instructions available in 8051 Assembly language. In the first section we
discuss instructions used for looping, as well as instructions for conditional and unconditional
jumps. In the second section we examine CALL instructions and their uses. In the third section,
time delay subroutines are described for both the traditional 8051 and its newer generation.

Looping in the 8051

Repeating a sequence of instructions a certain number of times is called a loop. The loop is one
of most widely used actions that any microprocessor performs. In the 8051, the loop action is
performed by the instruction ―DJNZ reg, label‖. In this instruction, the register is decremented; if
 it is not zero, it jumps to the target address referred to by the label. Prior to the start of the loop
the register is loaded with the counter for the number of repetitions. Notice that in this instruction
both the register decrement and the decision to jump are combined into a single instruction.

In the program in Example, the R2 register is used as a counter. The counter is first set to 10. In
each iteration the instruction DJNZ decrements R2 and checks its value. If R2 is not zero, it
jumps to the target address associated with the label ―AGAIN‖. This looping action continues
until R2 becomes zero. After R2 becomes zero, it falls through the loop and executes the
instruction immediately below it, in this case the ―MOV R5 , A‖ instruction. Notice in the DJNZ
instruction that the registers can be any of RO – R7. The counter can also be a RAM location

Loop inside a loop

As shown in Example the maximum count is 256. What happens if we want to repeat an action
more times than 256? To do that, we use a loop inside a loop, which is called a nested loop. In a
nested loop, we use two registers to hold the count.

Example
Write a program to (a) load the accumulator with the value 55H, and (b) complement the ACC
700 times.

Solution:
Since 700 is larger than 255 (the maximum capacity of any register), we use two registers to hold
the count. The following code shows how to use R2 and R3 for the count.
In this program, R2 is used to keep the inner loop count. In the instruction ―DJNZ R2 , AGAIN‖,
whenever R2 becomes 0 it falls through and ―DJNZ R3 , NEXT‖ is executed. This instruction
forces the CPU to load R2 with the count 70 and the inner loop starts again. This process will
continue until R3 becomes zero and the outer loop is finished.

Other conditional jumps

Conditional jumps for the 8051 are summarized in Table 3-1. More details of each instruction are
provided in Appendix A. In Table 3-1, notice that some of the instructions, such as JZ (jump if A
= zero) and JC (jump if carry), jump only if a certain condition is met. Next we examine some
conditional jump instructions with examples.

JZ (jump if A = 0)
In this instruction the content of register A is checked. If it is zero, it jumps to the target
address. For example, look at the following code.

In this program,. if either RO or Rl is zero, it jumps to the label OVER. Notice that the JZ
instruction can be used only for register A. It can only check to see whether the accumulator is
zero, and it does not apply to any other register. More importantly, you don‘t have to perform an
arithmetic instruction such as decrement to use the JNZ instruction. See Example 3-4.
 Example

JNC (jump if no carry, jumps if CY = 0)

In this instruction, the carry flag bit in the flag (PSW) register is used to make the decision
whether to jump. In executing ―JNC label‖, the processor looks at the carry flag to see if it is
raised (CY =1). If it is not, the CPU starts to fetch and execute instructions from the address of
the label. If CY = 1, it will not jump but will execute the next instruction below JNC.
Note that there is also a ―JC label‖ instruction. In the JC instruction, if CY = 1 it jumps to the
target address. We will give more examples of these instructions in the context of applications in
future chapters.
There are also JB (jump if bit is high) and JNB (jump if bit is low) instructions. These are
discussed in Chapters 4 and 8 when bit manipulation instructions are discussed.

All conditional jumps are short jumps

It must be noted that all conditional jumps are short jumps, meaning that the address of the target
must be within -128 to +127 bytes of the contents of the program counter (PC). This very
important concept is discussed at the end of this section.

Unconditional jump instructions

The unconditional jump is a jump in which control is transferred unconditionally to the target
location. In the 8051 there are two unconditional jumps: LJMP (long jump) and SJMP (short
jump). Each is discussed below.

LJMP (long jump)

LJMP is an unconditional long jump. It is a 3-byte instruction in which the first byte is the
opcode, and the second and third bytes represent the 16-bit address of the target location. The
2- byte target address allows a jump to any memory location from 0000 to FFFFH.
Remember that although the program counter in the 8051 is 16-bit, thereby giving a ROM
address space of 64K bytes, not all 8051 family members have that much on-chip program
ROM. The original 8051 had only 4K bytes of on-chip ROM for program space; consequently,
every byte was precious. For this reason there is also an SJMP (short jump) instruction, which is
a 2-byte instruction as opposed to the 3-byte LJMP instruction. This can save some bytes of
memory in many applications where memory space is in short supply. SJMP is discussed next.

SJMP (short jump)

In this 2-byte instruction, the first byte is the opcode and the second byte is the relative address
of the target location. The relative address range of 00 – FFH is divided into forward and
backward jumps; that is, within -128 to +127 bytes of memory relative to the address of the
current PC (program counter). If the jump is forward, the target address can be within a space of
 127 bytes from the current PC. If the target address is backward, the target address can be within
-128 bytes from the current PC. This is explained in detail next.

Calculating the short jump address

In addition to the SJMP instruction, all conditional jumps such as JNC, JZ, and DJNZ are also
short jumps due to the fact that they are all two-byte instructions. In these instructions the first
byte is the opcode and the second byte is the relative address. The target address is relative to the
value of the program counter. To calculate the target address, the second byte is added to the PC
of the instruction immediately below the jump.

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 levels programming
examples are given below.

1.3.5. Example Program for 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

1.4. Programming Parallel port

1.4.1. 8051 Microcontroller port programming

There are four ports P0, P1, P2 and P3 each use 8 pins, making them 8-bit ports. All the ports upon
RESET are configured as output, ready to be used as output ports. To use any of these ports as an input
port, it must be programmed.

1.4.2. Pin configuration of 8051/8031 microcontroller.

Pin configuration of 8951

Port 0: Port 0 occupies a total of 8 pins (pins 32-39) .It can be used for input or output. To use the pins of
port 0 as both input and output ports, each pin must be connected externally to a 10K ohm pull-up
resistor. This is due to the fact that P0 is an open drain, unlike P1, P2, and P3.Open drain is a term used
for MOS chips in the same way that open collector is used for TTL chips. With external pull-up resistors
connected upon reset, port 0 is configured as an output port. For example, the following code will
continuously send out to port 0 the alternating values 55H and AAH

MOV A,#55H
BACK: MOV P0,A
ACALL DELAY
CPL A
SJMP BACK
Port 0 as Input : With resistors connected to port 0, in order to make it an input, the port must be
programmed by writing 1 to all the bits. In the following code, port 0 is configured first as an input port
by writing 1‘s to it, and then data is received from the port and sent to P1.

8051 I/O Ports

MOV A,#0FFH ; A = FF hex

MOV P0,A ; make P0 an input port
BACK: MOV A,P0 ;get data from P0
MOV P1,A ;send it to port 1
SJMP BACK
Dual role of port 0: Port 0 is also designated as AD0-AD7, allowing it to be used for both address and
data. When connecting an 8051/31 to an external memory, port 0 provides both address and data. The
8051 multiplexes address and data through port 0 to save pins. ALE indicates if P0 has address or data.
When ALE = 0, it provides data D0-D7, but when ALE =1 it has address and data with the help of a
74LS373 latch.

Port 1: Port 1 occupies a total of 8 pins (pins 1 through 8). It can be used as input or output. In contrast to
port 0, this port does not need any pull-up resistors since it already has pull-up resistors internally. Upon
reset, Port 1 is configured as an output port. For example, the following code will continuously send out
to port1 the alternating values 55h & AAh

MOV A,#55H ; A = 55 hex

BACK: MOV P1,A ;send it to Port 1
ACALL DELAY ;call delay routine
CPL A ;make A=0
SJMP BACK

Port 1 as input: To make port1 an input port, it must programmed as such by writing 1 to all its bits. In
the following code port1 is configured first as an input port by writing 1‘s to it, then data is received from
the port and saved in R7 ,R6 & R5.
MOV A,#0FFH ;A=FF HEX
MOV P1,A ;make P1 an input port by writing all 1‘s to it
MOV A,P1 ;get data from P1
MOV R7,A ;save it in register R7
ACALL DELAY ;wait
MOV A,P1 ;get another data from P1
MOV R6,A ;save it in register R6
ACALL DELAY ;wait
MOV A,P1 ;get another data from P1
MOV R5,A ;save it in register R5

Port 2 : Port 2 occupies a total of 8 pins (pins 21- 28). It can be used as input or output. Just like P1, P2
does not need any pull-up resistors since it already has pull-up resistors internally. Upon reset,Port 2 is
configured as an output port. For example, the following code will send out continuously to port 2 the
alternating values 55h and AAH. That is all the bits of port 2 toggle continuously.

MOV A,#55H ; A = 55 hex

BACK: MOV P2,A ;send it to Port 2
ACALL DELAY ;call delay routine
CPL A ;make A=0
SJMP BACK

Port 2 as input : To make port 2 an input, it must programme as such by writing 1 to all its bits. In the
following code, port 2 is configured first as an input port by writing 1‘s to it. Then data is received from
that port and is sent to P1 continuously.

MOV A,#0FFH ;A=FF hex

MOV P2,A ;make P2 an input port by writing all 1‘s to it
BACK: MOV A,P2 ;get data from P2
MOV P1,A ;send it to Port1
SJMP BACK ;keep doing that

Dual role of port 2 : In systems based on the 8751, 8951, and DS5000, P2 is used as simple I/O.
However, in 8031-based systems, port 2 must be used along with P0 to provide the 16-bit address for the
external memory. As shown in pin configuration 8051, port 2 is also designed as A8-A15, indicating the
dual function. Since an 8031 is capable of accessing 64K bytes of external memory, it needs a path for the
16 bits of the address. While P0 provides the lower 8 bits via A0-A7, it is the job of P2 to provide bits
A8-A15 of the address. In other words, when 8031 is connected to external memory, P2 is used for the
upper 8 bits of the 16 bit address, and it cannot be used for I/O.

Port 3 : Port 3 occupies a total of 8 pins, pins 10 through 17. It can be used as input or output. P3 does
not need any pull-up resistors, the same as P1 and P2 did not. Although port 3 is configured as an output
port upon reset. Port 3 has the additional function of providing some extremely important signals such as
interrupts. This information applies both 8051 and 8031 chips.
Read-modify-write feature : The ports in the 8051 can be accessed by the read-modify-write technique.
This feature saves many lines of code by combining in a single instruction all three action of (1) reading
the port, (2) modifying it, and (3) writing to the port. The following code first places 01010101 (binary)
into port 1. Next, the instruction ―XLR P1,#0FFH‖ performs an XOR logic operation on P1 with 1111
1111 (binary), and then writes the result back into P1.

MOV P1,#55H ;P1=01010101

AGAIN: XLR P1,#0FFH ;EX-OR P1 with 1111 1111
ACALL DELAY
SJMP AGAIN

1.4.3. Addition of two 8-bit numbers in 8051 Microcontroller Using Ports Introduction:
To perform addition of two 8-bit numbers using ports in 8051 microcontroller, we need
to connect the two 8-bit numbers to be added to two ports of the microcontroller. We can use any
two ports of the microcontroller, for example, P1 and P2.

The first step is to load the two numbers into two different ports. For example, we can
load the first number into port P1 and the second number into port P2. We can use the MOV
instruction to load the numbers into the ports.

Once the numbers are loaded into the ports, we can use the ADD instruction to add the
two numbers. The ADD instruction adds the contents of the accumulator and the specified
operand and stores the result in the accumulator. Since the two numbers are already loaded into
the ports, we can simply use the ADD instruction with the accumulator and the appropriate port.

After the addition is complete, we can retrieve the result from the accumulator and store
it in another port or memory location for further processing or display. 8051 microcontroller is a
microcontroller designed by Intel in 1981. It is an 8-bit microcontroller with 40 pins DIP (dual
inline package), 4kb of ROM storage and 128 bytes of RAM storage, 16-bit timers. It consists of
four parallel 8-bit ports, which are programmable as well as addressable as per the requirement.

Issues in Addition of two 8-bit numbers 8051 Microcontroller Using Ports :

There are several issues that can arise when performing addition of two 8-bit numbers in 8051
 microcontroller using ports:
1. Overflow: If the result of the addition exceeds 8 bits, the carry flag (CY) in the program
status word (PSW) will be set. If this flag is not checked before storing the result, the result
may be incorrect.
2. Input validation: Before performing the addition, it is important to validate the input to
ensure that the numbers are within the range of 0 to 255. If the input is not validated, the
result may be incorrect.
3. Port initialization: The ports used for input and output must be properly initialized before
use. If the ports are not properly initialized, the data may not be transferred correctly.
4. Endianness: The order in which the bytes of the numbers are stored in memory can affect the
result of the addition. It is important to ensure that the bytes are stored in the correct order
before performing the addition.
5. Interrupts: If interrupts are enabled during the addition operation, the result may be affected.
It is important to disable interrupts during critical operations to ensure the correct result.
6. Timing: The timing of the addition operation can affect the result. It is important to ensure
that the necessary delays are added between instructions to ensure correct operation.
7. Code optimization: The code used to perform the addition should be optimized to ensure that
it uses the least number of instructions and takes the least amount of time. This is important
to avoid potential timing issues and to ensure that the microcontroller can perform other tasks
while the addition is being performed.

Problem: To write an assembly language program to add two 8 bit

numbers in 8051microcontroller using ports.

Example:
 Block diagram:

Algorithm:
• Initialize Ports P0 and P1 as input ports.
• Initialize Ports P2 and P3 as output ports.
• Initialize the R1 register.
• Move the contents from Port 0 to B register
• Move the contents from Port 1 to A register.
• Add contents in A and B.
• If carry is present increment R1.
• Move contents in R1 to Port 2.
• Move the sum in step 6 to Port 3.

Program:
ORG 00H // Indicates starting address

MOV P0,#0FFH // Initializes P0 as input port

MOV P1,#0FFH // Initializes P1 as input port
MOV P2,#00H // Initializes P2 as output port
MOV P3,#00H // Initializes P3 as output port

L1:MOV R1, #00H // Initializes Register R1

MOV B,P0 // Moves content of P0 to B
MOV A,P1 // Moves content of P1 to A
CLR C // Clears carry flag
ADD A,B // Add the content of A and B and store result in A
JNC L2 // If carry is not set, jump to label L2
 INC R1 // Increment Register R1 if carry present

L2: MOV P2, R1 // Moves the content from Register R1 to Port2

MOV P3,A // Moves the content from A to Port3
SJMP L1 // Jumps to label L1
END

Explanation:
• ORG 00H is the starting address of the program.
• Giving the values as #0FFH and #00H initializes the ports as input and output ports
respectively.
• R1 register is initialized to 0 so as to store any carry produced during the sum.
• MOV B, P0 moves the value present in P0 to the B register.
• MOV A, P1 moves the value present in P1 to Accumulator.
• ADD AB adds the values present in Accumulator and B register and stores the result in
Accumulator.
• JNC L2 refers to jump to label L2 if no carry is present by automatically checking whether
the carry bit is set or not.
• If the carry bit is set to increment register R1.
• MOV P2, R1, and MOV P3, A refers to moving the carry bit to P2 and result in Accumulator
to P3.

1.5. 8051 Timers

1.5.1. Introduction to 8051 Timers
8051 microcontrollers have two timers and counters which work on the clock
frequency. Timer/counter can be used for time delay generation, counting external events, etc.

8051 Clock

Every Timer needs a clock to work, and 8051 provides it from an external crystal which is the
main clock source for Timer. The internal circuitry in the 8051 microcontrollers provides a clock
source to the timers which is 1/12th of the frequency of crystal attached to the microcontroller,
also called Machine cycle frequency.

8051 Timer Clock

For example, suppose we have a crystal frequency of 11.0592 MHz then the microcontroller will
provide 1/12th i.e.
Timer clock frequency= (Xtal Osc.frequency)/12 = (11.0592 MHz)/12 = 921.6 KHz
period T= 1/(921.6 kHz)=1.085 μS

1.5.2. 8051 Timer

8051 has two timers Timer0 (T0) and Timer1 (T1), both are 16-bit wide. Since 8051 has 8-bit
architecture, each of these is accessed by two separate 8-bit registers as shown in the figure
below. These registers are used to load timer count.

8051 has a Timer Mode Register and Timer Control Register for selecting a mode of operation
and controlling purpose.
Let's see these registers,

1.5.2.1. TMOD register

TMOD is an 8-bit register used to set timer mode of timer0 and timer1.

Its lower 4 bits are used for Timer0 and the upper 4 bits are used for Timer1
Bit 7,3 – GATE:
1 = Enable Timer/Counter only when the INT0/INT1 pin is high and TR0/TR1 is set.
0 = Enable Timer/Counter when TR0/TR1 is set.
Bit 6,2 - C/ (Counter/Timer): Timer or Counter select bit
1 = Use as Counter
0 = Use as Timer

Bit 5:4 & 1:0 - M1:M0: Timer/Counter mode select bit

These are Timer/Counter mode select bit as per the below table
M1 M0 Mode Operation
0 0 0 (13-bit timer mode) 13-bit timer/counter, 8-bit of THx & 5-bit of TLx
0 1 1 (16-bit timer mode) 16-bit timer/counter, THx cascaded with TLx
8-bit timer/counter (auto-reload mode), TLx reload
1 0 2 (8-bit auto-reload mode)
with the value held by THx each time TLx overflow
Split the 16-bit timer into two 8-bit timers i.e. THx
1 1 3 (split timer mode)
and TLx like two 8-bit timer

1.5.2.2. TCON Register

TCON is an 8-bit control register and contains a timer and interrupt flags.
Bit 7 - TF1: Timer1 Overflow Flag
1 = Timer1 overflow occurred (i.e. Timer1 goes to its max and roll over back to zero).
0 = Timer1 overflow not occurred.
It is cleared through software. In the Timer1 overflow interrupt service routine, this bit will get
cleared automatically while exiting from ISR.

Bit 6 - TR1: Timer1 Run Control Bit

1 = Timer1 start.
0 = Timer1 stop.
It is set and cleared by software.

Bit 5 – TF0: Timer0 Overflow Flag

1 = Timer0 overflow occurred (i.e. Timer0 goes to its max and roll over back to zero).
0 = Timer0 overflow not occurred.
It is cleared through software. In the Timer0 overflow interrupt service routine, this bit will get
cleared automatically while exiting from ISR.

Bit 4 – TR0: Timer0 Run Control Bit

1 = Timer0 start.
0 = Timer0 stop.
It is set and cleared by software.

Bit 3 - IE1: External Interrupt1 Edge Flag

1 = External interrupt1 occurred.
0 = External interrupt1 Processed.
It is set and cleared by hardware.
Bit 2 - IT1: External Interrupt1 Trigger Type Select Bit
1 = Interrupt occurs on falling edge at INT1 pin.
0 = Interrupt occur on a low level at the INT1 pin.

Bit 1 – IE0: External Interrupt0 Edge Flag

1 = External interrupt0 occurred.
0 = External interrupt0 Processed.
It is set and cleared by hardware.

Bit 0 – IT0: External Interrupt0 Trigger Type Select Bit

1 = Interrupt occurs on falling edge at INT0 pin.
0 = Interrupt occur on a low level at INT0 pin.

Let's see the timers modes

1.5.3. 8051 Timer Modes

Timers have their operation modes which are selected in the TMOD register using M0 & M1 bit
combinations.

Mode 0 (13-bit timer mode)

The Mode 0 operation is the 8-bit timer or counter with a 5-bit pre-scaler. So it is a 13-bit
timer/counter. It uses 5 bits of TL0 or TL1 and all of the 8-bits of TH0 or TH1.

In this example the Timer1is selected, in this case, every 32 (25)event for counter operations or
32 machine cycles for timer operation, the TH1 register will be incremented by 1. When the
TH1overflows from FFH to 00H, then the TF1 of TCON register will be high, and it stops the
timer/counter. So for an example, we can say that if the TH1 is holding F0H, and it is in timer
mode, then TF1will be high after 10H * 32 = 512 machine cycles.
MOVTMOD, #00H
MOVTH1, #0F0H
MOVIE, #88H
SETB TR1
In the above program, the Timer1 is configured as timer mode 0. In this case Gate = 0. Then the
TH1 will be loaded with F0H, then enable the Timer1 interrupt. At last set the TR1 of TCON
register, and start the timer.
Mode1 (16-bit timer mode)

The Mode 1 operation is the 16-bit timer or counter. In the following diagram, we are using
Mode 1 for Timer0.

In this case every event for counter operations or machine cycles for timer operation, the TH0–
TL0 register-pair will be incremented by 1. When the register pair overflows from FFFFH to
0000H, then the TF0 of TCON register will be high, and it stops the timer/counter. So for an
example, we can say that if the TH0 – TL0 register pair is holding FFF0H, and it is in timer
mode, then TF0 will be high after 10H = 16 machine cycles. When the clock frequency is
12MHz, then the following instructions generate an interrupt 16 µs after Timer0 starts running.
MOVTMOD, #01H
MOVTL0, #0F0H
MOVTH0, #0FFH
MOVIE, #82H
SETB TR0
In the above program, the Timer0 is configured as timer mode 1. In this case Gate = 0. Then the
TL0 will be loaded with F0H and TH0 is loaded with FFH, then enable the Timer0 interrupt. At
last set the TR0 of TCON register, and start the timer.
Mode2 (8-bit auto-reload timer mode)

The Mode 2 operation is the 8-bit auto reload timer or counter. In the following diagram, we are
using Mode 2 for Timer1.
In this case every event for counter operations or machine cycles for timer operation, the
TL1register will be incremented by 1. When the register pair overflows from FFH to 00H, then
the TF1 of TCON register will be high, also theTL1 will be reloaded with the content of TH1
and starts the operation again.
So for an example, we can say that if the TH1 and TL1 register both are holding F0H and it is in
timer mode, then TF1 will be high after 10H= 16 machine cycles. When the clock frequency is
12MHz this happens after 16 µs, then the following instructions generate an interrupt once every
16 µs after Timer1 starts running.
MOVTMOD, #20H
MOVTL1, #0F0H
MOVTH1, #0F0H
MOVIE, #88H
SETBTR1
In the above program, the Timer1 is configured as timer mode 2. In this case Gate = 0. Then the
TL1 and TH1 are loaded with F0H. then enable the Timer1 interrupt. At last set the TR1 of
TCON register, and start the timer.
Mode 3 of Timer/Counter
Mode 3 is different for Timer0 and Timer1. When the Timer0 is working in mode 3, the TL0
will be used as an 8-bit timer/counter. It will be controlled by the standard Timer0 control bits,
T0 and INT0 inputs. The TH0 is used as an 8-bit timer but not the counter. This is controlled by
Timer1 Control bit TR1. When the TH0 overflows from FFH to 00H, then TF1 is set to 1. In the
following diagram, we can Timer0 in Mode 3.
 When the Timer1 is working in Mode 3, it simply holds the count but does not run. When
Timer0 is in mode 3, the Timer1 is configured in one of the mode 0, 1 and 2. In this case, the
Timer1 cannot interrupt the microcontroller. When the TF1 is used by TH0 timer, the Timer1 is
used as Baud Rate Generator.
The meaning of gate bit in Timer0 and Timer1 for mode 3 is as follows

It controls the running of 8-bit timer/counter TL0 as like Mode 0, 1, or 2. The running of TH0 is
controlled by TR1 bit only. So the gate bit in this mode for Timer0 has no specific role.
The mode 3 is present for applications requiring an extra 8-bit timer/counter. In Mode 3 of
Timer0, the 8051 has three timers. One 8-bit timer by TH0, another8-bit timer/counter by TL0,
and one 16-bit timer/counter by Timer1.
If the Timer0 is in mode3, and Timer1 is working on either 0, 1 or 2, then the gun control of the
Timer1 is activated when the gate bit is low or INT1 is high. The run control is deactivated
when the gate is high and INT1 is low.

1.6. Serial Port in 8051

There is a serial port in 8051 as mentioned in the pin diagram of 8051. 8051 has capability to
perform parallel as well as serial communication.

Parallel communication in 8051:

8051 can do 8-bit parallel communication as it has 8-bit ALU. For parallel communication, any
of the ports ( P0 / P1 / P2 / P3 ) is used as a transmission channel between transmitter and
receiver.

Serial communication in 8051:

For serial communication there are two separate pins known as serial port of 8051.
TxD:
This pin basically acts as a transmitter ( sending data ), but in some other modes it doesn‘t do the
job of transmitter. As it is serial communication, it sends bit by bit, the processor gives 8 -bit at 1
time and those 8-bits are stored in a register named SBUF. Processor gives 1 byte of data that is
to be transmitted to SBUF and from there bit by bit is transferred , firstly LSB and then at last
MSB of the byte stored in SBUF. Once the total byte is transmitted, an interrupt is sent to the
processor by making some flag 1, so that the processor can send more data for transmission as
soon as the interrupt is received.

After every bit is transmitted, it requires delay for next bit transmission. So SBUF needs
triggering which is provided by
• Timer T1 ( here T1 only needs to trigger, T1 does not require its overflow flag , mode 3
in timers ). Here we can vary the delay, so data transmission delay can be varied
( frequency can be varied ). It has a variable baud rate.
• There is an internal clock in 8051 ( fosc / 12 = 1Mhz ) , where delay cannot be varied, this
has fixed trigger delay. So frequency cannot be varied.It has a fixed baud rate.
Whenever SBUF transferred 8bit of data , T i flag becomes 1. Whenever processors go to ISR( in
other interrupts the flag is auto cleared whenever processor goes to ISR ) , in this the Ti flag is
not auto cleared.

RxD:
This pin is basically for data reception . It received data bit by bit ( as the transmitter sends LSB
first, it received LSB first ). There is also a register SBUF which stores 8 received bits. Once the
8 bits are received, instead of sending an interrupt it firstly checks for errors ( errors caused due
to transmission). Once there is no error in the received information R i flag is set and an interrupt
is sent to the processor. Processor goes to ISR ( here also R i is not cleared automatically ).
How are SBUF in TxD and RxD different from each other ?
In SBUF of TxD, data is sent from processor to SBUF
In SBUF of RxD, data is sent from SBUF to the processor.
In this way both registers are differentiated by the processor.

There is a bit named SM2 ;

If SM2 = 1, then after SBUF of RxD is filled there will be error check And if not then there will
be no error check, directly an interrupt will be sent to the processor once SBUF in RxD is filled.

1.6.1. Modes in serial communication:

Mode 1 ( 8-bit UART communication ):
UART stands for universal asynchronous receiver-transmitter. It means receiver and transmitter
are asynchronous which mean they don‘t have a common clock. Normally 8 bits are transmitted
through the channel, but in this mode 10 bits are transmitted.

Here start and stop bits are system generated.

Significance of start and stop bit:

For eg: There is a transmitter and receiver. First C8H ( 1100 1000 ) data is transmitted and then
for 10min there is no transmission and after that again 8EH ( 1000 1110 )is transmitted.
If there is no transmission, last bit transmitted would be remained in the channel
 Here green is the start bit which is zero. And then the yellow colored is stop bit which is 1.
Whenever the first 0 bit comes, the receiver discards the start bit and accepts the next 8 bits and
stores in SBUF. Then the 9th bit is 1 , this bit is stored in RB8 ( will be discussed later ). Then
after this whenever the next zero bit comes ( that zero bit is discarded and accepts the next 8 bits
and so on ).

Stop bit is also used for error checking. Whenever SM2=1, It checks for error, If the RB8 = 1
( which means stop = 1 received, so the data is received correctly ) and if RB8=0 ( transmitter
generated stop as 1, but received as 0 ) so there is an error. If there is an error in received data, no
interrupt is sent to the processor.

This mode is variable baud rate, which means it is triggered by timer 1.

Mode 2 ( 9-bit UART communication ):

The 9th bit is a programmable bit and it is given through TB8. Here 9th bit is 1 and it is used for
error checking and stop bit for triggering the data high ( so start bit gets 0 and so on ).
Why the 9th bit , when the already stop bit exists?
Standard value of 9th bit is 1 and can be made 0.
Whenever SM2 = 1( receiver accepts only errorless data ) and if 9th bit is 1, then only errorless
data is accepted or else discarded. Discarding data is a purpose.

Mode 3 ( 9-bit UART communication ):

This mode is completely similar to mode 2, in mode 2 for triggering timer is used Whereas in
this mode internal clock is used for triggering. It has a fixed baud rate.

Mode 0 :
Totally there were four modes in serial port of 8051, but for better understanding mode 0 is
explained after three modes. In this mode data is transferred and received only through the RxD
channel. TxD is used for clocks. This is synchronous mode of communication.
Such a system is also known as half duplex mode. It has fixed baud rate.
SCON register:

SM0 and SM1:

These are used to select the mode.

SM0 SM1 Mode

0 0 0
0 1 1
1 0 2
1 1 3

SM2:
If SM2 = 1, error is checked Or else no error checking is done.
REN:
Receiver enable, If REN=1, receiver will receive the data or else not.
TB8:
This is the 9th bit to be transmitted.
RB8:
This is the 9th bit to be received.
Ti :
When 8-bits are received in SBUF , then Ri = 1, that would send an interrupt to the processor.
Ri :
When 8-bits are sent from SBUF,and SBUF is empty , then Ri = 1, that would send an interrupt
to the processor. Before Ri=1, it checks for error based on SM2.

1.7. 8-Bit Interrupts

Interrupts are events detected by the MCU which cause normal program flow to be pre-empted.
Interrupts pause the current program and transfer control to a specified user-written firmware
routine called the Interrupt Service Routine (ISR). The ISR processes the interrupt event, then
resumes normal program flow.

1.7.1. Overview of Interrupt Process

Program MCU to react to interrupts
The MCU must be programmed to enable interrupts to occur. Setting the Global Interrupt Enable
(GIE) and, in many cases, the Peripheral Interrupt Enable (PEIE), enables the MCU to receive
interrupts. GIE and PEIE are located in the Interrupt Control (INTCON) special function
register.

Enable interrupts from selected peripherals

Each peripheral on the MCU has an individual enable bit. A peripheral's individual interrupt
enable bit must be set, in addition to GIE / PEIE, before the peripheral can generate an
interrupt. The individual interrupt enable bits are located in INTCON, PIE1, PIE2, and PIE3.
Peripheral asserts an interrupt request
When a peripheral reaches a state where program intervention is needed, the peripheral sets an
Interrupt Request Flag (xxIF). These interrupt flags are set regardless of the status of the GIE,
PEIE, and individual interrupt enable bits. The interrupt flags are located in INTCON, PIR1,
PIR2, and PIR3.
The interrupt request flags are latched high when set and must be cleared by the user-written
ISR.

Interrupt occurs
When an interrupt request flag is set and the interrupt is properly enabled, the interrupt process
begins:
1. Global Interrupts are disabled by clearing GIE to 0.
2. The current program context is saved to the shadow registers.
3. The value of the Program Counter is stored on the return stack.
4. Program control is transferred to the interrupt vector at address 04h.

ISR runs
The ISR is a function written by the user and placed at address 04h. The ISR does the following:
1. Checks the interrupt-enabled peripherals for the source of the interrupt request.
2. Performs the necessary peripheral tasks.
3. Clears the appropriate interrupt request flag.
4. Executes the Return From Interrupt instruction (RETFIE) as the final ISR instruction.

Control is returned to the Main program

When RETFIE is executed:
1. Global Interrupts are enabled (GIE=1).
2. The program context is restored from the Shadow registers.
3. The return address from the stack is loaded into the Program Counter.
4. Execution resumes from point at which it was interrupted.

1.7.2. Registers Used to Process Interrupts

Interrupt Control Register
INTCON register

GIE - Global Interrupt Enable

PEIE - Peripheral Interrupt Enable
TMR0IE - Timer0 Interrupt Enable
INTE - External Interrupt Enable
IOCIE
INTCON- Interrupt on Change Enable
TMR0IF - Timer0 Interrupt flag
INTF - External Interrupt flag
IOCIF- Interrupt on Change flag
INTCON_ contains global and peripheral interrupt enable flags as well as the individual
 interruptrequest flags and interrupt enable flags for three of the PIC16F1xxxx interrupts.

Interrupt Enable Registers

PIE1 register

TMR1GIE - Timer1 Gate Interrupt Enable

ADIE - Analog-to-Digital Converter (ADC) Interrupt Enable
RCIE - Universal Synchronous Asynchronous Receiver Tranmsitter (USART) Receive
Interrupt Enable
TXIE - U SART Transmit Interrupt Enable
SSPIE - S ynchronous Serial Port (MSSP) Interrupt Enable
CCP1IE - CCP1 Interrupt Enable

TMR2IE - Timer2 Interrupt Enable

TMR1IE - Timer1 Interrupt Enable
PIE2 register

OSFIE - Oscillator Fail Interrupt Enable

C2IE - Comparator C2 Interrupt Enable
C1IE - Comparator C1 Interrupt Enable
EEIE - EEPROM Write Completion Interrupt Enable
BCLIE - MSSP Bus Collision Interrupt Enable
LCDIE - LCD Module Interrupt Enable
--- - Unimplemented, read as 0
CCP2IE - CCP2 Interrupt Enable
PIE3 register

--- - Unimplemented read as 0

CCP5IE - CCP5 Interrupt Enable
CCP4IE - CCP4 Interrupt Enable
CCP3IE - CCP3 Interrupt Enable
TMR6IE - Timer6 Interrupt Enable
--- - Unimplemented, read as 0
TMR4IE - Timer4 Interrupt Enable
--- - Unimplemented, read as 0
PIE1 , PIE2, and PIE3 contain the individual interrupt enable flags for the MCU's peripherals.
Interrupt Request Registers
PIR1 register
TMR1GIF- Timer1 Gate Interrupt Flag
ADIF - ADC Interrupt Flag
RCIF - USA RT Receive Interrupt Flag
TXIF - USART Transmit Interrupt Flag
SSPIF - MS SP Interrupt Flag

CCP1IF - CCP1 Interrupt Flag

TMR2IF - Timer2 Interrupt Flag
TMR1IF - Timer1 Interrupt Flag

PIR2 register

OSFIF - Oscillator Fail Interrupt Flag

C2IF - Comparator C2 Interrupt Flag
C1IF - Comparator C1 Interrupt Flag
EEIF - EEPROM Write Completion Interrupt Flag
BCLIF - MSSP Bus Collision Interrupt Flag
LCDIF - LCD Module Interrupt Flag
--- - Unimplemented, read as 0
CCP2IF - CCP2 Interrupt Flag
PIR3 register

--- - Unimplemented, read as 0

CCP5IF - CCP5 Interrupt Flag
CCP4IF - CCP4 Interrupt Flag
CCP3IF - CCP3 Interrupt Flag
TMR6IF - Timer6 Interrupt Flag
--- - unimplemented, read as 0
TMR4IF - Timer4 Interrupt Flag
--- - unimplemented, read as 0
PIR1 , PIR2, and PIR3 contain the individual interrupt request flags for the MCU's peripherals.
OPTION_REG
OPTION_REG
 l OM oARc PSD|26 88 5 76 3

The INTEDG flag in OPTION_REG is used to set a rising or falling edge on

the INT pin as thetrigger for an INTE interrupt.
Enabling Interrupts
Core Interrupts
Three interrupt sources (Timer0, External Interrupt, and Interrupt on
Change) have interrupt enable bits located in INTCON. These
interrupts are referred to as core interrupts.

40 | P a g e