Q1: Program: Write an ALP to move a block of n bytes of data from source (20h) Q5: Write an ALP to add

o add the byte in the RAM at 34h and 35h, store the result in
to destination (40h) using Internal-RAM. the register R5 (LSB) and R6 (MSB), using Indirect Addressing Mode.

ORG 0000H​ ORG 0000H​

MOV R0, #20H​ MOV R0, #34H​
MOV R1, #40H​ MOV R1, #35H​
MOV R3, #05H​ MOV A, @R0​
BACK:​ ADD A, @R1​
MOV A, @R0​ MOV R5,A​
MOV @R1, A​ MOV R6, #00H​
INC R0​ JNC SKIP​
INC R1​ INC R6​
DJNZ R3, BACK​ SKIP:​
HERE:​ HERE:​
SJMP HERE​ ​ SJMP HERE​
END END
Q2: Program: Write an ALP to move a block of n bytes of data from source Q6: Write an ALP to subtract the bytes in Internal RAM 34h & 35h store the result
(2000h) to destination (2050h) using External RAM. in register R5 (LSB) & R6 (MSB).

ORG 0000H​ ORG 0000H​

MOV DPH, #20H​ MOV R0, #34H​
MOV R4, #00H​ MOV R1, #35H​
MOV R5, #50H​ MOV A, @R0​
MOV R6, #05H​ CLR C​
BACK:​ SUBB A,@R1​
MOV DPL, R4​ MOV R5, A​
MOVX A, @DPTR​ MOV R6, #00​
MOV DPL, R5​ JNC SKIP​
MOVX @DPTR, A​ DEC R6​
INC R4​ SKIP:​
INC R5​ HERE:​
DJNZ R6, BACK​ ​ SJMP HERE​
HERE:​ END
SJMP HERE​ Q7: Write an ALP to multiply two 8-bit numbers stored at 30h and 31h and
END store16- bit result in 32h and 33h of Internal RAM.

Q3: Program: Write an ALP To exchange the source block starting with address ORG 0000H​
20h, containing N bytes of data with destination block starting with address 40h.
MOV R0, #30H​
ORG 0000H​ MOV R1, #31H​
MOV R0, #20H​ MOV A, @R0 ​
MOV R1, #40H​ MOV B, @R1​
MOV R3, #05H​ MUL AB​
BACK:​ MOV R0, #32H​
MOV A, @R0​ MOV R1, #33H​
XCH A, @R1​ MOV @R0, A ​
MOV @R0, A​ MOV @R1, B​
INC R0​ HERE:​
INC R1​ ​ SJMP HERE​
DJNZ R3, BACK​ END
HERE:​ Q8: Write an ALP to perform division operation on 8-bit number by 8-bit number.
SJMP HERE​
END ORG 0000H​
MOV R0, #30H​
Q4:Program: Write an ALP to exchange the source block starting with address
MOV R1, #31H​
10h, containing N bytes of data with destination block starting at location 00h.
MOV A, @R0 ​
ORG 0000H​ MOV B, @R1​
MOV R0, #10H​ DIV AB​
MOV R1, #00H​ MOV 32H, A​
MOV R2, #06H​ MOV 33H, B​
MOV DPH, #00H​ HERE:​
BACK:​ ​ SJMP HERE​
MOV DPL, R1​ END
MOVX A, @DPTR​
XCH A, @R0​
MOVX @DPTR, A​
INC R0​
INC R1​
DJNZ R2, BACK​
HERE:​
SJMP HERE​
END
Q9: Write an ALP to separate positive and negative in a given array.
Q11: Write an ALP to arrange the numbers in Ascending & Descending order.
ORG 0000H​
MOV R0, #30H​ ORG 0000H​
MOV R3, #05H​ MOV R0,#30H​
MOV R4, #40H​ MOV R1,#05H​
MOV R5, #50H​ SORT:​
LOOP:​ ​ MOV B,R3​
​ MOV A, @R0​ ​ MOV R2,B​
​ JNB ACC.7, POSITIVE​ PASS:​
NEGATIVE:​ MOV R1,#04H​
//MOV R6, A​ MOV R0,#30H​
MOV B, R5​ COMPARE:​
MOV R1, B​ MOV A,@R0​
MOV @R1, A​ MOV B,A​
INC R5​ INC R0​
SJMP NEXT​ MOV A,@R0​
POSITIVE:​ CJNE A,B,CHECK​
//MOV R6, A​ SJMP SKIP​
MOV B, R4​ CHECK:​
MOV R1, B​ JNC SKIP ;JNC=Ascending AND JC=Descending​
MOV @R1, A​ MOV @R0, B​
INC R4​ DEC R0​
NEXT:​ MOV @R0, A​
INC R0​ INC R0​
DJNZ R3, LOOP​ SKIP:​
​ DJNZ R1,COMPARE​
HERE:​ DJNZ R2, PASS​
​ SJMP HERE​ HERE:​
END ​ SJMP HERE​
Q10: Write an ALP to separate even or odd elements in a given array.
END
Q12: Write an ALP to find Largest & Smallest number from a given array starting
ORG 0000H​
from 20h & store it in Internal Memory location 40h.
MOV R0, #30H​
MOV R3, #05H​ ORG 0000H​
MOV R4, #40H​ MOV R0,#20H​
MOV R5, #50H​ MOV R2,#05H​
LOOP:​ MOV A,@R0​
​ MOV A, @R0​ MOV R1,A​
​ JNB ACC.0, EVEN​ MOV R3,A​
ODD:​ DEC R2​
//MOV R6, A​ LOOP:​
MOV B, R5​ ​ INC R0​
MOV R1, B​ ​ MOV A,@R0​
MOV @R1, A​ MOV 30H,R1​
INC R5​ ​
SJMP NEXT​ ​ CJNE A,30H,COMPARE_MAX​
EVEN:​ ​ SJMP COMPARE_MIN​
//MOV R6, A​ COMPARE_MAX:​
MOV B, R4​ ​ JC COMPARE_MIN​
MOV R1, B​ ​ MOV R1,A​
MOV @R1, A​ COMPARE_MIN:​
INC R4​ ​ MOV 35H,R3​
NEXT:​ ​ CJNE A,35H,CHECK_MIN​
INC R0​ MOV R3,A​
DJNZ R3, LOOP​ SJMP NEXT​
HERE:​ CHECK_MIN:​
​ SJMP HERE​ ​ JNC NEXT​
END ​ MOV R3,A​
NEXT:​
​ DJNZ R2,LOOP​
MOV 40H,R1​
MOV 41H,R3​
END
Q13:Write an ALP for Decimal UP-Counter. Q15: Write an ALP for Hexadecimal UP-Counter.

ORG 0000H​ ORG 0000H​

​ MOV P1,#00H​ ​ MOV P1,#00H​
​ JMP MAIN​ ​ JMP MAIN​
MAIN:​ MAIN:​
​ MOV R2,#10​ ​ MOV R2,#15​
​ MOV R3,#00H​ ​ MOV R3,#00H​
COUNT_LOOP:​ COUNT_LOOP:​
​ MOV P1,R3​ ​ MOV P1,R3​
​ ACALL DELAY​ ​ INC R3​
​ INC R3​ ​ DJNZ R2,COUNT_LOOP​
​ DJNZ R2,COUNT_LOOP​ ​ JMP MAIN​
​ JMP MAIN​ DELAY:​
DELAY:​ ​ MOV R6,#200​
​ MOV R6,#200​ DELAY_OUTER:​
DELAY_OUTER:​ ​ MOV R7,#200​
​ MOV R7,#200​ DELAY_MIDDLE:​
DELAY_MIDDLE:​ ​ MOV R5,#200​
​ MOV R5,#200​ DELAY_INNER:​
DELAY_INNER:​ ​ NOP​
​ NOP​ ​ NOP​
​ NOP​ ​ DJNZ R5,DELAY_INNER​
​ DJNZ R5,DELAY_INNER​ ​ DJNZ R7,DELAY_MIDDLE​
​ DJNZ R7,DELAY_MIDDLE​ ​ DJNZ R6,DELAY_OUTER​
​ DJNZ R6,DELAY_OUTER​ ​ RET​
​ RET​ END
END Q16: Write an ALP for Hexadecimal DOWN-Counter.
Q14:Write an ALP for Decimal DOWN-Counter.
ORG 0000H​
ORG 0000H​ ​ MOV P1,#00H​
​ MOV P1,#00H​ ​ JMP MAIN​
​ JMP MAIN​ MAIN:​
MAIN:​ ​ MOV R2,#15​
​ MOV R2,#0FH​ ​ MOV R3,#0FH​
​ MOV R3,#00H​ COUNT_LOOP:​
COUNT_LOOP:​ ​ MOV P1,R3​
​ MOV P1,R3​ ​ DEC R3​
​ ACALL DELAY​ ​ DJNZ R2,COUNT_LOOP​
​ INC R3​ ​ JMP MAIN​
​ DJNZ R2,COUNT_LOOP​ DELAY:​
​ JMP MAIN​ ​ MOV R6,#200​
DELAY:​ DELAY_OUTER:​
​ MOV R6,#200​ ​ MOV R7,#200​
DELAY_OUTER:​ DELAY_MIDDLE:​
​ MOV R7,#200​ ​ MOV R5,#200​
DELAY_MIDDLE:​ DELAY_INNER:​
​ MOV R5,#200​ ​ NOP​
DELAY_INNER:​ ​ NOP​
​ NOP​ ​ DJNZ R5,DELAY_INNER​
​ NOP​ ​ DJNZ R7,DELAY_MIDDLE​
​ DJNZ R5,DELAY_INNER​ ​ DJNZ R6,DELAY_OUTER​
​ DJNZ R7,DELAY_MIDDLE​ ​ RET​
​ DJNZ R6,DELAY_OUTER​ END
​ RET​
END
Q17: Write an 8051 C program to find the sum of the first 10 Integer Numbers. Q21: Write an 8051 C Program to rotate the stepper motor in Clock &
Anti-Clockwise direction.
#include<reg51.h>​
void main(void)​ #include <at89c51xd2.h>​
{​ void delay(void);​
​ unsigned char x;​ void main(void)​
​ unsigned int sum=0;​ {​
​ for(x=1;x<=30;x++)​ ​ while(1)​
​ {​ ​ {​
​ ​ sum+=x;​ ​ ​ P2 = 0x07;​
​ }​ ​ ​ delay();​
​ P1=sum&0xFF;​ ​ ​ P2 = 0x08;​
​ P2=(sum>>8)&0xFF;​ ​ ​ delay();​
} ​ ​ P2 = 0x0D;​
​ ​ delay();​
Q18: Write an 8051 C program to find the Factorial of a given number.
​ ​ P2 = 0x0E;​
#include<reg51.h>​ ​ ​ delay();​
void main()​ ​ ​ // To rotate anti-clockwise, reverse
{​ the sequence: 0x0E → 0x0D → 0x08 → 0x07​
unsigned char num=7;​ ​ }​
unsigned int i;​ }​
unsigned long factorial=1;​ void delay(void)​
for(i=1;i<=num;i++)​ {​
{​ ​ int i;​
factorial=factorial*i;​ ​ for(i = 0; i < 30000; i++);​
}​ }
P1=factorial;​
Q22: Write an 8051 C program to Generate Sine & Square waveforms using DAC
P2=(factorial&0xFF00)>>8;​ interface.
}
/*Square Wave*/​
Q19: Write an 8051 C program to find the Square of a number (1 to 10) using #include <at89c51xd2.h>​
Look-Up Table.
void delay(void);​
#include<reg51.h>​ void main(void)​
unsigned char code square_table[11] {​
={0,1,4,9,16,25,36,49,64,81,100};​ ​ while(1)​
void main(void)​ ​ {​
{​ ​ ​ P1 = 0x00;​
unsigned char num = 6; //Change this value 0-10​ ​ ​ delay();​
unsigned char result;​ ​ ​ P1 = 0xFF;​
result = square_table[num];​ ​ ​ delay();​
P1 = result;​ ​ }​
while(1);​ }​
} void delay(void)​
Q20: Write an 8051 C program to count the number of Ones and Zeros in two {​
consecutive memory locations. ​ int i;​
#include <reg51.h>​ ​ for(i = 0; i < 300000; i++);​
void main(void)​ }​
{​ /*Sine Wave*/​
unsigned char byte1, byte2, i, bitval;​ #include <reg51.h>​
unsigned char ones = 0, zeros = 0;​ unsigned char code sine_tab[64] = {​
byte1 = *(unsigned char *)0x30;​ 128,140,153,165,177,188,199,209,218,226,234,240,246,
byte2 = *(unsigned char *)0x31;​ 250,253,255,255,254,252,248,243,237,230,222,213,203,
for(i = 0; i < 8; i++) {​ 193,182,170,158,146,134,121,109,97,85,73,62,51,41,32
bitval = (byte1 >> i) & 0x01;​ ,24,16,10,4,0,0,2,5,10,16,24,32,41,51,62,73,85,97,10
if(bitval) ones++;​ 9,121,134,146,158​
else zeros++;​ };​
}​ void main() {​
for(i = 0; i < 8; i++) {​ ​ while(1) {​
bitval = (byte2 >> i) & 0x01;​ ​ ​ for(unsigned char i = 0; i < 64; i++)
if(bitval) ones++;​ {​
else zeros++;​ ​ ​ ​ P2 = sine_tab[i];​
}​ ​ ​ ​ for(int j = 0; j < 1000; j++);​
P1 = ones; // Number of 1s​ ​ ​ }​
P2 = zeros; // Number of 0s​ ​ }​
while(1);​ }
}