MICROPROCESSORPROGRAMS:

Implementation of data transfer instructions using X86

A) To fill the registers using immediate data:

Program:
Label Mnemonics Comments
M OV AX,1 2 34 H As s ig n t h e v a lu e t o AX
M OV BL ,5 6 H M o v e t h e v a lu e o f 56H t o BL
M OV CX,2 4 56 H M o v e t h e v a lu e 2456H
M OV DH,8 4 H As s ig n t h e v a lu e o f 84H t o DH
HL T St o p t h e p r o gr a m

Register H L
AX 12H 34H
BX 00H 56H
CX 24H 56H
DX 84H 00H

B) Initialize register AXwith data 5678H

Program:
L a be l M n e m on ic s Co m m e n t s
M OV AX,5 6 78 H As s ig n t h e v a lu e t o AX
M OV BX,7 8 56 H As s ig n t h e v a lu e t o BX a s 7856
M OV CX,BX M o v e t h e v a lu e o f BX t o CX
M OV DX,BX M o v e t h e v a lu e o f BX t o DX
HL T St o p t h e p r o gr a m
 Register H L
AX 56H 78H
BX 78H 56H
CX 78H 56H
DX
78H 56H

C) Create an array of 5 numbers by direct addressing

Program:

Label Mnemonics Comments

M OV BL ,[2 0 0 0H] Assign the value for BL in 2000
M OV [2010H],B L Move the value of BLto 2010
M OV BL ,[2 0 0 1H] Assign value for BL in 2001
M OV [2011H],B L Move the value of BLto 2011
M OV BH,[2 0 02 H] Assign value for BL in 2002
M OV [2012H],B H Move the value of BLto 2012
M OV BH,[2 0 03 H] Assign value for BL in 2003
M OV [2013H],B H Move the value of BLto 2013
M OV BH,[2 0 04 H] Assign value for BL in 2004
M OV [2014H],B H Move the value of BLto 2014
HL T Stop the program

Input Input Output Output

Address Data Address Data
2000H 10H 2010H 10H
2001H 20H 2011H 20H
2002H 30H 2012H 30H
2003H 40H 2013H 40H
2004H 50H 2014H 50H

D) Create an array by usingMOV command and index registers:

Program:
Label Mnemonics Comments
M OV CX,0 5 H As s ig n t h e v a lu e o f CX in 05
M OV SI,2 0 0 0 H As s ig n t h e v a lu e o f SI in 2000
M OV DI,3 0 0 0 H As s ig n t h e v a lu e o f DI in 3000
Ne x t : M OV AL ,[SI ] M o v e t h e v a lu e o f SI t o AL
M OV [DI],AL M o v e t h e v a lu e o f AL t o DL
INC SI In c r em e n t SI v a lu e
INC DI In c r em e n t DI v a lu e
L OOP NEX T Re p e at t h e lo o p
HL T St o p t h e p ro g ra m

Input Input Output Output

Address Data Address Data
2000H 10H 3000H 10H
2001H 20H 3001H 20H
2002H 30H 3002H 30H
2003H 40H 3003H 40H
2004H 50H 3004H 50H
IMPLEMENTATION OFARITHMETICINSTRUCTIONSUSINGX 86
A) 8-Bit Addition –Direct Addressing
LABEL MNEMONICS COMMENTS
MOVCL, 00H Assign the value CLto 00
MOVAL,[2000H] Assign the value ALto 2000
MOVBL,[2001H] Assign the value BLto 2001
ADD AL,BL Add ALand BL
JNCL1 Jump to L1 if no carry
L1 MOV[2002H],AL Move value AL to 2002
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA
2000H 45H
2002H 50H
2001H 18H

B) 8-Bit Addition –Indirect Addressing

LABEL MNEMONICS COMMENTS
MOVBX,3000H Assign the value BXto 3000
MOVAL, [BX] Move value BXto AL
INCBX Increment BX
MOVCL, [BX] Move value BXto CL
ADD AL,CL Add ALand CL
INCBX Increment BX
MOV[BX],AL Move value AL to BX
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA
H L H L
3000H 00 23H
 3002H 00 68H
3001H 00 45H

C) 16-Bit Addition –Direct Addressing

LABEL MNEMONICS COMMENTS

MOVCX, 00H Assign the value CXto 00
MOVAX,[1000H] Assign the value AXto 1000
MOVBX,[1002H] Assign the value BXto 1002
ADD AX, BX Add AXand BX
JNCL1 Jump to L1 if no carry
INCCX Increment CX
L1: MOV[1004H],AX Move the value AXto 1004
MOV[1006H],CX Move the value CXto 1006
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA

2000H AAH
2023H 65H
2001H BAH
2024H 76H
2002H BBH
2033H 01H
2003H BBH

D) 16-Bit Addition –Indirect Addressing

LABEL MNEMONICS COMMENTS

MOVBX,2000H Assign the value BXto 2000
MOVAX,[BX] Move value BXto AX
MOVCX,00H Assign value CXto 00
MOVBX,2002H Assign value BXto 2002
MOVCX,[BX] Move value BXto CX
ADD AX,CX Add AXand CX
JNCL1 Jump 4 if no carry
 INCCX Increment CX
L1 MOV[BX+20H],AX Move value AXto BXand 20
MOV[BX+30H],CX Move value CXto BXand 30
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA
2000H AAH
2023H 65H
2001H BAH
2024H 76H
2002H BBH
2033H 01H
2003H BBH

E) 16-Bit subtraction –Direct Addressing

LABEL MNEMONICS COMMENTS

MOVCL,00H Assign the value CLto 00
MOVAX,[2000H] Assign the value AXto 2000
MOVBX,[2002H] Assign the value BXto 2002
SUB AX,BX Subtract AXand BX
JNCL1 Jump L1 if no carry
INCCL Increment CL
NEGAX If negative go to AX
L1 MOV[2004H] Move value AXto 2004
MOV[2006H] Move value CLto 2006
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA
2000H AAH
2004H 56H
2001H 77H
2005H 44H
2002H 44H
2006H 00H
2003H 33H

F) 16-Bit ubtraction –Indirect Addressing

LABEL MNEMONICS COMMENTS
MOVBX,2000H Assign value BXto 2000
MOVAX,[BX] Move value BXto AX
MOVCL,00H Assign value CLto 00
INCBX Increment BX
INCBX Increment BX
MOVDX,[BX] Move value BXto DX
SUB AX,DX Subtract AXto DX
INCL1 Jump L1 if no carry
INCCL Jump CLif no carry
NEGAX If negative go to AX
L1 INCBX Increment BX
INCBX Increment BX
MOV[BX},AX Move value AXto BX
INCBX Increment BX
INCBX Increment BX
MOV[BX],CL Move value CLto BX
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA
2000H AAH
2004H 66H
2001H 77H
2005H 46H
2002H 44H
2006H 00H
2003H 33H

G) 8-Bit –Multiplication
LABEL MNEMONICS COMMENTS
MOVAL,[3000H] Assign the value ALto 3000
MOVBL,[3001H] Assign the value ALto 3001
 MULBL Multiply with BL(ALX BL)
MOV[3002H],AL Move value to 3002
MOV[3003H],DL Move value to 3003
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA
3000H 20H 3002H 00H

3001H 60H 3003H 0CH

H) 16-Bit –Division
LABEL MNEMONICS COMMENTS
MOVAX,[3000H] Assign value ALto 3000
MOVBX,[3002H] Assign value BXto 3002
DIV BX Divide with BX
MOV[3004H],AX Move value AXto 3004
MOV[3006H],DX Move value DXto 3006
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA
3000H 50H
3004H 10H
3001H 00H
3005H 05H
3002H 05H

3003H 00H
IMPLEMENTATION OFLOGICAL OPERATIONSUSINGX86
A) Masking 8 Bit lower and higher nibble
LABEL MNEMONICS COMMENTS
MOVAL,[3000H] Assign the value to AL
MOVDL,AL Move ALto DL
MOVBL,0FF0H Assign BL=0FF0H
AND AL,BL And AL, BL
MOVCL,AL MOVALto CL
Shr CL,AL Shift CL4 timesright
MOV[3001H],CL Move CLto 3001H
MOVAL,BL Move BLto AL
MOVBL, 0FH Assign 0FH to BL
AND AL,BL And AL,BL
MOV[3002H],AL Move ALto 3002H
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA
3000H ABH 3001H 0AH

3002H 0BH
 B) Masking lower bit nibble to higher bit nibble using 16 bit data
LABEL MNEMONICS COMMENTS
MOVAX,[2000H] Assign the value to AX
MOVDX,AX Move AXto DX
MOVBX,0FF0H Assign BXas 0FF0H
AND AX,BX And AX, BX
Shr AX,08H Shift AXright 8 times
MOV[2002H],AX Move value of AXto 2002H
MOVBX,00FFH Assign BXas 00FFH
AND BX,DX And BXand DX
MOV[2004H],BX Move BXto 2004H
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA
2000H AAH 2002H AAH
2003H 00H
2001H BBH 2004H BBH
2005H 00H

C) Resetting the bit B5 to ATH:

LABEL MNEMONICS COMMENTS
MOVAL,A7H Assign ALas A7H
MOVDL,DFH Assign DLasDFH
AND AL,BL And between ALand BL
MOV[2500H],AL Move ALto 2500H
HLT Stop the program
INPUT INPUT OUTPUT OUTPUT
REGISTER DATA REGISTER DATA
AL A7H 2005H A7H

DL DFH

D) Setting B4 of data as 8FH:

LABEL MNEMONICS COMMENTS
MOVAL,8FH Assign ALas 8FH
MOVBL,10H Assign BLas10H
ORAL,BL ORALand BL
MOV[2600H],AL Move ALto 2600H
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

REGISTER DATA REGISTER DATA
AL 8FH 2600H 9FH

DL 10H

E) Complement the bit 67 of data 78H:

LABEL MNEMONICS COMMENTS
MOVAL,78H Assign ALas 8FH
MOVBL,80H Assign BLas80H
XORAL,BL X-ORAL and BL
MOV[2700H],AL Move ALto 2700H
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

REGISTER DATA REGISTER DATA
AL 78H 2700H 88H

BL 80H
 F) To separate the odd positive and even negative data.
LABEL MNEMONICS COMMENTS
MOVCL,06H Assign CLas06H
MOVBX,3000H Assign value to BXas 3000H
MOVSI,4000H Move value of 4000H to SI
MOVDI,4100H Move value of 4100H to DI
GO: MOVAL,[BX} Move value BXto AL
AND AL,01 And between ALand 01.
JNZODD Jump to odd if no zero
MOVAL,[BX] Move value BXto AL
AND AL,80H And between ALand 80H
JZSKIP Jump if zero to skip
MOVAL,[BX] Move value of BXto AL
MOV[SI],AL Move value of AL to SI
INCSI Increment SI
JMPSKIP Jump to skip
ODD: MOVAL,[BX] Move value of BXto AL
AND AL,80H And between ALand 80H
JNZSKIP Jump if no zero go to skip
MOVAL,[BX] Move value of BXto AL
MOV[DI],AL Move ALto DI
INCDI Increment DI
SKIP:: INCBX Increment BX
LOOPGO Starts again from Go
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA
3000H 3500H
3001H 3501H
3002H 3502H
3003H 3503H
3004H 3504H
3005H 3600H
3006H 3601H
3007H 3602H
3008H 3603H
3009H 3604H

SORTINGAND ARRAYPROCESSING USINGX86

A) Obtain largest and smallest data in a given array:
LABEL MNEMONICS COMMENTS
MOVSI,4000H Assign 4000H to SI
MOVCX,0004H Assign 0004H to CX
MOVAL,[SI] Move SI value to AL
MOVDL,[SI] Move SI value to DL
NEXT:INCSI Increment SI
CMPAL,[SI] Compare AL and SI values
JNCGO Jump if no carry to go
MOVAL,[SI] Move SI value to AL
GO:CMPDL,[SI] Compare DLand SI value
JCSKIP Jump if carry to skip
MOVDL,[SI] Move SI value to DL
SKIP:LOOPNEXT Go to loop next
MOV[4010H],AL Move ALvalue to 4010H
MOV[4020H],DL Move DLvalue to 4020H
HLT Stop the program
INPUT INPUT OUTPUT OUTPUT
ADDRESS DATA ADDRESS DATA
4000H 70H
4001H 80H 4010H 90H
4002H 20H
4003H 30H 4020H 20H
4004H 90H

B) Sort numbersin ascending order usingbubble sort technique:

LABEL MNEMONICS COMMENTS
MOVBX,0004H Assign BXvalue as0004H
OUTPUT:MOV CX,BX Move CXand BX
MOVSI,4000H Move 4000H to SI
IN LOOP:MOVAL,[SI] Move SI value to AL
INCSI Increment SI
CMPAL,[SI] Compare SI and ALvalue
JBNEXT Jump if borrow go to next
XCHGAL,[SI] Exchange SI and ALvalue
MOV[SI-1],AL Move ALto [SI-1]
NEXT:LOOPINLOOP Go to next IN-LOOP
DECBX Decrement BX
JNZ OUTPUT Jump if no zero go to output
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA
4000H 30H 4000H 10H
4001H 60H 4001H 30H
4002H 90H 4002H 60H
4003H 70H 4003H 70H
4004H 10H 4004H 90H

C) Sort numbersin descending order usingbubble sort technique:

LABEL MNEMONICS COMMENTS
MOVBX,0004H Assign 0004 value to BX
OUTPUT:MOV CX,BX Move BXvalue to CX
MOVSI,4000H Move 4000 to SI
IN LOOP:MOVAL,[SI] Move SI value to AL
 INCSI Increment SI
CMPAL,[SI] Compare SI and ALvalue
JNB NEXT Jump if no borrow to next
XCHGAL,[SI] Exchange AL and SI value
MOV[SI-1],AL Move ALto [SI-1]
NEXT:LOOPINLOOP Go to IN-LOOP
DECBX Decrement BX
JNZ: OUTPUT Jump if no zero; go to output
HLT Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA
4000H 30H 4000H 90H
4001H 60H 4001H 70H
4002H 90H 4002H 60H
4003H 70H 4003H 30H
4004H 10H 4004H 10H

MICROCONTROLLERPROGRAMS:

Code conversion programs using 8051:

A) Conversion of BCD to binary number:

LABEL MNEMONICS COMMENTS

MOVR4,#05H Move value of 05H to R4
MOVR0,#40H Assign R0 value as40H
MOVDPTR,#8400H Assign DPTRvalue to A
L1: MOVXA,@DPTR Move DPTRvalue to A
CALLCONVERT Call CONVERTfunction
INCDPTR Increment DPTR
DJNZR4,L1 Repeat till R4=0
SJMP$ Short jump here
CONVERT: MOVR2,A Move A value to R2
ANL A,#0F0H Perform AND between A and 0F0H
SWAP A Swap value of A
MOVB,#0AH Assign B value in 0AH
 MULAB Multiply A and B
MOVR1,A Move A value to R1
MOVA,R2 Move R2 value to A
ANL A,#0F0H Perform AND between A and 00FH
ADD A,R1 Add A and R1
MOV@R0,A Move A value to R0
INCR0 Increment R0
RET Return the main program
END Stop the program

INPUT INPUT OUTPUT OUTPUT

ADDRESS DATA ADDRESS DATA
X:8400H 10D D:40H 0AH
X:8401H 11D D:41H 0BH
X:8402H 12D D:42H 0CH
X:8403H 13D D:43H 0DH
X:8404H 14D D:44H 0EH

B) CONVERSION OFBINARYNUMBERINTO BCD:

LABEL MNEMONICS COMMENTS

MOVR4,#05H Assign the value of R4 as05H
MOVR0,#50H Assign the value of R0 as50H
MOV Assign the value of DPTRas
L1: DPTR,#9000H 9000H
MOVXA,@DPTR Move value of DPTRto A
CALLCONVERT Call convert function
INCDPTR Increment DPTR
DJNZR4,L1 Repeat until R4=0
CONVERT: SJMP$ Short jump
MOVB,#64H Move value of B as 64H
DIV AB Divide A and B
INCR0 Increment value of R0
MOV@R0,A Move value of A to R0
 MOVA,B Move the value of B to A
MOVB,#0AH Move the value of B as0AH
DIV AB Divide A and B
SWAP A Swap the value of A
ADD A,B Add A and B
DECR0 Decrement the value of R0
MOV@R0,A Move the value of A to R0
INCR0 Increment the value of R0
INCR0 Increment the value of R0
RET Return to main program
END Stop the program

Input Input Output Output

Address Data Address Data
X:9000H FFH D:50H 55
X:9001H 0AH D:51H 02
X:9002H 0BH D:52H 10
X:9003H 0CH D:53H 00
X:9004H 0DH D:54H 11
D:55H 00
D:56H 12
D:57H 00
D:58H 13

C) Convert an array of six ASCII code to binary value

Label Mnemonics Comments

MOVR2,#05H Move the value of 05H to R2
MOVR0,#20H Move value of 20H to R0
MOVDPTR,#8200H Move value of DPTR@8200H
L1: MOVXA,@DPTR Move value of DPTRto A
CALLCONVERT Call convert function
INCDPTR Increment DPTR
DJNZR2,L1 Repeat until R2=0
SJMP$ Short jump here
CONVERT: CJNEA,#40H,LOOP1 Move 40H to A
LOOP1: JCGO Jump if carry
SUBB A,#37H Subtract A and 37H
 SJMPSKIP Short jump to skip
GO: CLRC Clear C
SUBB A,#30H Subtract A and 37H
SKIP: MOV@R0,A Move A value to R0
INCR0 Increment R0
RET Return to main program
END Stop the program

Input Input Output Output

Address Data Address Data
X:8200H 42H D:20H 0BH
X:8201H 38H D:21H 08H
X:8202H 46H D:22H 0FH
X:8203H 33H D:23H 03H
X:8204H 43H D:24H 0CH

IMPLEMENTATION OFCOUNTERSUSING8051
A) Implementation of timer0 as counter:

Label Mnemonics Comments

MOVTMOD,#06H Set mode for timer as8-bit counter
MOVTH0,#00H Clear TH0
SETBP3.4 Get incoming pulses fed to pin 3.4
DO: SETBTR0 Set bit TR0
BACK: MOVA,TL0 Move TL0 to A
MOVP2,A Move A to P2
JNB TF0,BACK Poll TF0 bit forever flow
CLRTR0 Clear TR0
 CLRTF0 Clear TF0
SJMPDO Short jump
END Stop the program

Inline debug script: Output:

signal void count(void) TCON-10
{ TMOD-06
While(1) TL0-00H; goes on increasing
{ until FFH
P3.4=oxFF; P2-00H; goes on increasing
Swatch(0.5) until FFH
P3.4=ox00;
Swatch(0.5)
}
}
Count();

B) Implementation of timer1 as counter:

Label Mnemonics Comments

MOVTMOD,#60H Set mode for timer
MOVTH1,#00H Clear TH1
SETBP3.5 Get the incoming pulses on
DO: SETBTR1 Set bit TR1
BACK: MOVA,TL1 Move TL1 to A
MOVP2,A Move A to P2
JNB TF1,BACK Poll TF1 bit for overflow
CLRTR1 Clear TR1
 CLRTF1 Clear TF1
SJMPDO Short jump
END Stop the program

Inline debug script: Output:

Signal void count(void) TCON-10
{ TMOD-60
While(1) TH1-00H; goes on increasing
{ until FFH
P3.4=oxFF; P2-00H; goes on increasing
SWATCH(0.5); until FFH
P3.4=ox00;
SWATCH(0.5);
}
}
Count();

Interfacing ADCwith 8051

InterfacingADCwith 8051:

MNEMONICS COMMENTS
9000:MOVDPTR,#2023
9003:MOVA,#90 Issue control word to CWR
9005:MOVX@DPTR,A
9006:MOVA,#00 Select channel 0
9008:MOVDPTR,#2022
900B:MOVX@DPTR,A
900C:MOV DPTR,#2022
900F:MOV A,#80
9011:MOVX@DPTR,A Start of conversion signal in PC7 pin
9012:NOP
9013:NOP
9014:MOVDPTR,#2022
9017:MOVA,#00
9019:MOVX@DPTR,A
901A:MOV DPTR,#2020
901D:MOVXA,@DPTR
901E:ANL A,#80
9020:JNZ901D Check for EOC
9022:MOVA,#40
9024:MOVDPTR,#2022
9027:MOVXA,@DPTR,A Assert PC6 for enable signal(read)
9028:MOVDPTR,#2020
902B:MOVXA,@DPTR Receive digital output of A/P
902C:MOV DPTR,#8000 Converter in port A
902F:MOVX@DPTR,A
9030:MOVR6,A Store the value in 8000 and also display the
9031:LCALL677D same
9034:MOVR0,#FFH Call delay
9036:MOVR1,#FFH
9038:LCALL6850 Continuously monitor analoginput
903B:SJMP9006

Generation of waveforms using DACwith 8051

A) Generation of sawtooth waveform:

MNEMONICS COMMENTS
E000:MOVDPTR,#2023H Move 2023H to DPTR
E003:MOVA,#80H Move 80H to A
E005:MOVX@DPTR,#2020H Move A value of DPTR
E006:MOVDPTR,#2020H Move 2020 value to DPTR
E009:MOVA,#00H Move 00H to A
E00B:MOV @DPTR,A Move A value to DPTR
E00C:INCA Increment A
E00D:SJMPE00B Short jump E00B
E00F:LJMPE009 Long jump E009

B) Generation of triangular waveform:

MNEMONICS COMMENTS
E000:MOVDPTR,#2023H Move 2023H to DPTR
E003:MOVA,#80H Move 80H to A
E005:MOVX@DPTR,A Move A value to DPTR
E006:MOVDPTR,#2020H Move 2020H value to DPTR
E009:MOVA,#00H Move 00H value to A
E00B:MOVX@DPTR,A Move A value to DPTR
E00C:INCA Increment A value
E00D:CJNEA,FFH,E00B
E010:MOVX@DPTR,A Move A value to DPTR
E011:DJNZ0E0H,E010
E010:SJMPE009 Short jump E009

C) Generation of square waveform:

Mnemonics Comments
 E000:MOVDPTR,#2023H Move 2023H value to DPTR
E003:MOVA,#80H Move 80H value to A
E005:MOVX@DPTR,#2020 Move A value to DPTR
E006:MOVDPTR,#2020 Move 2020H value to DPTR
E009:MOVA,#00H Move 00H value to A
E00B:MOVX@DPTR,A Move A value to DPTR
E00C:LCALLE019
E00F:MOVA,#0FFH Move OFFvalue to A
E011:MOVX@DPTR,A Move A value to DPTR
E012:LCALLE019
E015:LJMPE009 Long jump E009
DELAY:
E019:MOVR6,#0F0H Move value of 0FH to R6
E01B:MOV R5,#0F0H Move value of 0FH to R5
E01D:DJNZR5,E01D
E01F:DJNZ R6,E01B
E012:RET Stop the program

Measurement of frequency using 8051

MNEMONICS COMMENTS
8600:MOVDPTR,#2023 Move control word to CWR
8603:MOVA,#82H
8605:MOVX@DPTR,A
8606:MOVDPTR,#2021 Get income in signal through #b0
8609:MOVR5,#00
860B:MOVXA,@DPTR
860C:RRCA Detect logic low of w/f
860D:JC860B
860F:MOVXA,@DPTR
8610:RRCA Detect logic high of w/f
8611:JNC860F
8613:NOP
8614:LCALL8700 Call unknown time delay of 0.5ms
8617:INCR5 Increment counter
8618:MOVXA,@DPTR
8619:RRCA Ensure still it islogic high. If so continuous
861A:JC8614 calling delay until it remain logic high.
861C:MOV A,R5 Store the count value in date memory location
861D:MOVDPTR,#9000 9000 and also display the vlue by calling
8620:MOVX@DPTR,A monitor routine
8621:MOVR6,A
8622:LCALL677D
8625:MOVR0,#FF
8627:MOVR1,#FF
8629:LCALL6850
862C:LCALL003
DELAY:
8700:MOVR1,#E5 Delay for 0.5ms
8702:DJNZR1,8702
8704:RET

Cont rol of firing circuit for SCRusing 8051

MNEMONICS COMMENTS
ORG000H
LJMPMAIN
ORG003H
LJMPISR
MAIN:
MOVTMOD,#01H
MOVTL0,#1FH
MOVTH0,#0F4H
MOVIE,#81H
SETBTCON.0
SETBIE0
HERE:SJMPHERE
ISR:MOVR0,#40H
MOVR1,#06H
GO:ACALLINITDELAY
MOVA,@R0
MOVP1,A
ACALLDELAY
INCR0
DJNZR1,GO
SJMPISR
RETI
INITDELAY:
MOVTL0,#0FFH
MOVTH0,#05H
SETBTR0
CONT:JNB TF0,COUNT
CLRTR0
CLRTF0
RET
DELAY:SETBTR0
AGAIN:JNB TF0,AGAIN
CLRTR0
CLRTF0
MOVTL0,#1FH
MOVTH0,#0F4H
RET
END

Recursion program using 8051

A) Program for recursion:

LABEL MNEMONICS COMMENTS

 MOVR1,30H Assign the value of R1 as30H
MOVR7,#01H Assign the value of R7 as01H
LCALLFACT Call the FACTsubroutine
MOVR7,A Move value of R7 to A
MOVR6,B Move value of R6 to B
FACT: MOVA,R7 Move value of A to R7
CJNER1,#O1,UP Jump if not zero
SJMPUP1 Short jump
UP: MOVB,R1 Move the value of R1 to B
MULAB Multiply A and B
DJNZR1,UP Jump if not zero
UP1: RET Return to the main program
END End the program

INPUT OUTPUT
ADDRESS DATA ADDRESS DATA
D:30H 04H R7 18H

B) PROGRAM FORFACTORIAL

LABEL MNEMONICS COMMENTS

 MOVDPTR,#8400H Assign DPTRvalue as 8400H
MOVXA,@DPTR Move DPTRvalue to A
MOVR3,A Move A value to R3
MOV40H,A Move A value to 40H
L1: DECR3 decrementR3
MOVA,R3 Move A value to R3
MOVB,40H Move B value to 40H
MULAB Multiply A and B
MOV40H,A Move 40H value to A
MOVA,R3 Move R3 value to A
CJNEA,#O1,L1 Jump if not 1
MOVA,40H Move 40Hvalue to A
MOVDPTR,#8401H Move 8401H value to DPTR
MOVX@DPTR,A Move A value to DPTR
L2: SJMP,L2 Short jump
END End the program

INPUT OUTPUT
ADDRESS DATA ADDRESS DATA
X:8400H 04H X:8401H 18H
SIMPLEPROGRAMSUSINGARITHMETICINSTRUCTIONS
OF8051 MICROCONTROLLER

A) PROGRAM FORADDITION

LABEL MNEMONICS COMMENTS

CLR C Make cy=0
MOV A,#E7H Assign A value asE7H
ADD A,#8DH Add A with 8DH
MOVR6,A Save the low byte result inR6
MOVA,#3CH Load the high byte
ADDCA,#3BH Add with carry (3B+3C+78)
MOVR7,A Save the high bit result in R7
END End the program

INPUT OUTPUT
REGISTER DATA REGISTER DATA
A E7H R6 74H
8DH
B 3CH R7 78H
3BH

B) PROGRAM FORSUBTRACTION:
LABEL MNEMONICS COMMENTS
MOVRO,#30H Assign R0 as 30H
MOVA, @R0 Move R0 value to A
INCRO Increment R0
MOVB,@R0 Move R0 value to B
SUBB A,B Subtract with borrow
INCR0 Increment R0
MOV@R0,A Move A value to R0
END End the program
 INPUT OUTPUT
REGISTER DATA REGISTER DATA
A 3F
RO 1CH
B 23

C) PROGRAM FORMULTIPLICATION

LABEL MNEMONICS COMMENTS

CLRC Make cy=0
MOVA,40H Assign A value in 40H
MOVB,41H Assign B value in 41H
MULAB Multiply A and B
MOV42H,A Move A value to 42H
MOV43H,B Move B value to 43H
END End the program

INPUT OUTPUT
REGISTER DATA REGISTER DATA
D:40H 25H D:42H 99H

D:41H 65H D:43H 0EH

D) PROGRAM FORDIVISION
LABEL MNEMONICS COMMENTS
CLRC Make cy=0
MOVA,40H Assign A value in 40H
MOVB,41H Assign B value in 41H
DIV AB Divide A and B
MOV42H,A Move A value to 42H
MOV43H,B Move B value to 43H
END End the program

INPUT OUTPUT
REGISTER DATA REGISTER DATA
D:40H 95H D:42H 09H

D:41H 10H D:43H 05H

E) To add two 8-bit number without carry using 8051:

Label Mnemonics Comments

ORG0000H AT ORIGINMEMORY 0000H
MOVA,#05H MOVETHEVALUEOF05H TOA
MOVR1,#09H MOVETHEVALUEOF09H TOR1
ADD A,R1 ADD A AND R1
MOVDPTR,#2050H STOREDPTRIN2050H MEMORY
MOVX@DPTR,A MOVEA TODPTR
AGAIN: SJMPAGAIN SHORTJUMPAGAIN

INPUT INPUT OUTPUT OUTPUT

REGISTER DATA ADDRESS DATA
A 05H D:2050H 0EH
R1 09H

F) TO SUBTRACTTWO 8 BITNUMBERWITHOUTCARRYUSING8051:

LABEL MNEMONICS COMMENTS

ORG4100H AT ORIGINMEMORY4100H
CLRC CLEARCARRY
MOVA,#0AH MOVETHEVALUEOATOA
MOVR1,#05H MOVETHEVALUE05 TOR1
SUBB A,R1 SUBTRACTA ANDR1
MOVDPTR#4500H STOREDPTRIN4500H MEMORY
MOVX@DPTR,A MOVEA TODPTR
HERE: SJMPHERE SHORTJUMPHERE

INPUT INPUT OUTPUT OUTPUT

REGISTER DATA REGISTER DATA
 A 0AH D:4500H 05H
R1 05H

Serial communication using UART with 8051

MNEMONICS COMMENTS

ORG0H
MOVTMOD,#20H Timer 1 mode 2 autoreloaded
MOVTH1,#-3 Load timer counter
MOVSCON,#50H
SETBTRI Start timer 1
MOVA,#M M is transferred to A
ACALLSEND Call the subroutine send
MOVA,#I I istransferred to A
ACALLSEND Call the subroutine send
MOVA,#C C is transferred to A
ACALLSEND Call the subroutine send
MOVA,#R R is transferred to A
ACALLSEND Call the subroutine send
MOVA,#0 O is transferred to A
ACALLSEND Call the subroutine send
SJMPUP Short jump up
MOVSBUF,A Move A value to sbuffer
JNB T1,HERE Wait for the lastbit
CLRT1 Clear t1 for next char
RET Stops the program

OUTPUT:
In serial window
DISPLAY:

MICRO

A) Stepper motor control using 8051

MNEMONICS COMMENTS
EOOO:MOVDPTR,#2023 Move the control word to CWR
E003:MOVA,#80 Assign a value in 80H
E005:MOVX@DPTR,A Move A value to DPTR
E006:MOVDPTR,#2022 Issue switching sequence for rotating motor
E009:MOVA,#DD Move A value
E00B:MOVX@DPTR,A Move A value to DPTR
E00C:LCALLE100(DELAY) Call delay between switching
E00F:RLA Rotate binary pattern left and get next switching sequence
E010:SJMPE00B Short jump 4
E100:MOVR0,#F7 Repeat
E102:MOVR1,#FF Continuously for continuous
E104:DJNZR1,E104 Rotation for motor
E106:DJNZR0,E102 Jump R0
E108:RET Return the program

B) Stepper motor in half-stepping mode

MNEMONICS COMMENTS
9000:MOVDPTR,#2023H Move control word CWR
9003:MOVA,#80H
9005:MOVX@DPTR,A
9006:MOVR3,#08 Move count for binary patterns
9008:MOVR0,#30 Initializing look u table at 30
900A:MOV DPTR,#2022
900D:MOVA,R0 Get 1 binary pattern in port-c
900E:MOVX@DPTR,A
900F:INCR0
9010:LCALL9017 Call delay isintroduced
9013:DJNZR3,900D
9015:SJMP9006
9017:MOVR1,#F7
9019:MOVR2,#FFH
901B:DJNZR2,901B
901E:DJNZR1,9019
901F:RET

Traffic light controller using 8051

MNEMONICS COMMENTS
8000:MOVDPTR,#2023H Configure control word in CWR
8003:MOVA,#80H Move value of 80H to A
8005:MOVX@DPTR,A Move A to DPTR
8006:MOVR0,#40H Initialize the count for 4-direction
8008:MOVR3,#04H Move 04 value to R3
800A:MOV DPTR,#2020H Move DPTRto 2020H
800D:MOVA,@R0 Move R0 to A
800E:MOVX@DPTR,A Move A to DPTR
800F:INCR0 Increment R0
8010:MOVDPTR,#2021 Move 2021 value to DPTR
8013:MOVA,@R0 Move R0 to A
8014:MOVX@DPTR,A Move A value to pointer
8015:INCR0 Increment R0
8016:MOVDPTR,#2022 Move 2022 value to pointer
8019:MOVA,@R0 Move R0 to A
801A:MOVX@DPTR,A Move A to DPTR
801B:INCR0 Increment R0
801C:ACALL8200 Call delay
801E:DJNZR3,800A If R3 not equal to 0 repeat
8020:SJMP8006 Short jump 8006
8200:MOVR5,#20 Move 20H value to R5
8202:MOVR2,#0FF Move OFFto R2
8204:MOVR4,#0FF Move OFFto R4
8206:DJNZR4,8206 If R4 not equal to 0,repeat
8208:DJNZR2,8204 If R2 not equal to 0,repeat
8204:DJNZR5,8202 If R5 not equal to 0,repeat
820C:RET Return the main