The Accumulator (A) is one of the most frequently used registers in the 8051 microcontroller.

It is an
8-bit register used for arithmetic, logical, and data transfer operations.

Here are examples of different types of Accumulator instructions with explanations:

1. Data Transfer Instructions

• MOV A, #immediate_value: Load an immediate value into the accumulator.

MOV A, #0x25h ; Load the immediate value 0x25 into the accumulator

• MOV A, address: Load a value from a memory location into the accumulator.

MOV A, 30h ; Load the value from internal RAM location 30h into A

• MOV address, A: Store the value in the accumulator to a memory location.

MOV 40h, A ; Store the value of A in internal RAM location 40h

2. Arithmetic Instructions

• ADD A, source: Add the value of the source to the accumulator.

MOV A, #0x05 ; Load 5 into A

ADD A, #0x03 ; Add 3 to A, A = 5 + 3 = 8

• SUBB A, source: Subtract the source value from the accumulator with borrow.

MOV A, #0x10 ; Load 16 into A

MOV C, #0 ; Clear carry (no borrow)

SUBB A, #0x05 ; Subtract 5 from A, A = 16 - 5 = 11

3. Logical Instructions

• ANL A, source: Perform bitwise AND between the accumulator and the source.

MOV A, #0x0F ; Load 0x0F into A

ANL A, #0xF0 ; A = 0x0F AND 0xF0, result A = 0x00

• ORL A, source: Perform bitwise OR between the accumulator and the source.

MOV A, #0x0F ; Load 0x0F into A

ORL A, #0xF0 ; A = 0x0F OR 0xF0, result A = 0xFF

• XRL A, source: Perform bitwise XOR between the accumulator and the source.

MOV A, #0xAA ; Load 0xAA into A

XRL A, #0xFF ; A = 0xAA XOR 0xFF, result A = 0x55

• RL A: Rotate the accumulator left.

MOV A, #0x85 ; Load 0x85 (10000101) into A

RL A ; Rotate left, A = 0x0A (00001010)

• RR A: Rotate the accumulator right.

MOV A, #0x85 ; Load 0x85 (10000101) into A

RR A ; Rotate right, A = 0xC2 (11000010)

5. Compare Instructions

• CJNE A, #immediate_value, rel_addr: Compare the accumulator with an immediate value,

MOV A, #0x10 ; Load 0x10 into A

CJNE A, #0x20, SKIP ; Compare A with 0x20, if not equal, jump to SKIP

; (If equal, execution continues here)

SKIP:

6. Increment/Decrement Instructions

• INC A: Increment the value in the accumulator by 1.

MOV A, #0x0A ; Load 10 into A

INC A ; Increment A, A = 11

• DEC A: Decrement the value in the accumulator by 1.

MOV A, #0x0A ; Load 10 into A

DEC A ; Decrement A, A = 9

7. Multiply and Divide

• MUL AB: Multiply the accumulator (A) and the B register.

MOV A, #0x02 ; Load 2 into A

MOV B, #0x03 ; Load 3 into B

MUL AB ; A = 0x06 (result low byte), B = 0x00 (result high byte)

• DIV AB: Divide the accumulator (A) by the B register.

MOV B, #0x02 ; Load 2 into B

DIV AB ; A = 4 (quotient), B = 0 (remainder)

8. Bit Instructions

• SETB ACC.0: Set a specific bit in the accumulator.

MOV A, #0x00 ; Clear A

SETB ACC.0 ; Set bit 0, A = 0x01

• CLR ACC.7: Clear a specific bit in the accumulator.

MOV A, #0xFF ; Load all bits as 1

CLR ACC.7 ; Clear bit 7, A = 0x7F

How do we know a number is signed or not in 8051

In the 8051 microcontroller, numbers themselves do not carry any inherent property indicating
whether they are signed or unsigned. Instead, the interpretation of a number as signed or unsigned
depends on the context of the program and the instructions being executed.

Key Points to Determine Signed or Unsigned Numbers

1. Programmer's Context:

o Whether a number is signed or unsigned is determined by how you, the

o For example:

▪ 0xFF can represent:

▪ Unsigned: 255

▪ Signed: -1 (in two's complement form)

2. Signed Range vs. Unsigned Range:

o In the 8051, all registers and memory locations are 8-bit, so they can hold values in
the range:

▪ Unsigned: 0 to 255 (0x00 to 0xFF)

▪ Signed: -128 to +127 (in two's complement format)

o To interpret a number as signed:

▪ The most significant bit (MSB) acts as the sign bit:

▪ 0: Positive number
 ▪ 1: Negative number (in two's complement)

3. Use of Overflow (OV) Flag:

o The OV flag in the PSW (Program Status Word) register is helpful when dealing with
signed arithmetic. It indicates whether the result of a signed operation has exceeded
the signed range (-128 to 127).

o Example:

MOV A, #0x7F ; Load +127 (01111111) into A

ADD A, #0x01 ; Add 1

; A = 0x80 (-128 in signed), OV = 1 (overflow occurred)

4. Carry (CY) Flag for Unsigned Operations:

o The CY flag in the PSW register indicates a carry in unsigned arithmetic (e.g., when
adding two numbers exceeds 255).

5. Signed-Specific Operations:

o No dedicated signed arithmetic instructions exist in the 8051. Instead, signed

▪ The OV flag for signed overflow.

▪ The MSB for the sign of the result.

Examples

Signed vs. Unsigned Interpretation

MOV A, #0xFF ; Load 255 (unsigned) or -1 (signed) into A

• Unsigned: 255 (11111111)

• Signed: -1 (two's complement of 11111111)

Adding Signed Numbers

MOV A, #0x7E ; Load 126 (signed) into A

ADD A, #0x03 ; Add 3

; Result: A = 0x81 (-127 in signed), OV = 1 (overflow occurred)

Adding Unsigned Numbers

MOV A, #0xFE ; Load 254 (unsigned) into A

ADD A, #0x02 ; Add 2

; Result: A = 0x00 (overflow), CY = 1 (carry occurred)

1. Check the Context of Arithmetic:

o If the CY flag is checked, it's likely dealing with unsigned numbers.

o If the OV flag is checked, it's likely dealing with signed numbers.

2. Interpret Based on Usage:

o If numbers are expected to represent negative values (e.g., temperatures, financial

o If numbers are strictly non-negative (e.g., counts, memory addresses), treat them as
unsigned.

3. Comment Your Code:

o Clearly indicate in your code whether a value is signed or unsigned to avoid