Scribd
Upload
50 views

Assighnment:-2: Omputer Peripherals & Interfaces

This document contains sample code and answers to questions about assembly language programming. It includes: 1) A program that uses if-then-else statements to light different colored lamps based on temperature. 2) Code to compute the average of 4 bytes stored in an array in memory. 3) An explanation of the differences between near and far call procedures in assembly language. It provides syntax examples and explanations of assembly language instructions like PUSH, POP, CALL, CMP, INC, INT, JNP/JPO. It also discusses the benefits of using macros for repetitive code.

Uploaded by

Ankur Singh
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
50 views

Assighnment:-2: Omputer Peripherals & Interfaces

This document contains sample code and answers to questions about assembly language programming. It includes: 1) A program that uses if-then-else statements to light different colored lamps based on temperature. 2) Code to compute the average of 4 bytes stored in an array in memory. 3) An explanation of the differences between near and far call procedures in assembly language. It provides syntax examples and explanations of assembly language instructions like PUSH, POP, CALL, CMP, INC, INT, JNP/JPO. It also discusses the benefits of using macros for repetitive code.

Uploaded by

Ankur Singh
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
You are on page 1/ 10

ASSIGHNMENT:-2

C OMPUTER PERIPHERALS &


INTERFACES

SUBMITTED TO: SUBMITTED


BY:
Respected ANKUR
SINGH
Sandeep Singh RE3801A29
CAP 212

PART A

Q1: Write a program using if-then-else statements :

If Temperature <30 : Light yellow lamp

If temperature >=30 and <40 : Light green lamp

If Temperature >=40 : Light red lamp

Ans:-

1 0000 code Segm


ent
2 Assume CS:
CODE
3
4 0000 BA FFFE MOV 0FFFEH
5 0003 BO 99 MOV 99H
6 0005 EE OUT AL
7
8 0006 BA FFF8 MOV 0FFF8
9 0009 EC IN DX
10 000A 3C 1E CMP 30
11 000C 72 03 JB YELLW
12 000E EB 0A 90 JMP GREEN
13 0011 BO 01 YELLO MOV 01H
W
14 0013 BA FFFA MOV 0FFFA
H
15 0016 EE OUT AL
16 0017 EB 07 90 JMP EXIT
17 001A BO BO 02 GREEN MOV 02H
18 001C BA BA MOV 0FFFA
FFFA H
19 001F EE EE OUT AL
20 0020 EB BA JMP OFFFC
FFFC H
21 0025 BO BO 02 RED MOV AL
22 0026 BA BA MOV OFFFC
FFFA H
23 001C EE EE OUT DX
24 0027 DX BA EXIT MOV OFFFC
FFFC H
25 0028 AL DX IN DX
26 0030 CODE END
27 END

Q2: Compute the average of 4 bytes stored in an array in memory.

Ans 2

Code_Seg SEGMENT
Assume DS:data_seg,cs:code_seg

MOV AL,data_seg

MOV DS,AL

MOV AL, LOW_TEMP

ADD Hi_TEMP

MOV BL,02H

DIV BL

Code_Seg ENDS

Q3: How the near call procedures and far call procedures are
different from each other.

Ans 3 The 8086 supports near and far subroutines. Near calls and returns
transfer control between procedures in the same code segment. Far calls
and returns pass control between different segments. The two calling and
return mechanisms push and pop different return addresses

Use the near ptr and far ptr operators to override the automatic
assignment of a near or far call. If NearLbl is a near label and FarLbl is a
far label then the following call instructions generate a near and far call
respectively:

call NearLbl ;Generates a NEAR call.


call FarLbl ;Generates a FAR call.

Suppose you need to make a far call to NearLbl or a near call to FarLbl.
You can accomplish this using the following instructions:

call far ptr NearLbl ;Generates a FAR call.


call near ptr FarLbl ;Generates a NEAR call.

Calling a near procedure using a far call or calling a far procedure using a
near call isn't something you'll normally do. If you call a near procedure
using a far call instruction the near return will leave the cs value on the
stack. Generally rather than:

call far ptr NearProc

you should probably use the clearer code:

push cs
call NearProc

Calling a far procedure with a near call is a very dangerous operation. If


you attempt such a call the current cs value must be on the stack.
Remember a far ret pops a segmented return address off the stack. A near
call instruction only pushes the offset not the segment portion of the
return address.

PART B

Q4: Write a program to push and pop some data using assembly
language.

Ans 4

Push — Push stack (Opcodes: FF, 89, 8A, 8B, 8C, 8E, ...)
The push instruction places its operand onto the top of the hardware
supported stack in memory. Specifically, push first decrements ESP by 4,
then places its operand into the contents of the 32-bit location at address
[ESP]. ESP (the stack pointer) is decremented by push since the x86 stack
grows down - i.e. the stack grows from high addresses to lower addresses.
Syntax
push <reg32>
push <mem>
push <con32>

Examples
push eax — push eax on the stack
push [var] — push the 4 bytes at address var onto the stack
pop — Pop stack
The pop instruction removes the 4-byte data element from the top of the
hardware-supported stack into the specified operand (i.e. register or
memory location). It first moves the 4 bytes located at memory location
[SP] into the specified register or memory location, and then increments
SP by 4.

Syntax
pop <reg32>
pop <mem>

Examples
pop edi — pop the top element of the stack into EDI.
pop [ebx] — pop the top element of the stack into memory at the four
bytes starting at location EBX.

Q5: Write the syntax and example of the following instructions

a) CALL b) CMP c)INC d)INT e)JNP/JPO

Ans5

CALL:- Subroutine call and return

These instructions implement a subroutine call and return. The call


instruction first pushes the current code location onto the hardware
supported stack in memory (see the push instruction for details), and then
performs an unconditional jump to the code location indicated by the label
operand. Unlike the simple jump instructions, the call instruction saves the
location to return to when the subroutine completes.

The ret instruction implements a subroutine return mechanism. This


instruction first pops a code location off the hardware supported in-
memory stack (see the pop instruction for details). It then performs an
unconditional jump to the retrieved code location.

Syntax
call <label>
ret
CMP:-Compare

Compare the values of the two specified operands, setting the condition
codes in the machine status word appropriately. This instruction is
equivalent to the sub instruction, except the result of the subtraction is
discarded instead of replacing the first operand.

Syntax
cmp <reg>,<reg>
cmp <reg>,<mem>
cmp <mem>,<reg>
cmp <reg>,<con>

Example
cmp DWORD PTR [var], 10
jeq loop

If the 4 bytes stored at location var are equal to the 4-byte integer
constant 10, jump to the location labeled loop.

INC:- Increment

The inc instruction increments the contents of its operand by one.

Syntax
inc <reg>
inc <mem>

Examples
inc DWORD PTR [var] — add one to the 32-bit integer stored at location
var

INT:- Some examples are:

int 21h ; calls DOS service


int 10h ; calls the Video BIOS interrupt
Most interrupts have more than one function, this means that you have to
pass a number to the function you want. This is usually put in AH. To print
a message on the screen all you need to do is this:

mov ah,9 ; subroutine number 9


int 21h ; call the interrupt

First you have to specify what to print. This function needs DS:DX to be a
far pointer to where the string is. The string has to be terminated with a
dollar sign ($). This would be easy if DS could be manipulated directly, to
get round this we have to use AX. Later one we will build a program that is
printing a string on the screen.

JNP/JPO:- Purpose: Conditional jump, and the state of the flags is taken
into
account.

Syntax:

JNP label

It jumps if there is no parity or if the parity is uneven.

The jump is done if PF = 0.

Q6: What are the benefits of using macros in microprocessor and


give an example to show the working of the macro.

Ans 6

A macro is a grow of repetitive instructions in a program which are


codified only once and can be used as many times as necessary.

The main difference between a macro and a procedure is that in the macro
the passage of parameters is possible and in the procedure it is not, this
is only applicable for the TASM - there are other programming languages
which do allow it. At the moment the macro is executed each parameter is
substituted by the name or value specified at the time of the call.

We can say then that a procedure is an extension of a determined


program,
while the macro is a module with specific functions which can be used by
different programs.

Another difference between a macro and a procedure is the way of calling


each one, to call a procedure the use of a directive is required, on the
other hand the call of macros is done as if it were an assembler
instruction.

Syntax of a Macro

The parts which make a macro are:

Declaration of the macro


Code of the macro
Macro termination directive

The declaration of the macro is done the following way:

NameMacro MACRO [parameter1, parameter2...]

Even though we have the functionality of the parameters it is possible to


create a macro which does not need them.

The directive for the termination of the macro is: ENDM

An example of a macro, to place the cursor on a determined position on


the
screen is:

Position MACRO Row, Column


PUSH AX
PUSH BX
PUSH DX
MOV AH, 02H
MOV DH, Row
MOV DL, Column
MOV BH, 0
INT 10H
POP DX
POP BX
POP AX
ENDM

To use a macro it is only necessary to call it by its name, as if it were


another assembler instruction, since directives are no longer necessary as
in the case of the procedures. Example:

Position 8, 6

You might also like