CHAPTER 4 Robotics

CHAPTER 4
Assembler directives and

operators
COMPILED BY: TIGABU YAYA

Assembler Directives and Operators
• To make the programming on microprocessor simpler, assemblers are used. The
main role of the assembler is to convert the assembly language program in to the
machine language program and in 8086 since the hand coding is a tedious job
mostly people follow the assembler for programming the microprocessor.
• For completing the task of the assembly, assembler needs some hints from the
programmer i.e. the required storage of particular constant or variable,
logical names of the segments, types of different subroutines or modules, end
of file etc.
• Such hints are given by the assembler directives.
• Another type of hint which helps the assembler to assign a particular constant
with a label or initialize particular memory locations or labels with
constants is an operator.
2
 Assembler directives are specific for a
particular assembler
 However all the popular assemblers like
the Intel 8086 macro assembler, the
turbo assembler and the IBM macro
assembler use common assembler
directives
3
8086 Microprocessor Assembler Directives
Instructions to the Assembler regarding the

program being executed.
Control the generation of machine codes and

organization of the program;
No machine codes are generated for assembler
directives.
Also called ‘pseudo instructions’

Used to
› specify the start and end of a program
› attach value to variables
› allocate storage locations to input/ output data
› define start and end of segments, procedures,
macros etc..
4
Assemble Directives SEGMENT
ENDS
SEGMENT : Used to indicate the beginning of a code/ group

of data/ group of instructions to be put together in a
particular segment and is called logical segment .
Used to indicate that the start of a logical segment.
Preceding the segment directive is the name you want to
give to the segment
Can use labels upto 31 characters , Spaces not allowed but
underscore can be used in between
General form:
Segnam SEGMENT
…
… Program code
… or
… Data Defining Statements
…
…
Segnam ENDS
User defined name of

5
the segment
Assembler Directives(contd.)
Assume
• Used to tell the assembler the names of the logical
segments to be assumed for different segments
used in program.
• You must tell the assembler that what to assume for any
segment you use in the program.
• Example, ASSUME CS: CODE tells the assembler that
the instructions for the program are in segment named
CODE, and hence the CS register is to be loaded with
the segment address allotted by the operating system
for label CODE.
• ASSUME DS:DATA indicates that data items related to
the program are available in logical segment named
DATA.
Another Format
 .CODE: This directive provides shortcut in definition of
the code segment.
 General format for this directive is as shown below
 .CODE[name]
 The name is optional. It is basically specified to
distinguish different code segments, when there are
multiple code segments in the program.
 .DATA: This directive provides shortcut in definition of
the data segment.
Naming Data and addresses
Programs work with three general categories of

data - Constants ,Variables and Addresses
Constants ,Variables and Addresses can be given

Names in your programs and assembler can use
these names to find a desired data or address when
referred to in a program.
Directives are for storage requirement of
 a particular constant or a variable
 Logical names of segments
 Types of different routines and modules
 End of file etc
8
Assemble Directives ---for variables
DB, DW, DD, DQ, DT: These directives are used to define
different types of variables, or to set aside one or more
storage locations of corresponding data type in memory
Their definitions are as follows:
DB – Define Byte … used to declare a byte type variable or to
store a byte in memory location.
DW – Define Word … used to define a variable of type word or to
reserve storage location of type word in memory
DD - Define Double word--- used to declare a variable of type
double word
DQ – Define Quad words --- used to declare a variable 4 words in
length
DT – Define Ten Bytes --- used to declare a variable which is 10
bytes in length. 9
DUP
• Allows a sequence of storage locations to be defined or
reserved . If you need to declare a large array you can
use DUP operator. It also assigns/intializes values to
this location
• The syntax for DUP:
format: Name Data_Type number DUP ( values )
• number - number of duplicate to make (any constant
value).
• value - expression that DUP will duplicate.
• LIST DB 4 DUP(9) is an alternative way of declaring:

LIST DB 9, 9, 9, 9,
DUP
• Allows a sequence of storage locations to be defined or
reserved . If you need to declare a large array you can
use DUP operator.
• The syntax for DUP:
format: Name Data_Type number DUP ( values )
• number - number of duplicate to make (any constant
value).
• value - expression that DUP will duplicate.
Example:
• LIST DB 4 DUP(9) is an alternative way of declaring:
• LIST DB 9, 9, 9, 9,
• Only used as an operand of a define directive
Array DB 40 DUP (?) ; 40 words, uninitialized
Mesg DW 10h DUP (0) ; 16 words, initialized as 0
• Multiple definitions can be abbreviated
Example:
message DB ’B’
DB ’y’
DB ’e’
DB 0DH
DB 0AH
can be written as
message DB ’B’,’y’,’e’,0DH,0AH
• More compactly as
message DB ’Bye’,0DH,0AH
13
14
8086 Microprocessor
Assemble Directives DW
DD
Define Word
Define a word type (16-bit) variable
Reserves two consecutive memory locations to each variable
Range : 0000H – FFFFH for unsigned value; 0000H – 7FFFH for

positive value and 8000H – FFFFH for negative value
General form : variable DW value/ values
The DD directive is used to declare a variable of type doubleword or to

reserve memory locations which can be accessed as type doubleword (Define
Doubleword)
The DQ directive is used to tell the assembler to declare a variable 4 words in

length or to reverse 4 words of storage in memory (Define Quadword)
15
Arrays
• Any consecutive storage locations of the

same size can be called an array
Arrays
• Arrays can be seen as chains of variables. A text

string is an example of a byte array, each character is
presented as an ASCII code value (0..255).
• Here are some array definition examples:
a DB 48h, 65h, 6Ch, 6Ch, 6Fh, 00h
b DB 'Hello', 0
b is an exact copy of the a array, when compiler
sees a string inside quotes it automatically converts it
to set of bytes.
You can access the value of any element in array using

square brackets, for example:
• MOV AL, a[3]
17
Equal Sign Directive
• name = expression
– expression must be numeric
– these symbols may be redefined at any
time
maxint = 7FFFh
count = 1
DW count
count = count * 2
DW count
EQU Directive
EQU – Equate
• Used to give a name to some value or to a symbol.
• It is just to reduce the recurrence of the numerical
values or constants in a program code
• Format: name EQU expression
– expression can be string or numeric
– Use < and > to specify a string EQU
– these symbols cannot be redefined later in the
program
sample EQU 7Fh;assigns 7FH with label
sample
aString EQU <1.234>
message EQU <This is a message>
• NAME: Logical Name of a Module

- The NAME directive is used to assign a name to an assembly
language program module. The module, may now referred to by its
declared name.
• LABEL: label
– The Label directive is used to assign a name to the current
content of the location counter. When the assembly process
starts, the assembler initializes a location counter to keep track
of memory location assigned to the program.
20
END – End the program

• To tell the assembler to stop fetching the instruction and end
the program execution .
– To tell the assembler that this is the end of the program module.
• The assembler ignores any source lines after an END
directive.
• ENDP – END Procedure
– It indicates the end of the procedure (subroutine) to the assembler.
• ENDS – END Segment

– This directive is used with the name of the segment to indicate the
end of that logical segment.
EVEN – Align on Even memory address

• Tells the assembler to increment the location counter to the next
even address if it is not already at an even address.
• EVEN –
• If the word is at even address 8086 can read a memory in 1 bus
cycle.
– If the word starts at an odd address, the 8086 will take 2 bus
cycles to get the data.
– A series of words can be read much more quickly if they are at
even address.
– When EVEN is used the location counter will simply
incremented to next address and NOP instruction is inserted in
that incremented location.
Example:
DATA1 SEGMENT ; Location counter will point to 0009 after

assembler reads next statement
SALES DB 9 DUP(?) ;declare an array of 9 bytes
EVEN ; increment location counter to 000AH
RECORD DW 100 DUP( 0 ) ;Array of 100 words will start from an
even address for quicker read
DATA1 ENDS
22
• OFFSET
– It is an operator which tells the assembler to determine the offset or
displacement of a named data item(variable) from the start of the segment
which contains it.
DATA SEGMENTS
LIST DB 10H
DATA ENDS
CODE SEGMENT
MOV SI, OFFSET LIST ; this is the same as, LEA SI, LIST
CODE ENDS
23
 SEG: Segment
– The segment operator returns the segment part of a label or
variable’s address.
– For example: for the definition below
DATA SEGMENT
NUM1 DB 0F2H
NUM2 DB 2EH
DATA ENDS
The statements: MOV AX, DATA

MOV DS, AX
Can be replaced as: MOV AX, SEG NUM1
MOV DS, AX 24
 .MODEL
– Provides short-cuts in defining segments.
– It initializes memory model before defining any segment.

– The memory model can be: TINY, SMALL, MEDIUM, COMPACT OR
LARGE.
– We can choose the memory model on our requirement referring following
table
Model Code segments Data segments
Tiny Both are fit in a single 64KB Segment

Small One One
Medium Multiple One
Compact One Multiple
Large Multiple Multiple 25
$
– A '$' is used to symbolically represent the

current value of the location at any point.
– This trick with the $ sign allows you to load the
number of string elements in CX symbolically,
rather than having to manually count the
number.
26
Assembly Language Example Programs
Write an assembly language program to transfer a block of bytes
from one memory location to another memory location by using
string instructions
ASSUME CS:CODE, DS:DATA
DATA SEGMENT
STR1 DB 'COMMUNICATION ENGINEERING'
LEN EQU $-STR
STR2 DB LEN DUP(0)
DATA ENDS
CODE SEGMENT
START:MOV AX,@DATA
MOV DS, AX
MOV SI, OFFSET STR1; LEA SI, STR1
LEA DI, STR2 ; MOV DI, OFFSET STR2
MOV CX, LEN
BACK: MOV AL, [SI]
MOV [DI], AL
INC SI
INC DI
DEC CX
JNZ BACK
HLT
CODE ENDS
END START
27
The above program can be again written in another format as follows
o In the above program replace the statements, DEC CX & JNZ BACK with
LOOP BACK, and it becomes as follows.
ASSUME CS:CODE, DS:DATA
DATA SEGMENT
LEN EQU $-STR
STR2 DB LEN DUP(0)
DATA ENDS
CODE SEGMENT
START:MOV AX,@DATA
MOV DS, AX
MOV CX, LEN
BACK: MOV AL, [SI]
MOV [DI], AL
INC SI
INC DI
LOOP BACK
HLT
CODE ENDS
END START
28
The above program can be again written in another format as
follows
.MODEL SMALL
.DATA
LEN EQU $-STR
STR2 DB LEN DUP(?)
.CODE
START:MOV AX,@DATA
MOV DS, AX
MOV CX, LEN
BACK: MOV AL, [SI]
MOV [DI], AL
INC SI
INC DI
LOOP BACK
HLT
END START
29
The above program can be again written in another format as
follows
.MODEL SMALL
.DATA
LEN EQU $-STR
STR2 DB LEN DUP(?)
.CODE
START:MOV AX,@DATA
MOV DS, AX
MOV ES, AX
MOV CX, LEN
CLD
BACK: MOVSB
LOOP BACK
HLT
END START
30
o By using the prefix instruction, REP, you can remove the LOOP
BACK statement
.MODEL SMALL
.DATA
LEN EQU $-STR
STR2 DB LEN DUP(?)
.CODE
START:MOV AX,@DATA
MOV DS, AX
MOV AX, 2000H
MOV ES, AX
MOV CX, LEN
CLD
REP MOVSB
HLT
END START
31
o In the above program, ES and DS were equals, i.e., They are on
the same segment. But, DS and ES can also have different
values as follows.
.MODEL SMALL
.DATA
LEN EQU $-STR
STR2 DB LEN DUP(?)
.CODE
START:MOV AX,@DATA
MOV DS, AX
MOV AX, 2000H
MOV ES, AX
MOV CX, LEN
CLD
REP MOVSB
HLT
END START
32
33
• An alternative method for the program of addition of two numbers is
given below:-
• Please note that in this method there is no need to have two different
segments of memory.
• In next few slides we will discuss few assembly language programs. 34
35
 ORG: Originate
– This directive directs the assembler to start the memory
allocation for a particular segment (data, code, or stack)
form the declared offset address in the ORG statement.
– While starting the assembly process for a memory segment,
the assembler initializes a location counter (LC) to keep track
of the allotted offset addresses for the segment.
– When the ORG directive is not mentioned , LC is initialized
with the offset address 0000h. When the ORG directive is
mentioned at the beginning of the statement, LC is initialized
with the offset address specified in the ORG directive.
36
 ORG – Originate
– The ORG statement changes the starting offset address of the data.
– When the ORG directive is not mentioned , LC is initialized with the
offset address 0000h.
– When the ORG directive is mentioned at the beginning of the
statement, LC is initialized with the offset address specified in the
ORG directive.
– Example:
• ORG 100h
o When this directive is placed at the beginning of the data
segment, the next data storage starts from the offset address
0100h within the data segment.
o If it is placed in the code segment, the location counter is
initialized with 0100h and the first instruction is stored from
37
the offset address 0100h within the code segment.
8086 Microprocessor
Assemble Directives
EXAMPLES
ORG 1000H Informs the assembler that the statements

following ORG 1000H should be stored in
memory starting with effective address 1000 H
LOOP EQU 10FEH Value of variable LOOP is 10FEH
_SDATASEGMENT In this data segment, effective address of

ORG 1200H memory location assigned to A will be 1200 H
A DB 4CH and that of B will be 1202H and 1203H.
EVEN
B DW 1052H
_SDATA ENDS
38
• PUBLIC
– The PUBLIC directive is used along with the Extern directive.
• This informs the assembler that the labels, variables constants, or
procedures declared PUBLIC may be accessed by other assembly
modules to form their codes, but while using the PUBLIC declared
labels, variables, constants or procedures, the user must declare
them externals using the extern directive.
• EXTERN: External
– The directive EXTERN informs the assembler that the names,
procedures and labels declared after this directive have
already been defined in some other assembly language
modules.
39
• GLOBAL
– The labels, variables, constants or procedures declared GLOBAL may
be used by other modules of the program. Once a variable is declared
GLOBAL, it can be used by any module in the program.
• LOCAL
– The labels, variables, constants or procedures declared LOCAL in a
module are to be used only by the particular module.
– LOCAL a, b, DATA, ARRAY, ROUTIN
• GROUP: Group the Related Segment

– This directive is used to form logical groups of segments with similar
purpose or type. This directive is used to inform the assembler to
form a logical group of the following segment names.
• PROGRAM GROUP CODE, DATA, STACK
40
• PROC: Procedure
– The PROC directives marks the start of named procedure
in the statement.
– Also the types NEAR or FAR specify the type the procedure
i.e. whether it is to be called by the main program located
within 64k of physical memory or not.
– Please, refer Procedures @ chapter 3, Unconditional
branch instructions.
• PTR: Pointer
– The POINTER operator is used to declare the type of a
label, variable or memory operand.
– The operator PTR prefixed by either BYTE or WORD.
– If prefix is byte then the particular label, variable or memory
operand is treated as an 8-bit quantity, while if word is the
prefix, then it is treated as a 16-bit quantity.
– MOV AL,BYTE PTR [SI]
41
Example:
• INC [BX] ; This instruction will not know
whether to increment the byte pointed to
by BX or a word pointed to by BX.
• INC BYTE PTR [BX] ;increment the
byte ;pointed to by BX
• This PTR operator can also be used to
override the declared type of variable . If
we want to access a byte in an array
• WORDS DW 437Ah, 0B97h,
• MOV AL, BYTE PTR WORDS
42
• FAR PTR
– This directive indicates the assembler that the label following
FAR PTR is not available within the same segment and the
address of the label is of 32- bits i.e. 2-bytes offset followed
two byte segment address.
• NEAR PTR
– This directive indicates that the label following NEAR PTR is
in the same segment and needs only 16-bit i.e. 2-byte offset to
address it.
• SHORT
– The SHORT operator indicates to the assembler that only one
byte is required to code the displacement for a jump (i.e.
displacement is within -128 to +127 bytes from address of the
byte next to the jump opcode).
• JMP SHORT LABEL 43
8086 Microprocessor
Assemble Directives
procname PROC[NEAR/ FAR]

…
… Program statements of
… the procedure
RET Last statement of the

procedure
procname ENDP
User defined name of

the procedure
44
8086 Microprocessor
Assemble Directives
Examples:
ADD64 PROC NEAR The subroutine/ procedure named

ADD64 is declared as NEAR and so
… the assembler will code the CALL
… and RET instructions involved in this
… procedure as near call and return
RET
ADD64 ENDP
CONVERT PROC The subroutine/ procedure named

FAR CONVERT is declared as FAR and so
the assembler will code the CALL
… and RET instructions involved in this
… procedure as far call and return
…
RET
CONVERT ENDP
45
8086 Microprocessor
Assemble Directives
Reserves one memory location for

SHORT 8-bit signed displacement in jump
instructions
Example:
JMP SHORT The directive will reserve one

AHEAD memory location for 8-bit
displacement named AHEAD
46
47
MACRO
• Macro is a group of instructions.
• The macro assembler generates the code in the program
each time where the macro is ‘called’.
• Macro can be defined by MACRO & ENDM assembler
directives.
• It is important to note the macro sequences execute faster

than procedures because there no CALL & RET instructions
to execute.
• The assembler places the macro instructions in the
program each time when it is invoked
o This procedure is known as macro expansion. 48
MACRO
• Comparison of Procedure and Macro
49
MACRO
• Passing Parameters in Macro
o In macro, parameters are passed as part of statement which
calls Macro.
o The macro instruction “PROMPT MES1” passes the MES1 as

a parameter and macro accepts that as an argument. 50
51
Timings and Delays
• In the real time applications, it is important to keep
track with time.
• Real Time Applications:
 Traffic Light Control, Digital Clock,
Process Control, Serial Communication
etc.
 For example in traffic light control application, it is
necessary to give time delays between two
transitions.
• These time delays are in few seconds
 Can be generated with the help of executing group
of instructions number of times.
52
Timings and Delays … Cont’d
• Timer Delays Using NOP Instruction
 NOP instruction does nothing but takes 3 clock
cycles of processor time to execute.
 So, by executing NOP instruction in between two
instructions we can get delay of 3 clock cycles.
• Timer Delay using Counters
 Counting can create time delays.
 Since the execution times of the instructions used in
counting routine are known, the initial value of the
counter, required to get specific time delay can be
determined.
53
• Timer Delay using Counters … Cont’d
 In this program, the instructions DEC CX and JNZ BACK

execute number of times equal to COUNT stored in the
CX register.
 The time taken by this program for execution can be
calculated with the help of clock cycles.
 The column to the right of the comments indicates the
number of clock cycles required for the execution of each
instruction.
 Two values are specified for the number of clock cycles
for JNZ instruction.
o The smaller value is applied when the condition is not
met, and
o The larger value is applied when it is met. 54
 The first instruction MOV CX, COUNT is executed only

once and it requires 4 clock cycles.
 There are COUNT-1 passes through the loop where the
condition is met and control is transferred back the first
instruction in the loop (DEC CX).
 The number of clock cycles that elapse while CX register is
not zero are (COUNT-1) x ( 2 +16 ).
 On the last pass through the loop the condition is not met
and the loop is terminated.
o The number of clock cycles that elapse in this pass are 2 +
4
55
 The whole calculation of the time delay
56
 Let us consider that we have to generate a delay of 50 ms

using an 8086 system that runs at 10 MHz frequency.
Using the same program we can calculate the count value
as follows.
57
 Assignment: what maximum delay can be produced with

the above code?
58
• Timer Delay using Nested Loops
 In this program, one more external loop is
added to execute the internal loop multiple
times.
 The inner loop is nothing but the program we
have seen in the last section.
59
• Timer Delay using Nested Loops … Cont’d
60
61
62
Assembly Language programming
• A program is a set of instructions arranged in the
specific sequence to do the specific task.
• It tells the microprocessor what it has to do.
• The process of writing the set of instructions which
tells the microprocessor what to do is called
“Programming”.
• In other words, we can say that programming is the
process of telling the processor exactly how to
solve a problem.
• To do this, the programmer must “speak” to the
processor in a language which processor can
understand.
63
 Steps involved in Programming
• Specify the problem
• Designing the problem-solution
• Coding
• Debugging
o Once the program is coded, the next step is
debugging the code.
o Debugging is the process of testing the code
to see if it does the given task.
o If program is not working properly,
debugging process helps in finding and
correcting errors.
64
 Flow Chart
• To develop the programming logic programmer
has to write down various actions which are to
be performed in proper sequence.
• The flow chart is a graphical tool that allows the
programmer to represent various actions which
are to be performed.
o The graphical representation is very useful
for clear understanding of the programming
logic.
65
 Flow Chart
• This figure shows the graphic symbols used in
the flow chart
Graphical symbols used in flow chart
66
 Sample Flow Chart
67
Assembly Language Programming
 Assembly Language programs
• Machine Level Language Programs
o a program which has simply a sequence of the binary
codes for the instructions
o this binary form of the program is referred to as
machine language because it is the form required by
the machine.
• However, to write program in machine language,
programmer has to memorize the thousands of
binary codes for a processor.
o This task is difficult and error prone.
• To make programming easier, usually programmers
write programs in assembly language.
o then, they translate the assembly language program
to machine language so that it can be loaded into 68
memory and executed.
• Assembly language uses two, three or four letter
words to represent each instruction types.
o These words are referred to as mnemonics.
• The letters in an assembly language mnemonics are
usually initials or a shortened form of English
word(s) for operation performed by the instruction.
o For Example:
 Mnemonic for additions is ADD,
 The mnemonic for logic AND operation is AND,
and
 The mnemonic for instruction copy data from one
location to another is MOV.
69
• Gives you a better appreciation of how the
hardware works than high-level languages
• Resources are given by the programmer’s model
• These include registers, hardware resources in
CPU, and memory used for data storage.
• Look through the instructions in category, find the
mnemonic for the required operation, then find
the correct addressing mode.
 The Assembler
• Converts (assembles) a source file into binary
codes (machine codes) executed by the computer.
o 1-to-1 correspondence between assembly
language statements and the machine code in
memory 70
71
Programming with an Assembler
• Steps
 Lets us see the steps involved in developing and
executing assembly language programs.
72
 Steps
• The first step in the development process is to write
an assembly language program.
• The assembly language program can be written with
an ordinary text editor such as word star, edit,
emu8086 editor and so on.
• The assembly language program text is an input to
the assembler.
o The assembler translates assembly language
statements to their binary equivalents, usually
known as object code.
o Time required to translate assembly code to object
code is called assemble time.
• During assembling process assembler checks for
syntax errors and displays them before giving object
code module. 73
 Steps
• The object code module contains information about
where the program or muddle to be loaded in
memory.
• If the object module is to be linked with other
separately assembled modules then it contains
additional linkage information.
• At link time, separately assembled modules are
combined into one single load module, by the linker.
• The linker also adds any required initialization or
finalization code to allow the operating system to start
the program running and to return control to the
operating system after the program has completed.
• At load time, the program loader copies the program
into the computer’s main memory, and at execution
time, program execution begins.
74
 Steps
• Assembling process
o As mentioned earlier, assembler translates a source file that
was created using the editor into machine language such as
binary or object code.
o The assembler reads the source file of our program from
the disk where we saved it after editing.
• Linking process
o A linker is a program used to join together several object
file.
o When writing large programs, it is usually much more
efficient to divide the large program into smaller modules.
 Each module can be individually written, tested and
debugged.
 When all the modules work, they can be linked together
to form a large functioning program.
75
• Linking process … cont’d
o The linker produces a link file which contains the
binary codes for all the combined modules.
• Debugging Process
o A debugger is a program which allows us to load our
object code program into system memory, execute the
program, and debug it.
o How does a debugger help in debugging a program?
1. the debugger allows to look the contents of registers
and memory locations after our program runs.
2. It allows us to change the contents of register and
memory locations and return the program
3. Some debugger allows us to stop execution after each
instruction so we can check or alter memory and
register contents.
4. Etc…
76
• Please compare these programs with lab manual II
77
• Please compare these programs with lab manual II
78

CHAPTER 4 Robotics

Uploaded by

Copyright:

Available Formats

You might also like

CHAPTER 4 Robotics

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CHAPTER 4 Robotics

Uploaded by

Copyright:

Available Formats

CHAPTER 4

Assembler directives and

COMPILED BY: TIGABU YAYA

• Such hints are given by the assembler directives.

Instructions to the Assembler regarding the

Control the generation of machine codes and

Also called ‘pseudo instructions’

SEGMENT : Used to indicate the beginning of a code/ group

User defined name of

Programs work with three general categories of

Constants ,Variables and Addresses can be given

• LIST DB 4 DUP(9) is an alternative way of declaring:

Define a word type (16-bit) variable

Reserves two consecutive memory locations to each variable

Range : 0000H – FFFFH for unsigned value; 0000H – 7FFFH for

General form : variable DW value/ values

The DD directive is used to declare a variable of type doubleword or to

The DQ directive is used to tell the assembler to declare a variable 4 words in

• Any consecutive storage locations of the

• Arrays can be seen as chains of variables. A text

You can access the value of any element in array using

• NAME: Logical Name of a Module

END – End the program

• ENDS – END Segment

EVEN – Align on Even memory address

DATA1 SEGMENT ; Location counter will point to 0009 after

The statements: MOV AX, DATA

– It initializes memory model before defining any segment.

Tiny Both are fit in a single 64KB Segment

– A '$' is used to symbolically represent the

ORG 1000H Informs the assembler that the statements

LOOP EQU 10FEH Value of variable LOOP is 10FEH

_SDATASEGMENT In this data segment, effective address of

• GROUP: Group the Related Segment

procname PROC[NEAR/ FAR]

RET Last statement of the

User defined name of

ADD64 PROC NEAR The subroutine/ procedure named

CONVERT PROC The subroutine/ procedure named

Reserves one memory location for

JMP SHORT The directive will reserve one

• It is important to note the macro sequences execute faster

o The macro instruction “PROMPT MES1” passes the MES1 as

 In this program, the instructions DEC CX and JNZ BACK

 The first instruction MOV CX, COUNT is executed only

 The whole calculation of the time delay

 Let us consider that we have to generate a delay of 50 ms

 Assignment: what maximum delay can be produced with

You might also like