1.
Addition of two 8-bit numbers
MOV DPTR, #3000H; //INITIALISE MEMORY POINTER TO EXTERNAL MEMORY
MOVX A, @DPTR; //LOAD 1ST NUMBER IN A
MOV R0, A; //LOAD 1ST NUMBER TO R0
INC DPTR; //INCREMENT MEMORY POINTER BY 1
MOVX A, @DPTR; //LOAD 2ND NUMBER IN A
ADD A, R0; //ADD 1ST NO.WITH 2ND NO.
INC DPTR; //INCREMENT MEMORY POINTER BY 1
MOVX @DPTR, A; // LOAD RESULT TO EXTERNAL MEMORY
END //END THE EXECUTION
2. Subtraction of two 8-bit numbers
MOV DPTR, #3000H; //INITIALISE MEMORY POINTER TO EXTERNAL MEMORY
MOVX A, @DPTR; //LOAD 1ST NUMBER IN A
MOV R0, A; //LOAD 1ST NUMBER TO R0
INC DPTR; //INCREMENT MEMORY POINTER BY 1
MOVX A, @DPTR; //LOAD 2ND NUMBER IN A
SUBB A, R0; //SUBTRACT 1ST NO.FROM 2ND NO.
INC DPTR; //INCREMENT MEMORY POINTER BY 1
MOVX @DPTR, A; // LOAD RESULT TO EXTERNAL MEMORY
END //END THE EXECUTION
3. Multiplication of two 8-bit numbers
MOV DPTR, #3000H; //INITIALISE MEMORY POINTER TO EXTERNAL MEMORY
MOVX A, @DPTR; //LOAD multiplicand IN A
MOV 0F0H, A; //LOAD MULTIPLICAND TO B
INC DPTR; //INCREMENT MEMORY POINTER BY 1
MOVX A, @DPTR; //LOAD multiplier IN A
MUL AB; //MULTIPLY MULTIPLICAND & MULTIPLIER
INC DPTR; //INCREMENT MEMORY POINTER BY 1
MOVX @DPTR, A; //LOAD LSB OF RESULT TO EXTERNAL MEMORY
MOV A, 0F0H; //LOAD MSB RESULT A
INC DPTR; //INCREMENT MEMORY POINTER BY 1
MOVX @DPTR, A; //LOAD MSB OF RESULT TO EXTERNAL MEMORY
END //END THE EXECUTION
4. Division of two 8-bit numbers
MOV DPTR, #3000H; //INITIALISE MEMORY POINTER TO EXTERNAL MEMORY
MOVX A, @DPTR; //LOAD divisor IN A
MOV 0F0H, A; //LOAD divisor TO B
INC DPTR; //INCREMENT MEMORY POINTER BY 1
MOVX A, @DPTR; //LOAD dividend IN A
DIV AB; //DIVIDE DIVIDEND BY DIVISOR
INC DPTR; //INCREMENT MEMORY POINTER BY 1
MOVX @DPTR, A; //LOAD QUOTIENT RESULT TO EXTERNAL MEMORY
MOV A, 0F0H; //LOAD REMAINDER RESULT A
INC DPTR; //INCREMENT MEMORY POINTER BY 1
MOVX @DPTR, A; //LOAD REMAINDER OF RESULT TO EXTERNAL MEMORY
END //END THE EXECUTION
5. Largest Number among the block/array
CLR PSW.3,
CLR PSW.4; //SELECT REGISTER BANK 0
MOV R1, 0AH; //INITIALISE BYTE COUNTER
MOV R0, #40H; //INITIALISE MEMORY POINTER
DEC R1; //DECREMENT BYTE COUNTER BY 1
MOV 60H, @R0; //LOAD NUMBER IN MEMORY LOCATION 60H
UP: INC R0; //INCREMENT MEMORY POINTER BY 1
MOV A, @R0; //LOAD NEXT NUMBER
CJNE A, 60H, DN; //IF NUMBER ≠ NEXT NUMBER, JUMP TO DN
AJMP NEXT; //ELSE GO TO NEXT
DN: JC NEXT; //IF NEXT NUMBER > NUMBER THEN JUMP TO NEXT
MOV 60H, A; //ELSE REPLACE NEXT NUMBER WITH NUMBER
NEXT: DJNZ R1, UP; //DECREMENT BYTE COUNTER BY 1, IF BYTE COUNTER ≠ 0 THEN JUMP TO UP
END
6. Smallest Number among the block/array
CLR PSW.3,
CLR PSW.4; //SELECT REGISTER BANK 0
MOV R1, 0AH; //INITIALISE BYTE COUNTER
MOV R0, #40H; //INITIALISE MEMORY POINTER
DEC R1; //DECREMENT BYTE COUNTER BY 1
MOV 60H, @R0; //LOAD NUMBER IN MEMORY LOCATION 60H
UP: INC R0; //INCREMENT MEMORY POINTER BY 1
MOV A, @R0; //LOAD NEXT NUMBER
CJNE A, 60H, DN; //IF NUMBER ≠ NEXT NUMBER, JUMP TO DN
AJMP NEXT; //ELSE GO TO NEXT
DN: JNC NEXT; //IF NEXT NUMBER > NUMBER THEN JUMP TO NEXT
MOV 60H, A; //ELSE REPLACE NEXT NUMBER WITH NUMBER
NEXT: DJNZ R1, UP; //DECREMENT BYTE COUNTER BY 1, IF BYTE COUNTER ≠ 0 THEN JUMP TO UP
END
7. Arrange Numbers in Descending order
MOV R0, #0AH; //INITIALISE PASS COUNTER
UP 1: MOV DPTR, #3000H; //INITIALISE MEMORY POINTER
MOV R1, #0AH; //INITIALISE BYTE COUNTER
UP: MOV R2, DPL; //SAVE LOWER BYTE ADDRESS
MOVX A, @DPTR; //READ NUMBER FROM ARRAY
MOV B, A; //LOAD NO TO B REGISTER
INC DPTR; //INCREMENT MEMORY POINTER
MOVX A, @DPTR; //READ NEXT NO FROM ARRAY
CJNE A, B, DN; //COMPARE NO WITH NEXT NO
AJMP SKIP;
DN: JC SKIP; //IF NO. < NEXT NO THEN JUMP TO SKIP
MOV DPL, R2; //ELSE EXCHANGE THE NO WITH NEXT NO
MOVX @DPTR, A;
INC DPTR;
MOV A, B;
MOVX @DPTR, A;
SKIP: DJNZ R1, UP; //DECREMENT BYTE COUNTER IF BYTE COUNTER ≠ 0 THEN JUMP TO UP
DJNZ R0, UP1; DECREMENT PASS COUNTER IF PASS COUNTER ≠ 0 THEN JUMP TO UP1
END
8. Arrange Numbers in ascending order
MOV R0, #0AH; //INITIALISE PASS COUNTER
UP 1: MOV DPTR, #3000H; //INITIALISE MEMORY POINTER
MOV R1, #0AH; //INITIALISE BYTE COUNTER
UP: MOV R2, DPL; //SAVE LOWER BYTE ADDRESS
MOVX A, @DPTR; //READ NUMBER FROM ARRAY
MOV B, A; //LOAD NO TO B REGISTER
INC DPTR; //INCREMENT MEMORY POINTER
MOVX A, @DPTR; //READ NEXT NO FROM ARRAY
CJNE A, B, DN; //COMPARE NO WITH NEXT NO
AJMP SKIP;
DN: JNC SKIP; //IF NO. < NEXT NO THEN JUMP TO SKIP
MOV DPL, R2; //ELSE EXCHANGE THE NO WITH NEXT NO
MOVX @DPTR, A;
INC DPTR;
MOV A, B;
MOVX @DPTR, A;
SKIP: DJNZ R1, UP; //DECREMENT BYTE COUNTER IF BYTE COUNTER ≠ 0 THEN JUMP TO UP
DJNZ R0, UP1; DECREMENT PASS COUNTER IF PASS COUNTER ≠ 0 THEN JUMP TO UP1
END
9. Count ODD numbers in Block of N numbers
MOV R0, #0AH; //INITIALISE BYTE COUNTER
MOV R1, #00H; //INITIALISE ODD COUNTER TO COUNT ODD NUMBERS
MOV R2, #30H; //INITIALISE MEMORY POINTER
UP: MOV A, @R2; //READ NO FROM ARRAY
RRC A; //ROTATE NUMBER TO RIGHT BY 1 BIT
JNC DN; //IF NUMBER ≠ ODD NUMBER THEN JUMP TO DN
INC R1; //ELSE INCREMENT ODD COUNTER BY 1
DN: INC R2; //INCREMENT MEMORY POINTER
DJNZ R0, UP; //DECREMENT BYTE COUNTER BY 1
END;
10. Count EVEN numbers in Block of N numbers
MOV R0, #0AH; INITIALISE BYTE COUNTER
MOV R1, #00H; //INITIALISE EVEN COUNTER TO COUNT ODD NUMBERS
MOV R2, #30H; //INITIALISE MEMORY POINTER
UP: MOV A, @R2; //READ NO FROM ARRAY
RRC A; //ROTATE NUMBER TO RIGHT BY 1 BIT
JC DN; //IF NUMBER ≠ EVEN NUMBER THEN JUMP TO DN
INC R1; //ELSE INCREMENT EVEN COUNTER BY 1
DN: INC R2; //INCREMENT MEMORY POINTER
DJNZ R0, UP; //DECREMENT BYTE COUNTER BY 1 IF BYTE COUNTER ≠ 0 THEN JIMP TO DN
END;
11. Count NEGATIVE numbers in Block of N numbers
MOV R0, #0AH; //INITIALISE BYTE COUNTER
MOV R1, #00H; //INITIALISE NEGATIVE COUNTER TO COUNT ODD NUMBERS
MOV R2, #30H; //INITIALISE MEMORY POINTER
UP: MOV A, @R2; //READ NO FROM ARRAY
RLC A; //ROTATE NUMBER TO LEFT BY 1 BIT
JNC DN; //IF NUMBER ≠ NEGATIVE NUMBER THEN JUMP TO DN
INC R1; //ELSE INCREMENT NEGATIVE COUNTER BY 1
DN: INC R2; //INCREMENT MEMORY POINTER
DJNZ R0, UP; //DECREMENT BYTE COUNTER BY 1 IF BYTE COUNTER ≠ 0 THEN JIMP TO DN
END;
12. Count POSITIVE numbers in Block of N numbers
MOV R0, #0AH; //INITIALISE BYTE COUNTER
MOV R1, #00H; //INITIALISE POSITIVE COUNTER TO COUNT ODD NUMBERS
MOV R2, #30H; //INITIALISE MEMORY POINTER
UP: MOV A, @R2; //READ NO FROM ARRAY
RLC A; //ROTATE NUMBER TO LEFT BY 1 BIT
JC DN; //IF NUMBER ≠ POSITIVE NUMBER THEN JUMP TO DN
INC R1; //ELSE INCREMENT POSITIVE COUNTER BY 1
DN: INC R2; //INCREMENT MEMORY POINTER
DJNZ R0, UP; //DECREMENT BYTE COUNTER BY 1 IF BYTE COUNTER ≠ 0 THEN JIMP TO DN
END;
13. Addition of two BCD numbers
MOV DPTR, #4000H; //INITIALISE MEMORY POINTER TO EXTERNAL MEMORY
MOVX A, @DPTER; //READ 1ST NUMBER IN A REGISTER
MOV R0, A; //STORE 1ST NUMBER IN R0 REGISTER
INC DPTR; //INCREMENT MEMORY POINTER BY 1
MOVX A, @DPTR; //LOAD 2ND NUMBER IN A REGISTER
ADD A, R0; //ADD 1ST NUMBER WITH 2ND NUMBER
DAA; //ADJUST RESULT TO BCD
INC DPTR //INCREMENT EXTERNAL MEMORY POINTER BY 1
MOVX @DPTR, A; //STORE RESULT TO EXTERNAL MEMORY
END
14. Block Transfer in Internal Memory
MOV R3, #0AH; //INITIALISE BYTE COUNTER
MOV R0, #40H; //INITIALISE MEMORY POINTER FOR SOURCE ARRAY
MOV R1, #50H; //INITIALISE MEMORY POINTER FOR DESTINATION ARRAY
MOV A, @R0; //READ NO FROM SOURCE ARRAY
MOV @R1, A; //WRITE NO TO DESTINATION ARRAY
INC R0; //INCREMENT SOURCE MEMORY POINTER BY 1
INC R1; //INCREMENT DESTINATION MEMORY POINTER BY 1
DJNZ R3, UP; //DECREMENT BYTE COUNTER BY 1, IF BYTE COUNTER ≠ 0
THEN JUMP TO UP
END
15. Sum of series of 8 bit numbers
CLR PSW.7; //CLEAR CARRY FLAG
MOV R3, #00H; //INITIALISE CARRY COUNTER WITH 00
MOV R0, #0AH; //INITIALISE BYTE COUNTER
MOV R1, #20H; //INITIALISE MEMORY POINTER
MOV A, #00H; //CLEAR ACCUMULATOR
ADDC A, @R1; //ADD A WITH NUMBER FROM ARRAY WITH CARRY
JNC DN; //IF CY=0 THEN JUMP TO DN
INC R3; //INCREMENT CARRY COUNTER
INC R1; //INCREMENT MEMORY POINTER
DJNZ R0, UP; //DECREMENT BYTE COUNTER BY 1, IF R0 ≠ 0 THEN JUMP TO UP
MOV @R1, A; //STORE LSB RESULT TO INTERNAL MEMORY
INC R1; //INCREMENT MEMORY POINTER
MOV A, R3; //STORE MSB RESULT TO A
MOV @R1, A; //STORE MSB RESULT TO INTERNAL MEMORY
END
