EE6502_ALP

8085 MICROPROCESSOR PROGRAMS

1. Statement: Store the data byte 32H into memory location 4000H. Program 1:

MVI A, 32H: Store 32H in the accumulator

STA 4000H: Copy accumulator contents at address 4000H

HLT: Terminate program execution

Program 2:

LXI H : Load HL with 4000H

MVI M : Store 32H in memory location pointed by HL register pair(4000H)

HLT : Terminate program execution

2. Statement: Exchange the contents of memory locations 2000H and 4000H

Program 1:

LDA 2000H : Get the contents of memory location 2000H into accumulator

MOV B, A : Save the contents into B register

LDA 4000H : Get the contents of memory location 4000Hinto accumulator

STA 2000H : Store the contents of accumulator at address 2000H

MOV A, B : Get the saved contents back into A register

STA 4000H : Store the contents of accumulator at address 4000H

Program 2:

LXI H 2000H : Initialize HL register pair as a pointer to memory location 2000H.

LXI D 4000H : Initialize DE register pair as a pointer to memory location 4000H.

MOV B, M : Get the contents of memory location 2000H into B register.

LDAX D : Get the contents of memory location 4000H into A register.

MOV M, A : Store the contents of A register into memory location 2000H.

MOV A, B : Copy the contents of B register into accumulator.

STAX D : Store the contents of A register into memory location 4000H.

HLT : Terminate program execution.

3: Subtract two 8-bit numbers

Source program:

LXI H, 4000H : HL points 4000H

MOV A, M : Get first operand

INX H : HL points 4001H

SUB M : Subtract second operand

INX H : HL points 4002H

MOV M, A : Store result at 4002H.


4. Statement: Find the 2's complement of the number stored at memory location

4200H and store the complemented number at memory location 4300H.

Sample problem:

(4200H) = 55H

Result = (4300H) = AAH + 1 = ABH

Source program:

LDA 4200H: Get the number

CMA: Complement the number

ADI, 01 H: Add one in the number

STA 4300H: Store the result

HLT: Terminate program execution

5.Statement: Pack the two unpacked BCD numbers stored in memory locations

4200H and 4201H and store result in memory location 4300H. Assume the least significant digit is

stored at 4200H.

Sample problem:

(4200H) = 04

(4201H) = 09

Result = (4300H) = 94

Source program

LDA 4201H : Get the Most significant BCD digit

RLC

RLC

RLC

RLC : Adjust the position of the second digit (09 is changed to 90)

ANI FOH : Make least significant BCD digit zero

MOV C, A : store the partial result

LDA 4200H : Get the lower BCD digit

ADD C : Add lower BCD digit

STA 4300H : Store the result


6. Statement: Two digit BCD number is stored in memory location 4200H. Unpack the BCD

number and store the two digits in memory locations 4300H and 4301H such that memory location

4300H will have lower BCD digit.

Sample problem

(4200H) = 58

Result = (4300H) = 08 and

(4301H) = 05

Source program

LDA 4200H : Get the packed BCD number

ANI FOH : Mask lower nibble

RRC

RRC

RRC

RRC : Adjust higher BCD digit as a lower digit

STA 4301H : Store the partial result

LDA 4200H : .Get the original BCD number

ANI OFH : Mask higher nibble



7.Statement: Calculate the sum of series of numbers. The length of the series is in memory location

4200H and the series begins from memory location 4201H.

a. Consider the sum to be 8 bit number. So, ignore carries. Store the sum at memory

location 4300H.

b. Consider the sum to be 16 bit number. Store the sum at memory locations 4300H

and 4301H

a. Sample problem

4200H = 04H

4201H = 10H

4202H = 45H

4203H = 33H

4204H = 22H

Result = 10 +41 + 30 + 12 = H

Source program:

LDA 4200H

MOV C, A : Initialize counter

SUB A : sum = 0

LXI H, 4201H : Initialize pointer

BACK: ADD M : SUM = SUM + data

INX H : increment pointer

DCR C : Decrement counter

JNZ BACK : if counter 0 repeat

STA 4300H : Store sum


b. Sample problem

4200H = 04H

420lH = 9AH

4202H = 52H

4203H = 89H

4204H = 3EH

Result = 9AH + 52H + 89H + 3EH = H

4300H = B3H Lower byte

4301H = 0lH Higher byte

Source program:

LDA 4200H



SUB A :Sum low = 0

MOV B, A : Sum high = 0

BACK: ADD M : Sum = sum + data

JNC SKIP

INR B : Add carry to MSB of SUM

SKIP: INX H : Increment pointer


JNZ BACK : Check if counter 0 repeat

STA 4300H : Store lower byte

MOV A, B

STA 4301H : Store higher byte

HLT :Terminate program exec

8. Statement: Multiply two 8-bit numbers stored in memory locations 2200H and

2201H by repetitive addition and store the result in memory locations 2300H and

2301H.

Sample problem:

(2200H) = 03H

(2201H) = B2H

Result = B2H + B2H + B2H = 216H

(2300H) = 16H

(2301H) = 02H

Source program

LDA 2200H

MOV E, A

MVI D, 00 : Get the first number in DE register pair

LDA 2201H


LX I H, 0000 H : Result = 0

BACK: DAD D : Result = result + first number

DCR C : Decrement count

JNZ BACK : If count 0 repeat

SHLD 2300H : Store result


9. Statement: Divide 16 bit number stored in memory locations 2200H and 2201H

by the 8 bit number stored at memory location 2202H. Store the quotient in memory

locations 2300H and 2301H and remainder in memory locations 2302H and 2303H.

Sample problem

(2200H) = 60H

(2201H) = A0H

(2202H) = l2H

Result = A060H/12H = 8E8H Quotient and 10H remainder

(2300H) = E8H

(2301H) = 08H

(2302H) = 10H

(2303H) = 00H

Source program

LHLD 2200H : Get the dividend

LDA 2202H : Get the divisor

MOV C, A

LXI D, 0000H : Quotient = 0

BACK: MOV A, L

SUB C : Subtract divisor

MOV L, A : Save partial result

JNC SKIP : if CY 1 jump

DCR H : Subtract borrow of previous subtraction

SKIP: INX D : Increment quotient

MOV A, H

CPI, 00 : Check if dividend < divisor

JNZ BACK : if no repeat

MOV A, L

CMP C

JNC BACK

SHLD 2302H : Store the remainder

XCHG

SHLD 2300H : Store the quotient


10. Statement: Find the number of negative elements (most significant bit 1) in a

block of data. The length of the block is in memory location 2200H and the block

Itself begins in memory location 2201H. Store the number of negative elements in

memory location 2300H

Sample problem

(2200H) = 04H

(2201H) = 56H

(2202H) = A9H

(2203H) = 73H

(2204H) = 82H

Result = 02 since 2202H and 2204H contain numbers with a MSB of 1.

Source program

LDA 2200H

MOV C, A : Initialize count

MVI B, 00 : Negative number = 0


BACK: MOV A, M : Get the number

ANI 80H : Check for MSB

JZ SKIP : If MSB = 1

INR B : Increment negative number count


DCR C : Decrement count

JNZ BACK : If count 0 repeat

MOV A, B



11.Statement:Find the largest number in a block of data. The length of the block

is in memory location 2200H and the block itself starts from memory location

2201H.

Store the maximum number in memory location 2300H. Assume that the numbers

in the block are all 8 bit unsigned binary numbers. Sample problem

(2200H) = 04H

(2201H) = 34H

(2202H) = A9H

(2203H) = 78H

(2204H) =56H

Result = (2202H) = A9H

Source program

LDA 2200H

MOV C, A: Initialize counter

XRA A : Maximum = Minimum possible value = 0


BACK: CMP M : Is number> maximum

JNC SKIP : Yes, replace maximum

MOV A, M

SKIP: INX H

DCR C

JNZ BACK

STA 2300H : Store maximum number


12. Statement: Write a program to sort given 10 numbers from memory location

2200H in the ascending order.

Source program:

MVI B, 09 : Initialize counter

START : LXI H, 2200H: Initialize memory pointer

MVI C, 09H : Initialize counter 2


INX H : Increment memory pointer

CMP M : Compare number with next number

JC SKIP : If less, don't interchange

JZ SKIP : If equal, don't interchange

MOV D, M

MOV M, A

DCX H

MOV M, D

INX H : Interchange two numbers

SKIP:DCR C : Decrement counter 2

JNZ BACK : If not zero, repeat

DCR B : Decrement counter 1

JNZ START


13. Statement: Calculate the sum of series of even numbers from the list of

numbers. The length of the list is in memory location 2200H and the series itself

begins from memory location 2201H. Assume the sum to be 8 bit number so you can

ignore carries and store the sum at memory location 2 Sample problem:

2200H= 4H

2201H= 20H

2202H= l5H

2203H= l3H

2204H= 22H

Result 22l0H= 20 + 22 = 42H

Source program:

LDA 2200H


MVI B, 00H : sum = 0



ANI 0lH : Mask Bit l to Bit7

JNZ SKIP : Don't add if number is ODD

MOV A, B : Get the sum

ADD M : SUM = SUM + data

MOV B, A : Store result in B register

SKIP: INX H : increment pointer


JNZ BACK : if counter 0 repeat

STA 2210H : store sum


14. Statement: Calculate the sum of series of odd numbers from the list of

numbers. The length of the list is in memory location 2200H and the series itself

begins from memory location 2201H. Assume the sum to be 16-bit. Store the sum at

memory locations 2300H and 2301H.

Sample problem:

2200H = 4H

2201H= 9AH

2202H= 52H

2203H= 89H

2204H= 3FH

Result = 89H + 3FH = C8H

2300H= H Lower byte

2301H = H Higher byte

Source program

LDA 2200H



MVI E, 00 : Sum low = 0

MOV D, E : Sum high = 0


ANI 0lH : Mask Bit 1 to Bit7

JZ SKIP : Don't add if number is even

MOV A, E : Get the lower byte of sum

ADD M : Sum = sum + data

MOV E, A : Store result in E register

JNC SKIP

INR D : Add carry to MSB of SUM


DCR C : Decrement

14. Statement:Find the square of the given numbers from memory location 6100H

and store the result from memory location 7000H

Source Program:

LXI H, 6200H : Initialize lookup table pointer

LXI D, 6100H : Initialize source memory pointer

LXI B, 7000H : Initialize destination memory pointer

BACK: LDAX D : Get the number

MOV L, A : A point to the square

MOV A, M : Get the square

STAX B : Store the result at destination memory location

INX D : Increment source memory pointer

INX B : Increment destination memory pointer

MOV A, C

CPI 05H : Check for last number

JNZ BACK : If not repeat


15. Statement: Search the given byte in the list of 50 numbers stored in the

consecutive memory locations and store the address of memory location in the

memory locations 2200H and 2201H. Assume byte is in the C register and starting

address of the list is 2000H. If byte is not found store 00 at 2200H and 2201H.

Source program:

LX I H, 2000H : Initialize memory pointer 52H

MVI B, 52H : Initialize counter


CMP C : Compare with the given byte

JZ LAST : Go last if match occurs

INX H : Increment memory pointer

DCR B : Decrement counter

JNZ B : I f not zero, repeat

LXI H, 0000H

SHLD 2200H

JMP END : Store 00 at 2200H and 2201H

LAST: SHLD 2200H : Store memory address

END: HLT : Stop

16. Statement: Write an assembly language program to separate even numbers

from the given list of 50 numbers and store them in the another list starting from

2300H. Assume starting address of 50 number list is 2200H

Source Program:

LXI H, 2200H : Initialize memory pointer l

LXI D, 2300H : Initialize memory pointer2

MVI C, 32H : Initialize counter

BACK:MOV A, M : Get the number

ANI 0lH : Check for even number

JNZ SKIP : If ODD, don't store

MOV A, M : Get the number

STAX D : Store the number in result list

INX D : Increment pointer 2

SKIP: INX H : Increment pointer l


JNZ BACK : If not zero, repeat

HLT : Stop

17. Statement: Write assembly language program with proper comments for the

following:

A block of data consisting of 256 bytes is stored in memory starting at 3000H.

This block is to be shifted (relocated) in memory from 3050H onwards. Do not shift

the block or part of the block anywhere else in the memory.

Source Program:

Two blocks (3000 - 30FF and 3050 - 314F) are overlapping. Therefore it

is necessary to transfer last byte first and first byte last.

MVI C, FFH : Initialize counter

LX I H, 30FFH : Initialize source memory pointer 3l4FH

LXI D, 314FH : Initialize destination memory pointer

BACK: MOV A, M : Get byte from source memory block

STAX D : Store byte in the destination memory block

DCX H : Decrement source memory pointer

DCX : Decrement destination memory pointer


JNZ BACK : If counter 0 repeat

HLT : Stop execution

18. 8085 PROGRAM TO OBTAIN SQUARE OF A NUMBER

LXI H, 5000 ;Initialize Look up table

LDA 5050 ; Get the data

CPI 0A ; Check input > 9

JC AFTER ;if yes error

MVI A,FF ;Error Indication

STA 5051

HLT

AFTER: MOV C,A ;Add the desired Address

MVI B,00

DAD B

MOV A,M

STA 5051 ; Store the result

HLT ; Terminate the program

LOOK UP TABLE:

5000 01

5001 04

5002 09

5003 16

5004 25

5005 36

5006 49

5007 64

5008 81

19) STEPPER MOTOR CONTROL PROGRAM (EXAMPLE FOR

SUBROUTINE PROGRAM) (ALSO EXAMPLE FOR STACK RELATED

OPERATION)

1) Discuss the (i) Arithmetic Instructions (ii) Logical Instructions (iii)Data

transfer Instructions (iv) Program and control (branching) instructions

and (v) Boolean variable instructions of 8051 microcontroller.

(i) ARITHMETIC INSTRUCTION

Mnemonics Description Bytes Instruction Cycles

ADD A, Rn A A + Rn 1 1

ADD A, direct A A + (direct) 2 1

ADD A, @Ri A A + @Ri 1 1

ADD A, #data A A + data 2 1

ADDC A, Rn A A + Rn + C 1 1

ADDC A, direct A A + (direct) + C 2 1

ADDC A, @Ri A A + @Ri + C 1 1

ADDC A, #data A A + data + C 2 1

DA A Decimal adjust accumulator 1 1

DIV AB Divide A by B

A quotient

B remainder

1 4

DEC A A A -1 1 1

DEC Rn Rn Rn - 1 1 1

DEC direct (direct) (direct) - 1 2 1

DEC @Ri @Ri @Ri - 1 1 1

INC A A A+1 1 1

INC Rn Rn Rn + 1 1 1

INC direct (direct) (direct) + 1 2 1

INC @Ri @Ri @Ri +1 1 1

INC DPTR DPTR DPTR +1 1 2

MUL AB Multiply A by B

A low byte (A*B)

B high byte (A* B)

1 4

SUBB A, Rn A A - Rn - C 1 1

SUBB A, direct A A - (direct) - C 2 1

SUBB A, @Ri A A - @Ri - C 1 1

SUBB A, #data A A - data - C 2 1

(ii)LOGICAL INSTRUCTION


ANL A, Rn A A AND Rn 1 1

ANL A, direct A A AND (direct) 2 1

ANL A, @Ri A A AND @Ri 1 1

ANL A, #data A A AND data 2 1

ANL direct, A (direct) (direct) AND A 2 1

ANL direct, #data (direct) (direct) AND data 3 2

CLR A A 00H 1 1

CPL A A A 1 1

ORL A, Rn A A OR Rn 1 1

ORL A, direct A A OR (direct) 1 1

ORL A, @Ri A A OR @Ri 2 1

ORL A, #data A A OR data 1 1

ORL direct, A (direct) (direct) OR A 2 1

ORL direct, #data (direct) (direct) OR data 3 2

RL A Rotate accumulator left 1 1

RLC A Rotate accumulator left through

carry

1 1

RR A Rotate accumulator right 1 1

RRC A Rotate accumulator right through

carry

1 1

SWAP A Swap nibbles within Acumulator 1 1

XRL A, Rn A A EXOR Rn 1 1

XRL A, direct A A EXOR (direct) 1 1

XRL A, @Ri A A EXOR @Ri 2 1

XRL A, #data A A EXOR data 1 1

XRL direct, A (direct) (direct) EXOR A 2 1

XRL direct, #data (direct) (direct) EXOR data 3 2

(iii)DATA TRANSFER INSTRUCTIONS

Mnemonics Description Bytes Instruction

Cycles

MOV A, Rn A Rn 1 1

MOV A, direct A (direct) 2 1

MOV A, @Ri A @Ri 1 1

MOV A, #data A data 2 1

MOV Rn, A Rn A 1 1

MOV Rn, direct Rn (direct) 2 2

MOV Rn, #data Rn data 2 1

MOV direct, A (direct) A 2 1

MOV direct, Rn (direct) Rn 2 2

MOV direct1,

direct2

(direct1) (direct2) 3 2

MOV direct, @Ri (direct) @Ri 2 2

MOV direct, #data (direct) #data 3 2

MOV @Ri, A @Ri A 1 1

MOV @Ri, direct @Ri (direct) 2 2

MOV @Ri, #data @Ri data 2 1

MOV DPTR,

#data16

DPTR data16 3 2

MOVC A,

@A+DPTR

A Code byte pointed by A + DPTR 1 2

MOVC A,

@A+PC

A Code byte pointed by A + PC 1 2

MOVC A, @Ri A Code byte pointed by Ri 8-bit address) 1 2

MOVX A,

@DPTR

A External data pointed by DPTR 1 2

MOVX @Ri, A @Ri A (External data - 8bit address) 1 2

MOVX @DPTR,

A

@DPTR A(External data - 16bit address) 1 2

PUSH direct (SP) (direct) 2 2

POP direct (direct) (SP) 2 2

XCH Rn Exchange A with Rn 1 1

XCH direct Exchange A with direct byte 2 1

XCH @Ri Exchange A with indirect RAM 1 1

XCHD A, @Ri Exchange least significant nibble of A with

that of indirect RAM

1 1

(iv)PROGRAM AND MACHINE CONTROL (BRANCHING )INSTRUCTIONS

Mnemonics Description Bytes Instruction

Cycles

ACALL addr11 PC + 2 (SP) ; addr 11 PC 2 2

AJMP addr11 Addr11 PC 2 2

CJNE A, direct, rel Compare with A, jump (PC + rel) if not

equal

3 2

CJNE A, #data, rel Compare with A, jump (PC + rel) if not

equal

3 2

CJNE Rn, #data, rel Compare with Rn, jump (PC + rel) if not

equal

3 2

CJNE @Ri, #data, rel Compare with @Ri A, jump (PC + rel) if

not equal

3 2

DJNZ Rn, rel Decrement Rn, jump if not zero 2 2

DJNZ direct, rel Decrement (direct), jump if not zero 3 2

JC rel Jump (PC + rel) if C bit = 1 2 2

JNC rel Jump (PC + rel) if C bit = 0 2 2

JB bit, rel Jump (PC + rel) if bit = 1 3 2

JNB bit, rel Jump (PC + rel) if bit = 0 3 2

JBC bit, rel Jump (PC + rel) if bit = 1 3 2

JMP @A+DPTR A+DPTR PC 1 2

JZ rel If A=0, jump to PC + rel 2 2

JNZ rel If A ≠ 0 , jump to PC + rel 2 2

LCALL addr16 PC + 3 (SP), addr16 PC 3 2

LJMP addr 16 Addr16 PC 3 2

NOP No operation 1 1

RET (SP) PC 1 2

RETI (SP) PC, Enable Interrupt 1 2

SJMP rel PC + 2 + rel PC 2 2

JMP @A+DPTR A+DPTR PC 1 2

JZ rel If A = 0. jump PC+ rel 2 2

JNZ rel If A ≠ 0, jump PC + rel 2 2

NOP No operation 1 1

BOOLEAN VARIABLE INSTRUCTIONS


CLR C C-bit 0 1 1

CLR bit bit 0 2 1

SET C C 1 1 1

SET bit bit 1 2 1

CPL C C 1 1

CPL bit bit 2 1

ANL C, /bit C C . 2 1

ANL C, bit C C. bit 2 1

ORL C, /bit C C + 2 1

ORL C, bit C C + bit 2 1

MOV C, bit C bit 2 1

MOV bit, C bit C 2 2

2) Write a 8051 program for (i) addition (ii) subtraction (iii) Multiplication (iv) Division (v) Ascending order (vi) Descending order.

BASIC 8051 PROGRAMS

8051 PROGRAM TO ADD TWO NUMBERS

MOV R0,#0X20 ; Move the first number to R0 register MOV R1,#0X30 ; Move the second number to R1 register MOV R2,#0X00 ; Move data 00 to R2 register MOV A,R0 ; Move the first number from R0 to accumulator

ADD A,R1; add the contents of accumulator with contents of R1register

JNC Result ;If no carry then goto Result MOV R2,#0X01 ; Make R2 content 01 to indicate Carry Result: MOV R3,A ; Move the result in accumulator to R3 register.

Here : SJMP Here

8051 PROGRAM TO SUBTRACT TWO 8 BIT NUMBERS

MOV R0,#0X20 ; Move the first number to R0 register MOV R1,#0X30 ; Move the second number to R1 register MOV R2,#0X00 ; Move the date 00 to R2 register MOV A,R1 ; Move the second number to accumulator from R1 reg SUBB A,R0 Subtract the contents of R0 register from accumulator JNC Result; If no carry then goto Result MOV R2,#0X01 ; Move 01 data to R2 register indicating carry

Result: MOV R3,A ; Move the result from accumulator to R3 register Here: SJMP Here; Control stays here

8051 PROGRAM TO SUBTRACT TWO 16 BIT NUMBERS MOV R0,#0X20 ; Move lower byte of 1st number to R0 register MOV R1,#0X30 ; Move Upper byte of 1st number to R1 register MOV R2,#0X20 ;Move Lower byte of 2nd number to R2 register MOV R3,#0X40 ;Move Upper byte of 2nd number to R3 register MOV R6,#0X00 ; Move data 00 to R6 register LCALL Adder ;Goto Adder subroutine Here SJMP Here ;Control stays here

Adder: MOV A,R2 ; Move lower byte of second number to accumulator SUBB A,R0 ;Sub the contents of accumulator to content of R0(lower byte 1 no) MOV R4,A ;Move the Lower byte of the result to R4 register MOV A,R3 ; Move the upper byte of second number to accumulator SUBB A,R1 ; Sub the contents of accumulator to content of R1(upper byte 2 no) JNC Result ;If no carry then goto the result MOV R6,#0X01 ;Indicate carry in R6 register Result:MOV R5,A ; Move the Upper byte of the result to R5 register RET

8051 PROGRAM TO DIVIDE TWO 8 BIT NUMBER

MOV R0,#0X60 ; Move the 1st number to R0 register MOV R1,#0X30 ; Move the second number to R1 register MOV A,R0 ; Move the first number to accumulator from R0 MOV B,R1 ; Move the second number to B register from R1 DIV AB ; Divide A/B MOV R2,A ; Move the result in accumulator to R2 register

HERE SJMP HERE

SORTING NUMBER IN ASCENDING ORDER

Sorting of array in ascending order ;Array size is 04 ;Array starting address is 70h

L0: MOV R1,#70 MOV R0,#70 MOV R2,#04 MOV R3,#00 DEC R2 L1: MOV A,@R0 MOV B,A INC R1 SUBB A,@R1 JC L2 MOV A,B XCH A,@R1 MOV @R0,A MOV R3,#01 L2: INC R0 DJNZ R2,L1 CJNE R3,#00,L0 HERE: SJMP HERE

SORTING NUMBER IN DESCENDING ORDER ;Sorting of array n descending order ;Array size is 04 ;Array starting address is 70h

L0: MOV R1,#70 MOV R0,#70 MOV R2,#04 MOV R3,#00 DEC R2 L1: MOV A,@R0 MOV B,A INC R1 SUBB A,@R1 JNC L2 MOV A,B XCH A,@R1 MOV @R0,A MOV R3,#01 L2: INC R0 DJNZ R2,L1 CJNE R3,#00,L0 HERE: SJMP HERE

LOOK UP TABLE PROGRAM

A look up table is a table which is predefined in the memory and the program gets some

necessary data from the table during runtime. This type of look up table is very important for

example if you want to perform some trigonometric operation (sin,cos,tan) during runtime of the

microcontroller then you need to perform a complicated calculation and it will increase the

controller overhead and will and cause the programme difficult and lengthy. But if you store the

values in memory previously then you can extract them easily during runtime which is very easy.

So here is an example of how to use look up table.

Finding Square of a Number Using Look up Table

MOVDPTR,#9000H ; Load look up table address 900H

MOVR0,#05 ;Load the number 05 in R0

MOVA,R0 ;Move data R0 to accumulator

MOVCA,@A+DPTR ;Get square of 05 from look up table and stored in

accumulator

MOVDPTR,#9100 ;Load 9100 in DPTR

MOVX@DPTR,ASend to 9100H memory location02 0

LJMP 00

LOOK UP TABLE

9000 00

9001 01

9002 04

9003 09

9004 16

9005 25

9006 36

9008 49

9009 64

9010 81

EE6502_ALP

Documents

Transcript of EE6502_ALP