Experiment.txt

Experiment No: 02
Experiment Name: Taking user input and printing output, printing output
using newline, printing output using space.
Introduction:
Input and output operations allow interaction between the user and the computer system.
In the 8086 microprocessor, keyboard input and screen output are handled through
software interrupts. Proper formatting of output using spaces and newlines improves
readability. This experiment demonstrates how to take user input and display output using
space and newline characters.
Description :
● User input is taken through keyboard using DOS interrupt services.
● Output is displayed using DOS interrupt functions.
● Space character is printed using ASCII value 32.
● Newline is created using Carriage Return 10 and Line Feed 13.
● Registers such as AX,BX, DX, and AH are used for input-output operations.
Taking Input and Printing Output:
Code:
.model small
.stack 100h
.code
main proc
mov ah,1
int 21h
mov bl,al
mov ah,2
mov dl,bl
int 21h
mov ah,4Ch
int 21h
main endp
end main
Output:
Taking Input and Printing Output with new line:
Code:
.model small
.stack 100h
.code
main proc
mov ah,1
int 21h
mov bl,al
mov ah,2
mov dl,10
int 21h
mov ah,2
mov dl,13
int 21h
mov ah,2
mov dl,bl
int 21h
mov ah,4Ch
int 21h
main endp
end main
Output:
Taking Input and Printing Output with space:
Code:
.model small
.stack 100h
.code
main proc
mov ah,1
int 21h
mov bl,al
mov ah,2
mov dl,32
int 21h
mov ah,2
mov dl,bl
int 21h
mov ah,4Ch
int 21h
main endp
end main
Output:
Conclusion:
In this experiment, user input was successfully taken and displayed with proper
formatting using space and newline characters. The experiment enhanced understanding
of keyboard input handling, output display, and formatted printing using ASCII control
characters in the 8086 microprocessor.



Experiment No: 03
Experiment Name: Implementing addition, subtraction,
multiplication and division in assembly language
Introduction:
Arithmetic instructions in the 8086 microprocessor allow manipulation of numeric data at the
register and memory level. These operations form the foundation of computational logic in
low-level programming.
The primary arithmetic instructions are:
● ADD → Addition
● SUB → Subtraction
● MUL → Unsigned multiplication
● DIV → Unsigned division
In this experiment, arithmetic operations are performed on 8-bit numbers. The result is displayed
in hexadecimal format using DOS interrupt 21h, following the same printing structure used in
the previous experiment.
Code:
Addition
.model small
.stack 100h
.data
num1 db 14h
num2 db 05h
msg db 'Result = $'
.code
main proc
mov ax, @data
mov ds,ax
; Print message
mov dx, offset msg
mov ah, 09
int 21h
; ---------------- ADDITION ----------------
mov al, num1
add al, num2
mov bl, al
; -------- PRINT HIGH NIBBLE --------
mov al, bl
shr al,4
call print_hex
; -------- PRINT LOW NIBBLE --------
mov al, bl
and al, 0Fh
call print_hex
; EXIT
mov ah, 4Ch
int 21h
main endp
;-------------------------------------------
; PRINTS hex digit in AL (0–15)
;-------------------------------------------
print_hex proc
add al, 48
cmp al, 57
jbe out
add al, 7
out:
mov dl, al
mov ah, 02h
int 21h
ret
print_hex endp
end main
Output:
Substraction
; ---------------- SUBTRACTION ----------------
mov al, num1
sub al, num2
mov bl, al
Output:
Multiplication
; ---------------- MULTIPLICATION ----------------
mov al, num1
mov ah, 00h
mov cl, num2
mul cl ; AX = AL × CL
mov bl, al ; lower byte
Output:
Division
; ---------------- DIVISION ----------------
mov ax, 0000h
mov al, num1
mov cl, num2
div cl ; AL = quotient, AH = remainder
mov bl, al
Output:
Explanation of Output:
Given:
num1 = 14h
num2 = 05h
Addition:
14h + 05h = 19h
Output:
Result = 19
Operation Calculation (Hex) Result
Addition 14h + 05h 19h
Subtraction 14h – 05h 0Fh
Multiplication 14h × 05h 64h
Division 14h ÷ 05h 04h
Conclusion:
This experiment demonstrates arithmetic operations using 8086 assembly
language instructions. The ADD, SUB, MUL, and DIV instructions enable basic
numeric computation at the hardware level.
Key Observations:
● ADD and SUB directly modify the destination register.
● MUL stores the result in AX (AL × operand).
● DIV stores quotient in AL and remainder in AH.
● Proper register preparation is essential before multiplication and division.
Understanding arithmetic instructions is fundamental for low-level programming,
embedded systems, operating systems development, and performance-critical
applications.





Experiment No: 04
Experiment Name: Implementing Logical (AND, OR, NOT), Shift
(Left, Right) and Rotate Operations in 8086 Assembly Language
Introduction:
Logical, shift, and rotate instructions are fundamental bitwise operations in the 8086
microprocessor. These instructions manipulate data at the bit level and are widely used in
low-level programming, cryptography, embedded systems, and performance-critical
routines.
● Logical Operations
○ AND → Performs bitwise conjunction.
○ OR → Performs bitwise disjunction.
○ NOT → Performs bitwise complement.
● Shift Operations
○ SHL (Shift Left) → Multiplies by 2 for each shift.
○ SHR (Shift Right) → Divides by 2 for each shift (unsigned).
● Rotate Operations
○ ROL (Rotate Left) → Rotates bits left without loss.
○ ROR (Rotate Right) → Rotates bits right without loss.
In this experiment, logical AND operation is implemented on an 8-bit number. The result
is displayed in hexadecimal format using DOS interrupt 21h.
Code:
AND
.model small
.stack 100h
.data
num db 017h
msg db 'Result = $'
.code
main proc
mov ax, @data
mov ds,ax
;Print message
mov dx, offset msg
mov ah, 09
int 21h
;AND operation
mov al, num
and al, 01h
mov bl, al
; ----------------PRINT HIGH Nibble------------------
mov al, bl
shr al,4
call print_hex
;-----------------PRINT LOW Nibble-------------------
mov al, bl
and al, 0Fh
call print_hex
;EXIT
mov ah, 4Ch
int 21h
main endp
;-------------------------------------------
; PRINTS hex digit in al (0u15)
;-------------------------------------------
print_hex proc
add al, 48
cmp al, 57
jbe out
add al, 7
out:
mov dl, al
mov ah, 02h
int 21h
ret
print_hex endp
end main
Output:
OR
;OR operation
mov al, num
or al, 01h
mov bl, al
Output:
NOT
;NOT operation
mov al, num
not al
mov bl, al
Output:
Shift Right
; SHR operation
mov al, num
shr al, 1
mov bl, al
Output:
Shift Left
; SHL operation
mov al, num
shl al, 1
mov bl, al
Output:
Rotate Left
; SHR operation
mov al, num
rol al, 1
mov bl, al
Output:
Rotate Right
; SHR operation
mov al, num
ror al, 1
mov bl, al
Output:
Explanation of Output:
Explanation of Output:
● AND
Initial value: num = 17h
AND with: 01h
17h Binary: 0001 0111
1h Binary: 0000 0001
-----------------------------
AND 0000 0001
● OR
Initial value: num = 17h
OR with: 01h
17h Binary: 0001 0111
1h Binary: 0000 0001
-----------------------------
OR 0001 0111
● NOT
Initial value: num = 17h
17h Binary: 0001 0111
-----------------------------
NOT 1110 1000
● SHIFT LEFT (SHL 1)
Initial value: num = 17h
17h Binary: 0001 0111
-----------------------------
SHL 0010 1110
● SHIFT RIGHT (SHR 1)
Initial value: num = 17h
17h Binary: 0001 0111
-----------------------------
SHR 0000 1011
● ROTATE LEFT (ROL 1)
Initial value: num = 17h
17h Binary: 0001 0111
-----------------------------
ROL 0010 1110
● ROTATE RIGHT (ROR 1)
Initial value: num = 17h
17h Binary: 0001 0111
-----------------------------
ROR 1000 1011
The program prints the result in hexadecimal format using nibble separation (high nibble
and low nibble).
Conclusion:
This experiment demonstrates how logical operations such as AND can be implemented
using 8086 assembly language. The bitwise AND operation isolates specific bits of a
number. Additionally, shift (SHL, SHR) and rotate (ROL, ROR) instructions are essential
for bit manipulation, arithmetic optimizations, and low-level system programming.
Understanding these instructions strengthens knowledge of:
● Bit-level data manipulation
● Flag behavior in 8086
● Efficient arithmetic transformations
● Foundations of cryptographic and embedded system logic
Hence, logical, shift, and rotate instructions are crucial tools in assembly-level
programming and hardware-near computation.





Experiment No: 05
Experiment Name: Assembly Language Programming –
Addition of n numbers using loop.
Introduction:
Looping and indexed addressing are essential concepts in assembly language programming.
The 8086 microprocessor provides the LOOP instruction, which automatically decrements the CX
register and continues execution until CX = 0.
In this experiment:
● An array of 10 word-sized integers is stored in memory.
● The program calculates the total sum using indexed addressing (SI register).
● The LOOP instruction is used to iterate through the array.
● The final sum is converted into decimal digits and displayed using DOS interrupt 21h.
This experiment demonstrates:
● Use of CX as loop counter
● Indexed memory access using SI
● Arithmetic accumulation
● Basic decimal output conversion
Code:
.model small
.stack 100h
.data
n dw 10
number dw 1,2,3,4,5,6,7,8,9,10
sum dw 0
.code
main proc
mov ax, @data
mov ds, ax
mov cx, n ; initializing count register
lea si, number ; load address of array
xor ax, ax ; clear AX (sum accumulator)
; loop
start_loop:
add ax, [si] ; add current array element
add si, 2 ; move to next word (2 bytes)
loop start_loop
mov sum, ax ; store total sum
mov bx, 10
xor dx, dx
div bx ; AX ÷ 10 (AL = tens, DX = remainder)
mov cx, dx ; store remainder (units digit)
; print tens value
add al, '0'
mov dl, al
mov ah, 02h
int 21h
; print units value
add cl, '0'
mov dl, cl
mov ah, 02h
int 21h
main endp
end main
Output:
Explanation:
Step 1: Array Elements
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
Step 2: Summation
Total Sum = 55
Step 3: Division for Decimal Output
The sum (55) is divided by 10:
55 ÷ 10
Quotient = 5
Remainder = 5
● Quotient → Tens digit
● Remainder → Units digit
ASCII conversion is done by adding '0' before printing.
Conclusion:
This experiment successfully demonstrates how to:
● Use the LOOP instruction for controlled iteration.
● Access array elements using indexed addressing (SI).
● Accumulate values using the accumulator register (AX).
● Convert binary values to decimal digits for display.
The program correctly calculates the sum of the first 10 natural numbers and outputs 55.
This experiment strengthens understanding of:
● Memory addressing modes
● Loop control using CX
● Arithmetic processing in registers
● Basic number-to-ASCII conversion techniques
Such techniques are fundamental in system-level programming and embedded software
development.




Experiment No: 06
Experiment Name: Take 2 inputs and print if they are greater
than, less than or equal
Introduction:
Decision-making is an important concept in programming where a program must
choose different actions based on conditions. In the 8086 microprocessor, comparison
between two values is performed using the CMP instruction, which subtracts one
operand from another without storing the result but updates the status flags.
After comparison, conditional jump instructions such as JG (Jump if Greater), JL
(Jump if Less), and JE (Jump if Equal) are used to determine the relationship
between the two numbers. These instructions check the processor flags and transfer
program control accordingly.
In this experiment, two numbers are taken as input and compared. The program then
prints whether the first number is greater than, less than, or equal to the second
number using DOS interrupt services.
Code:
;01.03.2026
.model small
.stack 100h
.data
msg1 db "Enter First Number A: $"
msg2 db "Enter Second Number B: $"
agreater db "A is greater than B $"
bgreater db "B is greater than A $"
abequal db "A is equal to B $"
.code
main proc
mov ax, @data
mov ds, ax
;print first message
mov ah, 09h
lea dx, msg1
int 21h
;Take First Input
mov ah, 1
int 21h
mov bl, al
;print Carriage Return
mov ah, 02h
mov dl, 0Dh
int 21h
;print New Line
mov ah, 02h
mov dl, 0Ah
int 21h
;print Second message
mov ah, 09h
lea dx, msg2
int 21h
;Take Second Input
mov ah, 1
int 21h
mov cl, al
;print Carriage Return
mov ah, 02h
mov dl, 0Dh
int 21h
;print New Line
mov ah, 02h
mov dl, 0Ah
int 21h
;Compare bl and cl
cmp bl, cl
ja acheck
jb bcheck
jmp equal
acheck:
mov ah, 09h
lea dx, agreater
int 21h
jmp exit
bcheck:
mov ah, 09h
lea dx, bgreater
int 21h
jmp exit
equal:
mov ah, 09h
lea dx, abequal
int 21h
jmp exit
exit:
mov ah, 4ch
mov al, 00
int 21h
main endp
end main
Output:
Example 1
Input:
First number = 5
Second number = 3
Comparison: 5 > 3
Output:
Example 2
Input:
First number = 2
Second number = 7
Comparison: 2 < 7
Output:
Example 3
Input:
First number = 4
Second number = 4
Comparison: 4 = 4
Output:
Conclusion:
This experiment demonstrates how two numbers can be compared in 8086 assembly
language using the CMP instruction and conditional jumps. The program successfully
determines whether one value is greater than, less than, or equal to another. This
concept is fundamental for implementing decision-making logic, conditional branching,
and control flow in assembly-level programming.





Experiment No: 07
Experiment Name: Find the smallest among 3 numbers
Introduction:
In programming, comparing multiple values is a common task used to determine the
minimum or maximum value among them. In the 8086 microprocessor, comparison
operations are performed using the CMP instruction, which updates the processor flags
based on the result. Using these flags, conditional jump instructions such as JL (Jump if
Less) or JG (Jump if Greater) can direct the program flow to the appropriate section.
In this experiment, three numbers A, B, and C are taken as input from the user. The
program compares these values step by step and determines which number is the
smallest. Conditional jumps are used after each comparison to identify the minimum
value and display the result.
Code:
.model small
.stack 100h
.data
msg1 db "Enter the value of A = $"
msg2 db "Enter the value of B = $"
msg3 db "Enter the value of C = $"
small db "The smallest number is = $"
.code
main proc
mov ax, @data
mov ds, ax
;print first message
mov ah, 09h
lea dx, msg1
int 21h
;Take First Input
mov ah, 1
int 21h
mov bl, al
;print Carriage Return
mov ah, 02h
mov dl, 0Dh
int 21h
;print New Line
mov ah, 02h
mov dl, 0Ah
int 21h
;print Second message
mov ah, 09h
lea dx, msg2
int 21h
;Take Second Input
mov ah, 1
int 21h
mov cl, al
;print Carriage Return
mov ah, 02h
mov dl, 0Dh
int 21h
;print New Line
mov ah, 02h
mov dl, 0Ah
int 21h
;print Third message
mov ah, 09h
lea dx, msg3
int 21h
;Take Third Input
mov ah, 1
int 21h
mov bh, al
;print Carriage Return
mov ah, 02h
mov dl, 0Dh
int 21h
;print New Line
mov ah, 02h
mov dl, 0Ah
int 21h
;Compare A and B
mov al, bl
cmp al, cl
jle checkA
;B < A
mov al, cl
cmp al, bh
jle showB
jmp showC
checkA:
cmp al, bh
jle showA
jmp showC
showA:
mov ah, 09h
lea dx, small
int 21h
mov ah, 02h
mov dl, bl
int 21h
jmp exit
showB:
mov ah, 09h
lea dx, small
int 21h
mov ah, 02h
mov dl, cl
int 21h
jmp exit
showC:
mov ah, 09h
lea dx, small
int 21h
mov ah, 02h
mov dl, bh
int 21h
exit:
mov ah, 4ch
mov al, 00
int 21h
main endp
end main
Output:
Output Generation:
The program first takes three inputs from the user and stores them in registers. It then
compares A with B using the CMP instruction. The smaller value is then compared with
C. Based on the results of these comparisons and the processor flags, conditional jump
instructions direct the program to display the smallest number.
Conclusion:
This experiment demonstrates how multiple comparisons and conditional jumps can be
used in the 8086 microprocessor to determine the smallest value among several inputs.
It helps in understanding decision-making logic and the use of comparison instructions
in assembly language programming.




Experiment No: 08
Experiment Name: Conversion of capital letter to small
letter and vise-versa.
Introduction:
In programming, character manipulation is essential when working with text data. In the
8086 microprocessor, characters are represented using ASCII codes. The difference
between uppercase and lowercase English letters is 32 in decimal.
For example, the ASCII value of 'A' becomes 'a' by adding 32, and 'a' becomes 'A' by
subtracting 32.
In this experiment, a character is taken as input from the user. The program checks
whether the character is uppercase or lowercase using comparison instructions. If it is
uppercase, 32 is added to convert it into lowercase. If it is lowercase, 32 is subtracted to
convert it into uppercase. Conditional jump instructions are used to control the flow and
display the converted result.
Code:
.model small
.stack 100h
.data
text db 'Input a letter: $'
output db 0Dh,0Ah,'After conversion: $'
.code
main proc
mov ax, @data
mov ds, ax
mov ah, 09h
lea dx, text
int 21h
; input
mov ah, 01h
int 21h
mov cl, al
; uppercase check
cmp cl, 'A'
jl lower_check
cmp cl, 'Z'
jg lower_check
; convert to lowercase
add cl, 32
jmp show_result
lower_check:
; lowercase check
cmp cl, 'a'
jl show_result
cmp cl, 'z'
jg show_result
; convert to uppercase
sub cl, 32
show_result:
; output text
mov ah, 09h
lea dx, output
int 21h
; print character
mov dl, cl
mov ah, 02h
int 21h
mov ah, 4Ch
mov al, 00
int 21h
main endp
end main
Output:
Output Generation:
The program first prompts the user to enter a character and stores it in a register. It then
checks whether the character lies within the ASCII range of uppercase letters ('A'–'Z'). If
true, it adds 32 to convert it to lowercase.
If the character is not uppercase, the program checks whether it lies within the range of
lowercase letters ('a'–'z'). If true, it subtracts 32 to convert it to uppercase.
If the input character does not fall into either category, it remains unchanged. Finally, the
converted character is displayed using DOS interrupt services.
Conclusion:
This experiment demonstrates how ASCII values can be used for character
manipulation in the 8086 microprocessor. It shows the use of comparison instructions
and conditional jumps to determine character type and perform appropriate conversion.
This concept is fundamental in text processing and low-level programming.