You are on page 1of 10

13EC305-MICROPROCESSOR AND INTERFACING

UNIT II
SIMPLE PROGRAMS USING ASSEMBLER

PROGRAM TO DISPLAY A STRING
org 100h
main proc near
mov ah,09h
mov dx,offset message
int 21h

mov ah,4ch
mov al,00
int 21h
endp

message db "Hello World This is a test $"
end main

ret

PROGRAM TO WAIT FOR KEY PRESS
org 100h

main proc near
mov ah,00 ; Function To Read Character
int 16h

mov ah,4ch ; Terminate and return to dos
mov al,00
int 21h
endp
end main

ret

PROGRAM TO CONVERT TO UPPERCASE
name "upper"
org 100h
jmp start
; first byte is buffer size,
; second byte will hold number
; of used bytes for string,
; all other bytes are for characters:
string db 20, 22 dup('?')
new_line db 0Dh,0Ah, '$' ; new line code.
start:
; int 21h / ah=0ah - input of a string to ds:dx,
; fist byte is buffer size, second byte is number
; of chars actually read. does not add '$' in the
; end of string. to print using int 21h / ah=09h
; you must set dollar sign at the end of it and
; start printing from address ds:dx + 2.

mov ah, 0ah
int 21h

mov bx, dx
mov ah, 0
13EC305-MICROPROCESSOR AND INTERFACING

mov al, ds:[bx+1]
add bx, ax ; point to end of string.

mov byte ptr [bx+2], '$' ; put dollar to the end.

; int 21h / ah=09h - output of a string at ds:dx.
; string must be terminated by '$' sign.
lea dx, new_line
mov ah, 09h
int 21h

lea bx, string

mov ch, 0
mov cl, [bx+1] ; get string size.

jcxz null ; is string is empty?

add bx, 2 ; skip control chars.
upper_case:

; check if it's a lower case letter:
cmp byte ptr [bx], 'a'
jb ok
cmp byte ptr [bx], 'z'
ja ok

; upper case letter do not have
; third bit set, for example:
; 'a' : 01100001b
; 'a' : 01000001b
; upper case mask : 11011111b

; clear third bit:
and byte ptr [bx], 11011111b
ok:
inc bx ; next char.
loop upper_case

; int 21h / ah=09h - output of a string at ds:dx.
; string must be terminated by '$' sign.
lea dx, string+2
mov ah, 09h
int 21h

; wait for any key press....
mov ah, 0
int 16h
null:
ret ; return to operating system.

PROGRAM PALIDROME
name "pali"
org 100h
jmp start
m1:
s db 'mom'
s_size = $ - m1
db 0Dh,0Ah,'$'
start:
13EC305-MICROPROCESSOR AND INTERFACING


; first let's print it:
mov ah, 9
mov dx, offset s
int 21h


lea di, s
mov si, di
add si, s_size
dec si ; point to last char!

mov cx, s_size
cmp cx, 1
je is_palindrome ; single char is always palindrome!

shr cx, 1 ; divide by 2!

next_char:
mov al, [di]
mov bl, [si]
cmp al, bl
jne not_palindrome
inc di
dec si
loop next_char
is_palindrome:
; the string is "palindrome!"
mov ah, 9
mov dx, offset msg1
int 21h
jmp stop
not_palindrome:
; the string is "not palindrome!"
mov ah, 9
mov dx, offset msg2
int 21h

stop:
; wait for any key press:
mov ah, 0
int 16h


ret
The Final Output:


PROGRAM TO FIND THE FACTORIAL OF A NUMBER
putc macro char
push ax
mov al, char
mov ah, 0eh
int 10h
pop ax
endm

org 100h

jmp start
13EC305-MICROPROCESSOR AND INTERFACING


result dw ?
start:

; get first number:

mov dx, offset msg1
mov ah, 9
int 21h
jmp n1
msg1 db 0Dh,0Ah, 'enter the number: $'
n1:

call scan_num


; factorial of 0 = 1:
mov ax, 1
cmp cx, 0
je print_result

; move the number to bx:
; cx will be a counter:

mov bx, cx

mov ax, 1
mov bx, 1

calc_it:
mul bx
cmp dx, 0
jne overflow
inc bx
loop calc_it

mov result, ax

print_result:

; print result in ax:
mov dx, offset msg2
mov ah, 9
int 21h
jmp n2
msg2 db 0Dh,0Ah, 'factorial: $'
n2:

mov ax, result
call print_num_uns
jmp exit
overflow:
mov dx, offset

PROGRAM TO FIND SQUARE AND CUBE OF A NUMBER
DATA SEGMENT
X DW 04H
SQUARE DW ?
CUBE DW ?
DATA ENDS
CODE SEGMENT
13EC305-MICROPROCESSOR AND INTERFACING

ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV AX,X
MOV BX,X
MUL BX
MOV SQUARE,AX
MUL BX
MOV CUBE,AX
MOV AH,4CH
INT 21H
CODE ENDS
END START

PROGRAM TO FIND LCM OF A GIVEN NUMBER
DATA SEGMENT
NUM DW 05,04
LCM DW 2 DUP(0)
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV DX,0H
MOV AX,NUM
MOV BX,NUM+2
UP: PUSH AX
PUSH DX
DIV BX
CMP DX,0
JE EXIT
POP DX
POP AX
ADD AX,NUM
JNC DOWN
INC DX
DOWN: JMP UP
EXIT: POP LCM+2
POP LCM
MOV AH,4CH
INT 21H
CODE ENDS
END START


PROGRAM TO FIND GCD OF TWO NUMBERS
DATA SEGMENT
NUM1 DW 000AH
NUM2 DW 0004H
GCD DW ?
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA ;Load the Data to AX.
MOV DS,AX ;Move the Data AX to DS.
MOV AX,NUM1 ;Move the first number to AX.
MOV BX,NUM2 ;Move the second number to BX.
UP: CMP AX,BX ;Compare the two numbers.
JE EXIT ;If equal, go to EXIT label.
13EC305-MICROPROCESSOR AND INTERFACING

JB EXCG ;If first number is below than second,
;go to EXCG label.
UP1: MOV DX,0H ;Initialize the DX.
DIV BX ;Divide the first number by second number.
CMP DX,0 ;Compare remainder is zero or not.
JE EXIT ;If zero, jump to EXIT label.
MOV AX,DX ;If non-zero, move remainder to AX.
JMP UP ;Jump to UP label.
EXCG:XCHG AX,BX ;Exchange the remainder and quotient.
JMP UP1 ;Jump to UP1.
EXIT:MOV GCD,BX ;Store the result in GCD.
MOV AH,4CH
INT 21H
CODE ENDS
END START

PROGRAM TO COMPUTE NCR USING RECURSIVE PROCEDURE. ASSUME THAT N AND R ARE NON-
NEGATIVE INTEGERS.
DATA SEGMENT
n db 10
r db 9
ncr db 0
DATA ENDS
code segment
assume cs:code,ds:data
start: mov ax,data
mov ds,ax
mov ncr,0
mov al,n
mov bl,r
call encr
call display
mov ah,4ch
int 21h
encr proc
cmp al,bl
je ncr1
cmp bl,0
je ncr1
cmp bl,1
je ncrn
dec al
cmp bl,al
je ncrn1
push ax
push bx
call encr
pop bx
pop ax
dec bl
push ax
push bx
call encr
pop bx
pop ax
ret
ncr1: inc ncr
ret
ncrn1: inc al
ncrn: add ncr,al
13EC305-MICROPROCESSOR AND INTERFACING

ret
encr endp

display proc
push cx
mov al,ncr
mov ch,al
and al,0f0h
mov cl,04
shr al,cl
cmp al,09h
jbe next
add al,07h
next:add al,30h
mov dl,al
mov ah,02h
int 21h
mov al,ch
and al,0fh
cmp al,09h
jbe next2
add al,07h
next2:add al,30h
mov dl,al
mov ah,02h
int 21h
pop cx
ret
display endp
code ends
end start

PROGRAM TO COMPUTE THE FACTORIAL OF A POSITIVE INTEGER N USING RECURSIVE PROCEDURE.
DATA SEGMENT
N DB 06H
FACT DW ?
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA
MOV DS, AX
MOV AX, 1
MOV BL, N
MOV BH, 0
CALL FACTORIAL
MOV FACT, AX
MOV AH, 4CH
INT 21H

FACTORIAL PROC
CMP BX, 1
JE L1
PUSH BX
DEC BX
CALL FACTORIAL
POP BX
MUL BX
L1: RET
FACTORIAL ENDP
13EC305-MICROPROCESSOR AND INTERFACING

CODE ENDS
END START

PROGRAM TO GENERATE THE FIRST N FIBONACCI NUMBERS.
DATA SEGMENT

f1 db 00h
f2 db 01h
f3 db ?
msg1 db "The Fibonacci series is", 10, 13, "$"
n db 12
DATA ENDS
code segment
assume cs:code, ds:data
start: mov ax, data
mov ds, ax
lea dx, msg1
mov ah, 09h
int 21h
mov bl, f1
CALL DISPNUM
mov dl, ' '
mov ah, 02h
int 21h
mov bl, f2
CALL DISPNUM
mov dl, ' '
mov ah, 02h
int 21h
mov ch, 00h
up1: cmp ch, n
jae exit
mov al, f1
add al, f2
mov f3, al
mov bl, f3
CALL DISPNUM
mov dl, ' '
mov ah, 02h
int 21h
mov al, f2
mov f1, al
mov al, f3
mov f2, al
inc ch
jmp up1
exit: mov ah, 4ch
int 21h
DISPNUM PROC NEAR
MOV DL, BL
AND DL, 0F0H ; display 1st digit
MOV CL, 04H
SHR DL, CL
CMP DL, 09H
JBE L2
ADD DL, 07H
L2: ADD DL, 30H
MOV AH, 02H
INT 21H
MOV DL, BL
13EC305-MICROPROCESSOR AND INTERFACING

AND DL, 0FH
CMP DL, 09H ;display 2nd digit
JBE L3
ADD DL, 07H
L3: ADD DL, 30H
MOV AH, 02H
INT 21H
RET
DISPNUM ENDP
code ends
end start

PROGRAM FOR ASCII ADJUSTMENT INSTRUCTIONS
CODE SEGMENT
ASSUME CS:CODE
START: MOV AX,31H ;Load ASCII 1
ADD AX,39H ;Load ASCII 9
AAA ;ASCII Adjust, AX=0100 UNPACKED BCD
ADD AX,3030H ;Answer in ASCII
MOV BL,9 ;Load divisor
MOV AX,0702H ;Load dividend, AAD instruction requires
Ax register to contain a two digit unpacked
;BCD number before executing
AAD ;AAD appears before division
DIV BL ;Contents of adjusted AX register is devised
;by an unpacked BCD number to generate
;a single digit result in AL with any
;remainder in AH
MOV AL,5 ;Load multiplicand
MOV CL,5 ;Load multiplier
MUL CL ;AX=0019H
AAM ;AX=0205(Unpacked BCD)
ADD AX,3030H ;AX=3235H
MOV AX,38H ;Load ASCII 8
SUB AX,31H ;Load ASCII 1
AAS ;AX=0007
AX,3030H ;AX=3037H
MOV AH,4CH
INT 21H
CODE ENDS
END START

PROGRAM FOR BINARY TO BCD CONVERSION
DATA SEGMENT
BIN DW 01A9H
BCD DB 2 DUP(0)
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV AX,BIN
MOV CL,64H
DIV CL
MOV BCD+1,AL
MOV AL,AH
MOV AH,00H
MOV CL,0AH
DIV CL
MOV CL,04
13EC305-MICROPROCESSOR AND INTERFACING

ROR AL,CL
ADD AL,AH
MOV AH,4CH
INT 21H
CODE ENDS
END START

PROGRAM FOR BCD TO BINARY CODE CONVERSION
DATA SEGMENT
BCD DW 27H
BIN DW ?
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV AX,BCD
AND AX,07H
MOV BX,AX
MOV AX,BCD
AND AX,0F0H
MOV CX,0AH
MUL CX
ADD AX,BX
MOV BIN,AX
MOV AH,4CH
INT 21H
CODE ENDS
END START

You might also like