WRITE A PROGRAM IN 8086 that accepts two floating point number form the correctly the format.

WRITE A PROGRAM IN 8086 that accepts two floating point number form the correctly the format.

Print macro msg
Mov ah, 09h
Mov dx , offset msg
Int 21h
End

DATA SEGEMENT
NUM1 DB 100 DUP(0)
NUM2 DB 100 DUP(0)
MSG1 DB “ ENTER THE FIRST NUMBER”
MSG2 DB “ENTER THE SECOND NUMBER”
MSG3 DB “ SUM OF TWO NUMBER”
MSG4 DB “ EXPONENT IS NOT EQUAL”
RES DB 100 DUP (0)

DATA ENDS

CODE SEGMENT
ASSUME CS:CODE, DS : DATA
START
MOV AX,DATA
MOV DS,AX
PRINT MSG2
MOV SI, OFFSET NUM1

X: MOV AH,02H
INT 21H
MOV [SI],AL
INC SI
CMP AL,0DH
JNE X

PRINT MSG2
MOV SI, OFFSET NUM2

Y:
MOV AH, 01H
INT 21H
MOV [SI],AL
INC SI
CMP AL, 0DH
JNE Y

W: MOV CL,03H
MOV SI,OFFSET NUM1
MOV DI,OFFSET NUM2
ADD SI, 07H
ADD DI,07H
MOV AL, [SI]
MOV BL,[DI]
COM AL, BL
INC SI
INC DI
JNE
LOOP W

MOV CL,04H

XY: MOV BX,OFFSET RES
MOV SI, OFFSET NUM1
MOV DI, OFFSET NUM2
MOV AL,[SI]
ADD AL,[DI]
MOV [BX],AL
INC SI
INC DI
INC BX

LOOP XY

RCL AL,01H
AND AL,01H
MOV [BX], AL

PRINT MSG3
PRINT RES
MOV AH,09CH
INT 21H
CODE ENDS
END START

PRINT MSG 4
MOV AH, 4CH
INT 21H





ALGORITHM

Step 1: start
Step 2: input number 1 and number2
Step3: n1=last character of number 1
N2=last character of number2
Step4: take a counter c and I=0
Step compare n1 and n2 of both are same go to step 6
Else
Go to step 11
Steps 6: n1= n1-1 and n2= n2-1
C=c+1
C=3 then go to step 7
Step 7
Take n1= 4th character of numebr1
And 4th character of number 2
C= 1

Step 8:
Add n1 and n2 , sum stored in variable s and carry stand in CA.

Step 9:
C=n+1
N1=n1-1 and n2=n2-1
Step 10
If c=5 the n go to step 12
Else
Go to step 8
Step 11: print “ exponent not match”
Step 12: print “ sum of two number”
Step 13: end

WAP in 8086 that can be used for password matching.

WAP in 8086 that can be used for password
matching.


;ABSTRACT : this program inputs a password
;registers used : CS,DS,ES,AX,DX,CX,SI,DI
;port used : fffah
;PROCEDURES : None used

DATA_HERE SEGMENT

PASSWORD DB ‘FAILSAFE’

INPUT_WORD DB 8 DUP(?) ; SPACE FOR USER INPUT

DATA_HERE ENDS

CODE_HERE SEGMENT
ASSUME CS:CODE_HERE,DS:DATA_HERE,
ES:DATA_HERE

MOV AX,DATA_HERE
MOV DS,AX
MOV ES,AX

MOV DX,OFFFEH
AL,99H
OUT DX,AL

LEA SI,PASSWORD
LEA DI, INPUT_WORD
MOV CX,O8H
CLD
REPE CMPSB
JNE SOUND_ALARM
JMP OK
SOUND_ALARM:
MOV AL,01
MOV DX,0FFFAH
OUT DX,AL
HLT
OK: NOP

CODE_HERE ENDS
END

Matrix multiplication

Write a program in 8086 assembly language that multiplies two 2*2 matrices to create a third matrix of size (2*2). Make suitable assumptions, if any. Properly document the program.

Solution.

;
; BUILD - TASM MATMUL.ASM
; TLINK MATMUL
;
; USAGE - MATMUL

READNUM MACRO NUM
PUSH AX
PUSH BX
MOV AH, OLH ;GET CHAR FROM KEYBOARD INT 21H CALL DOS SERVICE
SUB AL, ‘0’ ;ASCII NUM TO DECIMAL
MOV BH, OAH
MUL BH MULTIPLY BY 10
MOV NUM, AL STORE FIRST DIGIT IN NUM
MOV AH, OLH GET CHAR FROM KEYBOARD
INT 21H CALL DOS SERVICE
SUB AL, ‘0’ ASCII NUM TO DECIMAL
ADD NUM , AL ADD SECOND DIGIT
POP BX
POP AX
ENDM
PRINTSTRING MACRO MSG ;PRINTSTRING – THE USER
DEFINED MACRO
MOV AH, 09H DISPLAY STRING FUNCTION
MOV DX, OFFSET MSG ;INITIALIZE DX TO MSG
INT 21H CALL DOS SERVICE

_DATA SEGMENT _DATA – NAME OF USER DEFINED SEGMENT

CREQU 0DB ASCII CODE FOR CARRIAGE
RETURN
LF EQU OAH ;ASCII CODE FOR LINE FEED
M EQU 3 ;ORDER OF MATRIX
MSG DB ‘PROGRAM FOR FINDING THE PRODUCT OF MATRICES(M X M)$’
MSGO DB CR,LF,’ENTER ELEMENTS OF MATRIX A IN ROW MAJOR…$’
MSGL DB CR,LF,’ENTER ELEMENTS OF MATRIX B IN ROW MAJOR…$’
MSG2 DB CR,LF,’ELEMENT:’,‘$’
MSG3 DB CR,LF,’PRODUCT MATRIX’
C=A*B…….’, ‘$’
;VARIABLES FOR MATRIX MANIPULATION
MATA DB 20 DUP(0)
MATB DB 20 DUP(0)
MATC DB 20 DUP(0)
NEWLINE DB CR, LF, ‘$’

SPACE DB ‘$’
MATRIX OPERATION INDEX VARIABLES
I DB?
J DB?
K DB?
RESULT DB 5 DUP(0)
TNUM DB?
_DATA ENDS ;END OF _DATA SEGMENT

_CODE SEGMENT
;INITIALIAZE CS, DS
ASSUME CS: CODE, DS: _DATA
START: MOV AX, _DATA ;INITIALIZE OS TO THE
DATA SEGMENT
MOV DS, AX
PRINTSTRING MSG
;READ MATRIX A
PRINT STRING MSG0
;PUT ALL INPUT PARAMETERS ONTO THE STACK IN REVERSE ORDER
MOV AL, M
PUSH SI
CALL READMATRIX
ADD SP,4
PUSH OPERATIONS
;READ MATRIX B
PRINTSTRING MSGL

;PUT ALL INPUT PARAMETERS ONTO THE STACK IN REVERSE
ORDER
MOV AL,M
PUSH AX
MOV SI, OFFSET MATB
PUSH SI
CALL READMATRIX
ADD SP,4 ;ADJUST STACK FOR TWO PUSH OPERATIONS

;MAT C=MATA*MATB
;PUT ALL INPUT PARAMETERS ONTO THE STACK IN REVERSE ORDER

PRINTSTRING MSG3
MOV AL,M
PUSH AX,
MOV AX, OFFSET MATC
PUSH AX
MOV AX, OFFSET MATB
PUSH AX
MOV AX, OFFSET MATA
PUSH AX
CAL MULTIMATRIX
ADD SP,8 :ADJUST STACK FOR FOUR PUSH
OPERATION
MOV AL,M
PUSH AX
MOV SI, OFFSET MATC
PUSH SI
CALL PRINTMATRIX
ADD SP,4 ;ADJUST STACK FOR TWO PUSH OPERATION
MOV AH,4CH ;PROGRAM TERMINATE FUNCTION
MOV AL, 00H ;RETURN CODE
FOR ERROR LEVEL SETTING
INT 21 H ;CALL DOS SERVICE
;MACRO: MELEADDR
;LOGIC
;ADDR = ADDR(MAT)+J+(I-I)*ORDER
;RETURNS:
;BX-EFFECTIVE ADDRESS OF AN ELEMENT

MELEADDR MACRO MAT,I,J,ORDER

PUSH AX
MOV AL,I
DEC AL
MOV AH,00 ;AX = (I-I)
MOV BI, ORDER ;AX = (I-I)*ORDER
NUL BI
ADD AI,J
MOV BX,MAT
ADD BX,AX

(I-I)* ORDER

POP AX
ENDM

;MULTIMATRIX (A,B,C ORDER)
;C=A*B

MULTIMATRIX PROC NEAR
PUSH BP
MOV BP,SP ;MAKE STACK
ADDRESSABLE
PUSH SI
PUSH DI
PUSH CX
PUSH BX
PUSH AX
MOV SI, [BP+4] ; MATRIX A
MOV DI, [BP+6] ;MATRIX B
MOV BX,[BP+8] ; MATRIX C
MOV DX, [BP+10] ;ORDER OF MATRIX. USE
LOWER BYTE
;DL-ORDER OF THE MATRIX

MOV A1,01
MOV I, A1 ;I=1

MNEXTI:
MOV A1,01
MOV J1, A1 ;J=1
MNEXTJ:
MOV A1,01
MOV K, 01 ;K=1
MOV CL, 00 ;C[I][J]=0
MNEXTK:
MEMEADDR [BP+4],I,K,DL
MOV AH,00
MOV AL,[BX] ;AL=B[I][K]
MELEADDR [BP+6],K,J,DL
MUL BYTE PTR [BX] ;AX = B[I][K]
ADD CL,AL
C[I][J]=C[I][J]+B[I][K]*C[K][J]
;K=K+1
MOV AL,K
INC AL
MOV K,AL
CMP AL,DL
JLE MNEXTK ;REPEAT FOR K <= ORDER
MELEADDR [BP+8],I,J,DL
MOV [BX],CL ;PUT C[I][J] INTO C MATRIX

;J=J+1
MOV AL,J
INC AL
MOV J,AL
CMP AL,DL
JLE MNEXTI ;REPEAT FOR I ,= ORDER

POP AX ;RESTORE
REGISTERS
POP BX
POP CX
POP DI
POP SI
POP BP
RET
MULTIMATRIX ENDP

;FUNCTION: READ MATRIX (MATRIX, ORDER OF MATRIX)
;INPUT:
;PUT PARAMETERS INTO THE STACK IN REVERSE ORDER
;RETURNS:
; MATRIX

READMATRIX PROC NEAR
PUSH BP
MOV BP,SP ;SAVE REGISTERS
ADDRESSABLE
PUSH BX
PUSH AX
MOV SI, [BP+4] ;POINTER TO THE MATRIX

MOV AX, [BP+6] ;ORDER OF MATRIX
MOV CH, AL ;CH=I INDEX CONTROL
NEXTI:
MOV AX, [BP+6] ;CL=J INDEX CONTROL
MOV CL, AL
NEXTJ:
INC SI ;INDEX FOR NEXT ELEMENT
PRINTSTRING MSG2
READNUM TNUM ;READ NUMBER
MOV AL, TNUM ;STORE INTO AL
MOV [SI], AL ;STORE NUMBER INTO TABLE
DEC CL ;REPEAT FOR ALL
JNZ NEXTJ COLUMNS
DEC CH ;REPEAT FOR ALL ROWS
POP AX ;RESTORE THE REGISTERS
POP BX
POP BP
RET
READMATRIX ENDP
FUNCTION: PRINTMATRIX(MATRIX, ORDER OF MATRIX)
PRINTMATRIX PROC NEAR
PUSH BP
MOV BP, SP MAKE STACK ADDRESABLE
PUSH BX
PUSH AX
MOV SI, [BP+4] SI=POINTER TO MATRIX
MOV SI, [BP+6] ORDER OF MATRIX
MOV CH, AL CH=I INDEX CONTROL

PNEXTI:
PRINTSTRING NEW LINE
MOV AX, [BP+6]
MOV CL, AL ` ;CL=J INDEX CONTROL
PNEXTJ:
INC SI ;INDEX FOR NEXT ELEMENT
;DISPLAY ELEMENT
PUSH SI
MOV AH, 0 ;AX,=MAT[I][J]
MOV AL, BYTE PTR [SI]
MOV SI, OFFSET RESULT
CALL HEX2ASC
PRINTSTRING RESULT
PRINTSTRING SPACE
POP SI
DEC CI
JNZ PNEXTJ ;REPEAT FOR ALL COLUMNS
DEC CH
JNZ PNEXTI ;REPEAT FOR ALL ROWS
POP AX ;RESTORE REGISTERS
POP BX
POP BP
RET

PRINTMATRIX ENDP
;FUNCTION TO CONVERT HEXADECIMAL NUMBER TO ASCII STRING
;AX – INPUT NUMBER
;SI – POINTER TO RESULT STORAGE AREA

HEX2ASC PROC NEAR
PUSH AX ;SAVE REGISTERS
PUSH BX
PUSH CX
PUSH DX
PUSH SI
MOV CX, 00H ;COUNTER FOR INTERMEDIATE DATA PUSHED

MOV BX,OAH ;LOAD 10 IN BL
RPTL:
MOV DX, 00
DIV BX ;DIVIDE NUM BY 10
ADD DL, ’0’ ;CONVERT REMAINDER TO ASCII
PUSH DX ;STORE ASCII DIGIT ONTO THE STACK
INC CX ;UPDATE COUNTER

CMP AX, 0AH ;IS NUM LESS THAN OR EQUAL TO 10
JGE RPTL

ADD AL, ‘0’
MOV [SI], AL
;POP ALL INTERMEDIATE DATA FROM STACK AND STORE IN RESULT RPT2:
POP AX ;POP DATA
INC SI ;ADVANCE RESULT STRING POINTER
MOV [SI], AL ;STORE IN RESULT
LOOP RPT2

INC SI
MOV AL, ‘$’
MOV [SI], AL ;APPEND END OF STRING

POP SI ;RESTORE THE REGISTERS
POP DX
POP CX
POP BX
POP AX
RET

HEX2ASC ENDP
_CODE ENDS ;END OF SEGMENT
END START ;END OF PROGRAM

Program in 8086 assembly language that concatenates two given string to create a third string.

Write a program in 8086 assembly language that concatenates two given string to create a third string.


DATA SEGMENT
BITVAL DW 0921H,0825H,0804H,0972H
WORD1 Dw 3 dup(0000h)
ASCIINUM DB 13 DUP(‘0’)
OUTLOOPCNT BE ?
DATA ENDS

CODE SEGMENT
ASSUME CS: CODE,DS:DATA

START:
MOVE AX,DATA
MOV SI,00H
MOV DI,OOH
MOVE AX, BITVAL[SI]
MOV CL,04
SHL AX,CL
SHR AL, CL
MOV BH,AL
ADD SI,02
MOV DX,BITVAL[SI]
MOV BL,DH
SHL BL,CL
SHL BX,CL
MOV AL,BH
MOV WORD1[DI],AX
ADD DI,02

MOV AH,DL
ADD SI, 02
MOV DX,BITVAL[SI]
SHL DX,CL
MOV AL,DH
MOV WORD1[DI],AX
ADD DI,02

MOV DX,BITVAL[SI]
MOV AH,DL
ADD SI,02
MOV DX,BITVAL[SI]
MOV BL,DL
SHL DX,CL
MOV ALMDH
SHL AS,CL
MOV AL,BL
MOV WORD1[DI],AX
MOV BX , 00H
MOV SI,00H
LOOP1: MOV AX,WORD1[SI]
MOV AL,AH
MOV CL,02

LOOP 2: MOV OUTLOOPCNT,CL
MOV DL,AL
MOV CL,04
ROR DL,CL
AND DL,0FH
OR DL,30H
MOV ASCIINUM[BX],DL
INC BX
MOV DL,AL
AND DL,0FH
OR DL,30H
MOV ASCIINUM[BX],DL
INC BX
MOV AX,WORD1[SI]
MOV CL,OUTLOOPCNT
LOOP LOOP2
CMP SI,04
JE LOOP3
ADD SI,02
JUMP LOOP1
LOOP3: MOV ASCIINUM[BX],’$’
MOV AH,09H
LEA DX,ASCIINUM
INT 21H
MOV ZX,4C00H
INT 21H

CODE ENDS
END START

Write a program in 8086 assembly language that accepts a character string of a maximum size of 10 characters from the keyboard.......

Write a program in 8086 assembly language that accepts a character string of a maximum size of 10 characters from the keyboard; converts each alphabet in the string to upper case and coverts each alphabet to next alphabet, that is, A will be converted to B; B to C, C to D ….and Z to A. The resultant string is output on the monitor. You must run this program.



DATA SEGMENT
STR1 DB 80 DUP (0)
MSG1 DB ‘ENTER A STRIMG $’
CR EQU ODH
PORT DW?

DATA SEGMENT
ASSUME CS: CODE DS: DATA
START:
MOV AX, DATA
MOV DS, AX
MOV DX, OFFSET MSG1
INT 2H ; TO PRINT MSG1
RDCHAR1:
MOV SI, OFFSET STR1 ; READING STRING1
RDCHAR1:
MOV AH, 01
INT 21H
MOV [SI], AL
. INC SI
CMP AL, CR
JNE RDCHAR1
MOV SI, OFFSET STR1
MOV CL, 00
MOV CH, 00

END START

Write a subroutine of 8086 assembly language that coverts a 2 digit number entered by keyboard to equivalent binary in DX register

Write a subroutine of 8086 assembly language that coverts a 2 digit number entered by keyboard to equivalent binary in DX register, provided both the entered digits are numeric. Test this subroutine through an assembly program. The main program must get the result in DX register and put it in a memory location.


DATA SEGMENT
MSG 1 DB ‘ENTER 2 DIGIT NUMBER $’
PORT DW?
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE DS:DATA
START:
MOV AX, DATA
MOV DS, AX
MOV AH, 09H
MOV DX, OFFSET MSG1
INT 21H ; TO PRINT MSG1
MOV AH, 01H
INT 21H
SUB AL, ‘0’
MOV BH, OAH
MVL BH
MOV BL, AL
MOV AH, 01H
INT 21H
SUB AL, ‘0’
ADD BL, AL
OUT PORT, BL

CODE ENDS
END START