Write an assembly program (8086) that will Load AL by an arbitrary number, and Check whether it is an odd/even number.
- If it is an odd number, it will be converted to its next larger even number and will be shown in port 0 in the trainer kit.
- If it is an even number, it will be converted to its previous smaller odd number and will be shown in port 0 in the trainer kit.
Assuming the trainer kit has a 7-segment display connected to port 0 and the arbitrary number is stored at memory location 500, the following assembly code can be used:
MOV AH, 0
MOV AL, [500] ; load the arbitrary number from memory
AND AL, 1 ; check if AL is odd or even
; if odd, convert to next even number
CMP AL, 1 ; check if AL is odd
JNE even ; if not, jump to even
; if odd, add 1 to make it even
INC AL
JMP display ; jump to display
; if even, convert to previous odd number
even:
DEC AL ; subtract 1 to make it odd
AND AL, 0FE ; clear the least significant bit to make it even
; display the result on port 0 using 7-segment display
display:
MOV DL, AL ; move the result to DL
MOV AH, 1 ; set AH to 1 to output to port 0
OUT 0, DL ; output the result to port 0
RET ; return from the program
Note: The code assumes that the trainer kit has a latch to hold the output on port 0 until the next value is written to it. If not, some delay may need to be added before returning from the program to allow time for the value to be displayed.
Here's a step-by-step breakdown of how to write an assembly program in 8086 to load AL with an arbitrary number and determine if it is odd or even:
1. Set up the data segment:
- Start by declaring a data segment using the `ASSUME` directive.
- Define a variable to store the input number, e.g., `num DB ?`.
2. Set up the code segment:
- Define a code segment using the `ASSUME` directive.
- Start the code segment with the `START:` label.
3. Load the input number into AL:
- Move the input number into AL using the `MOV` instruction.
- For example: `MOV AL, num`.
4. Check if the number is odd or even:
- Use the `AND` instruction to perform a bitwise AND between AL and 1 (`00000001`).
- If the result of the AND operation is zero, the number is even.
- If the result is not zero, the number is odd.
5. Calculate the next larger even or previous smaller odd number:
- For an odd number, subtract 1 from AL.
- For an even number, add 2 to AL.
6. Output the converted number to Port 0:
- Move the value in AL to Port 0 using the `OUT` instruction.
- For example: `OUT 0, AL`.
7. Terminate the program:
- Use the `INT 20h` instruction to terminate the program.
Here's an example program in assembly (8086) that follows these steps:
```
.MODEL SMALL
.STACK 100h
.DATA
num DB ?
.CODE
ASSUME CS:START, DS:DATA
START:
MOV AX, DATA
MOV DS, AX
; Prompt the user for input (optional)
; Load the input number into AL
MOV AH, 1
INT 21h
SUB AL, '0'
MOV num, AL
; Check if the number is odd or even
MOV AH, 0
AND AL, 1
; Calculate the next larger even or previous smaller odd number
JZ even
SUB AL, 1 ; For odd numbers
JMP output
even:
ADD AL, 2 ; For even numbers
output:
; Output the converted number to Port 0
MOV DX, 0 ; Port number 0
OUT DX, AL
; Terminate the program
MOV AH, 4Ch
INT 21h
END START
```
Please note that this code assumes you have a trainer kit connected to Port 0 for output. Adjust the code accordingly if you are using a different port or output device.