Jawaharlal Nehru Engineering College: Laboratory Manual

Jawaharlal Nehru Engineering College
Laboratory Manual
MICROPROCESSORS
For
Second Year Students CSE

Dept: Computer Science & Engineering (NBA Accredited)
 Author JNEC, Aurangabad

FOREWORD
It is my great pleasure to present this laboratory manual for Second year Engineering students
for the subject Microprocessors.
As a student, many of you may be wondering with some of the questions in your mind
regarding the subject and exactly what has been tried is to answer through this manual.
You may be aware that MGM has already been awarded with ISO 9001:2000 certification
and it is our endure to technically equip our students taking the advantage of the procedural
aspects of ISO 9001:2000 Certification.
Faculty members are also advised that covering these aspects in initial stage itself, will
greatly relieve them in future as much of the load will be taken care by the enthusiasm
energies of the students once they are conceptually clear.
Dr. S.D.Deshmukh
Principal
LABORATORY MANUAL CONTENTS
This manual is intended for the Second year students of Computer Science and Engineering
in the subject of Microprocessors. This manual typically contains practical/Lab Sessions
related to 8086 Microprocessor covering various aspects of the subject to enhance
understanding.
Students' are advised to thoroughly go through this manual rather than only topics mentioned
in the syllabus as practical aspects are the key to understanding and conceptual visualization
of theoretical aspects covered in the books.
Good Luck for your Enjoyable Laboratory Sessions
Dr.Vijaya B.Musande Smita L. Kasar

Head, CSE Dept. Asst.Prof., CSE Dept.
MGM’s
Jawaharlal Nehru Engineering College, Aurangabad
Department of Computer Science and Engineering
Vision of CSE Department
To develop computer engineers with necessary analytical ability and human values who can
creatively design, implement a wide spectrum of computer systems for welfare of the society.
Mission of the CSE Department:
 Preparing graduates to work on multidisciplinary platforms associated with their

professional position both independently and in a team environment.
 Preparing graduates for higher education and research in computer science and
engineering enabling them to develop systems for society development.
Programme Educational Objectives
Graduates will be able to
I. To analyze, design and provide optimal solution for Computer Science & Engineering
and multidisciplinary problems.
II. To pursue higher studies and research by applying knowledge of mathematics and
fundamentals of computer science.
III. To exhibit professionalism, communication skills and adapt to current trends by
engaging in lifelong learning.
Programme Outcomes (POs):
Engineering Graduates will be able to:
1. Engineering knowledge: Apply the knowledge of mathematics, science, engineering

fundamentals, and an engineering specialization to the solution of complex engineering
problems.
2. Problem analysis: Identify, formulate, review research literature, and analyze complex
engineering problems reaching substantiated conclusions using first principles of
mathematics, natural sciences, and engineering sciences.
3. Design/development of solutions: Design solutions for complex engineering problems

anddesign system components or processes that meet the specified needs with appropriate
consideration for the public health and safety, and the cultural, societal, and
environmental considerations.
4. Conduct investigations of complex problems: Use research-based knowledge and

research methods including design of experiments, analysis and interpretation of data, and
synthesis of the information to provide valid conclusions.
5. Modern tool usage: Create, select, and apply appropriate techniques, resources, and
modern engineering and IT tools including prediction and modeling to complex
engineering activities with an understanding of the limitations.
6. The engineer and society: Apply reasoning informed by the contextual knowledge to
assess societal, health, safety, legal and cultural issues and the consequent responsibilities
relevant to the professional engineering practice.
7. Environment and sustainability: Understand the impact of the professional engineering

solutions in societal and environmental contexts, and demonstrate the knowledge of, and
need for sustainable development.
8. Ethics: Apply ethical principles and commit to professional ethics and responsibilities and
norms ofthe engineering practice.
9. Individual and team work: Function effectively as an individual, and as a member or

leader in diverse teams, and in multidisciplinary settings.
10. Communication: Communicate effectively on complex engineering activities with the

engineering community and with society at large, such as, being able to comprehend and
write effective reports and design documentation, make effective presentations, and give
and receive clear instructions.
11. Project management and finance: Demonstrate knowledge and understanding of the
engineering and management principles and apply these to one’s own work, as a member
and leader in a team, to manage projects and in multidisciplinary environments.
12. Life-long learning: Recognize the need for, and have the preparation and ability to
engage independent and life-long learning in the broadest context of technological
change.
LIST OF EXPERIMENTS
1. Study of Emulator for 8086-EMU8086 and Assembly Language
Programming
2. Write an assembly language program to perform 8 bit, 16 bit addition.
3. Write an assembly language program to perform 8 bit, 16 bit subtraction.
4. Write an assembly language program to perform negative result subtraction.
5. Write an assembly language program to perform 8 bit, 16 bit Multiplication.
6. Write an assembly language program to perform16 bit by 8 bit division
7. Write an assembly language program to check whether entered number is
even or odd.
8. Write an assembly language program to calculate average of temperatures.
9. Write an assembly language program to perform sum of digits for 2, 3 digits
Numbers.
10. Write an assembly language program to perform conversion from two
ASCII no’s to packed BCD.
11. Write an assembly language program to perform conversion from BCD to
Hex.
12. Write an assembly language program to interface stepper motor using 8255.
DOs and DON’Ts in Laboratory:
1. Make entry in the Log Book as soon as you enter the Laboratory.
2. All the students should sit according to their roll numbers starting from their left to
right.
3. All the students are supposed to enter the terminal number in the log book.
4. Do not change the terminal on which you are working.
5. All the students are expected to get at least the algorithm of the program/concept
to be implemented.
6. Strictly observe the instructions given by the teacher/Lab Instructor.
Instruction for Laboratory Teachers::
1. Submission related to whatever lab work has been completed should be done during the
next lab session. The immediate arrangements for printouts related to submission on the day
of practical assignments.
2. Students should be taught for taking the printouts under the observation of lab teacher.
3. The promptness of submission should be encouraged by way of marking and evaluation

patterns that will benefit the sincere students.
EXPERIMENT No. 1
AIM - Study of Emulator for 8086-EMU8086 and Assembly Language

Programming
Objectives:
 To understand the working of EMU8086 as emulator for 8086 Programming and get
acquainted with Assembly Language Programming.
Theory:
Assembly Language Programming is less powerful than the high level languages like
C, C++, JAVA, etc. it is necessary to understand basics of assembly language as it helps in
understanding the working and the instruction set of microprocessors and microcontrollers.
Microprocessors like 8085 , 8086 and many other microcontrollers could be easily operated
via simple instructions of assembly languages. MASM (Microsoft Macro Assembler) is a
very efficient assembly language programming tool for windows and MS-DOS. It is not a
emulator but an actual programming tool helps in programming with processor. Emulator
EMU8086 is an emulator for 8086 providing an easy and user friendly environment for
assembly language programming for 8086.
INTRODUCTION TO ASSEMBLY LANGUAGE PROGRAMMING:

LEVELS OF PROGRAMMING:
There are three levels of programming

1. Machine language programs are programs that the computer can understand and execute
directly.
2. Assembly language instructions match machine language instructions, but are written
using character strings so that they are more easily understood.
3. High-level language instructions are much closer to the English language and are
structured.
Ultimately, an assembly language or high level language program must be converted into
machine language by programs called translators. If the program being translated is in assembly
language, the translator is referred to as an assembler, and if it is in a high level language the
translator is referred to as a compiler or interpreter.
ASSEMBLY LANGUAGE PROGRAM DEVELOPMENT TOOLS:
1. EDITOR: An editor is a program, which allows you to create a file containing the
assembly language statements for your program.
2. ASSEMBLER: An assembler program is used to translate the assembly language
mnemonic instructions to the corresponding binary codes. The second file generated
by assembler is called the assembler List file.
3. LINKER: A Linker is a program used to join several object files in to one large object
file. The linkers produce link files with the .EXE extension.
MEMORY MODELS FOR THE ASSEMBLER
Model Type Description
TINY All data and code must fit into one segment. Tiny
programs are written in .COM format, which
means that the program must be originated at
location 100H
SMALL This model contains two segments: one data
segment of 64K bytes and one code segment of
64K bytes.
MEDIUM This model contains one data segment of 64K
bytes and any number of code segments for large
programs.
COMPACT One code segment contains the program, and any
number of data segments contains the data.
LARGE The large model allows any number of code and
data segments.
HUGE This model is the same as large, but the data
segments may contain more than 64K bytes each.
FLAT Only available to MASM 6.X. The flat model
uses one segment of 512K bytes to tore all data
and code. Note that this model is mainly used
with Windows NT
ASSEMBLER DIRECTIVES:
An assembler is a program used to convert an assembly language program into the
equivalent machine code modules. The assembler decides the address of each label and
substitutes the values for each of the constants and variables. It then forms the machine code for
mnemonics and data in assembly language program. Assembler directives help the assembler to
correctly understand assembly language programs to prepare the codes. Commonly used
assembler directives are DB, DD, DW, DUP, ASSUME, BYTE, SEGMENT, MACRO, PROC,
OFFSET, NEAR, FAR, EQU, STRUC, PTR, END, ENDM, ENDP etc. Some directives generate
and store information in the memory, while others do not.
DB :- Define byte directive stores bytes of data in memory.
BYTE PTR :- This directive indicates the size of data referenced by pointer.
SEGMENT :- This directive is to indicate the start of the segment.
DUP (Duplicate) :- The DUP directive reserves memory locations given by the
number preceding it, but stores no specific values in any of these locations.
ASSUME : - The ASSUME statement is only used with full segment definitions. This statement
tells the assembler what names have been chosen for the code, data, extra and stack segments.
EQU : - The equate directive equates a numeric ASCII or label to another label.
ORG : - The ORG (origin) statement changes the starting offset address in a segment.
PROC and ENDP : - The PROC and ENDP directives indicate start and end of a procedure (Sub
routine). Both the PROC and ENDP directives require a label to indicate the name of the
procedure. The PROC directive, must also be followed with the NEAR or FAR. A NEAR
procedure is one that resides in the same code segment as the program. A FAR procedure may
reside at any location in the memory system.
OFFSET : - Offset of a label. When the assembler comes across the OFFSET operator along
with a label, it first computes the 16 – bit displacement of the particular label, and replaces the
string ‘OFFSET LABEL’ by the computed displacement.
LENGTH : - Byte length of the label. This directive is used to refer to the
length of data array or a string.
DOS Function Calls: - In order to use DOS function calls, always place function number into
register AH, and load other information into registers. Following is INT 21H, which is software
interrupt to execute a DOS function. All function calls use INT 21H, and AH contains function
call number. User can access the hardware of PC using DOS subroutine .DOS subroutines are
invoked or called via software interrupt INT 21H.
Conclusion: The assembly Language programming for 8086 and the Emulator EMU8086 is
studied.
EXPERIMENT No. 2
AIM: Write an assembly language program to perform 8 bit and 16 bit
addition.
Objectives:
 Describe the internal registers and access in different addressing modes for addition
operations both 8 bit and 16 bits.
Theory:
The 8086 has four groups of the user accessible internal registers. They are
1. general purpose registers
2. Segment registers
3. pointer and index registers
4. Flag register
General Purpose Registers

 AX : Accumulator register consists of two 8-bit registers AL and AH, which can be
combined together and used as a 16- bit register AX. AL in this case contains the low-
order byte of the word, and AH contains the high-order byte. Accumulator can be used for
I/O operations and string manipulation.
 BX: Base register consists of two 8-bit registers BL and BH, which can be combined
together and used as a 16-bit register BX. BL in this case contains the low-order byte of
the word, and BH contains the high-order byte. BX register usually contains a data
pointer used for based, based indexed or register indirect addressing.
 CX: Count register consists of two 8-bit registers CL and CH, which can be combined
together and used as a 16-bit register CX. When combined, CL register contains the low-
order byte of the word, and CH contains the highorder byte. Count register can be used in
Loop, shift/rotate instructions and as a counter in string manipulation,.
 DX: Data register consists of two 8-bit registers DL and DH, which can be combined
together and used as a 16-bit register DX. When combined, DL register contains the low-
order byte of the word, and DH contains the highorder byte. Data register can be used as a
port number in I/O operations. In integer 32-bit multiply and divide instruction the DX
register contains high-order word of the initial or resulting number.
Segment register:
 Code segment (CS) is a 16-bit register containing address of 64 KB segment with
processor instructions. The processor uses CS segment for all accesses to instructions
referenced by instruction pointer (IP) register. CS register cannot be changed directly. The
CS register is automatically updated during far jump, far call and far return instructions.
 Stack segment (SS) is a 16-bit register containing address of 64KB segment with
program stack. By default, the processor assumes that all data referenced by the stack
pointer (SP) and base pointer (BP) registers is located in the stack segment. SS register
can be changed directly using POP instruction.
 Data segment (DS) is a 16-bit register containing address of 64KB segment with
program data. By default, the processor assumes that all data referenced by general
registers (AX, BX, CX, DX) and index register (SI, DI) is located in the data segment. DS
register can be changed directly using POP and LDS instructions.
 Extra segment (ES) is a 16-bit register containing address of 64KB segment, usually
with program data. By default, the processor assumes that the DI register references the
ES segment in string manipulation instructions. ES register can be changed directly using
POP and LES instructions
Pointer and Index Registers
 Instruction Pointer (IP) is a 16-bit register that contains the offset address. IP is
combined with the CS to generate the address of the next instruction to be executed.
 Stack Pointer (SP) is a 16-bit register pointing to program stack.
 Base Pointer (BP) is a 16-bit register pointing to data in stack segment. BP register is
usually used for based, based indexed or register indirect addressing.
 Source Index (SI) is a 16-bit register. SI is used for indexed, based indexed and register
indirect addressing, as well as a source data address in string manipulation instructions.
 Destination Index (DI) is a 16-bit register. DI is used for indexed, based indexed and
register indirect addressing, as well as a destination data address in string manipulation
instructions.
Flag Register
Flags is a 16-bit register containing nine 1-bit flags. 06 flags are status flags and 3 are Control
Flags
Overflow Flag (OF) - set if the result is too large positive number, or is too small
negative number to fit into destination operand.
Direction Flag (DF) - if set then string manipulation instructions will auto-decrement
index registers. If cleared then the index registers will be auto-incremented.
Interrupt-enable Flag (IF) - setting this bit enables maskable interrupts.
Single-step Flag (TF) - if set then single-step interrupt will occur after the next
instruction.
Sign Flag (SF) - set if the most significant bit of the result is set.
Zero Flag (ZF) - set if the result is zero.
Auxiliary carry Flag (AF) - set if there was a carry from or borrow to bits 0-3 in the AL
register.
Parity Flag (PF) - set if parity (the number of "1" bits) in the low-order byte of the
result is even.
Carry Flag (CF) - set if there was a carry from or borrow to the most significant bit
during last result calculation.
Data Transfer Instructions
Data transfer is one of the most common tasks when programming in an assembly
language. Data can be transferred between registers or between registers and the memory.
Immediate data can be loaded to registers or to the memory. The transfer can be done on an octet
or word. The two operands must have the same size. Data transfer instructions don’t affect the
condition indicators (excepting the ones that have this purpose). They are classified as follows:
 classical transfer instructions
 address transfer instructions
 condition indicator transfer instructions
 input/output instructions (peripheral register transfers)
One of the Classical transfer instructions Include the following instruction:

MOV <d>, <s>
The MOV instruction is used to transfer a byte or a word of data from a source
operand to a destination operand. These operands can be internal registers of the
8086 and storage locations in memory.
Mnemonic Meaning Format Operation Flags affected
MOV Move MOV D,S (S) → (D) None
Destination Source Example

Accumulator Memory MOV AX, TEMP
Register Register MOV AX, BX
Memory Register MOV COUNT [DI], CX
Register Immediate MOV CL, 04
Arithmetic Instructions : Addition
ADD – ADD Destination, Source
ADC – ADC Destination, Source
These instructions add a number from some source to a number in some destination and put the
result in the specified destination. The ADC also adds the status of the carry flag to the result. The
source may be an immediate number, a register, or a memory location. The destination may be a
register or a memory location. The source and the destination in an instruction cannot both be
memory locations. The source and the destination must be of the same type (bytes or words). If
you want to add a byte to a word, you must copy the byte to a word location and fill the upper
byte of the word with 0’s before adding. Flags affected: AF, CF, OF, SF, ZF.
 ADD AL, 74H ; Add immediate number 74H to content of AL. Result in AL
 ADC CL, BL ;Add content of BL plus carry status to content of CL(CL = CL+BL+Carry
Flag)
 ADD DX, BX ; Add content of BX to content of DX
 ADD DX, [SI] ;Add word from memory at offset [SI] in DS to content of DX
PROGRAM -1 (Using Registers and Immediate Data (Result is with carry))
MOV AL, 0F0H ; Load the value to 0F0H

MOV BL, 10H ;Load the value to 10H
ADD AL,BL ; Addition of above two numbers generates carry and carry flag is set CY=1,AL=00H
Output:
PROGRAM -2 (Using Registers and Immediate Data (Result is without carry))
MOV AL, 01H ; Load the value to 01H

Output:
PROGRAM -3 (Using Registers and Immediate Data)

ADD AL,02H ; Addition of AL and immediate data 02 gives result as CY=0,AL=03H
PROGRAM -4 (Using Registers and Memory)

ADD AL,02H ; Addition of AL and immediate data 02 gives result as CY=0,AL=03H
MOV [1234H],AL ; Physical Address=DS * 10 + 1234H . If DS=0700H then PA = 08234H
PROGRAM -4 ( To demonstrate the ADC Instruction)
MOV AL, 0F0H ; Load the value to 0F0H

ADC AL,20H ; ADC adds carry flag,contents of AL and 20H.Result=21H (If ADD instruction is used
result will be 20H)
Similarly all the above four programs can be repeated using 16 bit numbers.
Conclusion: The internal registers alogwith FLAG register is understood and 8-bit and 16-
bit addition is implemented.
EXPERIMENT No. 3
Aim: Write an assembly language program to perform 8 bit, 16 bit

subtraction.
Objectives:
 To use different addressing modes and understand the method of subtraction in 8086.
Theory
8086 ADDRESSING MODES
Immediate addressing mode:

In this mode, 8 or 16 bit data can be specified as part of the instruction. OP Code Immediate
Operand
Example 1 : MOV CL, 03 H
Moves the 8 bit data 03 H into CL
Example 2 : MOV DX, 0525 H

Moves the 16 bit data 0525 H into DX
In the above two examples, the source operand is in immediate mode and the destination operand
is in register mode. A constant such as “VALUE” can be defined by the assembler EQUATE
directive such as VALUE EQU 35H
Example : MOV BH, VALUE
Used to load 35 H into BH
Register addressing mode :

The operand to be accessed is specified as residing in an internal register of 8086.Internal
registers can be used as a source or destination operand, however only the data registers can be
accessed as either a byte or word.
Example 1 : MOV DX (Destination Register) , CX (Source Register)

Which moves 16 bit content of CS into DX.
Example 2 : MOV CL, DL

Moves 8 bit contents of DL into CL
MOV BX, CH is an illegal instruction.

 The register sizes must be the same.
Direct addressing mode :

The instruction Opcode is followed by an affective address, this effective address is directly used
as the 16 bit offset of the storage location of the operand from the location specified by the
current value in the selected segment register. The default segment is always DS.
The 20 bit physical address of the operand in memory is normally obtained as
PA = DS : EA
But by using a segment override prefix (SOP) in the instruction, any of the four segment registers
can be referenced,
In the direct addressing mode, the 16 bit effective address (EA) is taken directly from the
displacement field of the instruction.
Example 1 : MOV CX, START
If the 16 bit value assigned to the offset START by the programmer using an
assembler pseudo instruction such as DW is 0040 and [DS] = 3050.
Then BIU generates the 20 bit physical address 30540 H.
The content of 30540 is moved to CL
The content of 30541 is moved to CH
Example 2 : MOV CH, START

If [DS] = 3050 and START = 0040
8 bit content of memory location 30540 is moved to CH.
Example 3 : MOV START, BX

With [DS] = 3050, the value of START is 0040.
Physical address : 30540
MOV instruction moves (BL) and (BH) to locations 30540 and 30541
respectively.
Register indirect addressing mode :

The EA is specified in either pointer (BX) register or an index (SI or DI) register. The 20 bit
physical address is computed using DS and EA.
Example : MOV [DI], BX
register indirect
If [DS] = 5004, [DI] = 0020, [Bx] = 2456 PA=50060.
The content of BX(2456) is moved to memory locations 50060 H and 50061 H.
Based Addressing Mode:

when memory is accessed PA is computed from BX and DS when the stack is
accessed PA is computed from BP and SS.
Example : MOV AL, START [BX]
or
MOV AL, [START + BX]
based mode
EA : [START] + [BX]
PA : [DS] + [EA]
The 8 bit content of this memory location is moved to AL.
Indexed addressing mode:
Example : MOV BH, START [SI]

PA : [START] + [SI] + [DS]
The content of this memory is moved into BH.
Based Indexed addressing mode:
Example : MOV ALPHA [SI] [BX], CL

If [BX] = 0200, ALPHA – 08, [SI] = 1000 H and [DS] = 3000
Physical address (PA) = 31208
8 bit content of CL is moved to 31208 memory address.
Instructions:
SUB – SUB Destination, Source
SBB – SBB Destination, Source
These instructions subtract the number in some source from the number in some destination and
put the result in the destination. The SBB instruction also subtracts the content of carry flag from
the destination. The source may be an immediate number, a register or memory location. The
destination can also be a register or a memory location. However, the source and the destination
cannot both be memory location. The source and the destination must both be of the same type
(bytes or words). If you want to subtract a byte from a word, you must first move the byte to a
word location such as a 16-bit register and fill the upper byte of the word with 0’s. Flags affected:
AF, CF, OF, PF, SF, ZF.
 SUB CX, BX CX – BX; Result in CX
 SBB CH, AL Subtract content of AL and content of CF from content of CH. From BX
SUB PRICES [BX], 04H Subtract 04 from byte at effective address PRICES [BX],
if PRICES is declared with DB; Subtract 04 from word at effective address PRICES [BX], if it is
declared with DW.
 SBB CX, TABLE [BX] Subtract word from effective address TABLE [BX]
and status of CF from CX.

 SBB TABLE [BX], CX Subtract CX and status of CF from word in memory at
effective address TABLE[BX].
Result in CH
 SUB AX, 3427H Subtract immediate number 3427H from AX
 SBB BX, [3427H] Subtract word at displacement 3427H in DS and content of CF
Decrement Instruction
DEC – DEC Destination
This instruction subtracts 1 from the destination word or byte. The destination can be a register or
a memory location. AF, OF, SF, PF, and ZF are updated, but CF is not affected. This means that if
an 8-bit destination containing 00H or a 16-bit destination containing 0000H is decremented, the
result will be FFH or FFFFH with no carry (borrow).
 DEC CL Subtract 1 from content of CL register
 DEC BP Subtract 1 from content of BP register
 DEC BYTE PTR [BX] Subtract 1 from byte at offset [BX] in DS.
 DEC WORD PTR [BP] Subtract 1 from a word at offset [BP] in SS.
 DEC COUNT Subtract 1 from byte or word named COUNT in DS.
Decrement a byte if COUNT is declared with a DB;

Decrement a word if COUNT is declared with a DW.
Increment instruction
INC – INC Destination
The INC instruction adds 1 to a specified register or to a memory location. AF, OF, PF, SF, and
ZF are updated, but CF is not affected. This means that if an 8-bit destination containing FFH or a
16-bit destination containing FFFFH is incremented, the result will be all 0’s with no carry.
 INC BL Add 1 to contains of BL register

 INC CX Add 1 to contains of CX register
 INC BYTE PTR [BX] Increment byte in data segment at offset contained in BX.
 INC WORD PTR [BX] Increment the word at offset of [BX] and [BX + 1] in the data segment.
 INC TEMP Increment byte or word named TEMP in the data segment.
Increment byte if MAX_TEMP declared with DB.

Increment word if MAX_TEMP is declared with DW.
 INC PRICES [BX] Increment element pointed to by [BX] in array PRICES.
Increment a word if PRICES is declared as an array of words;

Increment a byte if PRICES is declared as an array of bytes.
Program:
8. Bit programs-
(Using registers)
MOV AL,09H ;Load immediate data 09h to register AL
MOV BL,06H ; Load immediate data to register BL
SUB AL, BL ;AL=AL-BL
Output-
(Using register and immediate data)
MOV AL, 09H ; Load immediate data 09h to register AL

SUB AL, 02H ; AL=AL-2
Output-
(Using register and memory)
MOV AL,07H ; Load immediate data 07h to register AL.

MOV BL,04H ; Load immediate data 04h to register BL.
SUB AL,BL ;AL=Al-BL
MOV[1234H],AL; ; Move the contents of AL to Memory location in DS with offset=1234H
16 bit Program:
(Using Registers)
MOV AX, 1F00H ; Load immediate data 1F00h to register AX.

MOV BX, 1234H ; Load immediate data 1234h to register BX.
SUB AX, BX ;AX=AX-BX
(Using register and immediate data)
Mov ax,1f00h ;Move 1fooh 16 bit data to register ax

Sub ax,1111h ; ;ax=ax-1111h
(Using registers and memory)
Mov ax,1f00h;
Mov bx,1111h;
Sub ax,bx;
Mov[1234h],ax;
Conclusion: Thus the addressing modes are studied and the 8-bit and 16-bit subtraction is
implemented,
EXPERIMENT No.4
AIM: Write an assembly language program to perform negative result

subtraction.
Objectives:
 To get acquainted with the stack related instructions and operations.
 To understand the concept of negative result ater subtraction and interpret the result
correctly.
Theory:
STACK RELATED INSTRUCTIONS

PUSH – PUSH Source
The PUSH instruction decrements the stack pointer by 2 and copies a word from a specified
source to the location in the stack segment to which the stack pointer points. The source of the
word can be general-purpose register, segment register, or memory. The stack segment register
and the stack pointer must be initialized before this instruction can be used. PUSH can be used to
save data on the stack so that it will not destroyed by a procedure. This instruction does not affect
any flag.
 PUSH BX Decrement SP by 2, copy BX to stack.
 PUSH DS Decrement SP by 2, copy DS to stack.
 PUSH BL Illegal; must push a word
 PUSH TABLE [BX] Decrement SP by 2, and copy word from memory in DS at
EA = TABLE + [BX] to stack

POP – POP Destination
The POP instruction copies a word from the stack location pointed to by the stack pointer to a
destination specified in the instruction. The destination can be a general-purpose register, a
segment register or a memory location. The data in the stack is not changed. After the word is
copied to the specified destination, the stack pointer is automatically incremented by 2 to point to
the next word on the stack. The POP instruction does not affect any flag.
 POP DX Copy a word from top of stack to DX; increment SP by 2
 POP DS Copy a word from top of stack to DS; increment SP by 2
 POP TABLE [DX] Copy a word from top of stack to memory in DS with
EA = TABLE + [BX]; increment SP by 2.

PUSHF (PUSH FLAG REGISTER TO STACK)
The PUSHF instruction decrements the stack pointer by 2 and copies a word in the flag register to
two memory locations in stack pointed to by the stack pointer. The stack segment register is not
affected. This instruction does to affect any flag.
POPF (POP WORD FROM TOP OF STACK TO FLAG REGISTER)
The POPF instruction copies a word from two memory locations at the top of the stack to the flag
register and increments the stack pointer by 2. The stack segment register and word on the stack
are not affected. This instruction does to affect any flag.
LEA – LEA Register, Source

This instruction determines the offset of the variable or memory location named as the source and
puts this offset in the indicated 16-bit register. LEA does not affect any flag.
 LEA BX, PRICES Load BX with offset of PRICE in DS
 LEA BP, SS: STACK_TOP Load BP with offset of STACK_TOP in SS
 LEA CX, [BX][DI] Load CX with EA = [BX] + [DI]
LDS – LDS Register, Memory address of the first word

This instruction loads new values into the specified register and into the DS register from four
successive memory locations. The word from two memory locations is copied into the specified
register and the word from the next two memory locations is copied into the DS registers. LDS
does not affect any flag.
 LDS BX, [4326] Copy content of memory at displacement 4326H in DS to BL,
content of 4327H to BH. Copy content at displacement of

4328H and 4329H in DS to DS register.
 LDS SI, SPTR Copy content of memory at displacement SPTR and SPTR + 1 in DS to SI
register. Copy content of memory at displacements SPTR + 2 and SPTR + 3 in DS to DS register.
DS: SI now points at start of the desired string.
LES – LES Register, Memory address of the first word
This instruction loads new values into the specified register and into the ES register from four
successive memory locations. The word from the first two memory locations is copied into the
specified register, and the word from the next two memory locations is copied into the ES
register. LES does not affect any flag.
 LES BX, [789AH] Copy content of memory at displacement 789AH in DS to BL,
content of 789BH to BH, content of memory at displacement

789CH and 789DH in DS is copied to ES register.
 LES DI, [BX] Copy content of memory at offset [BX] and offset [BX] + 1 in
DS to DI register. Copy content of memory at offset [BX] + 2

and [BX] + 3 to ES register.
Program-
Mov ax,10h ;Move 10h to register ax

Mov bx,11h ;Move 11h to register bx
Sub ax,bx ;ax=ax-bx
Conclusion: Thus the stack related instructions are studied and the negative result subtraction
is implemented.
EXPERIMENT No.5.
Aim: Write an assembly language program to perform 8 bit, 16 bit Multiplication.
Objectives:
 To study string related operations with the help of string instructions.
 To use Multiplication instruction for 8 bit and 16 bit numbers.
Theory:
MUL – MUL Source

This instruction multiplies an unsigned byte in some source with an unsigned byte in AL register
or an unsigned word in some source with an unsigned word in AX register. The source can be a
register or a memory location. When a byte is multiplied by the content of AL, the result
(product) is put in AX. When a word is multiplied by the content of AX, the result is put in DX
and AX registers. If the most significant byte of a 16-bit result or the most significant word of a
32-bit result is 0, CF and OF will both be 0’s. AF, PF, SF and ZF are undefined after a MUL
instruction.
If you want to multiply a byte with a word, you must first move the byte to a word location such
as an extended register and fill the upper byte of the word with all 0’s. You cannot use the CBW
instruction for this, because the CBW instruction fills the upper byte with copies of the most
significant bit of the lower byte.
 MUL BH Multiply AL with BH; result in AX
 MUL CX Multiply AX with CX; result high word in DX, low word in AX
 MUL BYTE PTR [BX] Multiply AL with byte in DS pointed to by [BX]
 MUL FACTOR [BX] Multiply AL with byte at effective address FACTOR [BX], if it
is declared as type byte with DB. Multiply AX with word at

effective address FACTOR [BX], if it is declared as type word
with DW.
 MOV AX, MCAND_16 Load 16-bit multiplicand into AX
MOV CL, MPLIER_8 Load 8-bit multiplier into CL

MOV CH, 00H Set upper byte of CX to all 0’s
MUL CX AX times CX; 32-bit result in DX and AX
IMUL – IMUL Source

This instruction multiplies a signed byte from source with a signed byte in AL or a signed word
from some source with a signed word in AX. The source can be a register or a memory location.
When a byte from source is multiplied with content of AL, the signed result (product) will be put
in AX. When a word from source is multiplied by AX, the result is put in DX and AX. If the
magnitude of the product does not require all the bits of the destination, the unused byte / word
will be filled with copies of the sign bit. If the upper byte of a 16-bit result or the upper word of a
32-bit result contains only copies of the sign bit (all 0’s or all 1’s), then CF and the OF will both
be 0; If it contains a part of the product, CF and OF will both be 1. AF, PF, SF and ZF are
undefined after IMUL.
If you want to multiply a signed byte with a signed word, you must first move the byte into a
word location and fill the upper byte of the word with copies of the sign bit. If you move the byte
into AL, you can use the CBW instruction to do this.
 IMUL BH Multiply signed byte in AL with signed byte in BH;
result in AX.
 IMUL AX Multiply AX times AX; result in DX and AX
 MOV CX, MULTIPLIER Load signed word in CX
STRING MANIPULATION INSTRUCTIONS

MOVS – MOVS Destination String Name, Source String Name
MOVSB – MOVSB Destination String Name, Source String Name
MOVSW – MOVSW Destination String Name, Source String Name
This instruction copies a byte or a word from location in the data segment to a location in the
extra segment. The offset of the source in the data segment must be in the SI register. The offset
of the destination in the extra segment must be in the DI register. For multiple-byte or multiple-
word moves, the number of elements to be moved is put in the CX register so that it can function
as a counter. After the byte or a word is moved, SI and DI are automatically adjusted to point to
the next source element and the next destination element. If DF is 0, then SI and DI will
incremented by 1 after a byte move and by 2 after a word move. If DF is 1, then SI and DI will be
decremented by 1 after a byte move and by 2 after a word move. MOVS does not affect any flag.
When using the MOVS instruction, you must in some way tell the assembler whether you want to
move a string as bytes or as word. There are two ways to do this. The first way is to indicate the
name of the source and destination strings in the instruction, as, for example. MOVS DEST, SRC.
The assembler will code the instruction for a byte / word move if they were declared with a DB /
DW. The second way is to add a “B” or a “W” to the MOVS mnemonic. MOVSB says move a
string as bytes; MOVSW says move a string as words.
 MOV SI, OFFSET SOURCE Load offset of start of source string in DS into SI
MOV DI, OFFSET DESTINATION Load offset of start of destination string in ES into DI
CLD Clear DF to auto increment SI and DI after move
MOV CX, 04H Load length of string into CX as counter
REP MOVSB Move string byte until CX = 0
LODS / LODSB / LODSW (LOAD STRING BYTE INTO AL OR STRING WORD INTO
AX)
This instruction copies a byte from a string location pointed to by SI to AL, or a word from a
string location pointed to by SI to AX. If DF is 0, SI will be automatically incremented (by 1 for a
byte string, and 2 for a word string) to point to the next element of the string. If DF is 1, SI will
be automatically decremented (by 1 for a byte string, and 2 for a word string) to point to the
previous element of the string. LODS does not affect any flag.
 CLD Clear direction flag so that SI is auto-incremented
MOV SI, OFFSET SOURCE Point SI to start of string

LODS SOURCE Copy a byte or a word from string to AL or AX
Note: The assembler uses the name of the string to determine whether the string is of type bye or
type word. Instead of using the string name to do this, you can use the mnemonic LODSB to tell
the assembler that the string is type byte or the mnemonic LODSW to tell the assembler that the
string is of type word.
STOS / STOSB / STOSW (STORE STRING BYTE OR STRING WORD)
This instruction copies a byte from AL or a word from AX to a memory location in the extra
segment pointed to by DI. In effect, it replaces a string element with a byte from AL or a word
from AX. After the copy, DI is automatically incremented or decremented to point to next or
previous element of the string. If DF is cleared, then DI will automatically incremented by 1 for a
byte string and by 2 for a word string. If DI is set, DI will be automatically decremented by 1 for
a byte string and by 2 for a word string. STOS does not affect any flag.
 MOV DI, OFFSET TARGET
STOS TARGET
Note: The assembler uses the string name to determine whether the string is of type byte or type
word. If it is a byte string, then string byte is replaced with content of AL. If it is a word string,
then string word is replaced with content of AX.
 MOV DI, OFFSET TARGET
STOSB
“B” added to STOSB mnemonic tells assembler to replace byte in string with byte from AL.
STOSW would tell assembler directly to replace a word in the string with a word from AX.
CMPS / CMPSB / CMPSW (COMPARE STRING BYTES OR STRING WORDS)

This instruction can be used to compare a byte / word in one string with a byte / word in another
string. SI is used to hold the offset of the byte or word in the source string, and DI is used to hold
the offset of the byte or word in the destination string.
The AF, CF, OF, PF, SF, and ZF flags are affected by the comparison, but the two operands are
not affected. After the comparison, SI and DI will automatically be incremented or decremented
to point to the next or previous element in the two strings. If DF is set, then SI and DI will
automatically be decremented by 1 for a byte string and by 2 for a word string. If DF is reset, then
SI and DI will automatically be incremented by 1 for byte strings and by 2 for word strings. The
string pointed to by SI must be in the data segment. The string pointed to by DI must be in the
extra segment.
The CMPS instruction can be used with a REPE or REPNE prefix to compare all the elements of
a string.
 MOV SI, OFFSET FIRST Point SI to source string
MOV DI, OFFSET SECOND Point DI to destination string

CLD DF cleared, SI and DI will auto-increment after compare
MOV CX, 100 Put number of string elements in CX
REPE CMPSB Repeat the comparison of string bytes until end of string
or until compared bytes are not equal
CX functions as a counter, which the REPE prefix will cause CX to be decremented after each
compare. The B attached to CMPS tells the assembler that the strings are of type byte. If you
want to tell the assembler that strings are of type word, write the instruction as CMPSW. The
REPE CMPSW instruction will cause the pointers in SI and DI to be incremented by 2 after each
compare, if the direction flag is set.
SCAS / SCASB / SCASW (SCAN A STRING BYTE OR A STRING WORD)
SCAS compares a byte in AL or a word in AX with a byte or a word in ES pointed to by DI.
Therefore, the string to be scanned must be in the extra segment, and DI must contain the offset
of the byte or the word to be compared. If DF is cleared, then DI will be incremented by 1 for
byte strings and by 2 for word strings. If DF is set, then DI will be decremented by 1 for byte
strings and by 2 for word strings. SCAS affects AF, CF, OF, PF, SF, and ZF, but it does not change
either the operand in AL (AX) or the operand in the string.
The following program segment scans a text string of 80 characters for a carriage return, 0DH,
and puts the offset of string into DI:
 MOV DI, OFFSET STRING
MOV AL, 0DH Byte to be scanned for into AL

MOV CX, 80 CX used as element counter
CLD Clear DF, so that DI auto increments
REPNE SCAS STRING Compare byte in string with byte in AL
REP / REPE / REPZ / REPNE / REPNZ (PREFIX)
(REPEAT STRING INSTRUCTION UNTIL SPECIFIED CONDITIONS EXIST)
REP is a prefix, which is written before one of the string instructions. It will cause the CX register
to be decremented and the string instruction to be repeated until CX = 0. The instruction REP
MOVSB, for example, will continue to copy string bytes until the number of bytes loaded into
CX has been copied.
REPE and REPZ are two mnemonics for the same prefix. They stand for repeat if equal and
repeat if zero, respectively. They are often used with the Compare String instruction or with the
Scan String instruction. They will cause the string instruction to be repeated as long as the
compared bytes or words are equal (ZF = 1) and CX is not yet counted down to zero. In other
words, there are two conditions that will stop the repetition: CX = 0 or string bytes or words not
equal.
 REPE CMPSB Compare string bytes until end of string or until string bytes not equal.
REPNE and REPNZ are also two mnemonics for the same prefix. They stand for repeat if not
equal and repeat if not zero, respectively. They are often used with the Compare String instruction
or with the Scan String instruction. They will cause the string instruction to be repeated as long as
the compared bytes or words are not equal (ZF = 0) and CX is not yet counted down to zero.
 REPNE SCASW Scan a string of word until a word in the string matches the word
in AX or until all of the string has been scanned.

The string instruction used with the prefix determines which flags are affected.
Program-
8 bit multiplication
MOV AX,04H ;MOVE 04H TO REGISTER AX
MOV BX,05H ;MOVE 05H TO REGISTER BX
MUL BX ;ax=ax*bx
16 bit multiplication
MOV AX, 0111H ;MOVE 0111H TO REGISTER AX
MOV BX, 1212H ;MOVE 1212H TO REGISTER BX
MUL BX ;AX=AX*BX
Conclusion: Thus the string instructions are studied and multiplication for 8 bit and 16 bit
multiplication.
EXPERIMENT No. 6
Aim - Write an assembly language program to perform 16 bit by 8 bit Division
Objectives:
 Describe the conditional and unconditional jump instructions.
 To study and implement the division instructions.
Theory:
DIV – DIV Source

This instruction is used to divide an unsigned word by a byte or to divide an unsigned double
word (32 bits) by a word. When a word is divided by a byte, the word must be in the AX register.
The divisor can be in a register or a memory location. After the division, AL will contain the 8-bit
quotient, and AH will contain the 8-bit remainder. When a double word is divided by a word, the
most significant word of the double word must be in DX, and the least significant word of the
double word must be in AX. After the division, AX will contain the 16-bit quotient and DX will
contain the 16-bit remainder. If an attempt is made to divide by 0 or if the quotient is too large to
fit in the destination (greater than FFH / FFFFH), the 8086 will generate a type 0 interrupt. All
flags are undefined after a DIV instruction.
If you want to divide a byte by a byte, you must first put the dividend byte in AL and fill AH with
all 0’s. Likewise, if you want to divide a word by another word, then put the dividend word in AX
and fill DX with all 0’s.
 DIV BL Divide word in AX by byte in BL; Quotient in AL, remainder in AH
 DIV CX Divide down word in DX and AX by word in CX;
Quotient in AX, and remainder in DX.

 DIV SCALE [BX] AX / (byte at effective address SCALE [BX]) if SCALE [BX] is of type
byte; or (DX and AX) / (word at effective address SCALE[BX]

if SCALE[BX] is of type word
IDIV – IDIV Source

This instruction is used to divide a signed word by a signed byte, or to divide a signed double
word by a signed word.
When dividing a signed word by a signed byte, the word must be in the AX register. The divisor
can be in an 8-bit register or a memory location. After the division, AL will contain the signed
quotient, and AH will contain the signed remainder. The sign of the remainder will be the same as
the sign of the dividend. If an attempt is made to divide by 0, the quotient is greater than 127
(7FH) or less than –127 (81H), the 8086 will automatically generate a type 0 interrupt.
When dividing a signed double word by a signed word, the most significant word of the dividend
(numerator) must be in the DX register, and the least significant word of the dividend must be in
the AX register. The divisor can be in any other 16-bit register or memory location. After the
division, AX will contain a signed 16-bit quotient, and DX will contain a signed 16-bit remainder.
The sign of the remainder will be the same as the sign of the dividend. Again, if an attempt is
made to divide by 0, the quotient is greater than +32,767 (7FFFH) or less than –32,767 (8001H),
the 8086 will automatically generate a type 0 interrupt.
All flags are undefined after an IDIV.
If you want to divide a signed byte by a signed byte, you must first put the dividend byte in AL
and sign-extend AL into AH. The CBW instruction can be used for this purpose. Likewise, if you
want to divide a signed word by a signed word, you must put the dividend word in AX and extend
the sign of AX to all the bits of DX. The CWD instruction can be used for this purpose.
 IDIV BL Signed word in AX/signed byte in BL
 IDIV BP Signed double word in DX and AX/signed word in BP
 IDIV BYTE PTR [BX] AX / byte at offset [BX] in DS
CWB
CWD
TRANSFER-OF-CONTROL INSTRUCTIONS
JMP (UNCONDITIONAL JUMP TO SPECIFIED DESTINATION)

This instruction will fetch the next instruction from the location specified in the instruction rather
than from the next location after the JMP instruction. If the destination is in the same code
segment as the JMP instruction, then only the instruction pointer will be changed to get the
destination location. This is referred to as a near jump. If the destination for the jump instruction
is in a segment with a name different from that of the segment containing the JMP instruction,
then both the instruction pointer and the code segment register content will be changed to get the
destination location. This referred to as a far jump. The JMP instruction does not affect any flag.
 JMP CONTINUE
This instruction fetches the next instruction from address at label CONTINUE. If the label is in
the same segment, an offset coded as part of the instruction will be added to the instruction
pointer to produce the new fetch address. If the label is another segment, then IP and CS will be
replaced with value coded in part of the instruction. This type of jump is referred to as direct
because the displacement of the destination or the destination itself is specified directly in the
instruction.
JA / JNBE (JUMP IF ABOVE / JUMP IF NOT BELOW OR EQUAL)

If, after a compare or some other instructions which affect flags, the zero flag and the carry flag
both are 0, this instruction will cause execution to jump to a label given in the instruction. If CF
and ZF are not both 0, the instruction will have no effect on program execution.
 CMP AX, 4371H Compare by subtracting 4371H from AX
JA NEXT Jump to label NEXT if AX above 4371H

 CMP AX, 4371H Compare (AX – 4371H)
JNBE NEXT Jump to label NEXT if AX not below or equal to 4371H

JAE / JNB / JNC
(JUMP IF ABOVE OR EQUAL / JUMP IF NOT BELOW / JUMP IF NO CARRY)
If, after a compare or some other instructions which affect flags, the carry flag is 0, this
instruction will cause execution to jump to a label given in the instruction. If CF is 1, the
instruction will have no effect on program execution.
JAE NEXT Jump to label NEXT if AX above 4371H

JNB NEXT Jump to label NEXT if AX not below 4371H

 ADD AL, BL Add two bytes
JNC NEXT If the result with in acceptable range, continue

JB / JC / JNAE (JUMP IF BELOW / JUMP IF CARRY / JUMP IF NOT ABOVE OR
EQUAL)
If, after a compare or some other instructions which affect flags, the carry flag is a 1, this
instruction will cause execution to jump to a label given in the instruction. If CF is 0, the
instruction will have no effect on program execution.
JB NEXT Jump to label NEXT if AX below 4371H

 ADD BX, CX Add two words
JC NEXT Jump to label NEXT if CF = 1

JNAE NEXT Jump to label NEXT if AX not above or equal to 4371H

JBE / JNA (JUMP IF BELOW OR EQUAL / JUMP IF NOT ABOVE)
If, after a compare or some other instructions which affect flags, either the zero flag or the carry
flag is 1, this instruction will cause execution to jump to a label given in the instruction. If CF and
ZF are both 0, the instruction will have no effect on program execution.
JBE NEXT Jump to label NEXT if AX is below or equal to 4371H

JNA NEXT Jump to label NEXT if AX not above 4371H

JG / JNLE (JUMP IF GREATER / JUMP IF NOT LESS THAN OR EQUAL)
This instruction is usually used after a Compare instruction. The instruction will cause a jump to
the label given in the instruction, if the zero flag is 0 and the carry flag is the same as the
overflow flag.
 CMP BL, 39H Compare by subtracting 39H from BL
JG NEXT Jump to label NEXT if BL more positive than 39H

JNLE NEXT Jump to label NEXT if BL is not less than or equal to 39H
JGE / JNL (JUMP IF GREATER THAN OR EQUAL / JUMP IF NOT LESS THAN)
the label given in the instruction, if the sign flag is equal to the overflow flag.
JGE NEXT Jump to label NEXT if BL more positive than or equal to 39H
JNL NEXT Jump to label NEXT if BL not less than 39H

JL / JNGE (JUMP IF LESS THAN / JUMP IF NOT GREATER THAN OR EQUAL)
the label given in the instruction if the sign flag is not equal to the overflow flag.
JL AGAIN Jump to label AGAIN if BL more negative than 39H

JNGE AGAIN Jump to label AGAIN if BL not more positive than or equal to
39H
JLE / JNG (JUMP IF LESS THAN OR EQUAL / JUMP IF NOT GREATER)
the label given in the instruction if the zero flag is set, or if the sign flag not equal to the overflow
flag.
JLE NEXT Jump to label NEXT if BL more negative than or equal to 39H
JNG NEXT Jump to label NEXT if BL not more positive than 39H
JE / JZ (JUMP IF EQUAL / JUMP IF ZERO)
This instruction is usually used after a Compare instruction. If the zero flag is set, then this
instruction will cause a jump to the label given in the instruction.
 CMP BX, DX Compare (BX-DX)
JE DONE Jump to DONE if BX = DX
JNE / JNZ (JUMP NOT EQUAL / JUMP IF NOT ZERO)

This instruction is usually used after a Compare instruction. If the zero flag is 0, then this
instruction will cause a jump to the label given in the instruction.
 ADD AX, 0002H Add count factor 0002H to AX
DEC BX Decrement BX
JNZ NEXT Jump to label NEXT if BX  0
JS (JUMP IF SIGNED / JUMP IF NEGATIVE)
This instruction will cause a jump to the specified destination address if the sign flag is set. Since
a 1 in the sign flag indicates a negative signed number, you can think of this instruction as saying
“jump if negative”.
 ADD BL, DH Add signed byte in DH to signed byte in DL
JS NEXT Jump to label NEXT if result of addition is negative number

JNS (JUMP IF NOT SIGNED / JUMP IF POSITIVE)
This instruction will cause a jump to the specified destination address if the sign flag is 0. Since a
0 in the sign flag indicate a positive signed number, you can think to this instruction as saying
“jump if positive”.
 DEC AL Decrement AL
JNS NEXT Jump to label NEXT if AL has not decremented to FFH

JP / JPE (JUMP IF PARITY / JUMP IF PARITY EVEN)
If the number of 1’s left in the lower 8 bits of a data word after an instruction which affects the
parity flag is even, then the parity flag will be set. If the parity flag is set, the JP / JPE instruction
will cause a jump to the specified destination address.
JNP / JPO (JUMP IF NO PARITY / JUMP IF PARITY ODD)

If the number of 1’s left in the lower 8 bits of a data word after an instruction which affects the
parity flag is odd, then the parity flag is 0. The JNP / JPO instruction will cause a jump to the
specified destination address, if the parity flag is 0.
JO (JUMP IF OVERFLOW)
The overflow flag will be set if the magnitude of the result produced by some signed arithmetic
operation is too large to fit in the destination register or memory location. The JO instruction will
cause a jump to the destination given in the instruction, if the overflow flag is set.
 ADD AL, BL Add signed bytes in AL and BL
JO ERROR Jump to label ERROR if overflow from add

JNO (JUMP IF NO OVERFLOW)
The overflow flag will be set if some signed arithmetic operation is too large to fit in the
destination register or memory location. The JNO instruction will cause a jump to the destination
given in the instruction, if the overflow flag is not set.
 ADD AL, BL Add signed byte in AL and BL
JNO DONE Process DONE if no overflow

JCXZ (JUMP IF THE CX REGISTER IS ZERO)
This instruction will cause a jump to the label to a given in the instruction, if the CX register contains
all 0’s. The instruction does not look at the zero flag when it decides whether to jump or not.
 JCXZ SKIP If CX = 0, skip the process
SUB [BX], 07H Subtract 7 from data value

SKIP: ADD C Next instruction
LOOP NEXT Repeat until all elements adjusted
Program-
8 bit division
MOV AX,20H
MOV BX,10H
DIV BX
16 bit division
MOV DX,0102H
MOV AX,1000H
MOV BX,1010H
DIV BX
Conclusion: 16 bit by 8 bit Division is implemented.

EXPERIMENT No. 7
AIM - Write an assembly language program to check whether entered number is even
or odd.
Objectives:
 Describe the Miscellaneous Data Transfer Instructions.
 To study and implement the jump instructions to find whether entered number is even
or odd.
Theory:
Miscellaneous Data Transfer Instructions
CMP – CMP Destination, Source
This instruction compares a byte / word in the specified source with a byte / word in the specified
destination. The source can be an immediate number, a register, or a memory location. The
destination can be a register or a memory location. However, the source and the destination
cannot both be memory locations. The comparison is actually done by subtracting the source byte
or word from the destination byte or word. The source and the destination are not changed, but
the flags are set to indicate the results of the comparison. AF, OF, SF, ZF, PF, and CF are updated
by the CMP instruction. For the instruction CMP CX, BX, the values of CF, ZF, and SF will be as
follows:
CF ZF SF
CX = BX 0 1 0 Result of subtraction is 0
CX > BX 0 0 0 No borrow required, so CF = 0
CX < BX 1 0 1 Subtraction requires borrow, so CF = 1
 CMP AL, 01H Compare immediate number 01H with byte in AL
 CMP BH, CL Compare byte in CL with byte in BH
 CMP CX, TEMP Compare word in DS at displacement TEMP with word at CX
XCHG – XCHG Destination, Source

The XCHG instruction exchanges the content of a register with the content of another register or
with the content of memory location(s). It cannot directly exchange the content of two memory
locations. The source and destination must both be of the same type (bytes or words). The
segment registers cannot be used in this instruction. This instruction does not affect any flag.
 XCHG AX, DX Exchange word in AX with word in DX
 XCHG BL, CH Exchange byte in BL with byte in CH
LAHF (COPY LOW BYTE OF FLAG REGISTER TO AH REGISTER)

The LAHF instruction copies the low-byte of the 8086 flag register to AH register. It can then be
pushed onto the stack along with AL by a PUSH AX instruction. LAHF does not affect any flag.
SAHF (COPY AH REGISTER TO LOW BYTE OF FLAG REGISTER)
The SAHF instruction replaces the low-byte of the 8086 flag register with a byte from the AH
register. SAHF changes the flags in lower byte of the flag register.
XLAT / XLATB – TRANSLATE A BYTE IN AL

The XLATB instruction is used to translate a byte from one code (8 bits or less) to another code
(8 bits or less). The instruction replaces a byte in AL register with a byte pointed to by BX in a
lookup table in the memory. Before the XLATB instruction can be executed, the lookup table
containing the values for a new code must be put in memory, and the offset of the starting address
of the lookup table must be loaded in BX. The code byte to be translated is put in AL. The
XLATB instruction adds the byte in AL to the offset of the start of the table in BX. It then copies
the byte from the address pointed to by (BX + AL) back into AL. XLATB instruction does not
affect any flag.
8086 routine to convert ASCII code byte to EBCDIC equivalent: ASCII code byte is in AL at the
start, EBCDIC code in AL after conversion.
 MOV BX, OFFSET EBCDIC Point BX to the start of EBCDIC table in DS
XLATB Replace ASCII in AL with EBCDIC from table.
IN – IN Accumulator, Port
The IN instruction copies data from a port to the AL or AX register. If an 8-bit port is read, the
data will go to AL. If a 16-bit port is read, the data will go to AX.
The IN instruction has two possible formats, fixed port and variable port. For fixed port type, the
8-bit address of a port is specified directly in the instruction. With this form, any one of 256
possible ports can be addressed.
 IN AL, OC8H Input a byte from port OC8H to AL
 IN AX, 34H Input a word from port 34H to AX
For the variable-port form of the IN instruction, the port address is loaded into the DX register
before the IN instruction. Since DX is a 16-bit register, the port address can be any number
between 0000H and FFFFH. Therefore, up to 65,536 ports are addressable in this mode.
 MOV DX, 0FF78H Initialize DX to point to port
IN AL, DX Input a byte from 8-bit port 0FF78H to AL

IN AX, DX Input a word from 16-bit port 0FF78H to AX
The variable-port IN instruction has advantage that the port address can be computed or
dynamically determined in the program. Suppose, for example, that an 8086-based computer
needs to input data from 10 terminals, each having its own port address. Instead of having a
separate procedure to input data from each port, you can write one generalized input procedure
and simply pass the address of the desired port to the procedure in DX.
The IN instruction does not change any flag.
OUT – OUT Port, Accumulator

The OUT instruction copies a byte from AL or a word from AX to the specified port. The OUT
instruction has two possible forms, fixed port and variable port.
For the fixed port form, the 8-bit port address is specified directly in the instruction. With this
form, any one of 256 possible ports can be addressed.
 OUT 3BH, AL Copy the content of AL to port 3BH
 OUT 2CH, AX Copy the content of AX to port 2CH
For variable port form of the OUT instruction, the content of AL or AX will be copied to the port
at an address contained in DX. Therefore, the DX register must be loaded with the desired port
address before this form of the OUT instruction is used.
 MOV DX, 0FFF8H Load desired port address in DX
OUT DX, AL Copy content of AL to port FFF8H

OUT DX, AX Copy content of AX to port FFF8H
The OUT instruction does not affect any flag.
Program:
.MODEL SMALL
.DATA
M1 DB "EVEN NUMBER$"
M2 DB "ODD NUMBER $"
.CODE
.STARTUP
MOV AL,08H
MOV BL,02H
DIV BL
CMP AH,00H
JNZ XYZ
LEA DX,M1
MOV AH,09H
INT 21H
.EXIT
XYZ:
MOV DX, OFFSET M2
MOV AH,09H
INT 21H
.EXIT
Output-
Conclusion: Thus the program for even and odd number is implemented.
EXPERIMENT No.8
AIM–. Write an assembly language program to calculate average of temperatures.
Objectives:
 Describe the Logical Instructions.
 To study and implement the concept of arrays in Assembly Language Programming.
Theory:
LOGICAL INSTRUCTIONS
AND – AND Destination, Source
This instruction ANDs each bit in a source byte or word with the same numbered bit in a
destination byte or word. The result is put in the specified destination. The content of the
specified source is not changed.
The source can be an immediate number, the content of a register, or the content of a memory
location. The destination can be a register or a memory location. The source and the destination
cannot both be memory locations. CF and OF are both 0 after AND. PF, SF, and ZF are updated
by the AND instruction. AF is undefined. PF has meaning only for an 8-bit operand.
 AND CX, [SI] AND word in DS at offset [SI] with word in CX register;
Result in CX register
 AND BH, CL AND byte in CL with byte in BH; Result in BH
 AND BX, 00FFH 00FFH Masks upper byte, leaves lower byte unchanged.
OR – OR Destination, Source
This instruction ORs each bit in a source byte or word with the same numbered bit in a
location. The destination can be a register or a memory location. The source and destination
cannot both be memory locations. CF and OF are both 0 after OR. PF, SF, and ZF are updated by
the OR instruction. AF is undefined. PF has meaning only for an 8-bit operand.
 OR AH, CL CL ORed with AH, result in AH, CL not changed
 OR BP, SI SI ORed with BP, result in BP, SI not changed
 OR SI, BP BP ORed with SI, result in SI, BP not changed
 OR BL, 80H BL ORed with immediate number 80H; sets MSB of BL to 1
XOR – XOR Destination, Source

This instruction Exclusive-ORs each bit in a source byte or word with the same numbered bit in a
location. The destination can be a register or a memory location. The source and destination
cannot both be memory locations. CF and OF are both 0 after XOR. PF, SF, and ZF are updated.
PF has meaning only for an 8-bit operand. AF is undefined.
 XOR CL, BH Byte in BH exclusive-ORed with byte in CL.
Result in CL. BH not changed.

 XOR BP, DI Word in DI exclusive-ORed with word in BP.
Result in BP. DI not changed.
NOT – NOT Destination

The NOT instruction inverts each bit (forms the 1’s complement) of a byte or word in the
specified destination. The destination can be a register or a memory location. This instruction
does not affect any flag.
 NOT BX Complement content or BX register
NEG – NEG Destination

This instruction replaces the number in a destination with its 2’s complement. The destination can
be a register or a memory location. It gives the same result as the invert each bit and add one
algorithm. The NEG instruction updates AF, AF, PF, ZF, and OF.
 NEG AL Replace number in AL with its 2’s complement
 NEG BX Replace number in BX with its 2’s complement
TEST – TEST Destination, Source

This instruction ANDs the byte / word in the specified source with the byte / word in the specified
destination. Flags are updated, but neither operand is changed. The test instruction is often used to
set flags before a Conditional jump instruction.
location. The destination can be a register or a memory location. The source and the destination
cannot both be memory locations. CF and OF are both 0’s after TEST. PF, SF and ZF will be
updated to show the results of the destination. AF is be undefined.
 TEST AL, BH AND BH with AL. No result stored; Update PF, SF, ZF.
 TEST CX, 0001H AND CX with immediate number 0001H;
No result stored; Update PF, SF, ZF

 TEST BP, [BX][DI] AND word are offset [BX][DI] in DS with word in BP.
No result stored. Update PF, SF, and ZF
Program
.MODEL SMALL
.DATA
ARR DB 01H,02H,03H,04H,05H
.CODE
.STARTUP
MOV AX,00H
MOV CL,05H
MOV SI,00H
BACK:
ADD AL, ARR[SI]
INC SI
DEC CL
JNZ BACK
MOV BL,05H
DIV BL
.EXIT
END
Output-
Conclusion: Thus the concept of Arrays are studied and implemented to find average of
temperatures.
EXPERIMENT No.9
AIM : Write an assembly language program to perform sum of digits for 2, 3 digits
Numbers.
Objectives:
 Describe the Rotate and Shift Instructions.
 To implement the Rotate and Shift Instructions to perform sum of digits for 2, 3 digits
Numbers.
Theory:
ROTATE AND SHIFT INSTRUCTIONS
RCL – RCL Destination, Count

This instruction rotates all the bits in a specified word or byte some number of bit positions to the
left. The operation circular because the MSB of the operand is rotated into the carry flag and the
bit in the carry flag is rotated around into LSB of the operand.
For multi-bit rotates, CF will contain the bit most recently rotated out of the MSB.
The destination can be a register or a memory location. If you want to rotate the operand by one
bit position, you can specify this by putting a 1 in the count position of the instruction. To rotate
by more than one bit position, load the desired number into the CL register and put “CL” in the
count position of the instruction.
RCL affects only CF and OF. OF will be a 1 after a single bit RCL if the MSB was changed by
the rotate. OF is undefined after the multi-bit rotate.
 RCL DX, 1 Word in DX 1 bit left, MSB to CF, CF to LSB
 MOV CL, 4 Load the number of bit positions to rotate into CL
RCL SUM [BX], CL Rotate byte or word at effective address SUM [BX] 4 bits left
Original bit 4 now in CF, original CF now in bit 3.
RCR – RCR Destination, Count

This instruction rotates all the bits in a specified word or byte some number of bit positions to the
right. The operation circular because the LSB of the operand is rotated into the carry flag and the
bit in the carry flag is rotate around into MSB of the operand.
For multi-bit rotate, CF will contain the bit most recently rotated out of the LSB.
bit position, you can specify this by putting a 1 in the count position of the instruction. To rotate
more than one bit position, load the desired number into the CL register and put “CL” in the count
position of the instruction.
RCR affects only CF and OF. OF will be a 1 after a single bit RCR if the MSB was changed by
the rotate. OF is undefined after the multi-bit rotate.
 RCR BX, 1 Word in BX right 1 bit, CF to MSB, LSB to CF
 MOV CL, 4 Load CL for rotating 4 bit position
RCR BYTE PTR [BX], 4 Rotate the byte at offset [BX] in DS 4 bit positions right
CF = original bit 3, Bit 4 – original CF.
ROL – ROL Destination, Count

This instruction rotates all the bits in a specified word or byte to the left some number of bit
positions. The data bit rotated out of MSB is circled back into the LSB. It is also copied into CF.
In the case of multiple-bit rotate, CF will contain a copy of the bit most recently moved out of the
MSB.
The destination can be a register or a memory location. If you to want rotate the operand by one
bit position, you can specify this by putting 1 in the count position in the instruction. To rotate
ROL affects only CF and OF. OF will be a 1 after a single bit ROL if the MSB was changed by
the rotate.
 ROL AX, 1 Rotate the word in AX 1 bit position left, MSB to LSB and CF
 MOV CL, 04H Load number of bits to rotate in CL
ROL BL, CL Rotate BL 4 bit positions

 ROL FACTOR [BX], 1 Rotate the word or byte in DS at EA = FACTOR [BX]
by 1 bit position left into CF
ROR – ROR Destination, Count

This instruction rotates all the bits in a specified word or byte some number of bit positions to
right. The operation is desired as a rotate rather than shift, because the bit moved out of the LSB
is rotated around into the MSB. The data bit moved out of the LSB is also copied into CF. In the
case of multiple bit rotates, CF will contain a copy of the bit most recently moved out of the LSB.
bit position, you can specify this by putting 1 in the count position in the instruction. To rotate by
ROR affects only CF and OF. OF will be a 1 after a single bit ROR if the MSB was changed by
the rotate.
 ROR BL, 1 Rotate all bits in BL right 1 bit position LSB to MSB and to CF
 MOV CL, 08H Load CL with number of bit positions to be rotated
ROR WORD PTR [BX], CL Rotate word in DS at offset [BX] 8 bit position right
SAL – SAL Destination, Count

SHL – SHL Destination, Count
SAL and SHL are two mnemonics for the same instruction. This instruction shifts each bit in the
specified destination some number of bit positions to the left. As a bit is shifted out of the LSB
operation, a 0 is put in the LSB position. The MSB will be shifted into CF. In the case of multi-bit
shift, CF will contain the bit most recently shifted out from the MSB. Bits shifted into CF
previously will be lost.
The destination operand can be a byte or a word. It can be in a register or in a memory location. If
you want to shift the operand by one bit position, you can specify this by putting a 1 in the count
position of the instruction. For shifts of more than 1 bit position, load the desired number of shifts
into the CL register, and put “CL” in the count position of the instruction.
The flags are affected as follow: CF contains the bit most recently shifted out from MSB. For a
count of one, OF will be 1 if CF and the current MSB are not the same. For multiple-bit shifts,
OF is undefined. SF and ZF will be updated to reflect the condition of the destination. PF will
have meaning only for an operand in AL. AF is undefined.
 SAL BX, 1 Shift word in BX 1 bit position left, 0 in LSB
 MOV CL, 02h Load desired number of shifts in CL
SAL BP, CL Shift word in BP left CL bit positions, 0 in LSBs

 SAL BYTE PTR [BX], 1 Shift byte in DX at offset [BX] 1 bit position left, 0 in LSB
SAR – SAR Destination, Count

This instruction shifts each bit in the specified destination some number of bit positions to the
right. As a bit is shifted out of the MSB position, a copy of the old MSB is put in the MSB
position. In other words, the sign bit is copied into the MSB. The LSB will be shifted into CF. In
the case of multiple-bit shift, CF will contain the bit most recently shifted out from the LSB. Bits
shifted into CF previously will be lost.
The destination operand can be a byte or a word. It can be in a register or in a memory location. If
you want to shift the operand by one bit position, you can specify this by putting a 1 in the count
position of the instruction. For shifts of more than 1 bit position, load the desired number of shifts
into the CL register, and put “CL” in the count position of the instruction.
The flags are affected as follow: CF contains the bit most recently shifted in from LSB. For a
count of one, OF will be 1 if the two MSBs are not the same. After a multi-bit SAR, OF will be 0.
SF and ZF will be updated to show the condition of the destination. PF will have meaning only
for an 8- bit destination. AF will be undefined after SAR.
 SAR DX, 1 Shift word in DI one bit position right, new MSB = old MSB
 MOV CL, 02H Load desired number of shifts in CL
SHR – SHR Destination, Count
This instruction shifts each bit in the specified destination some number of bit positions to the
right. As a bit is shifted out of the MSB position, a 0 is put in its place. The bit shifted out of the
LSB position goes to CF. In the case of multi-bit shifts, CF will contain the bit most recently
shifted out from the LSB. Bits shifted into CF previously will be lost
The destination operand can be a byte or a word in a register or in a memory location. If you want
to shift the operand by one bit position, you can specify this by putting a 1 in the count position of
the instruction. For shifts of more than 1 bit position, load the desired number of shifts into the
CL register, and put “CL” in the count position of the instruction.
The flags are affected by SHR as follow: CF contains the bit most recently shifted out from LSB.
For a count of one, OF will be 1 if the two MSBs are not both 0’s. For multiple-bit shifts, OF will
be meaningless. SF and ZF will be updated to show the condition of the destination. PF will have
meaning only for an 8-bit destination. AF is undefined.
 SHR BP, 1 Shift word in BP one bit position right, 0 in MSB
 MOV CL, 03H Load desired number of shifts into CL
SHR BYTE PTR [BX] Shift byte in DS at offset [BX] 3 bits right; 0’s in 3 MSBs
Program-
2 Digit Addition
.MODEL SMALL
.DATA
N1 DB 23H
.CODE
.STARTUP
MOV AL,N1
MOV BL,AL
AND AL,0FH
AND BL,0F0H
ROR BL,04H
ADD BL,AL
.EXIT
END
Output-
3 Digit Addition
.MODEL SMALL
.DATA
N1 DW 0234H
.CODE
.STARTUP
MOV AX,N1
MOV BX,AX
MOV CX,AX
AND AX,000FH
AND BX,00F0H
ROR BX,04H
AND CX,0F00H
ROR CX,08H
ADD BX,AX
ADD BX,CX
.EXIT
END
Output
Conclusion: Thus the Rotate and Shift instructions were studied and implemented to perform
sum of digits for 2, 3 digits Numbers.
EXPERIMENT No.10
AIM – Write an assembly language program to perform conversion from two ASCII
no’s to packed BCD.
Objectives:
 To study the concept of ASCII in Assembly Language programming.
 To implement the instructions related to ASCII arithmetic.
Theory:
ASCII Arithmetic
AAA (ASCII ADJUST FOR ADDITION)
Numerical data coming into a computer from a terminal is usually in ASCII code. In this code,
the numbers 0 to 9 are represented by the ASCII codes 30H to 39H. The 8086 allows you to add
the ASCII codes for two decimal digits without masking off the “3” in the upper nibble of each.
After the addition, the AAA instruction is used to make sure the result is the correct unpacked
BCD.
 Let AL = 0011 0101 (ASCII 5), and BL = 0011 1001 (ASCII 9)
ADD AL, BL AL = 0110 1110 (6EH, which is incorrect BCD)

AAA AL = 0000 0100 (unpacked BCD 4)
CF = 1 indicates answer is 14 decimal.
The AAA instruction works only on the AL register. The AAA instruction updates AF and CF; but
OF, PF, SF and ZF are left undefined.
AAS (ASCII ADJUST FOR SUBTRACTION)
Numerical data coming into a computer from a terminal is usually in an ASCII code. In this code
the numbers 0 to 9 are represented by the ASCII codes 30H to 39H. The 8086 allows you to
subtract the ASCII codes for two decimal digits without masking the “3” in the upper nibble of
each. The AAS instruction is then used to make sure the result is the correct unpacked BCD.
 Let AL = 00111001 (39H or ASCII 9), and BL = 00110101 (35H or ASCII 5)
SUB AL, BL AL = 00000100 (BCD 04), and CF = 0

AAS AL = 00000100 (BCD 04), and CF = 0 (no borrow required)
 Let AL = 00110101 (35H or ASCII 5), and BL = 00111001 (39H or ASCII 9)
SUB AL, BL AL = 11111100 (– 4 in 2’s complement form), and CF = 1

AAS AL = 00000100 (BCD 06), and CF = 1 (borrow required)
The AAS instruction works only on the AL register. It updates ZF and CF; but OF, PF, SF, AF are
left undefined.
AAM (BCD ADJUST AFTER MULTIPLY)

Before you can multiply two ASCII digits, you must first mask the upper 4 bit of each. This
leaves unpacked BCD (one BCD digit per byte) in each byte. After the two unpacked BCD digits
are multiplied, the AAM instruction is used to adjust the product to two unpacked BCD digits in
AX. AAM works only after the multiplication of two unpacked BCD bytes, and it works only the
operand in AL. AAM updates PF, SF and ZF but AF; CF and OF are left undefined.
 Let AL = 00000101 (unpacked BCD 5), and BH = 00001001 (unpacked BCD 9)
MUL BH AL x BH: AX = 00000000 00101101 = 002DH
AAM AX = 00000100 00000101 = 0405H (unpacked BCD for 45)
AAD (BCD-TO-BINARY CONVERT BEFORE DIVISION)
AAD converts two unpacked BCD digits in AH and AL to the equivalent binary number in AL.
This adjustment must be made before dividing the two unpacked BCD digits in AX by an
unpacked BCD byte. After the BCD division, AL will contain the unpacked BCD quotient and
AH will contain the unpacked BCD remainder. AAD updates PF, SF and ZF; AF, CF and OF are
left undefined.
 Let AX = 0607 (unpacked BCD for 67 decimal), and CH = 09H
AAD AX = 0043 (43H = 67 decimal)

DIV CH AL = 07; AH = 04; Flags undefined after DIV
If an attempt is made to divide by 0, the 8086 will generate a type 0 interrupt.
Program-
MOV AL,’5’ ;Load ASCII value of ‘5’ to register AL ,i.e AL=35H
MOV BL,’3’ ;Load ASCII value of ‘3’ to register BL, i.e BL=33H
AND AL,0FH ; Perform AND operation of data present in AL with 0Fh
AND BL,0FH ; Perform AND operation of data present in BLwith 0Fh
MOV CL, 04H ;Load 04h to register CL
ROL AL,CL ;Rotate data present in AL four times
ADD AL,BL ;Add AL=AL+BL
Output-
Conclusion: Thus the ASCII arithmetic instructions were studied and implemented.
EXPERIMENT No.11
AIM – Write an assembly language program to perform conversion from
BCD to Hex.
Objectives:
 To study the concept of BCD in Assembly Language programming.
 To implement the instructions related to BCD arithmetic.
Theory:
BCD Arithmetic
DAA (DECIMAL ADJUST AFTER BCD ADDITION)

This instruction is used to make sure the result of adding two packed BCD numbers is adjusted to
be a legal BCD number. The result of the addition must be in AL for DAA to work correctly. If
the lower nibble in AL after an addition is greater than 9 or AF was set by the addition, then the
DAA instruction will add 6 to the lower nibble in AL. If the result in the upper nibble of AL in
now greater than 9 or if the carry flag was set by the addition or correction, then the DAA
instruction will add 60H to AL.
 Let AL = 59 BCD, and BL = 35 BCD
ADD AL, BL AL = 8EH; lower nibble > 9, add 06H to AL

DAA AL = 94 BCD, CF = 0
 Let AL = 88 BCD, and BL = 49 BCD
ADD AL, BL AL = D1H; AF = 1, add 06H to AL

DAA AL = D7H; upper nibble > 9, add 60H to AL
AL = 37 BCD, CF = 1
The DAA instruction updates AF, CF, SF, PF, and ZF; but OF is undefined.
DAS (DECIMAL ADJUST AFTER BCD SUBTRACTION)
This instruction is used after subtracting one packed BCD number from another packed BCD
number, to make sure the result is correct packed BCD. The result of the subtraction must be in
AL for DAS to work correctly. If the lower nibble in AL after a subtraction is greater than 9 or the
AF was set by the subtraction, then the DAS instruction will subtract 6 from the lower nibble AL.
If the result in the upper nibble is now greater than 9 or if the carry flag was set, the DAS
instruction will subtract 60 from AL.
 Let AL = 86 BCD, and BH = 57 BCD
SUB AL, BH AL = 2FH; lower nibble > 9, subtract 06H from AL

AL = 29 BCD, CF = 0
 Let AL = 49 BCD, and BH = 72 BCD
SUB AL, BH AL = D7H; upper nibble > 9, subtract 60H from AL
DAS AL = 77 BCD, CF = 1 (borrow is needed)
The DAS instruction updates AF, CF, SF, PF, and ZF; but OF is undefined.
Program-
MOV BH,35H ; Load value 35h in register BH
MOV AL,47H ; Load value 47h in register BH
ADD AL,BH ; Perform the hex addition that result in AL=7C H
DAA ; since lower nibble >09 , 06h is added to the result ,
; result is 7C + 06 = 82 H
Output
MOV BH,47H
MOV AL,35H
SUB BH,AL
MOV AL,BH
DAS
Output
Conclusion- Thus the BCD arithmetic instructions were studied and implemented.
EXPERIMENT No.12
AIM – To study an assembly language program to interface stepper motor using 8255.
Objectives:
 To study the 8255 IC and interface the stepper motor using 8255.
Theory:
Stepper motor is a device used to obtain an accurate position control of rotating shafts. A stepper
motor employs rotation of its shaft in terms of steps, rather than continuous rotation as in case of
AC or DC motor. To rotate the shaft of the stepper motor, a sequence of pulses is needed to be
applied to the windings of the stepper motor, in proper sequence. The numbers of pulses required
for complete rotation of the shaft of the stepper motor are equal to the number of internal teeth on
its rotor. The stator teeth and the rotor teeth lock with each other to fix a position of the shaft.
With a pulse applied to the winding input, the rotor rotates by one teeth position or an angle x. the
angle x may be calculated as.
x = 3600 / no. of rotor teeth
After the rotation of the shaft through angle x, the rotor locks it self with the next tooth in the
sequence on the internal surface of the stator. The typical schematic of a typical stepper motor
with four windings is as shown below.
The stepper motors have been designed to

work with digital circuits. Binary level pulses of 0-5V are required at its winding inputs to obtain
the rotation of the shafts. The sequence of the pulses can be decided, depending upon the required
motion of the shaft. By suitable sequence of the pulses the motor can be used in three modes of
operation.
 One phase ON (medium torque)

 Two phase ON (high torque)
 Half stepping (low torque)
WORKING:-
8255 is interfaced with 8086 in I/O mapped I/O. port C (PC0, PC1, PC2, PC3) is used to give
pulse sequence to stepper motor. The 8255 provides very less current which will not be able to
drive stepper motor coils so each of the winding of a stepper motor needs to be interfaced using
high speed switching Darlington transistors with max 1A, 80V rating with heat sink, with the
output port of 8255. Output the sequence in correct order to have the desired direction to rotate
the motor.
Assembly Language Program to rotate Stepper Motor in Clockwise direction

MODEL SMALL
.STACK 100
.DATA
PORTA EQU FFC0H ; PORTA ADDRESS
PORTB EQU FFC2H ; PORTB ADDRESS
PORTC EQU FFC4H ; PORTC ADDRESS
CWR EQU FFC6H ; CONTROL PORT ADDRESS
PHASEC EQU 03H
PHASEB EQU 06H ; SEQUENCE IN SERIES TO ROTATE MOTOR
PHASED EQU 0CH ; IN CLOCKWISE DIRECTION
PHASEA EQU 09H
.CODE
START:
MOV AL,@DATA
MOV DX,CTL
OUT DX,AL
AGAIN:
MOV AL,PHASEC
MOV DX,PORTC
OUT DX,AL
MOV CX,0FFFFH
UP:
LOOP UP
MOV AL,PHASEB
MOV DX,PORTC
OUT DX,AL
MOV CX,0FFFFH
UP1:
LOOP UP1
MOV AL,PHASED
MOV DX,PORTC
OUT DX,AL
MOV CX,0FFFFH
UP2:
LOOP UP2
MOV AL,PHASEA
MOV DX,PORTC
OUT DX,AL
MOV CX,0FFFFH
UP3:
LOOP UP3
JMP AGAIN ; REPEATE OUTPUT SEQUENCE
INT 03H
END START
Assembly Language Program to rotate Stepper Motor in Anticlockwise direction

MODEL SMALL
.STACK 100
.DATA
PORTA EQU FFC0H ; PORTA ADDRESS
PORTB EQU FFC2H ; PORTB ADDRESS
PORTC EQU FFC4H ; PORTC ADDRESS
CWR EQU FFC6H ; CONTROL PORT ADDRESS
PHASEC EQU 03H
PHASEA EQU 09H ; SEQUENCE IN SERIES TO ROTATE MOTOR
PHASED EQU 0CH ; IN ANTICLOCKWISE DIRECTION
PHASEB EQU 06H
.CODE
START:
MOV AL,@DATA
MOV DX,CTL
OUT DX,AL
AGAIN:
MOV AL,PHASEC
MOV DX,PORTC
OUT DX,AL
MOV CX,0FFFFH
UP:
LOOP UP
MOV AL,PHASEA
MOV DX,PORTC
OUT DX,AL
MOV CX,0FFFFH
UP1:
LOOP UP1
MOV AL,PHASED
MOV DX,PORTC
OUT DX,AL
MOV CX,0FFFFH
UP2:
LOOP UP2
MOV AL,PHASEB
MOV DX,PORTC
OUT DX,AL
MOV CX,0FFFFH
UP3:
LOOP UP3
JMP AGAIN ; REPEATE OUTPUT SEQUENCE
INT 03H
END START
PROCEDURE:-
1. Connect power supply 5V & GND to both microprocessor trainer kit & Stepper motor
interfacing kit.
2. Connect data bus between microprocessor trainer kit & Stepper motor interfacing kit.
3. Enter the program to rotate Stepper motor in clockwise & anticlockwise.
4. Execute the program by typing GO E000:00C0 ENTER for clockwise, GO E000:0030 ENTER
for anticlockwise.
5. Observe the rotation of stepper motor.
Conclusion: Thus the program and procedure to interface stepper motor using 8255.

Jawaharlal Nehru Engineering College: Laboratory Manual

Uploaded by

Copyright:

Available Formats

Jawaharlal Nehru Engineering College: Laboratory Manual

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Jawaharlal Nehru Engineering College: Laboratory Manual

Uploaded by

Copyright:

Available Formats

Jawaharlal Nehru Engineering College

Second Year Students CSE

 Author JNEC, Aurangabad

Good Luck for your Enjoyable Laboratory Sessions

Dr.Vijaya B.Musande Smita L. Kasar

Department of Computer Science and Engineering

Vision of CSE Department

Mission of the CSE Department:

 Preparing graduates to work on multidisciplinary platforms associated with their

Programme Educational Objectives

Graduates will be able to

1. Engineering knowledge: Apply the knowledge of mathematics, science, engineering

3. Design/development of solutions: Design solutions for complex engineering problems

4. Conduct investigations of complex problems: Use research-based knowledge and

7. Environment and sustainability: Understand the impact of the professional engineering

9. Individual and team work: Function effectively as an individual, and as a member or

10. Communication: Communicate effectively on complex engineering activities with the

1. Study of Emulator for 8086-EMU8086 and Assembly Language

2. Write an assembly language program to perform 8 bit, 16 bit addition.

3. Write an assembly language program to perform 8 bit, 16 bit subtraction.

4. Write an assembly language program to perform negative result subtraction.

5. Write an assembly language program to perform 8 bit, 16 bit Multiplication.

6. Write an assembly language program to perform16 bit by 8 bit division

7. Write an assembly language program to check whether entered number is

8. Write an assembly language program to calculate average of temperatures.

9. Write an assembly language program to perform sum of digits for 2, 3 digits

10. Write an assembly language program to perform conversion from two

ASCII no’s to packed BCD.

11. Write an assembly language program to perform conversion from BCD to

4. Do not change the terminal on which you are working.

6. Strictly observe the instructions given by the teacher/Lab Instructor.

Instruction for Laboratory Teachers::

3. The promptness of submission should be encouraged by way of marking and evaluation

AIM - Study of Emulator for 8086-EMU8086 and Assembly Language

INTRODUCTION TO ASSEMBLY LANGUAGE PROGRAMMING:

There are three levels of programming

ASSEMBLY LANGUAGE PROGRAM DEVELOPMENT TOOLS:

Model Type Description

DB :- Define byte directive stores bytes of data in memory.

SEGMENT :- This directive is to indicate the start of the segment.

AIM: Write an assembly language program to perform 8 bit and 16 bit

General Purpose Registers

Pointer and Index Registers

Data Transfer Instructions

One of the Classical transfer instructions Include the following instruction:

Destination Source Example

Arithmetic Instructions : Addition

ADD – ADD Destination, Source

ADC – ADC Destination, Source

PROGRAM -1 (Using Registers and Immediate Data (Result is with carry))

MOV AL, 0F0H ; Load the value to 0F0H

PROGRAM -2 (Using Registers and Immediate Data (Result is without carry))

MOV AL, 01H ; Load the value to 01H

MOV AL, 01H ; Load the value to 01H

PROGRAM -4 (Using Registers and Memory)

MOV AL, 01H ; Load the value to 01H

MOV AL, 0F0H ; Load the value to 0F0H

Aim: Write an assembly language program to perform 8 bit, 16 bit