Microcontroller 8051 Overview

In this addressing mode, the data to be manipulated is stored in a register.

The immediate data is provided directly within the instruction.

The address of the data to be accessed is specified directly within the instruction.

The address of the data to be accessed is indirectly specified by the contents of a pointer register (R0 or R1).

This mode uses the Data Pointer (DPTR) register to access data in external RAM and code space.

A temporary storage location inside the CPU that holds data being processed.

The special function registers (SFRs) in the 8051 microcontroller are directly accessible.

A specific area in the 8051 microcontroller's memory used to store temporary data and program information.

This instruction moves data from the code or constant memory location to the A register. The address of the data is determined by adding the current program counter (PC) value to the specified offset.

MOVX instructions move data between the A register and the external data memory. The address in external memory is accessed using either the DPTR register or the Ri register as a pointer.

This instruction moves a byte from a direct internal RAM or Special Function Register (SFR) location into the stack after incrementing the stack pointer.

Exchanges the contents of accumulator (A) with the byte stored at the memory location pointed to by the register R0 or R1.

This instruction moves a byte from the stack to a direct internal RAM or SFR location, then decrements the stack pointer.

Exchanges the contents of accumulator (A) with the contents of a specified register (Rn).

The XCH instruction exchanges the contents of the A register with a source location, which can be either a direct or indirect register address.

Exchanges the contents of accumulator (A) with the byte stored at a direct address.

This instruction moves a byte from the external data memory to the A register. The address in external memory is determined by the current value of the DPTR register.

Exchanges the lower four bits (hex-digits) of the Accumulator (A) with the lower four bits of the data at the address pointed to by register R0 or R1.

Adds the contents of the accumulator (A) with the value stored in the specified register (Rn).

This instruction moves a byte from the A register to external data memory. The address in external memory is determined by the current value of the DPTR register.

This instruction moves a byte from the external data memory to the A register. The address of the data in external memory is determined by the value in the Ri register.

Adds the contents of the accumulator (A) with the immediate data value provided within the instruction.

Adds the contents of the accumulator (A) with the value at a specified direct memory address.

Adds the contents of the accumulator (A) with the carry flag (CY) and the value stored in the specified register (Rn).

This instruction moves the value of the Carry Flag (CF) to a specified bit location (bit).

This instruction sets the value of the Carry Flag (CF) to 1.

This instruction performs a logical AND operation between the Carry Flag (CF) and a specified bit location (bit). The result is stored in the Carry Flag.

This instruction performs a logical AND operation between the Carry Flag (CF) and a specified bit location (bit). The result is stored in the bit location.

This instruction performs a logical OR operation between the Carry Flag (CF) and a specified bit location (bit). The result is stored in the Carry Flag.

This instruction performs a logical OR operation between the Carry Flag (CF) and a specified bit location (bit). The result is stored in the bit location.

This instruction clears the Carry Flag (CF), setting its value to 0.

This instruction clears the specified bit location (bit), setting its value to 0.

This instruction decrements the value of a register (Rn) or a memory location pointed to by a direct address and then jumps to a specified relative location if the result of the decrement is not zero. It's used for implementing loops and countdown timers in assembly code.

This instruction compares the contents of the accumulator (A) with an immediate data value and then jumps to a specified relative location if the two values are not equal. It's a way to make decisions in your code based on the comparison result. For example, you can use CJNE to see if a counter has reached a certain value.

This instruction compares the contents of a specified register (Rn) with an immediate data value and then jumps based on the comparison result. It also sets the carry flag. It's a versatile instruction that can be used for decision-making in various scenarios.

This instruction compares the contents of the accumulator (A) with a specified data value and jumps to a specific relative address if they are not equal. This instruction is useful for making conditional jumps within your program based on the values stored in the accumulator and the data value.

These instructions are used in conjunction with the DJNZ instruction to implement more complex loops. They compare the contents of the accumulator (A) with a specified data value and jump to a specific relative address if they are not equal. This helps to create more flexible and efficient program code.

An assembler is a program that translates assembly language instructions into machine code, which is the language that the computer's processor can understand and execute. Assembly language uses mnemonics (short, easy-to-remember codes) to represent machine instructions, making it easier for programmers to write and understand code.

The assembly language program (ALP) is a set of instructions written in assembly language. These instructions are designed to perform specific tasks, such as adding numbers, manipulating data, or controlling hardware.

In this ALP, the program starts by initializing a pointer (R0) to the memory location where the data is stored (40H). A counter (R2) is set to the number of data items (5) to control the loop. The accumulator (A) is cleared to initialize the sum. Then, it iterates through the data, adding each value to the accumulator and updating the counter. Each time a carry is generated (indicating a sum exceeding the maximum value), the higher byte register (R7) is incremented to account for the overflow. The loop continues until the counter reaches zero.

The program initializes a pointer (R0) to the starting memory location (40H) where the BCD data is stored. A counter (R2) is set to 5 to control the loop. The accumulator (A) is cleared for accumulating the sum, and R7 is also cleared. The loop iterates through the BCD data adding each value to the accumulator. It then uses the 'DA' instruction to adjust the accumulator to correct the BCD representation after each addition. If a carry occurs, the counter (R7) is incremented. The loop continues until the counter reaches zero.

The ALP initializes the pointer to the starting RAM location (40H). A counter (R2) is set to 5 to control the loop. The accumulator (A) is cleared to store the sum, and R7 is cleared. The loop iterates through the memory locations, adding each value to the accumulator. If a carry occurs during the addition, increment the counter. Increment the pointer (R0) to point to the next memory location. It then checks the counter using the 'DJNZ' instruction to determine if the loop should repeat. Once the loop completes, a 'SJMP' instruction keeps the program in a loop, preventing it from ending.

The program initializes a pointer (R0) to the starting memory location (40H) of the BCD data. A counter (R2) is set to 5. It then enters a loop adding each value to the accumulator (A). The 'DA' instruction ensures the sum remains in a valid BCD format. If a carry occurs, the program increments the counter (R7) in the higher byte register. It continues to add, adjust, and increment the counter until all BCD values are processed.

The ALP receives a hexadecimal value from port 1, which is in the range of 00-FFH. It then converts this hexadecimal value to its decimal equivalent. The decimal digits are stored in R7, R6, and R5, with R7 holding the least significant digit.

The program reads a hex value from port 1. The 'MOV' instruction is used to store the value in a register. The program uses a series of logic operations and shifting operations to separate the individual decimal digits present in the hex value. These individual digits are then stored in different registers (R7, R6, and R5) with the least significant digit in R7.