1

8085 MICROPROCESSOR PROGRAMMING

2
Ex. No: 01 AIM: To perform addition and subtraction of two 8-bit numbers using 8085 microprocessor. APPARATUS REQUIRED: 8085 Microprocessor Kit Power Chord

8-BIT ADDITION AND SUBTRACTION

8-BIT ADDITION: ALGORITHM: Step1: Start the program. Step2: Load the accumulator with the content of the memory location. Step3: Move the content of accumulator to register B. Step4: Load the accumulator with content of memory location. Step5: Add the content of A with register B. Step6: Store the content of accumulator in to memory location. Step7: Stop the program. MNEMONICS: MVI C,00H LXI H,4200H MOV A,M INX H MOV B,M ADD B JNC XX INR C

3
XX STA 4202H MOV A,C STA 4203H HLT TABLE 1: Memory Label 4100 4101 4102 4103 4104 4105 4106 MOV 4107 4108 4109 410A 410B 410C 410D 410E 410F 4110 XX MOV A,C 02 42 79 Move the content of c reg to accumulator INR STA C 4202H ADD JNC B,M B XX 80 D2 0D 41 0C 32 Increment value to reg c Store the content of accumulator in memory 4202 46 MOV INX A,M H 23 LXI H,4200H Mnemonics Instruction MVI Operand C,00H HEX CODE 0E 00 21 00 42 7E Move the content of memory to reg A Increment the memory location. Move the content of memory to reg B Add content of B reg to accumulator If there is no carry jump to XX Load the value in HL pair. Move the value 00 to reg C Description

4
4111 4112 4113 4114 HLT STA 4203H 32 03 42 76 Halt the execution Store the content of accumulator in memory 4203

OUTPUT (WITHOUT CARRY): INPUT DATA: 4200: 06 4201: 02 OUTPUT (WITH CARRY): INPUT DATA: 4200: FF 4201: FF OUTPUT DATA: 4202: FE 4203: 01 OUTPUT DATA: 4202: 08 4203: 00

5
8-BIT SUBTRACTION: ALGORITHM: Step1: Load the accumulator with content of memory location Step2: Move the content of accumulator to B reg Step3: Load the accumulator with the content of memory location Step4: Subtract the content of A with reg B Step5: Store the content of accumulator into memory location Step6: Stop the program

MNEMONICS: MVI C,00 LXI H,4200H MOV A,M INX H MOV B,M SUB B JNC XX INR C CMA INR A XX: STA 4202H MOV A,C STA 4203H HLT

6
TABLE 2: Mnemonics Instruction Operand MVI LXI C,00 H,4200H HEX CODE 0E 00 21 00 42 MOV INX MOV SUB JNC A,M H B,M B XX 7E 23 46 90 D2 0F 41 INR CMA INR XX STA A 4202H C 0C 2F 3C 32 02 42 MOV STA A,C 4203H 79 32 03 Move the content of C reg to A Store the accumulator content in 4203H 4114 Increment the C reg Take 1s complement for accumulator 410E 410F 4110 4111 4112 4113 Add 1s complement with 1 Store the accumulator content in 4202H Move the content of memory to accumulator 4106 4107 4108 4109 410A 410B 410C 410D Increment the HL register pair Move the content memory to reg B Sub reg B from accumulator Jump to label XX if no carry Load the value in HL reg pair Move the value 00 to reg c Description

Memory Label 4100 4101 4102 4103 4104 4105

7
4115 4116 HLT 42 76 Halt the execution

OUTPUT (WITHOUT BORROW): INPUT DATA: 4200:05 4201:03 OUTPUT (WITH BORROW): INPUT DATA: 4200:14 4201:89 OUTPUT DATA: 4202:75 4203:01 OUTPUT DATA: 4202:02 4203:00

RESULT: Thus the addition and subtraction of two 8-bit numbers using 8085 microprocessor was performed successfully

8 Ex. No: 02
AIM: To write an assembly language program to add and subtract two 16-bit numbers using 8085 microprocessor kit.

16 BIT ADDITION AND SUBTRACTION

APPARATUS REQUIRED: 8085 Microprocessor Kit Power Chord 16-BIT ADDITION: ALGORITHM: Step1: Start the program. Step2: Load 16 bit data in HL pair and move data 00H to C register. Step3: Exchange data from HL pair to DE pair. Step4: Load another 16 bit data in HL pair. Step5: Add HL pair and DE pair contents and store the result in HL pair. Step6: If carry present Increment the content of CX register once else leave it as it is. Step7: Store data in HL pair to specified memory. Step8: Move data from C register to accumulator. Step9: Store the accumulator data in specified memory. Step10: End.

MNEMONICS: MVI C, 00H LHLD 5300 XCHG LHLD 5302 DAD D JNC Loop1 INR C Loop1: SHLD 5500 MOV A, C STA 5502 HLT TABLE: 1 Mnemonics
Instruction

Memory Label 4100 4101 4102 4103 4014 4105 4106 4107 4108 4109 410A 410B 410C

HEX CODE

Description Move 00H to C register Load 16 bit data to HL pair

Operand

MVI LHLD

C, 00H 5300

0E 00 2A 00 53

XCHG LHLD 5302

EB 2A 02 53

Exchange HL pair data with DE pair Load another 16 bit data in HL pair

DAD JNC

D Loop1

19 D2 0E 41

Add HL pair and DE pair contents and store the result in HL pair If no carry move to specified address

410D 410E 410F 4110 4111 4112 4113 4114 4115 Loop1:

INR SHLD

C 5500

0C 22 00 55

Increment C register content once Store data in HL pair to specified memory Move C register data to accumulator Store the accumulator data in specified memory Halt

MOV STA

A, C 5502

79 32 02 55

HLT

76

OUTPUT: INPUT DATA: 5300: 77 5301: 88 5302: 99 5303: 11 OUTPUT DATA: 5500: 10 5501: 9A 5502: 00

16-BIT SUBTRACTION: ALGORITHM: Step1: Start the program. Step2: Move immediately the data 00H to C register and accumulator. Step3: Load 16 bit data in HL pair and exchange data from HL pair to DE pair. Step4: Load another 16 bit data in HL pair. Step5: Move data from L register to accumulator. Step6: Subtract E register content from accumulator. Step7: Move data from accumulator to L register. Step8: Move data from H register to accumulator. Step9: Subtract with borrow content of D register from accumulator. Step10: Jump to Step 11 when no carry increment the content of C register once. Step11: Move data from accumulator to H register. Step12: Store data in HL pair to specified memory. Step13: Move data from C register to accumulator. Step14: Store the accumulator data in specified memory. Step15: End. MNEMONICS: MVI C, 00H MVI A, 00H LHLD 5600 XCHG LHLD 5602 MOV A, L SUB E MOV L, A MOV A, H SBB D JNC Loop1

INR C MOV H, A Loop1: SHLD 5700 MOV A, C STA 5702 HLT TABLE: 2 Mnemonics
Instruction Operand

Memory Label 41FE 41FF 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 420A 420B 420C 420D 420E 420F
MVI

HEX CODE

Description Move 00H to C register Move 00H to Accumulator Load 16 bit data to HL pair

MVI

C, 00H
A, 00H

0E 00 3E 00 2A 00 56

LHLD

5600

XCHG LHLD 5602

EB 2A 02 56

Exchange HL pair data with DE pair Load another 16 bit data in HL pair

MOV SUB MOV MOV SBB JNC

A, L E L, A A, H D Loop1

7D 93 6F 7C 9A D2 12

Move L register data to accumulator Subtract E register content from accumulator

Move accumulator data to L register

Move H register data to Acc. Subtract with borrow content of D register from accumulator If no carry move to specified address

4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 421A HLT
MOV

42 INR Loop1: MOV SHLD C H, A 5700 0C 67 22 00 57 A,C 5502 79 32 02 57 76 Halt Move C register data to accumulator Store the accumulator data in specified memory STA Increment C register content once Move Acc. data to H register Store data in HL pair to specified memory

OUTPUT: INPUT DATA: 5600: 11 5601: 21 5602: 77 5603: 99 OUTPUT DATA: 5700: 66 5701: 78

RESULT: Thus an assembly language program to add and subtract two 16-bit numbers was written and executed using 8085 microprocessor kit.

Ex. No: 03

8 BIT DATA MULTIPLICATION

AIM: To multiply two 8 bit numbers stored at consecutive memory locations and store the result in memory. ALGORITHM: LOGIC: Multiplication can be done by repeated addition. 1. Initialize memory pointer to data location. 2. Move multiplicand to a register. 3. Move the multiplier to another register. 4. Clear the accumulator. 5. Add multiplicand to accumulator 6. Decrement multiplier 7. Repeat step 5 till multiplier comes to zero. 8. The result, which is in the accumulator, is stored in a memory location. PROGRAM:
ADDRES S OPCOD E LABEL MNEMONIC S OPERAND COMMENT

4100 4101 4102 4103 4104 4105 4106 4107 4108

LXI

H, 4500

Initialize HL reg. to 4500

MOV INX MVI

B, M H A, 00H

Transfer first data to reg. B Increment HL reg. to point next mem. Location. Clear the acc.

MVI

C, 00H

Clear C reg for carry

4109

LOOP1

ADD

Add multiplicand multiplier times.

410A 410B 410C 410D 410E 410F 4110 4111 4112 4113 4114 4115 4116 LOOP2

JNC

LOOP2

Jump to LOOP2 if there is no carry

INR DCR JNZ

C B LOOP1

Increment C reg Decrement B reg Jump to LOOP1 if B is not zero.

INX MOV INX MOV HLT

H M, A H M, C

Increment HL reg. to point next mem. Location. Transfer the result from acc. to memory. Increment HL reg. to point next mem. Location. Transfer the result from C reg. to memory. Stop the program

OBSERVATION:
S.NO 1. INPUT 4500 4501 4502 4503 OUTPUT

RESULT:

Thus the 8-bit multiplication was done in 8085p using repeated addition method

Ex. No: 04
AIM:

16 BIT MULTIPLICATION

To write an assembly language program to multiply two 16-bit datas using 8085 microprocessor kit. APPARATUS REQUIRED: 8085 Microprocessor Kit Power Chord

ALGORITHM: Step1: Start the program. Step2: Load 16 bit data in HL pair and move data from HL pair to Stack Pointer. Step3: Load another 16 bit data in HL pair and move the data to DE pair. Step4: Move data 0000H to BC and HL pair. Step5: Add 16 bit data present in Stack Pointer with HL pair. Step6: If carry present goto Step 8 else goto step 7. Step7: Increment BC register pair content once. Step8: Decrement DE register pair content once. Step9: Move D register content to accumulator and OR function it with E register content. Step10: Check whether A is zero or not. If A=0 goto Step 6 else goto Step 5. Step11: Store HL pair content in memory. Step12: Move BC pair content to HL pair and then to memory. Step13: End.

MNEMONICS: LHLD 4200 SPHL LHLD 4202 XCHG LXI LXI JNC INX H, 0000H B, 0000H Loop2 B

Loop1: DAD SP

Loop2: DCX D MOV A, D ORA E JNZ Loop1 SHLD 4500 MOV H, B MOV L, C SHLD 4502 HLT TABLE: 1 Mnemonics
Instruction

Memory Label 4100 4101 4102 4103 4104 4105 4106 SPHL LHLD LHLD

HEX CODE

Description Load 16 bit data from memory to HL pair

Move HL pair content to stack pointer Load another 16 bit data from memory to accumulator

Operand

4200

2A 00 42 F9

4202

2A 02 42

4107 4108 4109 410A 410B 410C 410D 410E 410F 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 411A 411B 411C 411D 411E 411F 4120 4121 Loop2: Loop1:

XCHG LXI H, 0000H

EB 21 00 00

Move HL pair content to DE pair

Move data 0000H to HL pair

LXI

B, 0000H

01 00 00

Move data 0000H to BC pair

DAD JNC

SP Loop2

39 D2 13 41

Add SP data with HL pair data If carry present jump to specified memory Increment BC pair content once Decrement DE pair content once Move D register content to Acc. OR function Accumulator content with E register content Jump when no zero to specified memory Store HL pair content in specified memory Move B register content to H register Move C register content to L register Store HL pair content in specified memory Halt

INX DCX MOV ORA JNZ

B D A, D E Loop1

03 1B 7A B3 C2

4500 SHLD H, B MOV MOV SHLD L, C 4502

0E 41 22 00 45 60 69 22 02 45

HLT

76

OUTPUT: INPUT DATA: 4200: 22 4201: 22 4202: 33 4203: 33 OUTPUT DATA: 4500: C6 4501: 92 4502: D3 4503: 06

RESULT: Thus an assembly language program to multiply two 16-bit datas and was written and executed using 8085 microprocessor kit.

Ex. No: 05
AIM:

8- BIT DIVISION

To write an assembly language program to divide two 8 bit datas using 8085 microprocessor kit. APPARATUS REQUIRED: 8085 Microprocessor Kit Power Chord ALGORITHM: Step1: Start the program. Step2: Move immediately the data 00H to B register and load 8 bit data from memory to accumulator. Step3: Move the accumulator content to C register. Step4: Load another 8 bit data in HL pair. Step5: Compare accumulator content with C register content. If equal Zero Flag gets affected. Step6: If A<C then carry gets affected. Step7: Increment B register content once and subtract C register content from
accumulator.

Step8: Goto Step 5. Step9: Store the accumulator data in specified memory. Step10: Move data from B register to accumulator. Step11: Store the accumulator data in specified memory. Step12: End.

MNEMONICS: MVI B, 00H LDA 5100 MOV C, A LDA 5100 Loop1: CMP C JC INR JMP Loop2 B Loop1

SUB C Loop2: STA 5300 MOV A, B STA HLT 5301

TABLE: 1 Mnemonics
Instruction

Memory Label 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 420A 420B 420C 420D 420E 420F 4210 4211 4212 4213 4214 MOV 4215 STA 4216 Loop1: STA INR SUB JMP Loop2: CMP JC MOV LDA LDA MVI

HEX CODE

Description Move immediately the data 00H to B register Load 8 bit data from memory to accumulator Move accumulator content to C register Load another 8 bit data in HL pair from memory. Compare accumulator content with C register content When carry set jump to specified memory Increment B register content once
Subtract C register content from accumulator

Operand

B, 00H 5100

06 00 3A 00 51

C,A 5100

4F 3A 01 51

C Loop2

B9 DA 12 42

BC Loop1

04 91 C3

Jump to specified memory

5300

09 42 32 Store accumulator data in specified Memory Move data from B register to accumulator Store accumulator data in specified 00 53 78 32

A, B 5301

4217 4218 4219 HLT

01 53 76

memory Halt

OUTPUT: INPUT DATA: 5100: 20 5101: 60 OUTPUT DATA: 5300: 00 5301: 03

RESULT: Thus an assembly language program to divide two 8 bit datas was written and executed using 8085 microprocessor kit.

Ex. No: 06
AIM:

16 BIT DIVISION

To perform Multiplication of two 16 bit numbers and store the result in a memory location using 8085 microprocessor kit

ALGORITHM:

1. 2. 3. 4. 5.

Get the dividend and divisor. Initialize the register for quotient. Repeatedly subtract divisor from dividend till dividend becomes less than divisor. Count the number of subtraction which equals the quotient. Store the result in memory.

PROGRAM: Memory Label

LHLD

Mnemonics
4502

Opcode

Description
Load the first No. in stack pointer through HL reg. pair

XCHG LHLD 4500

Load the second No. in HL reg. pair & Exchange with DE reg. pair.

LXI

B, 0000H

Clear BC reg. pair.

LOOP

MOV

A, L

Move the content of reg. L to Acc. Subtract reg. E from that

SUB

of Acc. MOV L, A Move the content of Acc to L. Move the content of reg. H Acc. Subtract reg. D from that of Acc. Move the content of Acc to H. Increment reg. Pair BC If there is no carry, go to the location labeled LOOP.

MOV

A, H

SBB MOV INX JNC

D H, A B LOOP

DCX DAD SHLD

B D 4504

Decrement BC reg. pair. Add content of HL and DE reg. pairs. Store the content of HL pair in 4504 & 4505.

MOV STA

A, C 4506

Move the content of reg. C to Acc. Store the content of Acc. in memory 4506

MOV STA

A, B 4507

Move the content of reg. B to Acc. Store the content of Acc. in memory 4507.

HLT

Stop the program execution.

OBSERVATION:

INPUT ADDRESS 4500 4501 4502 4503 DATA

OUTPUT ADDRESS 4504 4505 4506 4507 DATA

RESULT: Thus the 16-bit division was done in 8085p using repeated subtraction method.

Ex. No: 07
AIM:

SMALLEST AND LARGEST AMONG N NUMBERS

To find the smallest and largest among N numbers using 8085 microprocessor. APPARATUS REQUIRED: 8085 Microprocessor Kit Power Chord

SMALLEST AMONG N NUMBERS: ALGORITHM: Step1: Start the program Step2: Get the first number in the accumulator and move it to B Step3: Get the second number in the memory and move it to the accumulator Step4: Increment the address of memory and compare the data with accumulator Step5: If there is carry the above process is continued until carry is not present Step6: If carry is present then continue to compare with increment memory Step7: If carry is absent move that data to accumulator and decrement the B register until it become zero Step8: Store the smallest number in the accumulator Step9: End the program

MNEMONICS: LDA 5000 MOV B,A LXI H,5001 MOV A,M XX: INX H CMP M JC XX MOV A,M XY: DCR B JNZ XY STA 6000 HLT TABLE 1: Mnemonics Instruction LDA Operand 5000 HEX CODE 3A 00 50 MOV LXI B,A H,5001 47 21 01 50 MOV XX INX CMP JC A,M H M XX 7E 23 BE DA 0E 23 Move data from M toA Increment the memory Compare M with A Jump if carry Move the data from A to B Move the second data to memory Move the first data to accumulator 4501 4502 4503 4504 4505 4506 4507 4508 4509 450A 450B Description

Memory Label 4500

450C 450D 450E 450F 4510 4511 4512 4513 4514 4515 HLT STA 6000 XY MOV DCR JNZ A,M B XY

45 7E 05 C2 08 45 32 00 60 76 End of program Store the data in accumulator Move the data from M to A Decrement B register Jump if no zero

OUTPUT: INPUT DATA: 5000: 15 5001:03 5002:95 5003:28 OUTPUT DATA: 6000:03

LARGEST AMONG N NUMBERS: ALGORITHM: Step1: Start the program Step2: Get the first number in the accumulator and move it to B Step3: Get the second number in the memory H and move it to the accumulator Step4: Increment the address of memory and compare the data with accumulator Step5: If there is no carry the above process is continued until carry is present Step6: If carry is present move that data to accumulator and decrement the B register until It becomes zero Step7: Store the largest number in the accumulator Step8: End the program

MNEMONICS: LDA 5000 MOV B,A LXI H,5001 MOV A,M XX: INX H CMP M JNC XX MOV A,M XY: DCR B JNZ XY STA 6000 HLT

TABLE 2: Mnemonics Instruction LDA Operand 5000 HEX CODE 3A 00 50 MOV LXI B,A H,5001 47 21 01 50 MOV XX INX CMP JNC A,M H M XX 7E 23 BE DA 0E 45 MOV XY DCR JNZ A,M B XY 7E 05 C2 08 45 STA 6000 32 00 60 HLT 76 End of program Store the data in accumulator Move the data from M to A Decrement B register Jump if no zero Move data from M toA Increment the memory Compare M with A Jump no carry Move the data from A to B Move the second data to memory Move the first data to accumulator 4501 4502 4503 4504 4505 4506 4507 4508 4509 450A 450B 450C 450D 450E 450F 4510 4511 4512 4513 4514 4515 Description

Memory Label 4500

OUTPUT: INPUT DATA: 5000: 15 5001:03 5002:95 5003:28 OUTPUT DATA: 6000:95

RESULT: Thus the smallest and largest among n numbers was found using 8085 microprocessor and their output was verified

Ex. No: 08 ASCENDING AND DECENDING ORDER OF N NUMBERS

AIM: To determine the ascending and descending order of the given number using 8085 microprocessor. APPARATUS REQUIRED: 8085 Microprocessor Kit Power Chord ASCENDING ORDER: ALGORITHM: Step1: Start the program Step2: Get the first number and store it in B register and get the second number in memory and move it to accumulator. Step3: Increment memory and compare it with accumulator if carry is present increment memory by decrementing B register if it is not zero. Step4: If B register become zero decrement D register which contain number first , zero is not obtained then get in the memory. Step5: If it is zero store the result in the accumulator. Step6: If the compared output contains no carry , move the value in memory to C register and accumulator to memory and increment the value in memory. Step7: stop the program.

MNEMONICS: LDA 5000 MOV B,A MOV D,A MOV E,A LXI H,5001 MOV A,M MOV B,E LOOP2 INX H CMP M JC LOOP1 MOV C,M MOV M,A DCX H MOV M,C INX H LOOP1 MOV A,M DCR B; JNZ LOOP2 DCR B JNZ LOOP3 HLT

TABLE: 1 Mnemonics Instruction LDA Operand 5000 HEX CODE 3A 00 50 MOV MOV MOV LOOP 3 LXI B,A D,A E,A H,5001 47 5F 57 21 01 50 MOV MOV LOOP 2 INX CMP JC A,M B,E H M LOOP1 7E 43 25 BE DA 15 45 MOV MOV DCX MOV INX LOOP 1 MOV DCR JNZ C,M M,A H M,C H A,M B LOOP 2 4E `77 2B 71 23 7E O5 C2 0B 45 DCR D 30 15 Decrement D Register Move M to C register Move A to Memory Decrement H Register Move the value from C to H Increment H Register Move the value from M to A Decrement B Register Jump is no zero to LOOP 2 Move M to Accumulator Move E to B register Increment H Register Compare A and M Jump if carry to loop1 Move the data from A to B Move the data from A to D Move the data from A to E Move second data to memory Get the first data to accumulator Description

Memory Label 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 450A 450B 450C 450D 450E 450F 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 451A

451B 451C 451D 451E

JNZ

LOOP 3

C2 06 45

Jump is no zero to LOOP 3

HLT

76

End of Program

OUTPUT: INPUT DATA: 5000: 03 5001:05 5002:02 5003:06 OUTPUT DATA: 6000: 02 6001: 03 6002: 05 6003: 06

DESCENDING ORDER: ALGORITHM: Step1: Start the program Step2: Get the first number and store it in B register and get the second number in memory and move it to accumulator. Step3: Increment memory and compare it with accumulator if carry is present increment memory by decrementing B register if it is not zero. Step4: If B register become zero decrement D register which contain number first , zero is not obtained then get in the memory. Step5: If it is zero store the result in the accumulator. Step6: If the compared output contains no carry , move the value in memory to C register and accumulator to memory and increment the value in memory. Step7: stop the program. MNEMONICS: LDA 5000 MOV B,A MOV D,A MOV E,A LXI H,5001 MOV A,M MOV B,E LOOP2 INX H CMP M JNC LOOP1 MOV C,M MOV M,A DCX H MOV M,C INX H

LOOP1 MOV A,M DCR B; JNZ LOOP2 DCR B JNZ LOOP3 HLT TABLE: 2 Mnemonics Instruction LDA Operand 5000 HEX CODE 3A 00 50 MOV MOV MOV LOOP 3 LXI B,A D,A E,A H,5001 47 5F 57 21 01 50 MOV MOV LOOP 2 INX CMP JNC A,M B,E H M LOOP1 7E 43 25 BE DA 15 45 MOV MOV DCX MOV C,M M,A H M,C 4E `77 2B 71 Move M to C register Move A to Memory Decrement H Register Move the value from C to H Move M to Accumulator Move E to B register Increment H Register Compare A and M Jump if carry to loop1 Move the data from A to B Move the data from A to D Move the data from A to E Move second data to memory Get the first data to accumulator Description

Memory Label 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 450A 450B 450C 450D 450E 450F 4510 4511 4512 4513

4514 4515 4516 4517 4518 4519 451A 451B 451C 451D 451E LOOP1

INX MOV DCR JNZ

H A,M B LOOP 2

23 7E O5 C2 0B 45

Increment H Register Move the value from M to A Decrement B Register Jump is no zero to LOOP 2

DCR JNZ

D LOOP 3

15 C2 06 45

Decrement D Register Jump is no zero to LOOP 3

HLT

76

End of Program

OUTPUT: INPUT DATA: 5000: 03 5001:05 5002:02 5003:06 OUTPUT DATA: 6000: 06 6001: 05 6002: 03 6003: 02

RESULT: Thus the Ascending and Descending order of given N- numbers was performed and their output was verified.

Ex. No: 09
AIM:

CODE CONVERSIONS

To write an assembly language program to convert hexadecimal to decimal and hexadecimal to binary datas using 8085-microprocessor kit.

APPARATUS REQUIRED: 8085 Microprocessor Kit Power Chord

HEXADECIMAL TO DECIMAL CONVERSION: ALGORITHM: Step1: Start the program. Step2: Load data from memory to accumulator and move the data 00 to D and E registers. Step3: Compare the accumulator data with the data 64. Step4: If carry=0 jump to Step 6 else jump to Step 5. Step5: Jump to Step 10. Step6: Subtract accumulator data by 64. Step7: Increment the content of D register once. Step8: If carry=0 jump to Step 6 else jump to Step 9. Step9: Decrement the content of D register once and add data 64 with accumulator. Step10: Subtract accumulator data by 0A and Increment E register content once. Step11: If carry=0 jump to Step 10 and Decrement E register content once. Step12: Add data 64 with accumulator and move it to C register. Step13: Move E register content to accumulator. Step14: Rotate the accumulator content 4 tines by left. Step15: Add C register content with accumulator content. Step16: Store data in accumulator pair to specified memory Step17: Move D register content to accumulator

Step18: Store data in accumulator pair to specified memory. Step19: End. MNEMONICS: MVI E, 00 MVI D, 00 LDA 4200 CPI JNC JMP Loop1: SUI INR JNC ADI Loop2: SUI INR JNC ADI 64 Loop1 Loop2 64 D Loop1 64 0A E Loop2 0A

DCR D

DCR E MOV C, A MOV A, E RLC RLC RLC RLC ADD C STA STA HLT 4500 4501 MOV A, D

TABLE: 1 Mnemonics
Instruction

Memory Label
4100 4101 4102 4103 4014 4105 4106 4107 4108 4109 410A 410B 410C 410D 410E 410F 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 411A 411B 411C Loop2 Loop1 SUI INR JNC JMP CPI JNC MVI MVI

HEX CODE

Description
Move data 00 to E register Move data 00 to D register Load data from memory to accumulator Compare the accumulator data with the data 64 If carry=0 jump to specified memory

Operand

E, 00H D, 00H 4200

1E 00 16 00 3A 00 42

LDA

64 410F

FE 64 D2 0F 41

4118

C3 18 41

Jump to specified memory

64 D

D6 64 14 D2 0F 41

Subtract accumulator data by 64 Increment D register content once If carry=0 jump to specified memory

DCR ADI SUI INR JNC

410F

D 64 0A E 4118

15 C6 64 D6 0A 1C D2 18

Decrement D register content once Add data 64 with accumulator Subtract accumulator data by 0A Increment E register content once If carry=0 jump to specified memory

37

411D 411E 411F 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 412A 412B 412C 412D 412E 412F HLT MOV STA A, D 4501 MOV MOV RLC RLC RLC RLC ADD STA C 4500 C, A A, E DCR ADI E 0A

41 1D C6 0A 4F 7B 07 07 07 07 81 32 00 45 7A 32 01 45 76 Halt Move D register content to accumulator Store data in accumulator pair to specified memory Add C register content with accumulator content Store data in accumulator pair to specified memory Rotate the accumulator content 4 tines by left Move accumulator content to C register Move E register content to accumulator Decrement E register content once Add data 64 with accumulator

OUTPUT: INPUT DATA: 4200: CE OUTPUT DATA: 4500: 06 4501: 02

HEXADECIMAL TO BINARY CONVERSION: ALGORITHM: Step1: Start the program. Step2: Load data from memory to accumulator Step3: Divide accumulator content by 2 and store the quotient in accumulator and reminder in next consecutive memory location. Step4: Repeat Step 3 until quotient becomes 1. Step5: If quotient becomes 1 store it in next memory location. Step6: End. MNEMONICS: LXI H, 4300 MOV A, M MVI C, 02 Loop4: MVI D, 00 Loop1: SUB C INR JC JMP INX D Loop2 Loop1 H

Loop2: ADD C MOV M, A DCR D MOV A, D CPI JZ JMP 01 Loop3 Loop4

Loop3: INX H MOV M, D HLT

TABLE: 2 Mnemonics
Instruction

Memory Label 4100 4101 4102 4103 4014 4105 4106 4107 4108 4109 410A 410B 410C 410D 410E 410F 4110 4111 4112 4113 4114 4115 4116 4117 4118 JZ Loop2: Loop4: Loop1: LXI

HEX CODE

Description Load memory to HL register pair

Operand

H,4300

21 00 43

MOV MVI MVI SUB INR JC

A,M C,02 D, 00 CD Loop2

72 0E 02 16 00 91 14 DA 10

Move

data

from

memory

to

accumulator Move data 02 to C register Initialize D register Subtract C register content from A Increment D register content once Jump when carry=1 to specified Memory Jump to specified Memory

Loop1 JMP C ADD INX MOV DCR MOV CPI Loop3 D A, D 01 H M, A

44 C3 08 41 81 23 77 15 7A FE 01 C4 1C Jump when ZF=1 to specified Memory Add C register content with A Increment HL pair content once Move data from accumulator to memory Decrement D register content once Move D register content to A Compare D register content with 01

4119 411A 411B 411C 411D 411E 411F Loop3: INX MOV HLT H M, D JMP Loop4

41 C3 06 44 23 72 76 Increment HL pair memory once Move D register data to Memory Halt Jump to specified Memory

OUTPUT: INPUT DATA: 4300: DE OUTPUT DATA: 4301: 00 4302: 01 4303: 01 4304: 01 4305: 01 4306: 00 4307: 01 4308: 01

RESULT: Thus an assembly language program to convert hexadecimal to decimal and hexadecimal to binary datas was written and executed using 8085-microprocessor kit.

Ex. No: 10
AIM:

FIBONACCI SERIES

To write an assembly language program to generate Fibonacci series of N number of datas using 8085 microprocessor kit. APPARATUS REQUIRED: 8085 Microprocessor Kit Power Chord ALGORITHM: Step1: Start the program. Step2: Move data 0A to B register. Step3: Clear the accumulator content and load data of 4200 to HL pair. Step4: Move the data from accumulator to specified memory. Step5: Decrement B content once and Increment accumulator content once. Step6: Increment HL pair content once. Step7: Move the data from accumulator to specified memory and decrement HL pair content once. Step8: Move data in memory to C register and add C register content with Acc. Step9: Increment HL pair content once and Decrement B content once. Step10: If no zero goto Step 11 else goto Step 6. Step11: End.

MNEMONICS: MVI B, 0A XRA A LXI H, 4200 MOV M, A DCR B INR A Loop1: INX H MOV M, A DCX H ADD M INX JNZ HLT H Loop1 DCR B

TABLE: 1 Mnemonics
Instruction

Memory Label 4100 4101 4102 4103 4014 4105 4106 4107 4108 4109 410A 410B 410C 410D 410E 410F 4110 4111 4112
HLT MVI

HEX CODE

Description Move data 0A to B register content Clear the accumulator content Load data of 4200 to HL pair

Operand B, 0A

06

0A XRA LXI A H, 4200 AF 21 00 42

MOV M, A

77 05 23 77 2B 86 23 05 CZ 09 41 76

Move data from accumulator to M Decrement B content once Increment accumulator content once Increment H register content once Move data from accumulator to M Decrement HL pair content once Add data from M with accumulator Increment HL pair content once Decrement B content once Jump to specified memory if no zero

DCR
INR

B
A

Loop1

INX
MOV

H
M, A

DCX
ADD

H
M

INX DCR
JNZ

H B
Loop1

Halt

OUTPUT: INPUT DATA: 4101: 0A OUTPUT DATA: 4200: 00 4201: 01 4202: 01 4203: 02 4204: 03 4205: 05 4206: 08 4207: 13 4208: 1B 4209: 2E

RESULT: Thus an assembly language program to generate Fibonacci series of N number of datas was written and executed using 8085 microprocessor kit.

45

Ex. No: 11
AIM:

FACTORIAL OF N DATAS

To write an assembly language program to calculate factorial of N number of datas using 8085 microprocessor kit. APPARATUS REQUIRED: 8085 Microprocessor Kit Power Chord ALGORITHM: Step1: Start the program. Step2: Load 16 bit data in HL pair and move data from HL pair to DE pair. Step3: Move E register content to B register. Step4: Decrement B register content once and move B register content to C register. Step5: Decrement B register pair content once and load 0000H HL pair. Step6: Add DE pair content with HL pair content. Step7: Decrement B register content once. Step8: If there is no zero flag jump to Step 6. Step9: Move HL pair content to DE pair and load 0000H HL pair. Step10: Move C register content to B register. Step11: Decrement C register content once. Step12: If zero flag is set jump to Step 18. Step13: Jump to Step 9. Step14: Move HL pair content to DE pair. Step15: Store HL pair content in specified memory. Step16: End.

MNEMONICS: LHLD 4200 XCHG MOV B, E DCR B MOV C, B DCR C LXI H, 0000H Loop1: DAD D DCR B JNZ XCHG LXI H, 0000H MOV B, C DCR C JZ JMP Loop2 Loop1 Loop1

Loop2: XCHG SHLD 4300 HLT

TABLE: 1 Mnemonics
Instruction

Memory Label 4100 4101 4102 4103 4014 4105 4106 4107 4108 4109 410A 410B 410C 410D 410E 410F 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 Loop1

HEX CODE

Description Load 16 bit data to HL pair

Operand

LHLD

4200

2A 00 42

XCHG MOV DCR MOV DCR LXI B, E B C, B C H, 0000H

EB 42 05 48 0D 21 00 00

Exchange HL pair data with DE pair Move E register data to B register Decrement B content once Move B register data to C register Decrement C content once Load data of 0000 to HL pair

DAD DCR JNZ

D B 410B

19 05 C2 0B 41

Add HL pair and DE pair contents and store the result in HL pair Decrement B content once Jump when no zero to specified address Exchange HL pair data with DE pair Load data of 0000 to HL pair

XCHG LXI H, 0000H

4B 21 00 00

MOV DCR JZ

B, C C 411C

41 0D CA 1C 41

Move C register data to B register Decrement C content once If zero flag set jump to specified address Jump to specified address

JMP

410B

C3

411A 411B 411C 411D 411E 411F 4120 HLT Loop2 XCHG SHLD 4300

0B 41 EB 22 00 43 76 Halt Exchange HL pair data with DE pair Store data in HL pair to specified memory

OUTPUT:

INPUT DATA: 4200: 05

OUTPUT DATA: 4300: 78

RESULT: Thus an assembly language program to calculate factorial of N number of datas was written and executed using 8085 microprocessor kit.

Ex. No: 12
AIM:

PALINDROME

To write an assembly language program to check whether the given number is palindrome or not (for 32-bit data) using 8085-microprocessor kit. APPARATUS REQUIRED: 8085 Microprocessor Kit Power Chord ALGORITHM: Step1: Start the program. Step2: Load16 bit data in HL pair and exchange data from HL pair to DE pair. Step3: Load another 16 bit data in HL pair. Step4: Move the data from H register to accumulator. Step5: Rotate the accumulator content 4 times by left. Step6: Perform XOR operation with accumulator and E register content. Step7: Move accumulator data to B register. Step8: Move D register content to accumulator. Step9: Rotate the accumulator content 4 times by left. Step10: Perform XOR operation with accumulator and L register content. Step11: Perform OR operation with accumulator and B register content. Step12: If zero flag set jump to specified address. Step13: Store data in accumulator pair to specified memory. Step14: End.

MNEMONICS: LHLD 4200 XCHG LHLD 4202 MOV A, H RLC RLC RLC RLC XRA E MOV B, A MOV A, D RLC RLC RLC RLC XRA L ORA B JZ HLT Loop1 Loop1: STA 4300

51

TABLE: 1 Mnemonics
Instruction

Memory Label 4100 4101 4102 4103 4014 4105 4106 4107 4108 4109 410A 410B 410C 410D

HEX CODE

Description Load data to HL pair from memory

Operand

LHLD

4200

2A 00 42

XCHG LHLD 4202

EB 2A 02 42

Exchange HL pair data with DE pair Load another data to HL pair from memory Move data from H register to accumulator Rotate the accumulator content 4 times by left Perform XOR operation with

MOV RLC RLC RLC RLC XAR MOV

A, H

7C 07 07 07 07

E B, A

AB 47 7A 07 07 07 07 AD

accumulator and E register content Move data from accumulator to B register Move data from D register to accumulator Rotate the accumulator content 4 tines by left Perform Perform XOR OR operation operation with with

MOV 410E 410F 4110 4111 4112 4113 OAR 4114 RLC RLC RLC RLC XAR

A, D

L B

accumulator and L register content accumulator and B register content

B0

52

4115 4116 4117 4118 4119 411A 411B 411C Loop2

JZ

CA 19 41

If zero flag set jump to specified address Move data 01 to accumulator Store data in accumulator pair to specified memory Halt

MVI STA

A, 01 4300

3E 32 00 43

HLT

76

OUTPUT: INPUT DATA: 4200: 45 4201: 54 4202: 45 4203: 54 OUTPUT DATA: 4300: 00

RESULT: Thus an assembly language program to check whether the given number is palindrome or not (for 32-bit data) was written and executed using 8085 microprocessor kit.

Ex. No: 13
AIM:

SUM OF SERIES

To write an assembly language program to calculate sum of series of N number of datas with carry using 8085 microprocessor kit. APPARATUS REQUIRED: 8085 Microprocessor Kit Power Chord ALGORITHM: Step1: Start the program. Step2: Move the memory address to H register. Step3: Move the data present in memory to E register. Step4: Initialize the C register as 00H. Step5: Clear the accumulator content and increment H register pair. Step6: Move the data from memory to accumulator. Step7: Increment H content once and add it with accumulator. Step8: Decrement E content once. Check whether carry is present or not. Step9: If no carry, increment H content once and add it with accumulator. Step10: If carry present Increment the content of CX register once and repeat Step 8. Step11: Repeat the above steps for N number of datas. Step12: Store the result in specified memory. Step13: End.

MNEMONICS: LXI H, 5300

MOV E, M MVI C, 00H XRA A Loop1: INX H ADD M JNC INR JNZ STA STA HLT Loop 2 C Loop1 4600 4601

Loop2: DCR E

MOV A, C

55

TABLE: Mnemonics
Instruction

Memory Label 4100 4101 4102 4103 4014 4105 4106 4107 4108 4109 410A 410B 410C 410D 410E 410F 4110 4111 4112 4113 4114 4115 4116 4117 4118 Loop2: INR Loop1
LXI

HEX CODE

Description
Load 16 bit address in HL register

Operand H, 5300

21

00 53 MOV MVI
XRA

pair Move data from memory to E register Move data 00H to register C OR function the accumulator content Increment H register content once Add data from M with accumulator Jump on no carry

E, M C, 00H
A

5E 0E 00 AF 23 86 D2 0D 41

INX
ADD

H
M

JNC

Loop 2

CE Loop1

0C 1D C2 07

Increment C register content once Decrement E content once Jump on no zero

DCR JNZ

4600 STA A, C MOV STA 4601

41 32 00 46 79 32 01 46 Move data form C register to Acc. Store data from accumulator to the specified memory Halt Store data from accumulator to the specified memory

HLT

76

OUTPUT: INPUT DATA: 5300: 0A 5301: 11 5302: 12 5303: 13 5304: 04 5305: 05 5306: 06 5307: 17 5308: 09 5309: 0A 530A: 01 OUTPUT DATA: 4600: 70 4601: 00

RESULT: Thus an assembly language program to calculate sum of series of N number of datas with carry was written and executed using 8085 microprocessor kit.

Ex No: 14
AIM:

SQUARE ROOT

To find the square root of a given 8 bit number by using 8085 microprocessor. APPARATUS REQUIRED: 8085 Microprocessor Kit Power Chord

ALGORITHM: Step1: Start the program. Step2: Load the data to accumulator and move it to the B register. Step3: Load another data in the accumulator. Step4: Clear the accumulator. Step5: Subtract the data and if there is no carry go to loop1 Step6: Increment C by 1 and increment B by 1 two times. Step7: If there is carry go to loop2. Step8: Move the data C - registers to accumulator. Step9: Store the result. Step10:Stop the program. MNEMONICS: LDA 5000 MOV B,A LDA 5001 MVI C,00H LOOP1 SUB B JC LOOP2 INR C INR B INR B

JMP LOOP1 LOOP2 MOV A,C STA 6000 HLT TABLE: Mnemonics
Instruction

Memory 4100 4101 4102 4103 4014 4105 4106 4107 4108 4109 410A 410B 410C 410D 410E 410F 4110 4111 4112 4113 4114 4115

Label

HEX CODE

Description Load the data in accumulator.

Operand 5000

LDA

3A 00 50

MOV LDA

B,A 5001

47 3A 01 50

Move data to B register Load the another data in accumulator

MVI LOOP1 SUB JC

C,00H B LOOP2

0E 00 90 DA 13 41

Clear the C-register. Subtract the data If carry=1 go to loop2

INR INR INR JMP

C B B LOOP1

0C 04 04 C3 09 41

Increment C by 1 Increment B by 1 Increment B by 1 Jump to loop1

LOOP2

MOV STA

A,C 6000

79 32 00 59

Move the data to A-reg Store the result

4116 4117 HLT

60 76 Stop the program

OUTPUT: OUTPUT DATA: 5000:01H 5001:10H 6000:04H

RESULT: Thus the square root of the given 8- bit number was obtained by using 8085 microprocessor.

8086 MICROPROCESSOR PROGRAMMING

Ex. No: 15
AIM:

32 BIT ADDITION AND SUBTRACTON

To write an assembly language program to add and subtract two 32-bit numbers using 8086 microprocessor kit. APPARATUS REQUIRED: 8086 Microprocessor Kit Power Chord Key Board 32- BIT ADDITION: ALGORITHM: Step1: Start the program. Step2: Move immediately the number 0000H to CX register. Step3: Copy the contents of the memory 3000 to AX register. Step4: Add the content of the memory 3004 with the content of AX register. Step5: Copy the content to AX register to two memories from 2000. Step6: Copy the contents of the memory 3002 to AX register. Step7: Add the content of the memory 3006 with the content of AX register. Step8: Jump to specified memory location if there is no carry i.e. CF=0. Step9: Increment the content of CX register once. Step10: Copy the content to AX register to two memories from 2002. Step11: Copy the content to CX register to two memories from 2004. Step12: End.

MNEMONICS: MOV CX, 0000 MOV AX, [3000] ADD AX, [3004] MOV [2000], AX MOV AX, [3002] ADC AX, [3006] JNC INC loop1 CX

Loop1 MOV [2002], AX MOV [2004], CX HLT TABLE: 1 Memory Label 1000 1004 1008 100C 1010 1014 1018 101A 101B Loop1 Mnemonics
Instruction Operand

Description
Move immediately 0000H to CX register

MOV

CX,0000

MOV ADD MOV MOV ADC JNC INC MOV

AX, [3000] AX, [3004] [2000], AX AX, [3002] AX, [3006] loop1 CX [2002], AX

Copy contents of 3000 to AX register Add content of memory 3004 with content of AX register Copy content to AX register to two memories from 2000 Copy contents of memory 3002 to AX register Add content of memory 3006 with content of AX register Jump to specified memory CF=0 Increment content of CX register once Copy content to AX register to two memories from 2002

101F 1023

MOV HLT

[2004], CX

Copy content to CX register to two memories from 2004 Halt

OUTPUT: INPUT DATA: 3000: 9999 3002: 9999 3004: 9999 3006: 9999 OUTPUT DATA: 2000: 3332 2002: 3333 2004: 1

32- BIT SUBTRACTION:

ALGORITHM: Step1: Start the program. Step2: Move immediately the number 0000H to CX register. Step3: Copy the contents of the memory 3000 to AX register. Step4: Add the content of the memory 3004 with the content of AX register. Step5: Copy the content to AX register to two memories from 2000. Step6: Copy the contents of the memory 3002 to AX register. Step7: Subtract the content of the memory 3006 from AX register. Step8: Jump to specified memory location if there is no carry i.e. CF=0. Step9: Increment the content of CX register once. Step10: Copy the content to AX register to two memories from 2002. Step11: Copy the content to CX register to two memories from 2004. Step12: End. MNEMONICS: MOV CX, 0000 MOV AX, [3000] ADD AX, [3004] MOV [2000], AX MOV AX, [3002] SBB JNC INC AX, [3006] loop1 CX

Loop1 MOV [2002], AX MOV [2004], CX HLT

TABLE: 2 Memory Label 1000 1004 1008 100C 1010 1014 1018 101A 101B 101F 1023 OUTPUT: INPUT DATA: 3000: 9999 3002: 9799 3004: 9999 3006: 9999 RESULT: Thus an assembly language program to add and subtract two 32-bit numbers was written and executed using 8086 microprocessor kit. OUTPUT DATA: 2000: 0000 2002: FE00 Mnemonics
Instruction Operand

Description
Move immediately 0000H to CX register

MOV

CX,0000

MOV ADD MOV MOV SBB JNC INC MOV Loop1 MOV HLT

AX, [3000] AX, [3004] [2000], AX AX, [3002] AX, [3006] loop1 CX [2002], AX [2004], CX

Copy contents of 3000 to AX register Add content of memory 3004 with content of AX register Copy content to AX register to two memories from 2000 Copy contents of memory 3002 to AX register Subtract content of memory 3006 from content of AX register Jump to specified memory CF=0 Increment content of CX register once Copy content to AX register to two memories from 2002 Copy content to CX register to two memories from 2004 Halt

Ex. No: 16
AIM:

16 BIT MULTIPLICATION AND DIVISION

To write an assembly language program to multiply and divide two unsigned 16-bit numbers using 8086 microprocessor kit. APPARATUS REQUIRED: 8086 Microprocessor Kit Power Chord Key Board MULTIPLICATION: ALGORITHM: Step 1: Start the program. Step2: Copy the contents of the memory 3000 to AX register. Step3: Copy the contents of the memory 3002 to CX register. Step4: Multiply the content of the CX register with the content of accumulator. Step5: Copy the content to AX register to the memory 2000. Step6: Copy the contents of DX register to the memory 2002. Step7: End. MNEMONICS: MOV AX, [3000] MOV CX, [3002] MUL CX MOV [2000], AX MOV [2002], DX HLT

TABLE: 1 Memory Label 1000 1004 1008 100A 100E 1012 Mnemonics
Instruction Operand

Description Copy contents of 3000 to AX register Copy contents of 3002 to CX register

Multiply the content of the CX register with the content of accumulator

MOV MOV MUL MOV MOV HLT

AX, [3000] CX, [3002] CX [2000], AX [2004], DX

Copy content to AX register to the memory 2000 Copy content to DX register to the memory 2002 Halt

OUTPUT: INPUT DATA: 3000: 1234 3002: 5678 OUTPUT DATA: 2000: 0060 2002: 0626

DIVISION: ALGORITHM: Step 1: Start the program. Step2: Copy the contents of the memory 3000 to AX register. Step3: Copy the contents of the memory 3002 to CX register. Step4: Divide the content of the CX register from the content of accumulator. Step5: Copy the content to AX register to the memory 2000. Step6: Copy the contents of DX register to the memory 2002. Step7: End. MNEMONICS: MOV AX, [3000] MOV CX, [3002] DIV CX MOV [2000], AX MOV [2002], DX HLT TABLE: 2 Memory Label 1000 1004 1008 100A 100E 1012 Mnemonics
Instruction Operand

Description Copy contents of 3000 to AX register Copy contents of 3002 to CX register

Divide the content of the CX register with the content of accumulator

MOV MOV DIV MOV MOV HLT

AX, [3000] CX, [3002] CX [2000], AX [2004], DX

Copy content to AX register to the memory 2000 Copy content to DX register to the memory 2002 Halt

OUTPUT: INPUT DATA: 3000: 1234 3002: 5678 OUTPUT DATA: 2000: 0000 2002: 4444

RESULT: Thus an assembly language program to multiply and divide two unsigned 16-bit numbers was written and executed using 8086 microprocessor kit.

EXPT NO:17 LARGEST& SMALLEST AIM: To write an Assembly Language Program (ALP) to find the largest and smallest number in a given array.
APPARATUS REQUIRED: 8086 Microprocessor Kit Power Chord Key Board

PROBLEM STATEMENT: An array of length 10 is given from the location. Find the largest and smallest number and store the result. ALGORITHM: (i) a. b. c. d. is 0. (ii) a. b. c. d. Finding largest number: Load the array count in a register C1. Get the first two numbers. Compare the numbers and exchange if the number is small. Get the third number from the array and repeat the process until C 1

Finding smallest number: Load the array count in a register C1. Get the first two numbers. Compare the numbers and exchange if the number is large. Get the third number from the array and repeat the process until C1 is 0.

LARGEST
PROGRAM COMMENTS

MOV SI,1200H MOV CL,[SI] INC SI MOV AL,[SI] DEC CL L2 : INC SI CMP AL,[SI] JNB L1 MOV AL,[SI] L1 : DEC CL JNZ L2 MOV DI,1300H MOV [DI],AL HLT

Initialize array size Initialize the count Go to next memory location Move the first data in AL Reduce the count Move the SI pointer to next data Compare two datas If AL > [SI] then go to L1 ( no swap) Else move the large number to AL Decrement the count If count is not zero go to L2 Initialize DI with 1300H Else store the biggest number in 1300 location Stop

RESULT: INPUT MEMORY DATA OUTPUT MEMO RY DATA

SMALLEST
PROGRAM COMMENTS

MOV SI,1200H MOV CL,[SI] INC SI MOV AL,[SI] DEC CL L2 : INC SI CMP AL,[SI] JB L1 MOV AL,[SI] L1 : DEC CL JNZ L2 MOV DI,1300H MOV [DI],AL HLT

Initialize array size Initialize the count Go to next memory location Move the first data in AL Reduce the count Move the SI pointer to next data Compare two datas If AL < [SI] then go to L1 ( no swap) Else move the large number to AL Decrement the count If count is not zero go to L2 Initialize DI with 1300H Else store the biggest number in 1300 location Stop

RESULT: INPUT MEM ORY DAT A OUTPUT MEMO RY DAT A

RESULT Thus largest and smallest number is found in a given array.

Ex. No: 18
AIM:

FACTORIAL

To write an assembly language program to calculate factorial of n-numbers using 8086 microprocessor kit. APPARATUS REQUIRED: 8086 Microprocessor Kit Power Chord Key Board ALGORITHM: Step 1: Start the program. Step2: Move immediately the number 0000H to AX register. Step3: Copy the contents of the memory 3000 to CX register. Step4: Move immediately the number 0001H to AX register. Step5: Multiply the content of the CX register with the content of accumulator. Step6: Decrement the content of CX register once. Step7: Jump to specified memory location if there is no zero in CX register. Step8: Copy the content to AX register to two memories from 2000. Step10: End.

MNEMONICS: MOV AX, 0001 MOV CX, [3000] MOV AX, 0001 Loop1 MUL CX DEC CX JNZ HLT TABLE: 1 Mnemonics
Instruction Operand

loop1

MOV [2000], AX

Memory Label 1000 1004

Description Move immediately the number

MOV MOV

AX, 0001 CX, [3000]

0001H to AX register Copy the contents of memory 3000 to CX register Move immediately the number 0000H to AX register
Multiply content of CX register with content of accumulator

MOV AX, 0001 1006 100A 100B 100C 100E 1012 loop1 MUL DEC JNZ MOV HLT [2000], AX CX loop1 CX

Decrement content of CX register once Jump to specified memory location if there is no zero in CX register Copy content to AX register to memory 2000 Halt

OUTPUT: INPUT DATA: 3000: 0008 OUTPUT DATA: 2000: 9d80

RESULT: Thus an assembly language program to calculate factorial of n-numbers was written and executed using 8086 microprocessor kit.

Ex. No: 19
AIM:

SORTING IN ASCENDING ORDER

To write an assembly language program to sort n-numbers in ascending order using 8086 microprocessor kit. APPARATUS REQUIRED: 8086 Microprocessor Kit Power Chord Key Board

ALGORITHM: Step 1: Start the program. Step2: Load datas into the memory. Step3: Set the conditions to sort n-numbers in ascending order. Step4: Sort the n given numbers in ascending order. Step5: Store the result in the memory. Step6: Display the sorted result from memory. Step7: End.

MNEMONICS: MOV BX, 2000 MOV CX, [BX] MOV CH, CL Loop2 INC INC INC INC JC BX BX BX BX loop1

MOV AX, [BX]

CMP AX, [BX] MOV DX, [BX] MOV [BX], AX DEC BX DEC BX MOV [BX], DX INC INC Loop1 DEC DEC JNZ BX BX BX BX DEC CL loop2 MOV BX, 2000 MOV CH, CL DEC CH JNZ HLT loop2

TABLE: 1 Memory Label 1000 1004 1006 1008 1009 100A 100C 100D 100E 1011 MOV 1013 1015 1017 1018 1019 101B 101C 101D 101E 101F 1020 MOV DEC DEC MOV INC INC DEC DEC Loop1 DEC JNZ DX, [BX] [BX], AX BX BX [BX], DX BX BX BX BX CL loop2 Mnemonics
Instruction Operand

Description Move2000 to BX register

Move BX memory data to CX register

MOV MOV MOV Loop2 INC INC MOV INC INC CMP JC

BX, 2000 CX, [BX] CH, CL BX BX AX, [BX] BX BX AX, [BX] loop1

Move data from CL to CH Increment BX register content once Increment BX register content once Move BX memory data to AX register Increment BX register content once Increment BX register content once Compare AX register content and BX memory Jump to specified memory location if carry is 1 Move BX memory data to DX register Move data from AX register to BX memory data Decrement BX register content once Decrement BX register content once Move data from DX register to BX memory data Increment BX register content once Increment BX register content once Decrement BX register content once Decrement BX register content once Decrement CL register content once Jump to specified memory location if there is no zero in CX register

1022 1026 1028 1029 102B

MOV MOV DEC JNZ HLT

BX, 2000 CH, CL CH loop2

Move2000 to BX register
Copy CL register data to CH register

Decrement CH register content once Jump to specified memory location if there is no zero in CX register Halt

OUTPUT: INPUT DATA: 2000: 0004 2002: 0003 2004: 0005 2006: 0004 2008: 0002 200A: 0001 OUTPUT DATA: 2002: 0001 2004: 0002 2006: 0003 2008: 0004 200A: 0005

RESULT: Thus an assembly language program to sort n-numbers in ascending order was written and executed using 8086 microprocessor kit.

Ex. No: 20
AIM:

SOLVING AN EXPRESSION

To write an assembly language program for solving an expression using 8086 microprocessor kit. APPARATUS REQUIRED: 8086 Microprocessor Kit Power Chord Key Board

ALGORITHM: Step 1: Start the program. Step2: Load datas from memory to AX register. Step3: Set the conditions to solve an expression. Step4: Solve the expression given below using the conditions assumed. Step5: Store the result in the memory. Step6: Display the sorted result from memory. Step7: End.

MNEMONICS: MOV BX, [2000] MUL AX MOV BX, [2002] MUL BX MOV [3000], AX MOV AX, [2000] MOV BX, [2004] MUL BX ADD AX, [3000] ADD AX, 0001 MOV [2006], AX HLT

TABLE: 1 Mnemonics
Instruction Operand

Memory Label 1000 1004 1005 1009 100A 100E 1012 1016 1017 101B 101F 1023

Description Move data from memory 2000 to AX register

Multiply content of AX register with content of AX register

MOV MUL MOV MUL MOV MOV MOV MUL ADD ADD MOV HLT

AX, [2000] AX BX, [2002] BX [3000], AX AX, [2000] BX, [2004] BX AX, [3000] AX, 0001 [2006], AX

Move data from memory 2002 to BX register

Multiply content of BX register with content of AX register

Copy content to AX register to memory 3000 Move data from memory 2000 to AX register Move data from memory 2004 to BX register
Multiply content of BX register with content of AX register

Add content of memory 3000 with content of AX register Add the number 0001 to AX register Copy content to AX register to memory 2006 Halt

OUTPUT: INPUT DATA: 2000: 0002 2002: 0004 2004: 0007 OUTPUT DATA: 2006: 1F

RESULT: Thus an assembly language program for solving an expression was written and executed using 8086 microprocessor kit.

Ex No: 21

SUM OF N NUMBERS IN AN ARRAY

AIM: To write a program to find sum of n numbers in an array.

APPARATUS REQUIRED: 8085 Microprocessor Kit Power Chord

ALGORITHM: Step1: Start the program. Step2: Initialize the counter. Step3: Get the first number. Step4: Decrement the counter. Step5: Load the base address of an array in to BX Step6: By using the loop get the next number in to DX and add it with AX. Step7: Increment the pointer and decrement the counter. Step8: If the counter value is not equal to zero then go to step6 Step9: Else store the result. Step10:Stop the program.

MNEMONICS: MOV CL,[2000] MOV AX,[2002] DEC CL XOR D1,D1 LEA BX,[2004] LOOP1 MOV DX,[BX+D1] ADD AX,BX INC D1 INC D1 DEC CL JNZ LOOP1 MOV [3000],AX HLT TABLE: LABEL OPCODE MOV MOV DEC XOR LEA MOV ADD INC INC DEC LOOP 1 JNZ MOV HLT OPERAND CL,[2000] AX,[2002] CL D1,D1 BX,[2004] DX,[BX+DI] AX,BX DI DI CL LOOP 1 [3000],AX DESCRIPTION Move the memory content to CL. Move the memory content to AX Decrement the CL register. XOR,D1 registers Move the content of 2004 to BX Move the content of BX+D1 to DX Add AX with DX content. Increment D1 Increment D1 Decrement CL If zero flag is reseted go to loop1 Move the content to memory location Halt

OUTPUT: INPUT DATA: 2000:0003 2002:0002 2004:0003 2006:0001 OUTPUT DATA: 3000:0006

RESULT: Thus the sum of n numbers in an array has been done using 8086 microprocessor and the output is verified.

8051 MICROCONTROLLER PROGRAMMING

EXPT NO:22 8 BIT ADDITION AIM: To write a program to add two 8-bit numbers using 8051 microcontroller. APPARATUS REQUIERED 8051 Microcontroller kit. Power chord. ALGORITHM: 1. Clear Program Status Word. 2. Select Register bank by giving proper values to RS1 & RS0 of PSW. 3. Load accumulator A with any desired 8-bit data. 4. Load the register R 0 with the second 8- bit data. 5. Add these two 8-bit numbers. 6. Store the result. 7. Stop the program. 8 Bit Addition (Immediate Addressing)
ADDRES S 4100 LABE L MNEMONI C CLR OPERAND C HEX CODE C3 COMMENTS Clear CY Flag

4101

MOV

A,# data1

74,data Get the data1 in 1 Accumulator 24,data Add the data1 2 with data2 90,45,0 0 Initialize the memory location

4103 4105

ADDC MOV

A, # data 2 DPTR, # 4500H

4108

MOVX

@ DPTR, A

F0

Store the result in memory location Stop the program

4109

L1

SJMP

L1

80,FE

OUTPUT

OUTPUT MEMORY LOCATION DATA

4500

RESULT: Thus the 8051 ALP for addition of two 8 bit numbers is executed.

EXPT NO:23 8 BIT SUBTRACTION AIM: To perform subtraction of two 8 bit data and store the result in memory.

APPARATUS REQUIERED 8051 Microcontroller kit. Power chord. ALGORITHM: a. b. c. d. e. f.

ADDRESS 4100

Clear the carry flag. Initialize the register for borrow. Get the first operand into the accumulator. Subtract the second operand from the accumulator. If a borrow results increment the carry register. Store the result in memory.
PROGRAM LABEL MNEMONIC CLR OPERAND C HEX CODE C3 COMMENTS Clear CY flag

4101

MOV

A, # data1

74, data1 94,data 2 90,45,0 0 F0

Store data1 in accumulator Subtract data2 from data1 Initialize memory location Store the difference in memory location

4103

SUBB

A, # data2

4105

MOV

DPTR, # 4500 @ DPTR, A

4108

MOVX

4109

L1

SJMP

L1

80,FE

Stop

OUTPUT OUTPUT MEMORY LOCATION 4500 DATA

RESULT

Thus the 8051 ALP for subtraction of two 8 bit numbers is executed.

EXPT NO:24 8 BIT MULTIPLICATION AIM: To perform multiplication of two 8 bit data and store the result in memory.

APPARATUS REQUIERED 8051 Microcontroller kit. Power chord. ALGORITHM: a. Get the multiplier in the accumulator. b. Get the multiplicand in the B register. c. Multiply A with B. d. Store the product in memory. PROGRAM ADDRE SS 4100 LABE L MNEMON OPERAND HEX IC CODE MOV A ,#data1 74, data1 B, #data2 75,da ta2 COMMENTS Store data1 in accumulator Store data2 in B reg

4102

MOV

4104

MUL

A,B

F5,F0

Multiply both

4106

MOV

DPTR, # 4500H @ DPTR, A DPTR

90,45 ,00 F0

Initialize memory location Store lower order result Go to next memory location

4109

MOVX

401A

INC

A3

410B

MOV

A,B

E5,F0 Store higher order result

410D

MOV

@ DPTR, A STOP

F0

410E

STOP SJMP

80,FE

Stop

OUTPUT INPUT MEMORY LOCATION 4500 DATA OUTPUT MEMORY LOCATION DATA

4502

4501

4503

RESULT: Thus the 8051 ALP for multiplication of two 8 bit numbers is executed.

EXPT NO:25 8 BIT DIVISION AIM: To perform division of two 8 bit data and store the result in memory. APPARATUS REQUIERED 8051 Microcontroller kit. Power chord. ALGORITHM: 1. 2. 3. 4. Get the Dividend in the accumulator. Get the Divisor in the B register. Divide A by B. Store the Quotient and Remainder in memory.

PROGRAM ADDRE LABE MNEMO SS L NIC 4100 MOV OPERAND A, # data1 B, # data2 HEX COMMENTS CODE 74,da Store data1 in ta1 accumulator 75,da Store data2 in ta2 B reg

4102

MOV

4104

DIV

A,B

84

Divide

4015

MOV

DPTR, # 4500H

90,45 Initialize ,00 memory location Store remainder Go to next memory location

4018

MOVX

@ DPTR, A F0

4109

INC

DPTR

A3

410A

MOV

A,B

E5,F0 Store quotient

410C

MOV

@ DPTR, A F0

410D

STO P

SJMP

STOP

80,FE Stop

RESULT: INPUT MEMORY LOCATION 4500 (dividend) 4501 (divisor) DATA OUTPUT MEMORY LOCATION 4502 (remainder) 4503 (quotient) DATA

RESULT:

Thus the 8051 ALP for division of two 8 bit numbers is executed.

Ex. No: 26
AIM:

16 BIT ADDITION

To write an assembly language program to add the two 16 bit datas using 8051 Micro controller.

APPARATUS REQUIRED: 8051 Microcontroller kit. Power chord.

ALGORITHM: Step1: Start the program. Step2: Load the lower byte of the two datas into accumulator and R0 register. Step3: Add the two datas. Step4: Move the added data into R6 register and initialize the R2 register. Step5: Load the higher byte of the two datas into accumulator and R1 register. Step6: Add the two datas with carry. Step7: If carry comes, increment R2 register content once. Step8: Store the accumulator data and R6 and R2 register datas into the memory. Step9: Stop the program.

MNEMONICS: MOV MOVX MOV MOV INC MOVX MOV INC MOVX ADD MOV MOVX ADDC JNC INC LOOP1: INC MOVX INC MOV MOVX INC MOV MOVX LOOP2: SJMP DPTR,#4400 A,@DPTR R0,A R2,#00 DPTR A,@DPTR R1,A DPTR A,@DPTR A,R0 R6,A INC DPTR A,@DPTR A,R1 LOOP1 R2 DPTR @DPTR,A DPTR A,R6 @DPTR,A DPTR A,R2 @DPTR,A LOOP2

TABLE:

Memory 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109

Label

MNEMONICS MOV DPTR,#4400

Hex code 90 44 00

Description Move data 4400 to DPTR

MOVX A,@DPTR MOV R0,A MOV R2,#00 INC DPTR MOVX A,@DPTR MOV R1,A

E0 F8 7A 00 A3 E0 F9

Move data from DPTR to Accumulator. Move data from Accumulator to R0 register. Clear the R2 register. Increment DPTR content once. Load the data from DPTR to Accumulator. Move the data to R1 register from Accumulator. Increment DPTR content once. Load the data from DPTR to Accumulator.

INC DPTR 410A 410B 410C 410D 410E 410F 4110 4111 MOVX A,@DPTR ADD A,R0 MOV R6,A INC DPTR MOVX A,@DPTR ADDC A,R1 JNC LOOP1 A3 E0 28 FE A3 E0 39 50

Add Accumulator data and R0 register data. Move data from Accumulator to R6 register. Increment DPTR content once. Load the data from DPTR to Accumulator. Add Accumulator data and R0 register data with carry. Jump when carry=0 to loop1.

4112 4113 4114 4115 4116 4117 4118 4119 411A 411B 411C 411D 411E Loop2 Loop1 INC R2 INC DPTR MOVX @DPTR,A INC DPTR MOV A,R6 MOVX @DPTR,A INC DPTR MOV A,R2 MOVX @DPTR,A SJMP LOOP2

01 0A A3 F0 A3 EE F0 A3 EA F0 80 41 1C Increment the content of R2 register once. Increment DPTR content once. Store the Accumulator data to DPTR. Increment DPTR content once. Move the data from R6 register to Accumulator. Store the Accumulator data to DPTR. Increment DPTR content once. Move the data from R2 register to Accumulator. Store the Accumulator data to DPTR. Jump to loop2.

OUTPUT: INPUT DATA: 4400: 23 4401: 32 4402: 47 4403: 74 RESULT: Thus an assembly language program to add two 16-bit datas was written and executed using 8051 micro controller kit. OUTPUT DATA: 4404: A6 4405: 6A 4406: 00

Ex. No: 27
AIM:

16 BIT SUBTRACTION

To write an assembly language program to subtract the two 16 bit datas using 8051 Micro controller.

APPARATUS REQUIRED: 8051 Microcontroller kit. Power chord.

ALGORITHM: Step1: Start the program. Step2: Load the lower byte of the two datas into accumulator and R0 register. Step3: Subtract the two datas. Step4: Move the subtracted data into R6 register and initialize the R2 register. Step5: Load the higher byte of the two datas into accumulator and R1 register. Step 6: Subtract the two datas with borrow. Step7: If carry comes, increments R2 register content once. Step8: Store the accumulator data and R6 and R2 register datas into the memory. Step9: Stop the program.

MNEMONICS: MOV MOVX MOV MOV INC MOVX MOV INC MOVX SUBB MOV INC MOVX SUBB JNC INC LOOP1: INC MOVX INC MOV MOVX INC MOV MOVX LOOP2: SJMP DPTR,#4400 A,@DPTR R0,A R2,#00 DPTR A,@DPTR R1,A DPTR A,@DPTR A,R0 R6,A DPTR A,@DPTR A,R1 LOOP1 R2 DPTR @DPTR,A DPTR A,R6 @DPTR,A DPTR A,R2 @DPTR,A LOOP2

TABLE:

Memory 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109

Label

Mnemonics MOV DPTR,#4400

Hex code 90 44 00

Description Move data 4400 to DPTR

MOVX A,@DPTR MOV R0,A MOV R2,#00 INC DPTR MOVX A,@DPTR MOV R1,A

E0 F8 7A 00 A3 E0 F9

Move data from DPTR to Accumulator. Move data from Accumulator to R0 register. Clear the R2 register. Increment DPTR content once. Load the data from DPTR to Accumulator. Move the data to R1 register from Accumulator. Increment DPTR content once. Load the data from DPTR to Accumulator.

INC DPTR 410A 410B 410C 410D 410E 410F 4110 4111 MOVX A,@DPTR SUBB A,R0 MOV R6,A INC DPTR MOVX A,@DPTR SUBB A,R1 JNC LOOP1 A3 E0 98 FE A3 E0 99 50

Subtract Accumulator data and R0 register data. Move data from Accumulator to R6 register. Increment DPTR content once. Load the data from DPTR to Accumulator. Subtract Accumulator data and R0 register data with carry. Jump when carry=0 to loop1.

4112 4113 4114 4115 4116 4117 4118 4119 411A 411B 411C 411D 411E Loop2 Loop1 INC R2 INC DPTR MOVX @DPTR,A INC DPTR MOV A,R6 MOVX @DPTR,A INC DPTR MOV A,R2 MOVX @DPTR,A SJMP LOOP2

01 0A A3 F0 A3 EE F0 A3 EA F0 80 41 1C Increment the content of R2 register once. Increment DPTR content once. Store the Accumulator data to DPTR. Increment DPTR content once. Move the data from R6 register to Accumulator. Store the Accumulator data to DPTR. Increment DPTR content once. Move the data from R2 register to Accumulator. Store the Accumulator data to DPTR. Jump to loop2.

OUTPUT: INPUT DATA: 4500: BC 4501: 19 4502: 88 4503: 99 OUTPUT DATA: 4504: 80 4505: 34 4506: 01

RESULT: Thus an assembly language program to subtract two 16-bit datas was written and executed using 8051 micro controller kit.

Ex. No: 28
AIM:

16 BIT MULTIPLICATION

To write an assembly language program to multiply two 16 bit datas using 8051 Micro controller.

APPARATUS REQUIRED: 8051 Microcontroller kit. Power chord. ALGORITHM: Step1: Start the program. Step2: Load the two datas into Accumulator and B register. Step3: Multiply the two datas. Step4: Store the result into the memory. Step5: Stop the program. MNEMONICS: MOV MOVX MOV INC MOVX MUL INC MOVX INC MOV MOVX LOOP1: SJMP DPTR,#4400 A,@DPTR 0F0,A DPTR A,@DPTR AB DPTR @DPTR,A DPTR A,0F0 @DPTR,A LOOP1

TABLE: 1

Memory 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 410A 410B 410C 410D 410E 410F 4110 4111

Label

Mnemonics MOV DPTR,#4400

Hex code 90 44 00

Description Move data 4400 to DPTR

MOVX A,@DPTR MOV 0F0,A INC DPTR MOVX A,@DPTR MUL AB INC DPTR MOVX @DPTR,A INC DPTR MOV A,0F0 MOVX @DPTR,A Loop2 SJMP LOOP1

E0 F5 F0 A3 E0 A4 A3 F0 A3 E5 F0 F0 80 41 1C

Move data from DPTR to Accumulator. Move data from Accumulator to B register. Increment DPTR content once. Move data from DPTR to Accumulator. Multiply the Accumulator content and B register. Increment DPTR content once. Store the Accumulator content to DPTR. Increment DPTR content once. Move the data from B register to Accumulator. Store the Accumulator content to DPTR. Jump to loop1.

OUTPUT: INPUT DATA: 4400: 23 4401: 32 OUTPUT DATA: 4404: 6D 4405: 06

RESULT: Thus an assembly language program to multiply two datas was written and executed using 8051 micro controller kit.

Ex. No: 29
AIM:

16 BIT DIVISION

To write an assembly language program to divide two 16 bit datas using 8051 Micro controller. APPARATUS REQUIRED: 8051 Microcontroller kit. Power chord. ALGORITHM: Step1: Start the program. Step2: Load the two datas into Accumulator and B register. Step3: Divide the two datas. Step4: Store the result into the memory. Step5: Stop the program. MNEMONICS: MOV MOVX MOV INC MOVX DIV INC MOVX INC MOV MOVX LOOP1: SJMP DPTR,#4400 A,@DPTR 0F0,A DPTR A,@DPTR AB DPTR @DPTR,A DPTR A,0F0 @DPTR,A LOOP1

TABLE: 1

Memory 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 410A 410B 410C 410D 410E 410F 4110 4111

Label

Mnemonics MOV DPTR,#4400

Hex code 90 44 00

Description Move data 4400 to DPTR

MOVX A,@DPTR MOV 0F0,A INC DPTR MOVX A,@DPTR DIV AB INC DPTR MOVX @DPTR,A INC DPTR MOV A,0F0 MOVX @DPTR,A Loop2 SJMP LOOP1

E0 F5 F0 A3 E0 84 A3 F0 A3 E5 F0 F0 80 41 1C

Move data from DPTR to Accumulator. Move data from Accumulator to B register. Increment DPTR content once. Move data from DPTR to Accumulator. Divide the Accumulator content and B register. Increment DPTR content once. Store the Accumulator content to DPTR. Increment DPTR content once. Move the data from B register to Accumulator. Store the Accumulator content to DPTR. Jump to loop1.

OUTPUT: INPUT DATA: 4400: ED 4401: 23 OUTPUT DATA: 4404: 06 4405: 1B

RESULT: Thus an assembly language program to divide two datas was written and executed using 8051 microcontroller kit.

INTERFACING PROGRAMS

Ex. No: 30
AIM:

STEPPER MOTOR INTERFACING

To write a program fro inter facing stepper motor and to run the motor in different directions and in different speeds. ALGORITHM: Step1: Start the program. Step2: Load HL register pair with memory address at look up. Step3: Move the contents of HL pair to accumulator. Step4: Out the contents of accumulator to run the motor. Step5: Decrease b register. If register content is not zero then rotate the motor continuously. Step6: If zero then move to the Seginning of the program. Step7: Stop the process. THEORY: STEPPER MOTOR: A motor in which the rotor is able to assume only discrete stationary angular position is a Stepper Motor. The rotary motion in a stepper motor is a stepwise manner from one equilibrium position to another. CONSTRUCTIONAL FEATURES: A stepper motor could be either of the reluctance type or of the permanent magnet type (PM). A PM stepper consists of multiphase stator and two part permanent magnet rotor. The VR stepper motor has unmagnetised rotor. PM stepper motor is the most commonly used type. The basic two phase stepper motor consists of two pairs of stator poles. Each of the four poles has its own winding. The excitation

of any winding generates a north pole (N), a south pole (S) gets induced at the diametrically opposite side. As shown in the figure the four pole structure is continuous with the stator frame and the magnetic field passes through the cylindrical stator annular ring. The rotor magnetic system has two end faces. The left face is permanently magnetized as South Pole and their right face as North Pole. The South Pole structure and the North Pole structure posses similar pole faces. The north pole structure is twisted with respect to the south pole structure by one pole pitch. Stepper Motor Cross-sectional View

MP & MC LAB MANUAL

ECE

Page | 102

In an arrangement where four stator poles and three poles of rotor poles, there exists 12 possible positions in which a south pole of the rotor can lock with a north pole of the stator. From this it can be rotated that the step size is 360 = Ns*Nr where, Ns is the number of stator pole pairs Nr is the number of pairs rotor pole Generally step size of the stepper motor depends upon NR. These stable positions can be attained by simply energizing the winding on any one of the stator poles with a DC. There are three different schemes available for stepping a stepper motor. They are, a) Wave Scheme b) 2-Phase scheme c) Half stepping or mixed scheme 2-PHASE SCHEME: In this scheme any two adjacent stator windings are energized. There are two magnetic fields active in quadrature and none of the rotor pole faces can in direct alignment with the stator poles. A partial but symmetric alignment of the rotor poles is of course possible.
o

Typical equilibrium conditions of the rotor when the windings on two successive stator poles are excited are illustrated. In Step (a) A1 and B1 are energized. The pole-face S1 tries to align itself with the axis of A1 (N) and the poleface S2 with B1 (N). The North Pole N3 of the rotor finds itself in neutral zone between A1 (N) and B1 (N). S1 and S2 of the rotor position themselves symmetrically with respect to the two stator north pole. Next when B1 and A2 are energized S2 tends to align with B1 (N) and S3 with A2 (N) of course. Again under equilibrium conditions only partial alignment is possible and N1 finds itself in the neutral region midway between B1 (N) and A2 (N) [Step (b)]. In Step (c), A2(N) and B2(N), respectively, with N2 in the neutral zone. Step (d) illustrates the case when A1 and B2 are ON. The step angle is 30 as in the two phases scheme. However the rotor is offset by 15 in the two phases scheme with respect to the wave scheme. A total of 12 steps are required to move the rotor by 360 (mechanical) Two Phases drives produce more torque than the wave drives. MNEMONICS: START: REPT: LXI MVI H, LOOK UP B, 04

MOV A, M OUT 0C0H LXI D, 0303H

DELAY:

NOP DCX D MOV A, E ORA D JNZ INX JNZ JMP DELAY H REPT START 09 05 06 0A

DCR B

LOOK UP:

DB

TABLE: 1 LOOK UP TABLE Anticlockwise 1 2 3 4 TABLE: 2 Mnemonics

Instruction

Clockwise 1 0 0 1 0 1 1 0 1 1 0 0 0 0 1 1

Step A1 A2 B1 B2 A1 A2 B1 B2 1 0 0 1 0 1 1 0 0 0 1 1 1 1 0 0

Memory Label 4100 4101 4102 4103 4014 4105 4106 4107 4108 4109 410A 410B 410C 410D 410E 410F 4110
DELAY: START: LXI

HEX CODE

Description
Load HL pair with memory address

Operand H, LOOK UP

21

1A 41 MVI REPT: MOV MOV LXI B,04 A,M [2000], AX D, 0303H 06 04 7E 03 C0 11 03 NOP DCX MOV ORA JNZ D A,E D 410B 03 00 1B 7B B2 C2 0B

at Look Up Move immediate the given data to B register Move content of memory to Acc. Out the content of Accumulator to C0 port address Load the data 0303H to D register

Perform No operation
Decrement address of DE pair once

Move E register content to Acc. Perform OR operation With Acc. Jump on no zero to the instruction at specified memory

4111 4112 4113 4114 4115 4116 4117 4118 4119 411A LOOK
UP INX H B

41 23 05 C2 05 41 JMP
START

Address Increment HL pair address once

Decrement B register content once

DCR JNZ

Jump on no zero to the instruction at specified memory Address Jump to the instruction at specified memory Data will be stored in the location

C3 00 41 09 05 06 04

RESULT: Thus the stepper motor is rotated by varying the speed using COUNT operation and its direction is also changed using program written and executed using 8085 micro processor kit.

Ex. No: 31

INTERFACING WITH PROGRAMMABLE INPUT OUTPUT 8255

AIM: To initialize port A as input port and port B as output port in mode 0.To input the data at port A and set by the spot switches and to output the same data to port B to glow the LEDS accordingly. APPARATUS REQUIRED: 8085 Microprocessor Kit 8255 microprocessor programmable input/output Power Chord 8b call cable

PRODUCTION: The 8255 has been displayed as general purpose programmable I/O device compatible with intel inputs. It contains three 8 bit parts which can be configured by software means to provide any one of the three programmable data transfer available with 8255. PORT A One 8 bit data output latch/ buffer and one 8 bit data input latch. Port A can function as input or output ports in three modes. The details are given in the following section. PORT B One 8 bit data output latch/ buffer and one 8 bit data input latch. Port B can function as input or output ports in two modes.

PORT C One 8 bit data output latch/ buffer and one 8 bit data input latch. Port C can function as simple input or output port. Thus port can be divided into two four bit ports which intern can function as sample input or output port. In addition the port C line can be used for the control signal outputs and the status signal outputs in conjunction with port A and port B. GROUP A AND GROUP B CONTROLS: The three ports of 8255 have been divided into two groups group A and group B. Group A contains port B and port C higher address lines. Group B contains port B and port C lower address lines. The ports are configured as input are output by command window contains information such as mode, bit set etc. In short command window decides. Whether the port is input port or output port and modes of transfer through a port. Each of the control blocks accepts command to its associated ports. CONFIGURATION 8255 WITH A MICROPROCESSOR: The 8255 has all the necessary hardware for direct interfacing with 8116 bit bus. Data communication and configuration for direct data transfer can be done using the fal registers, namely three ports A, B and E and the control register available in the chip, register can be accessed with the help of A0 and A1 pin lines which are connected to the lower order bits A1 and A2 of the 8 bit microprocessor unit. The port registers are read / write register where as write registers is a control register. PROGRAMMING THE 8255: The control word can be programmed to configure the ports in a write variety of functional characteristics, the mode definition format is shown. Port lines have been divided into two groups: Group A and Group B. Group A can be configured in these modes, mode 0, mode 1 and mode 2 where as group B can be configured into two modes mode 0 and mode 1.

The control word is 8 bit wide. Bit 7 decides whether the mode set of operation in bit set and reset operation is selected. With Bit 7=1 Bit 6,5,4 and 3 to set the modes of group A while Bit 2,1 and 0 are to set the modes of group B. Detailed operation will be discussed later. PROCEDURE: Initialise the port A as input port and out to control read input from port A and out to the control port B. store the content of Accumulator in add 4500. MNEMONICS: ORG 4100H MVI A,90 OUT 0C6H OUT C6H IN COH STA 4500H HLT OBSERVATION: Enter the program starting from the USER RAM address set a known data at the spot switches. Execute the program. The Above program initialises port A as an input port and port B as an out port. The data set by SPOT switches setting is input to the accumulator and is outputted to port B and the data output at the LEDs is the same, as that set by the SPOT switches settings. This input value from the accumulator is stored at 4500H.

RESULT: Thus a program to initialise port A as input port and port B as output port in mode 0 in processor 8255 was performed and their output was verified.

Ex. No: 32

INTERFACING WITH KEYBOARD DISPLAY CONTROLLER - 8279

INTRODUCTION: The INTEL 8279 is responsible for debouncing of the keys, coding of the keyboard matrix and refreshing of the display elements in a microprocessor based development system. Its main features are Simultaneous keyboard and display operation. Three input modes such as scanned keyboard mode , scanned sensor mode and stored input entry mode. R output mode such as 8 or 16 bit character multiplexed display right entry or left entry display format. Clock puscalar Programmable scan timing 2 key increment facility for easy programming. Auto increment facility for easy programming. The 8279 is designed specifically to connect to any CPU to do some other Work other than scanning the keyboard and refreshing the display. This CPU can program the operating modes for 8279.It uses the CS, A0, RD and WR lines to control data. How to and from various internal registers and buffer as given in table.

SEGMENT DEFINITION: Segment definitions of the seven segment display are shown below. The correspondence between the data bus and output port bits 8279.Also the segment relationship with these given in table 1.

D0 bit of the byte sent to the display RAM corresponds to B0 and D7 of the byte sent to the display corresponds AB. Inorder to right up a segment the corresponding bit of data are written into the RAM should be a 0.

DISPLAY MODE SETUP: DD DISPLAY MODE: 00-8 8 bit character display-left entry 01-16 8 bit character display- left entry 10-8 8 bit character display- right entry 11-16 8 bit character display-right entry Kkk-KEYBOARD MODE: 000-Encoded scan keyboard-2 KEY LOCK OUT 001-Encoded scan keyboard-2 KEY LOCK OUT 010-Encoded scan keyboard-N key roll over 011-Decoded scan sensor matrix 100- Decoded scan keyboard N key roll over 101- Decoded scan sensor matrix 110-Strobed input, Encoded Display scans 111-Strobed input, decoded display scan

WRITE DISPLAY RAM: The write display RAM command word format is shown in table 1.AI auto increment flag .If AI=1,the row address selected will be incremented after the each following read or write to the DISPLAY RAM AAAA - select any one of the 16 rows of DISPLAY RAM.

READ FIFO STATUS: The status word is read by the CPU when A0 is high and CS and RD are low. FIFO status is used in the keyboard and strobed input modes to indicate whether an error has occurred. There are two types of errors possible over run and under run over run occur. when the entry of another character in to a full. FIFO is attempted. Under RUN across when the CPU tried to read an empty FIFO. The FIFO status word also has been at bit to indicate that the display RAM is unavailable because a clear display or clear all comment has not completed is cleaning operation. The use of this flag is clear the display. In a sensor matrix SIE bit act as error flag and indicates whether a simultaneous multiple closure error has occurred.SIE bit is set in FIFO status word to indicate at least one sensor closure indication is contained in the sensor RAM. READ FIFO/SENSOR RAM: READ FIFO/SENSOR RAM control, word format is given in a table 2. The CPU sets the 8279 for a read of the FIFO1 sensor RAM by writing command word. X - Dont care AI auto increment flag irrelevant is scanned keyboard mode. For sensor matrix mode. If AI=1, then successive read will be from subsequent row of the sensor RAM. AAA- In scanned keyboard mode, the 8279 will automatically drive the data bus for subsequent read in the same sequence in which data first entered the FIFO. READ A KEY: PROCEDURE: Set FIFO status check for a key and repeat the loop. Set 8279 for A and of read of FIFO RAM store the content of accumulator at the memory address 4200 CNT EQU 0C2H; DAT EQU 0C0H.

MNEMONICS: ORG 4100H LOO IN JZ CNT LOOP ANI 07 MVI A, 40H OUT CNT IN HLT OBSERVATION: The key 0 is pressed and the data entered at FIFO RAM is W. ROUTING DISPLAY: PROCEDURE: The initialization of 8279 to display the characters. The data is fetched from address 412CH and displayed in the second digit of the display. Since in the command word for write display. RAM the auto increment flag is set. A time delay is given between successive digit to likely display. MNEMONICS: START LXI 412CH MVI D,OFH MVI A,10F OUT 0C2H MVI A,0CCH OUT 0C2H LOOP MOV A,M OUT 0C0H DAT STA 4200

CALL DELAY INX H DCR D JNZ LOOP JMP START DELAY MVI B,0A0H LOOP1 MVI C,0FFH LOOP2 DCR C JNZ LOOP2 DCR C JNZ LOOP1 RET OBSERVATION: The rolling message HELP US is displayed in the display when the input given is 412C FF 4130 FF 4134 98 4138 1C FF FF 68 29 FF FF 70 FF FF FF 08 FF

RESULT: Thus a program to read akey and rolling display by interfacing 8085 with 8279 is executed and the output is verified.