Central Women’s University
Lab Report: 02
Course Title: Microprocessor and Micro Controller Sessional
Course Code: CSE-334
Submitted By:
Afrina Sultana
ID: 2018-1-17-016
Department of Computer Science and Engineering
Submitted To:
Ayesha Siddiqua
Lecturer
Department of CSE, CWU
Submission Date: 21-10-2020
Introduction: In this lab we have discussed one program of our previous lab and
also worked with new instructions and OPCODES. The programs that I learnt in
this lab are OR, AND, XOR implementations, how to check password, swap
values etc.
Question: 05
Write a program to print triangle of star using assembly language.
Source Code:
.MODEL SMALL
.STACK 100H
.CODE
MAIN PROC
MOV CX, 4
LEVEL1:
MOV BX, CX
LEVEL2:
MOV AH, 2
MOV DL, '*'
INT 21H
LOOP LEVEL2
1
MOV AH, 2
MOV DL, 10
INT 21H
MOV DL, 13
INT 21H
MOV CX, BX
LOOP LEVEL1
EXIT:
MOV AH, 4CH
INT 21H
MAIN ENDP
END MAIN
Output:
2
****
***
**
Explanation: In this code the first three lines,
.MODEL SMALL
.STACK 100H
.CODE
Work as header files.
MAIN PROC is the main function for this program where PROC stands for
procedure.
MOV CX, 4: Here we have used CX for a loop which decides that the triangle will
have 4 lines.
We’ll declare our first level like this:
LEVEL1:
MOV BX, CX
Here we have copied the value 4 into BX. This level basically controls the outer
loop of the triangle.
3
Then we write the instructions,
LEVEL2: This is our second level.
MOV AH, 2
MOV DL, '*'
INT 21H
This level controls the inner loop of the triangle. To print the asterisk we have to
use the display register.
LOOP LEVEL2: This instruction means that the instruction will execute till
LEVEL2. The loop will get back to LEVEL2 after executing a loop and also it
decreases the value of the loop by one every time.
Then we use the instructions to print a new line.
Now we write the lines,
MOV CX, BX
Here the value of BX will be copied into CX.
LOOP LEVEL1: Here the new CX value will be decreased and it will go to
LEVEL1.
To end our program we write,
EXIT:
MOV AH, 4CH
INT 21H
4
MAIN ENDP
END MAIN
Discussion: In my previous lab class there I had some confusion with the loops
and the levels. But in this lab my confusions got cleared.
Question: 06
Write a program that exchange and swap values using assembly language.
Source Code:
.MODEL SMALL
.STACK 100H
.CODE
MAIN PROC
MOV AH, 1
INT 21H
MOV BL, AL
INT 21H
5
MOV BH, AL
INT 21H
MOV CL, AL
MOV AH, 2
MOV DL, 10
INT 21H
MOV DL, 13
INT 21H
MOV AH, 2
MOV DL, CL
INT 21H
MOV DL, BH
INT 21H
MOV DL, BL
INT 21H
6
MOV AH, 2
MOV DL, 10
INT 21H
MOV DL, 13
INT 21H
MOV AH, 1
INT 21H
MOV BL, AL
INT 21H
MOV BH, AL
MOV AH, 2
MOV DL, 10
INT 21H
MOV DL, 13
INT 21H
7
XCHG BL, BH
MOV AH, 2
MOV DL, BL
INT 21H
MOV DL, BH
INT 21H
EXIT:
MOV AH, 4CH
INT 21H
MAIN ENDP
END MAIN
Output:
CSE
ESC
AD
DA
8
Explanation: In this code the first three lines,
.MODEL SMALL
.STACK 100H
.CODE
Work as header files.
MAIN PROC is the main function for this program where PROC stands for
procedure.
First we take three inputs through AL register and copy them to BL, BH and CL
respectively. Now we have to print our inputs in backwards. For that we have
displayed our inputs in backward direction. Such as our last input was in CL, that’s
why we’ll display CL register then BH and then BL register.
Now this backward direction printing can be done by second method which is the
exchange method.
In our code first we took two inputs through BL and BH register.
For the exchange operation we have to use XCHG OPCODE. We write this
instruction as follow,
XCHG BL, BH
MOV AH, 2
MOV DL, BL
INT 21H
9
MOV DL, BH
INT 21H
Here, after the XCHG OPCODE we have to write the two register in which we are
going to do the swapping or exchange operation. Then through our output function
we will display our registers according to the sequence of our inputs.
The main work is done by the XCHG OPCODE.
To end our program we write,
EXIT:
MOV AH, 4CH
INT 21H
MAIN ENDP
END MAIN
Discussion: The first portion of the program was the basic of taking multiple
inputs and displaying them. But the second portion of the program introduced us
with a new OPCODE which is XCHG. Through this OPCODE I can easily
exchange or swap the values of registers.
Question: 07
Write a program that implements the AND, OR, XOR, ADD and SUB operations
using assembly language.
10
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
A DB 10, 13,'FOR AND $'
B DB 10, 13,'FOR OR $'
C DB 10, 13,'FOR XOR $'
D DB 10, 13,'FOR ADD $'
E DB 10, 13,'FOR SUB $'
.CODE
MAIN PROC
MOV AX, @DATA
MOV DS, AX
MOV AH, 9
LEA DX, A
INT 21H
11
MOV BL, 111B
AND BL, 101B
ADD BL, 48
MOV AH, 2
MOV DL, BL
INT 21H
LEVELOR:
MOV AH, 9
LEA DX, B
INT 21H
MOV BL, 100B
OR BL, 110B
ADD BL, 48
MOV AH, 2
12
MOV DL, BL
INT 21H
LEVELXOR:
MOV AH, 9
LEA DX, C
INT 21H
MOV BL, 111B
XOR BL, 101B
ADD BL, 48
MOV AH, 2
MOV DL, BL
INT 21H
LEVELADD:
MOV AH, 9
LEA DX, D
13
INT 21H
MOV BL, 011B
ADD BL, 100B
ADD BL, 48
MOV AH, 2
MOV DL, BL
INT 21H
LEVELSUB:
MOV AH, 9
LEA DX, E
INT 21H
MOV BL, 111B
SUB BL, 100B
ADD BL, 48
14
MOV AH, 2
MOV DL, BL
INT 21H
EXIT:
MOV AH, 4CH
MAIN ENDP
END MAIN
Output:
FOR AND 5
FOR OR 6
FOR XOR 2
FOR ADD 7
FOR SUB 3
Explanation: Inside our data segment we declare our messages. To initialize our
data segment we write these two lines:
MOV AX, @DATA
15
MOV DS, AX
For our first string it will print A. For that we write:
MOV AH, 9
LEA DX, A
INT 21H
Here, MOV ah, 9 is our output function to print strings. LEA stands for load
effective address which loads the string of A to DX.
Then we take binary numbers for our inputs as,
MOV BL, 111B: Number 111 is copied to BL. 111B stands for binary number.
AND BL, 101B: OPCODE AND is used to implement the operation of AND
between 101 and 111.
ADD BL, 48: Converts the result from binary to decimal.
To show the output we write,
MOV AH, 2
MOV DL, BL
INT 21H
Now for our OR operation we write,
LEVELOR:
16
MOV AH, 9
LEA DX, B
INT 21H
These lines print the string of B.
MOV BL, 100B: Number 100 is copied to BL register.
OR BL, 110B: OR operation takes place between 110B and BL through the OR
OPCODE.
ADD BL, 48: Converts the result of OR operation from binary to decimal.
To print the output result we write,
MOV AH, 2
MOV DL, BL
INT 21H
Similarly we can implement the operations of XOR, ADD and SUB.
To end our program we write the following,
EXIT:
MOV AH, 4CH
MAIN ENDP
17
END MAIN
Discussion: In this program I have used OPCODES AND, OR, XOR, ADD and
SUB. These OPCODEs are built in. We can use various numbers and implement
the operations. We can display the results in binary number also.
Question: 08
Write a program to check password using assembly language.
Source Code:
.MODEL SMALL
.STACK 100H
.DATA
A DB 'ENTER YOUR PASSWORD $'
OK DB 'CORRECT PASSWORD $'
NOTOK DB 'WRONG PASSWORD $'
PASS DB 'DIPTI $'
PASS1 DW 5
.CODE
18
MAIN PROC
MOV AX, @DATA
MOV DS, AX
MOV CX, PASS1
MOV BX, OFFSET PASS
MOV AH, 9
LEA DX, A
INT 21H
L1:
MOV AH, 8
INT 21H
CMP AL, [BX]
JNE L2
INC BX
LOOP L1
19
MOV AH, 9
LEA DX, OK
INT 21H
JMP EXIT
L2:
MOV AH, 9
LEA DX, NOTOK
INT 21H
EXIT:
MOV AH, 4CH
INT 21H
MAIN ENDP
END MAIN
Output:
ENTER PASSWORD WRONG PASSWORD
or
20
ENTER PASSWORD CORRECT PASSWORD
Explanation: Inside our data segment we will declare some messages.
INPUT DW 5: My password contains 5 characters. That’s why I have declared 5.
To initialize our data segment we write these two lines:
MOV AX, @DATA
MOV DS, AX
MOV CX, INPUT: The value of my input will be copied to CX.
MOV BX, OFFSET PASS: The values that are placed in the PASS variable is
checked through the OFFSET and copied to BX.
To print our first string for entering the password we write,
MOV AH, 9
LEA DX, A
INT 21H
L1: This is our first level L1.
MOV AH, 8: This is a function which is taking input from the user keeps in a
hidden form.
CMP AL, [BX]: The offset value of the BX is compared with the AL register.
JNE L2: If one value doesn’t match it will jump to the level L2.
21
INC BX: If the values are equal then BX will increase after comparing every input
with [BX].
LOOP L1: Then it will go to the level L1 after every successful comparison.
If the password is correct then the message of the variable OK will be printed.
MOV AH, 9
LEA DX, OK
INT 21H
JMP EXIT: After the correct entered password it will straight jump to exit.
L2: This is the second level L2.
If any entered character is not equal to the password then following instructions
will be executed.
MOV AH, 9
LEA DX, NOTOK
INT 21H
To end our program we will write,
EXIT:
MOV AH, 4CH
INT 21H
MAIN ENDP
END MAIN
22
Discussion: In this program I have learned how to take input in a hidden form,
about the offset instruction. This program assures security also.
Intel 80x86 Assembly Language OPCODES: An OPCODE is short for
'Operation Code'. An OPCODE is a single instruction that can be executed by the
CPU. Following are the OPCODES used in assembly language.
1. AAA ASCII Adjust for Addition
2. AAD ASCII Adjust for Division
3. AAM ASCII Adjust for Multiplication
4. AAS ASCII Adjust for Subtraction
5. ADC Add With Carry
6. ADD Arithmetic Addition
7. AND Logical And
8. ARPL Adjusted Requested Privilege Level of Selector
9. BOUND Array Index Bound Check
10. BSF Bit Scan Forward
11. BSR Bit Scan Reverse
12. BSWAP Byte Swap
13. BT Bit Test
14. BTC Bit Test with Compliment
15. BTR Bit Test with Reset
16. BTS Bit Test and Set
17. CALL Procedure Call
23
18. CBW Convert Byte to Word
20. CLC Clear Carry
21. CLD Clear Direction Flag
22. CLI Clear Interrupt Flag
23. CLTS Clear Task Switched Flag
24. CMC Complement Carry Flag
25. CMP Compare
26. CMPS Compare String
27. CMPXCHG Compare and Exchange
28. CWD Convert Word to Double word
29. CWDE Convert Word to Extended Double word
30. DAA Decimal Adjust for Addition
31. DAS Decimal Adjust for Subtraction
32. DEC Decrement
33. DIV Divide
34. ENTER Make Stack Frame
35. ESC Escape
36. Floating point instructions no descriptions
37. HLT Halt CPU
38. IDIV Signed Integer Division
39. IMUL Signed Multiply
40. IN Input Byte or Word From Port
41. INC Increment
42. INS Input String from Port
43. INT Interrupt
24
44. INTO Interrupt on Overflow
45. INVD Invalidate Cache
46. INVLPG Invalidate Translation Look Aside Buffer Entry
47. IRET/IRETD Interrupt Return
48. JA/JNBE Jump Above / Jump Not Below or Equal
49. JAE/JNB Jump Above or Equal / Jump on Not Below
50. JB/JNAE Jump Below / Jump Not Above or Equal
51. JBE/JNA Jump Below or Equal / Jump Not Above
52. JC Jump on Carry
53. JCXZ/JECXZ Jump if Register (E)CX is Zero
54. JE/JZ Jump Equal / Jump Zero
55. JG/JNLE Jump Greater / Jump Not Less or Equal
56. JGE/JNL Jump Greater or Equal / Jump Not Less
57. JL/JNGE Jump Less / Jump Not Greater or Equal
58. JLE/JNG - Jump Lessor Equal/Jump Not Greater
59. JMP – Unconditional Jump
60. JNC Jump Not Carry
61. JNE/JNZ Jump Not Equal /Jump Not Zero
62. JNO Jump Not Overflow
63. JNS Jump Not Signed
64. JNP/JPO Jump Not Parity/Jump Parity Odd
65. JO Jump on Overflow
66. JP/JPE Jump on Parity/Jump on Parity Even
67. JS Jump Signed
71. LEA Load Effective Address
25
82. LOOP Decrement CX and Loop if CX Not Zero
83. LOOPE/LOOPZ Loop While Equal /Loop While Zero
84. LOOPNZ/LOOPNE Loop While Not Zero/Loop While Not Equal
88. MOV Move Byte or Word
89. MOVS Move String
90. MOVSX Move with Sign Extend
91. MOVZX Move with Zero Extend
92. MUL Unsigned Multiply
94. NOP No Operation
95. NOT One's Compliment Negation
96. OR Inclusive Logical OR
97. OUT Output Data to Port
99. POP Pop Word off Stack
102. PUSH Push Word onto Stack
105. RCL Rotate Through Carry Left
106. RCR Rotate Through Carry Right
110. RET/RETF - Return From Procedure
111. ROL Rotate Left
112. ROR Rotate Right
114. SAL/SHL – Shift Arithmetic Left/Shift Logical Left
115. SAR – Shift Arithmetic Right
116. SBB Subtract with Borrow
137. SHR Shift Logical Right
141. STC Set Carry
142. STD Set Direction Flag
26
143. STI Set Interrupt Flag
146. SUB Subtract
147. TEST Test for Bit Pattern
150. WAIT/FWAIT Event Wait
152. XCHG Exchange
153. XLAT/XLATB Translate
154. XOR Exclusive OR
Conclusion: Through this lab I have learned a lot of new things. I’ve been
introduced with various new OPCODEs and instructions. The problems I faced in
the previous lab have been solved in this lab.
27
