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

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

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

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