Beruflich Dokumente
Kultur Dokumente
2013A7PS101H
GROUP NO:4
WEDNESDAY 2 PM - 4 PM
Experiment - 1
ASM 1.1
Store two 8 bit numbers in CL and DL. Add them and save the result in CL
ASM Program
MOV CL,23H;
MOV DL,46H;
ADD CL,DL;
INT 03H;
Results
CX = 0069
DX = 0046
Conclusion
As we know format of MOV instruction is MOV destination , source and
format of ADD instruction is ADD destination , source and the result of
addition is stored in destination address or register. So in the above ASM
we first stored 23H and 46H in CL and DL respectively using MOV
instruction and after ADD instruction the result is stored in CX or CL
depending on the numbers given to add in our case CL is sucient to
store result that is 0069H.
ASM - 1.2
Store two 16 bit numbers in AX and BX. Add them and save result in AX
ASM Program
MOV AX,2345H
MOV BX,4000H
ADD AX,BX
INT 03H
Results
AX = 6345
BX = 4000
Conclusion
This is similar to first ASM the only dierences are here we are storing 16
bit numbers instead of 8 bit numbers in AX , BX the result is stored in AX ,
as the instruction is ADD AX , BX according to the values given that is
6345H
ASM - 1.3
Store two 8 bit numbers in CL and DL. Subtract DL from CL and save
result in CL
ASM Program
MOV CL,46H
MOV DL,22H
SUB CL,DL
INT 03H
Results
CX = 0024
DX = 0022
Conclusion
The format of SUB instruction is SUB destination , source , the source
value is subtracted from destination and the result value is stored in
destination , In our case as DL should be subtracted from CL and the
result should be stored in CL we give instruction as SUB CL , DL as per
given values after subtraction the result is stored in destination that is CX =
0024H
ASM - 1.4
Store two 16 bit numbers in BX and CX. Subtract CX from BX and save
result in AX
ASM Program
MOV BX,2345H
MOV CX,0AAAAH
SUB BX,CX
MOV AX,BX
INT 03H
Results
AX = 789B
BX = 789B
CX = AAAA
Conclusion
This is similar to 8 bit subtraction here the numbers are 16 bits and stored
in BX , CX after subtraction results should be stored in AX . As we subtract
CX from BX the result is stored in BX but we need the result to be in AX so
we use MOV instruction to transfer the value in BX to AX. So according to
given values the result is 789B stored in BX and after MOV instruction AX
value also becomes 789B
ASM - 1.5
Store two 8 bit numbers in AL and BL. Multiply AL and BL and save result
in AX.
ASM Program
MOV AL,22H
MOV BL,09H
MUL BL
INT 03H
Results
AX = 0132
Conclusion
Here we need to multiply two 8 bit numbers. The format of MUL
instruction is MUL multiplier, the multiplier is multiplied by AL or AX or EAX
depending on the multiplier. Here multiplier is BL so it is multiplied with the
value in AL as we are multiplying two 8 bit numbers we can get maximum
16 bits result it is stored in AX that is 0132H in our case.
ASM - 1.6
Store two 16 bit numbers in AX and BX. Multiply AX and BX and save
result in CX and DX.
ASM Program
MOV BX,1234H
MOV AX,4321H
MUL BX
MOV CX,AX
INT 03H
Results
AX = F4B4
BX = 1234
CX = F4B4
DX = 04C5
Conclusion
Here we are multiplying two 16 bit numbers in AX , BX. When we multiply
two 16 bit numbers we can get maximum 32 bit number. The lower 16 bits
are stored in AX and higher 16 bits are stored in DX. According to the
question we need lower 16 bits in CX so we use MOV instruction to
transfer higher 16 bit value in AX to CX. Therefore the final value in our
case is CX = F4B4H the lower 16 bits and DX = 0465H the higher 16 bits.
ASM - 1.7
Store two 8 bit numbers in AL and BL. Divide AL by BL and save results in
registers of your choice.
ASM Program
MOV AL,24H
MOV BL,06H
DIV BL
INT 03H
Results
AX = 0006H
BX = 0006H
Remainder = 00H
Quotient = 06H
Conclusion
The format of DIV instruction is DIV source this divides Axor DX-AX by the
source where source can be register or memory location. In this case we
divide a word by a byte that is DIV BL that divides AX by the byte in BL
quotient is stored in AL and remainder is stored in AH.
ASM - 1.8
Store two 16 bit numbers in AX and BX. Divide AX by BX and save result in
registers of your choice
ASM Program
MOV AX,0210H
MOV BX,0020H
MOV DX,0000H
DIV BX
INT 03H
Results
AX = 0010H
BX = 0020H
DX = 0010H
Remainder = 0010H
Quotient = 0010H
Conclusion
This is similar to 8 bit division but here we use DIV BX that is divides the
double word in DX-AX by the word in BX. The quotient is stored in AX and
remainder is stored in DX.
Experiment - 2
ASM 2
An array of N words is stored in a data segment as an array. The count of
words N is also stored as a byte. Compute the average of the N
numbers and store the result in memory at location Average
Output: Average
ASM Program
MOV AX,0000H
MOV SI,3000H
MOV CX,[5000H]
MOV BX,CX
CLC
INC SI
INC SI
DEC CX
JNZ X1
DIV BX
INT 03H
Results
Number of words = 4;
Average = 0028H
Conclusion
Here we need to take array of words and find their average so first we start
array at address 3000H we take all the words whose average should be
found and also the count of number of words in CX at address 5000H. We
write a loop to repeat CX times in that we add the value in the address [SI]
to AX and SI is increased to point next word, CX is decreased when CX is
equal to ZERO the loop stops and the value in AX is divided by BX which
is the count of number of words. The result quotient is stored in AX and
remainder is stored in DX
ASM 3
We have to find the approximate Fahrenheit temperature for a given
Celsius value. The Fahrenheit temperature is store in fixed point format in
two bytes. The input Centigrade temp is 0 to 100 degrees. Using a lookup
table method to convert the Celsius to Fahrenheit .
10
ASM Program
MOV AX,0000H
MOV AL,[5000H]
MOV BX,4000H
XLATB
INT 03H
Results
LooK up Table
4000 - 0020H
4005 - 0029H
4010 - 0032H
4015 - 003BH
4020 - 0044H
Conclusion
Here we use XLATB and a lookup table first we enter the fahrenheit value
corresponding to the oset value considered as celsius value now in our
program we use XLATB which goes to this lookup table and sees the
11
Experiment - 3
ASM 4
Sort an array of 16 bit signed binary numbers so that they are arranged in
ascending order.
Input: N=count.
ASM Program
MOV DX, 0005H
MOV CX, DX
DEC DX
JZ X4
MOV BX, [SI+2]
CMP AX,BX
JL X2
XCHG AX, [SI+2]
XCHG AX, [SI]
X2: INC SI
INC SI
DEC CX
JNZ X1
JZ X3
Results
Array is 0009H, 0001H, 0006H, 0004H, 0002H at address starting from
4000H
12
Conclusion
Here we use the Bubble sort technique to sort the array of binary numbers
in ascending order we compare every element with the numbers in the
array next to it if the number is smaller than the number with which we are
13
ASM 5
A company makes several parts. Each part is coded as below. The code is
16 bit width with 4 bits for model umber and 4 bits for part number and 8
bits for serial number. Find the total number of items with part number = 5.
ASM Program
MOV DX, 0005H
MOV SI,4000H
AND AH, 0FH
CMP AH,DL
JE X2
X3: INC SI
INC SI
DEC BX
JNZ X1
INT 03H
X2: INC CX
JNZ X3
14
Results
Item Count = 5
Conclusion
Here we iterate through every element and first copy the value into AX now
we mash AH with 0FH by doing an AND operation with AH and 0FH so by
doing AND with 0FH we get the part number in AH now we increment CX if
the part value AH is equal to 5. By performing this loop for every element
we get the count of number of Codes with part number equal to 5.
Experiment - 4
ASM 6
Write a program to reverse the given string and store at the same location.
No additional memory is to be used.
15
ASM Program
MOV SI,4000H
MOV CX,[5000H]
DEC CX
MOV DI,SI
ADD DI,CX
MOV BL,[DI]
MOV [SI],BL
MOV [DI],AL
INC SI
DEC DI
CMP SI,DI
JL X1
INT 03H
Results
Reversed String FF BF B2 A5 E5 55 CD 32 AB 45
Conclusion
Here we swap first and last word and then second and last but one word
and so on.. by doing this the half times the number of words in string we
reverse the string
16
ASM 7
Write a program using the LOOP instruction with indirect addressing that
copies a string from source to target, reversing the character order in the
process.
ASM Program
MOV SI,4000H
MOV DI,5000H
MOV CX,[6000H]
DEC CX
ADD DI,CX
INC CX
X1 :CLD
LODSB
STD
STOSB
LOOP X1
INT 03H
Results
Input string at address 4000H is FF BF B2 A5 E5 55 CD 32 AB 45
17
Conclusion
Here first we go to the end of the source string and start copying from
there to the destination string address by executing this loop the number
of times of length of string the loop will be reversed and stored in
destination address.
Experiment - 5
INT-1
Press the KB INT key on your kit for some time and release. The kit has
to display on the LCD panel the number of seconds you kept the key
pressed. Use the interrupt provided with this key and develop the
program.
ASM Program
Interrupt program
MOV BX, 0000H
MOV [SI],AX
MOV [SI],AX
HERE:
CMP CX, 0000H
JE HERE
CALL DEBOUNCE
MOV ES, AX
CALL 0FE00H:0013H
JMP COUNT
DEBOUNCE:
18
LOOP DEBOUNCE
RET
COUNT:
CMP CX, 0000H
JNE DOWN
INC BX
CMP BX, 0FFFFH
JNE DOWN1
INC SI
MOV BX,0000H
DOWN1:
JMP COUNT
DOWN:
MOV AX, 0000H
MOV ES, AX
MOV AX,5000H
CALL 0FE00H:0013H
INT 03H
ISR program
MOV CX,0FFFH
IRET
Conclusion
Here we use interrupts and interrupt service routines to record the time we
kept the key pressed we store it in BX there are two cases when the time
limit exceeds the maximum value in BX it again goes to 0000H and starts
to increase again for every second
Results
Case(1)
Case(2)
Case(3)
SI: 0004H
SI: 0000H
SI:0013H
19
Experiment - 6
The speed of a stepper motor has to be controlled by KBINT key. The
motor starts when KBINT is pressed and speed increases gradually to
maximum when key is pressed. When the key is released speed comes
down to zero gradually. Set the speed, maximum limits as per your choice.
20
ASMProgram
ORG 2000H
MOV SI, 0008H
MOV AX, 3000H
MOV [SI], AX
MOV SI, 000AH
MOV AX, 0000H
MOV [SI], AX
MOV AX, 0000H
MOV ES, AX
MOV DX, 0FFE6H
MOV AL, 80H
OUT DX, AL
MOV CX, 0H
MOV BX, 0000H
MOV DI, 0810H
MOV AL, 11H
MOV DX, 0FFE0H
R1:
OUT DX, AL
CALL DELAY
ROL AL, 1H
JMP R1
DELAY:
CMP BL, 01H
JNE DOWN1
MOV BL, 00H
CALL DEBOUNCE
CMP DI, 0400H
JL INCR
CMP DI, 0D00H
JG DECR
JMP COMP
INCR:
MOV BH, 00H
JMP COMP
21
DECR:
MOV BH, 01H
COMP:
CMP BH, 00H
JE AD
SUB DI, 0100H
JMP DOWN1
AD:
ADD DI, 0100H
DOWN1:
MOV CX, DI
HERE:
LOOP HERE
RET
DEBOUNCE:
MOV CX, 0FFFH
DEBOUNCE1: LOOP DEBOUNCE1
RET
ISR program
MOV BL, 01H
IRET
Result
Here we observe that when we press KBINT the stepper motor speed
increases.
Conclusion
Here we use interrupts and interrupt service routine to control the speed of
Stepper motor.
22
Experiment - 7
Design a system to control trac lights. The trac light should be
controlled in such a way that
It will allow the trac from west to east and east to west transition for
some fixed delay.
It will allow the trac from north to south and south to north for some
fixed delay.
ASMProgram
ORG 2000H
MOV DX,0FFE6H
OUT DX,AL
MOV DX,0FFE0H
OUT DX,AL
INC BX
ADD DX,2
MOV AL,[BX]
OUT DX,AL
INC BX
ADD DX,2
MOV AL,[BX]
OUT DX,AL
INC BX
CALL DELAY
MOV AL,[BX]
CMP AL,00H
JNZ NEXTST
JMP AGAIN
DLY5: PUSH CX
23
MOV CX,03FFH
DLY10: NOP
LOOP DLY10
POP CX
LOOP DLY5
RET
Results
At address 3000H 18H, 18H, 0A5H at stage 1
Conclusion
First we initialize 8255 to Mode - 0 and make all ports to output and set
the values of ports to the signals according to which we needed in the
address 3000H as per our program we also write a subroutine for using
delay between changing the color of lights of trac controller.Here we see
a real life scenario i.e trac lights controlling
Experiment - 8
Seven segment display.
ASMProgram
MOV DX, 0FFE6H
MOV AL,80H
OUT DX,AL
MOV SI,3000H
MOV CL,04H
MOV AL,[SI]
INC SI
LOOP1:
ROL AL,1
MOV DX,0FFE2H
OUT DX,AL
24
MOV AH,AL
MOV AL,01H
MOV DX,0FFE4H
OUT DX,AL
DEC AL
OUT DX,AL
MOV AL,AH
DEC BL
JNZ LOOP1
DEC CL
JNZ LOOP2
INT 03H
Results
S 3000 - 83
S 3001 - 8C
S 3002 - 8B
S 3003 - C6
Displays BPHC
S 3000 - 82
S 3001 - C0
S 3002 - 88
S 3003 - 87
Displays GOAT
S 3000 - 82
S 3001 - C0
S 3002 - A1
S 3003 - 92
Displays GODS
Conclusion
Here first we initialize 8255 and give the values we want to display to a, b,
c, d, e ,f ,g in active low mode so we need to give 0 to display LED This
helps us to interface 8255 with Seven segment display
25
26