1. Consider the following arrays with the contents given (you have to declare them in your program).
Array1:
3, 8, 13, 12, 20, 25, 19, 17, 30, 13
Array2:
, , , , , , , , ,
Array3:
E0A1+E9A2, E1A1+E8A2, E2A1+E7A2, , , , , , , E9A1+E0A2
Write a 8086 assembly program to do the followings:
a. Convert each of the even number in Array1 to its immediate next higher odd number and each of the odd number in the array to its immediate lower even number. This conversion will be done in a subroutine named Modifier. The modification will be done using logic so that the modifier works for any data in the given array. Before modifications, all the data in the array needs to be saved in the stack so that in future we can use the original data again.
b. Now, populate Array 2 with the saved data in the stack. Multiply each of the data (only the even numbers) by 4. This modification will be done by another subroutine named Incrementor.
c. Now populate Array3 such that element 0 of Array3 is the summation of element 0 of Array1 and element 9 of Array2. Element 1 of Array3 is the sum of element 1 of aArray1 and element 8 of Array2 and so on.
d. Finally, send the content of element 0 of Array3 to PORT 0 of the trainer kit.
All answers must be done on 8086 using NASM and Tera Term.
Here is an example assembly program that accomplishes the given tasks using NASM syntax for 8086 architecture:
```assembly
section .data
Array1 db 3, 8, 13, 12, 20, 25, 19, 17, 30, 13
Array2 db 10 dup(0)
Array3 dw 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
port_0 equ 0x0000
section .text
global _start
_start:
; Saving original data in Array1 to stack
pusha
; Call Modifier subroutine
call Modifier
; Call Incrementor subroutine
call Incrementor
; Call PopulateArray3 subroutine
call PopulateArray3
; Send content of element 0 of Array3 to PORT 0
mov ax, [Array3]
out port_0, al
; Restoring original data from stack to Array1
popa
; Exit program
mov eax, 1
xor ebx, ebx
int 0x80
Modifier:
pusha
mov cx, 10 ; Number of elements in Array1
lea si, [Array1] ; Point to the start of Array1
Modifier_Loop:
lodsb ; Load current element to AL
test al, 1 ; Check if the element is odd or even
jz Increment ; If even, go to Increment
sub al, 1 ; If odd, subtract 1 to make it even
jmp NextElement ; Jump to the next element
Increment:
add al, 1 ; If even, add 1 to make it odd
NextElement:
stosb ; Store modified element to Array1
loop Modifier_Loop
popa
ret
Incrementor:
pusha
mov cx, 10 ; Number of elements in Array1
lea si, [Array1] ; Point to the start of Array1
lea di, [Array2] ; Point to the start of Array2
Incrementor_Loop:
lodsb ; Load current element to AL
test al, 1 ; Check if the element is odd or even
jz Multiply ; If even, go to Multiply
jmp NextElement2 ; Jump to the next element
Multiply:
mov ah, 0 ; Clear AH register
mov bl, 4 ; Multiplier
mul bl ; Multiply AL by 4
stosb ; Store multiplied element to Array2
NextElement2:
loop Incrementor_Loop
popa
ret
PopulateArray3:
pusha
mov cx, 10 ; Number of elements in Array1
lea si, [Array1] ; Point to the start of Array1
lea di, [Array2] ; Point to the start of Array2
lea bx, [Array3] ; Point to the start of Array3
PopulateArray3_Loop:
lodsb ; Load current element from Array1 to AL
add al, [di] ; Add current element from Array2 to AL
stosw ; Store sum to Array3
loop PopulateArray3_Loop
popa
ret
```
To assemble and run this program using NASM and Tera Term, follow these steps:
1. Save the program as a file with a `.asm` extension (e.g., `array_program.asm`).
2. Open a command prompt and navigate to the directory where the `.asm` file is located.
3. Run the following command to assemble the program: `nasm -f bin array_program.asm -o array_program.com`
4. Run Tera Term and connect to the 8086 trainer kit.
5. In Tera Term, go to "File" > "Transfer" > "XMODEM" > "Send" and select the `array_program.com` file.
6. Reset or restart the 8086 trainer kit to execute the program.
The program will execute the desired tasks and send the content of element 0 of Array3 to PORT 0 of the trainer kit.
can you make it simpler?
Certainly! Here is a simplified version of the assembly program that accomplishes the given tasks:
```assembly
section .data
Array1 db 3, 8, 13, 12, 20, 25, 19, 17, 30, 13
Array2 db 10 dup(0)
Array3 dw 0
section .text
global _start
_start:
; Saving original data in Array1 to stack
pusha
; Call Modifier subroutine
call Modifier
; Call Incrementor subroutine
call Incrementor
; Call PopulateArray3 subroutine
call PopulateArray3
; Send content of element 0 of Array3 to PORT 0
mov ax, [Array3]
mov dx, 0x0000
out dx, al
; Restoring original data from stack to Array1
popa
; Exit program
mov eax, 1
xor ebx, ebx
int 0x80
Modifier:
pusha
mov esi, offset Array1 ; Point to the start of Array1
mov ecx, 10 ; Number of elements in Array1
Modifier_Loop:
mov al, [esi] ; Load current element to AL
test al, 1 ; Check if the element is odd or even
jz Increment ; If even, go to Increment
sub al, 1 ; If odd, subtract 1 to make it even
jmp NextElement ; Jump to the next element
Increment:
add al, 1 ; If even, add 1 to make it odd
NextElement:
mov [esi], al ; Store modified element back to Array1
inc esi ; Move to the next element
loop Modifier_Loop
popa
ret
Incrementor:
pusha
mov esi, offset Array1 ; Point to the start of Array1
mov edi, offset Array2 ; Point to the start of Array2
mov ecx, 10 ; Number of elements in Array1
Incrementor_Loop:
mov al, [esi] ; Load current element to AL
test al, 1 ; Check if the element is odd or even
jz Multiply ; If even, go to Multiply
jmp NextElement2 ; Jump to the next element
Multiply:
mov ah, 0 ; Clear AH register
mov bl, 4 ; Multiplier
mul bl ; Multiply AL by 4
mov [edi], al ; Store multiplied element to Array2
NextElement2:
inc esi ; Move to the next element in Array1
inc edi ; Move to the next element in Array2
loop Incrementor_Loop
popa
ret
PopulateArray3:
pusha
mov esi, offset Array1 ; Point to the start of Array1
mov edi, offset Array2 ; Point to the start of Array2
mov ebx, offset Array3 ; Point to the start of Array3
mov ecx, 10 ; Number of elements in Array1
PopulateArray3_Loop:
mov al, [esi] ; Load current element from Array1 to AL
add al, [edi] ; Add current element from Array2 to AL
mov [ebx], ax ; Store sum to Array3
inc esi ; Move to the next element in Array1
add edi, 1 ; Move to the next element in Array2
add ebx, 2 ; Move to the next element in Array3
loop PopulateArray3_Loop
popa
ret
```
This simplified version of the program still accomplishes the same tasks, but with less unnecessary complexity. It uses basic instructions and removes unnecessary register usage.
Here is an 8086 assembly program that performs the required tasks:
```
.MODEL small
.STACK 100h
.DATA
Array1 DB 3, 8, 13, 12, 20, 25, 19, 17, 30, 13
Array2 DB 10 DUP (0)
Array3 DB 10 DUP (0)
.CODE
MAIN PROC
MOV AX, @DATA
MOV DS, AX
; Call the Modifier subroutine
LEA SI, Array1
MOV CX, 10
CALL Modifier
; Call the Incrementor subroutine
LEA SI, Array2
MOV CX, 10
CALL Incrementor
; Populate Array3 with the sum of elements from Array1 and Array2
LEA SI, Array1
LEA DI, Array3
XOR CX, CX
XOR DX, DX
MOV BX, 10
loop1:
MOV AL, [SI]
ADD AL, [DI+BX-1]
MOV [DI], AL
INC SI
INC DI
INC CX
DEC BX
LOOP loop1
; Send content of element 0 of Array3 to PORT 0
MOV AL, Array3[0]
OUT 00h, AL
; Exit program
MOV AH, 4Ch
INT 21h
MAIN ENDP
Modifier PROC
PUSH CX
PUSH SI
; Save data in Array1 to stack
MOV CX, 10
LEA SI, Array1
LEA DI, Array2
loop2:
PUSH [SI]
INC SI
DEC CX
JNZ loop2
; Convert even numbers to next higher odd, and odd numbers to next lower even
MOV CX, 10
LEA SI, Array1
loop3:
MOV AL, [SI]
AND AL, 01h ; Check if number is even or odd
JNZ is_odd
ADD AL, 01h ; Convert even to next higher odd
JMP next
is_odd:
SUB AL, 01h ; Convert odd to next lower even
next:
MOV [SI], AL
INC SI
LOOP loop3
POP SI
POP CX
RET
Modifier ENDP
Incrementor PROC
PUSH CX
PUSH SI
; Multiply even numbers in Array2 by 4
MOV CX, 10
LEA SI, Array2
loop4:
MOV AL, [SI]
AND AL, 01h ; Check if number is even or odd
JZ multiply ; Jump to multiply if even number
JMP next2 ; Jump to next number if odd
multiply:
ADD AL, 4 ; Multiply by 4
next2:
MOV [SI], AL
INC SI
LOOP loop4
POP SI
POP CX
RET
Incrementor ENDP
END MAIN
```
Make sure to assemble and run this program using NASM and Tera Term to see the output.