Assembly Program To find Even and Odd numbers in Set of Numbers in memory

Explanation

This 8051 assembly program's primary purpose is to read a set of ten numbers stored sequentially in memory, classify each number as either even or odd, and then store these classified numbers into two separate memory locations: one for even numbers and another for odd numbers.

Here's a step-by-step breakdown of its logic:

1. Initialization: The program starts by setting up three pointers and a counter.

   • R0 is initialized to 30H, acting as the "input pointer" to the first number in the original set.
   • R1 is initialized to 40H, serving as the "even numbers pointer" where even numbers will be stored.
   • R2 is initialized to 50H, serving as the "odd numbers pointer" where odd numbers will be stored.
   • R3 is initialized to 0AH (decimal 10), which acts as a loop counter, indicating that ten numbers will be processed.

2. Main Loop (CHECK): The program enters a loop that iterates ten times, once for each number in the input set.

   • Inside the loop, it first fetches a number from the memory location currently pointed to by R0 and loads it into the Accumulator (A).

3. Even/Odd Check: This is the core logic for classification.

   • The instruction ANL A, #01H performs a bitwise AND operation between the number in the Accumulator and the binary value 00000001B.
   • If the original number was even, its Least Significant Bit (LSB) is 0. The result of A AND 01H will be 00H.
   • If the original number was odd, its LSB is 1. The result of A AND 01H will be 01H.
   • The JZ EVEN instruction then checks the result in the Accumulator. If A is 00H (meaning the number was even), the program jumps to the EVEN section. If A is 01H (meaning the number was odd), the program continues to the instructions immediately following JZ EVEN.

4. Handling Odd Numbers: If the number is odd, the following sequence is executed:

   • The current value of R1 (the even pointer) is temporarily saved in internal RAM address 60H. This is crucial because R1 will be repurposed for storing the odd number.
   • The value of R2 (the odd pointer) is loaded into the Accumulator and then transferred to R1. Now, R1 temporarily points to the next available location for an odd number.
   • The original number (which was determined to be odd) is reloaded into the Accumulator from the input memory location (@R0), as the previous ANL operation modified A.
   • This odd number is then stored in the memory location pointed to by R1 (which is currently the odd numbers storage address).
   • The actual odd numbers pointer R2 is incremented to prepare for the next odd number.
   • Finally, the original value of R1 (the even pointer) is restored from 60H.
   • A SJMP NEXT instruction then bypasses the EVEN section and jumps to the NEXT label.

5. Handling Even Numbers: If the number is even, the program jumps to the EVEN section:

   • The original number (which was determined to be even) is reloaded into the Accumulator from the input memory location (@R0).
   • This even number is then stored in the memory location pointed to by R1 (which is the even numbers storage address).
   • The even numbers pointer R1 is incremented to prepare for the next even number.

6. Loop Progression (NEXT): After processing either an odd or even number:

   • The input pointer R0 is incremented to move to the next number in the original set.
   • DJNZ R3, CHECK decrements the loop counter R3. If R3 is not zero, the program jumps back to the CHECK label to process the next number.

7. Termination: When R3 becomes zero, all ten numbers have been processed, and the program terminates (END).

Algorithm

The algorithm implemented by this code can be described as follows:

1. Initialization:

   • Set R0 as the input data pointer to 30H.
   • Set R1 as the even numbers storage pointer to 40H.
   • Set R2 as the odd numbers storage pointer to 50H.
   • Initialize a counter R3 to 10 (0AH).

2. **Loop Execution (10 times