If you order your custom term paper from our custom writing service you will receive a perfectly written assignment on HC11. What we need from you is to provide us with your detailed paper instructions for our experienced writers to follow all of your specific writing requirements. Specify your order details, state the exact number of pages required and our custom writing professionals will deliver the best quality HC11 paper right on time.

Out staff of freelance writers includes over 120 experts proficient in HC11, therefore you can rest assured that your assignment will be handled by only top rated specialists. Order your HC11 paper at affordable prices with cheap essay writing service!



1.1 INTRODUCTION


This is the users reference manual for the IBM-PC hosted Motorola


Freeware 8 bit cross assemblers. It details the features and


capabilities of the cross assemblers, assembler syntax and


Help with essay on HC11




directives, options, and listings. It is intended as a detailed


reference and an introduction for those unfamiliar with Motorola


assembler syntax and format. Those experienced with Motorola


assembler products may wish to examine the file ASSEMBLER.DOC


available with the cross assemblers, which briefly describes the


differences between these assemblers and earlier, non-pc based


versions.


Assemblers are programs that process assembly language source program


statements and translate them into executable machine language object


files. A programmer writes his source program using any text editor


or word processor that can produce an ASCII text output. With some


word processors this is known as non document mode. Non document


mode produces a file without the non-printable embedded control


characters that are used in document formatting. (Caution assembling


a file that has been formatted with embedded control characters may


produce assembler errors. The solution is to convert the source file


to ASCII text.) Once the source code is written, the source file is


assembled by processing the file via the assembler.


Cross assemblers (such as the Motorola Freeware Assemblers) allow


source programs written and edited on one computer (the host) to


generate executable code for another computer (the target). The


executable object file can then be downloaded and run on the target


system. In this case the host is an IBM-PC or compatible and the


target system is based on a Motorola 8-bit microprocessor (6800,


6801, 680, 6805, 68HC05, 680, or 68HC11).


The assemblers are the executable programs AS.EXE where is any of


0, 1, 4, 5, , or 11 depending on which microprocessor you are


writing code for. The details of executing the assembler programs


are found in Chapter . The assembly language format and syntax for


the various processors is very similar with slight variations due to


varied programming resources (instructions, addressing modes, and


registers). These variations are explained in Appendix B.


1. ASSEMBLY LANGUAGE


The symbolic language used to code source programs to be processed by


the Assembler is called assembly language. The language is a


collection of mnemonic symbols representing operations (i.e.,


machine instruction mnemonics or directives to the assembler),


symbolic names, operators, and special symbols. The assembly language


provides mnemonic operation codes for all machine instructions in the


instruction set. The instructions are defined and explained in the


Programming Reference Manuals for the specific devices, available


from Motorola. The assembly language also contains mnemonic directives


which specify auxiliary actions to be performed by the Assembler.


These directives are not always translated into machine language.


1. OPERATING ENVIRONMENT


These assemblers will run on any IBM-PC, XT, AT, PS-, or true


compatible. The assemblers may be run off of a floppy disk drive or


they may be copied onto a hard drive for execution. DOS .0 or later


is required.


1.4 ASSEMBLER PROCESSING


The Macro Assembler is a two-pass assembler. During the first pass,


the source program is read to develop the symbol table. During the


second pass, the object file is created (assembled) with reference to


the table developed in pass one. It is during the second pass that


the source program listing is also produced.


Each source statement is processed completely before the next source


statement is read. As each statement is processed, the Assembler


examines the label, operation code, and operand fields. The operation


code table is scanned for a match with a known opcode. During the


processing of a standard operation code mnemonic, the standard


machine code is inserted into the object file. If an Assembler


directive is being processed, the proper action is taken.


Any errors that are detected by the Assembler are displayed before


the actual line containing the error is printed. If no source listing


is being produced, error messages are still displayed to indicate


that the assembly process did not proceed normally.


--------------------------------------------------------------------------------


CHAPTER


CODING ASSEMBLY LANGUAGE PROGRAMS


.1 INTRODUCTION


Programs written in assembly language consist of a sequence of source


statements. Each source statement consists of a sequence of ASCII


characters ending with a carriage return. Appendix A contains a list


of the supported character set.


. SOURCE STATEMENT FORMAT


Each source statement may include up to four fields a label (or


for a comment line), an operation (instruction mnemonic or assembler


directive), an operand, and a comment.


..1 Label Field


The label field occurs as the first field of a source statement. The


label field can take one of the following forms


1. An asterisk () as the first character in the label field


indicates that the rest of the source statement is a comment.


Comments are ignored by the Assembler, and are printed on the source


listing only for the programmers information.


. A white space character (blank or tab) as the first character


indicates that the label field is empty. The line has no label and is


not a comment.


. A symbol character as the first character indicates that the line


has a label. Symbol characters are the upper or lower case letters a-


z, digits 0-, and the special characters, period (.), dollar sign


($), and underscore (_). Symbols consist of one to 15 characters, the


first of which must be alphabetic or the special characters period


(.) or underscore (_). All characters are significant and upper and


lower case letters are distinct.


A symbol may occur only once in the label field. If a symbol does


occur more than once in a label field, then each reference to that


symbol will be flagged with an error.


With the exception of some directives, a label is assigned the value


of the program counter of the first byte of the instruction or data


being assembled. The value assigned to the label is absolute. Labels


may optionally be ended with a colon (). If the colon is used it is


not part of the label but merely acts to set the label off from the


rest of the source line. Thus the following code fragments are


equivalent


here deca


bne here


here deca


bne here


A label may appear on a line by itself. The assembler interprets


this as set the value of the label equal to the current value of the


program counter.


The symbol table has room for at least 000 symbols of length 8


characters or less. Additional characters up to 15 are permissible


at the expense of decreasing the maximum number of symbols possible


in the table.


.. Operation Field


The operation field occurs after the label field, and must be


preceded by at least one white space character. The operation field


must contain a legal opcode mnemonic or an assembler directive.


Upper case characters in this field are converted to lower case


before being checked as a legal mnemonic. Thus nop, NOP, and


NoP are recognized as the same mnemonic. Entries in the operation


field may be one of two types


Opcode. These correspond directly to the machine instructions. The


operation code includes any register name associated with the


instruction. These register names must not be separated from the


opcode with any white space characters. Thus clra means clear


accumulator A, but clr a means clear memory location identified by


the label a.


Directive. These are special operation codes known to the Assembler


which control the assembly process rather than being translated into


machine instructions.


.. Operand Field


The operand fields interpretation is dependent on the contents of


the operation field. The operand field, if required, must follow the


operation field, and must be preceded by at least one white space


character. The operand field may contain a symbol, an _expression, or


a combination of symbols and expressions separated by commas.


The operand field of machine instructions is used to specify the


addressing mode of the instruction, as well as the operand of the


instruction. The following tables summarize the operand field


formats for the various processor families. (NOTE in these tables


parenthesis () signify optional elements and angle brackets


denote an _expression is inserted. These syntax elements are present


only for clarification of the format and are not inserted as part of


the actual source program. All other characters are significant and


must be used when required.)


...1 M6800/6801 Operand Syntax


The format of the operand field for M6800/6801 instructions is


Operand Format M6800/M6801 Addressing Mode


-------------- ---------------------------


no operand accumulator and inherent


_expression direct, extended, or relative


#_expression immediate


_expression,X indexed


Details of the M6800/6801 addressing modes may be found in Appendix B.


... M6804/68HC Operand Syntax


For the M6804/68HC04, the following operand formats exist


Operand Format M6804/68HC04 Addressing Mode


-------------- ----------------------------


no operand accumulator and inherent


_expression direct, extended, or relative


#_expression immediate


_expression bit set or clear


_expression,_expression bit test and branch


[x or y] register indirect


_expression,#_expression move indirect


Details of the M6804/68HC04 addressing modes may be found in Appendix


B.


... M6805/M68HC05 Operand Syntax


For the M6805/68HC05, the operand formats are


Operand Format M6805/68HC05 Addressing Mode


-------------- ----------------------------


no operand accumulator and inherent


_expression direct, extended, or relative


#_expression immediate


_expression,X indexed


_expression,_expression bit set or clear


_expression,_expression,_expression bit test and branch


Details of the M6805/68HC05 addressing modes may be found in Appendix


B.


...4 M680 Operand Syntax


For the M680, the following operand formats are used


Operand Format M680 Addressing Mode


-------------- ---------------------


no operand accumulator and inherent


_expression direct, extended, or relative


#_expression immediate


_expression,X indexed


_expression forced direct


_expression forced extended


_expression] extended indirect


_expression,R indexed


_expression,R forced 8-bit offset indexed


_expression,R forced 16-bit offset indexed


[_expression,R] indexed indirect


[_expression,R] forced 8-bit offset indexed indirect


[_expression,R] forced 16-bit offset indexed indirect


Q+ auto increment by 1


Q++ auto increment by


[Q++] auto increment indirect


-Q auto decrement by


--Q auto decrement by


[--Q] auto decrement indirect


W1,[W,...,Wn] immediate


where R is one of the registers PCR, S, U, X, or Y, and Q is one of


the registers S, U, X, or Y. Wi (i=1 to n) is one of the symbols A,


B, CC, D, DP, PC, S, U, X, or Y.


Details of the M680 addressing modes may be found in Appendix B.


...5 M68HC11 Operand Syntax


For the M68HC11, the following operand formats exist


Operand Format M68HC11 Addressing Mode


-------------- -----------------------


no operand accumulator and inherent


_expression direct, extended, or relative


#_expression immediate


_expression,X indexed with X register


_expression,Y indexed with Y register


_expression _expression bit set or clear


_expression _expression _expression bit test and branch


The bit manipulation instruction operands are separated by spaces in


this case since the HC11 allows bit manipulation instructions on


indexed addresses. Thus a ,X or ,Y may be added to the final two


formats above to form the indexed effective address calculation.


Details of the M68HC11 addressing modes may be found in Appendix B.


The operand fields of assembler directives are described in Chapter 4.


...6 Expressions. An _expression is a combination of symbols,


constants, algebraic operators, and parentheses. The _expression is


used to specify a value which is to be used as an operand.


Expressions may consist of symbols, constants, or the character


(denoting the current value of the program counter) joined together


by one of the operators + - / % & | ^ .


...7 Operators. The operators are the same as in c


+ add


- subtract


multiply


/ divide


% remainder after division


& bitwise and


| bitwise or


^ bitwise exclusive or


Expressions are evaluated left to right and there is no provision for


parenthesized expressions. Arithmetic is carried out in signed twos


complement integer precision (thats 16 bits on the IBM PC).


...8 Symbols. Each symbol is associated with a 16-bit integer


value which is used in place of the symbol during the _expression


evaluation. The asterisk () used in an _expression as a symbol


represents the current value of the location counter (the first byte


of a multi-byte instruction).


... Constants. Constants represent quantities of data that do


not vary in value during the execution of a program. Constants may


be presented to the assembler in one of five formats decimal,


hexadecimal, binary, or octal, or ASCII. The programmer indicates


the number format to the assembler with the following prefixes


$ HEX


% BINARY


@ OCTAL


ASCII


Unprefixed constants are interpreted as decimal. The assembler


converts all constants to binary machine code and are displayed in


the assembly listing as hex.


A decimal constant consists of a string of numeric digits. The value


of a decimal constant must fall in the range 0-6555, inclusive. The


following example shows both valid and invalid decimal constants


VALID INVALID REASON INVALID


----- ------- --------------


1 1456 more than 5 digits


145 1. invalid character


A hexadecimal constant consists of a maximum of four characters from


the set of digits (0-) and the upper case alphabetic letters (A-F),


and is preceded by a dollar sign ($). Hexadecimal constants must be


in the range $0000 to $FFFF. The following example shows both valid


and invalid hexadecimal constants


VALID INVALID REASON INVALID


----- ------- --------------


$1 ABCD no preceding $


$ABCD $GA invalid character


$001F $F018 too many digits


A binary constant consists of a maximum of 16 ones or zeros preceded


by a percent sign (%). The following example shows both valid and


invalid binary constants


VALID INVALID REASON INVALID


----- ------- --------------


%00101 1010101 missing percent


%1 %10011000101010111 too many digits


%10100 %10101 invalid digit


An octal constant consists of a maximum of six numeric digits,


excluding the digits 8 and , preceded by a commercial at-sign (@).


Octal constants must be in the ranges @0 to @177777. The following


example shows both valid and invalid octal constants


VALID INVALID REASON INVALID


----- ------- --------------


@1764 @174 too many digits


@77 @777 out of range


@177600 @14 invalid character


A single ASCII character can be used as a constant in expressions.


ASCII constants are preceded by a single quote (). Any character,


including the single quote, can be used as a character constant. The


following example shows both valid and invalid character constants


VALID INVALID REASON INVALID


----- ------- --------------


VALID too long


For the invalid case above the assembler will not indicate an error.


Rather it will assemble the first character and ignore the remainder.


..4 Comment Field


The last field of an Assembler source statement is the comment field.


This field is optional and is only printed on the source listing for


documentation purposes. The comment field is separated from the


operand field (or from the operation field if no operand is required)


by at least one white space character. The comment field can contain


any printable ASCII characters.


. ASSEMBLER OUTPUT


The Assembler output includes an optional listing of the source


program and an object file which is in the Motorola S Record format.


Details of the S Record format may be found in Appendix E. The


Assembler will normally suppress the printing of the source listing.


This condition, as well as others, can be overridden via options


supplied on the command line that invoked the Assembler.


Each line of the listing contains a reference line number, the


address and bytes assembled, and the original source input line. If


an input line causes more than 6 bytes to be output (e.g. a long FCC


directive), additional bytes (up to 64) are listed on succeeding


lines with no address preceding them.


The assembly listing may optionally contain a symbol table or a cross


reference table of all symbols appearing in the program. These are


always printed at the end of the assembly listing if either the


symbol table or cross reference table options (Paragraph 4.8) are in


effect. The symbol table contains the name of each symbol, along with


its defined value. The cross reference table additionally contains


the assembler-maintained source line number of every reference to


every symbol. The format of the cross reference table is shown in


Appendix D.


--------------------------------------------------------------------------------


CHAPTER


RUNNING THE ASSEMBLERS


.1 ASSEMBLER INVOCATION


The Motorola Freeware Assembly programs are named as.exe where


is any of 0, 1, 4, 5, , or 11 depending on which processor family


you wish to assemble code for. For example, to generate M6800 code


run the as0.exe program. To generate M68HC05 code run the as5.exe


program, and so forth. To run the assembler enter the following


command line


as file1 (file . . . ) ( - option1 option . . . )


where file1, file, etc are the names of the source files you wish to


assemble. The source filenames may have extensions but the assembler


does not check for any particular extension ( however, do not use the


.S1 extension since that is the extension of the object file created


by the assembler. Its creation would overwrite the source file when


it is written to the disk).


The options are one or more of the following


l enables output listing


no disables output listing (default).


cre enables the cross reference table generation


s enables the symbol table generation


c enables cycle counting


noc disables cycle counting


The minus sign preceding the option should be separated from the last


file name by a space. These options may also be indicated to the


assembler by the use of the OPT directive in the source file. The


OPT directive is described in Paragraph 4.8.


The object file created is written to disk and given the name


FILENAME.S1 where FILENAME is the name of the first source file


specified on the command line. Any errors and the optional listing


(if specified) are displayed on the screen. The listing and/or error


messages may be saved to a file for later examination or printing by


append an i/o redirection command to the command line. On the PC i/o


redirection is indicated with the greater-than () symbol followed


by any new or existing file name.


Command line examples


The command line


as5 myfile


would run the M6805/68HC05 assembler on the source file myfile.


The object file would be written to myfile.s1 and any errors would


appear on the screen.


The command line


as test.asm nexttest.s -l


would run the M680 assembler on the source files test.asm and


nexttest.s. The object file would be written to test.s1 and any


errors and the assembly listing would appear on the screen.


The command line


as test.asm nexttest.s -l cre s test.lst


would run the M680 assembler on the source files test.asm and


nexttest.s. The object file would be written to test.s1. A


listing would be created followed by a symbol table and cross


reference which would all be written to the file test.lst


.


. ERROR MESSAGES


Error diagnostic messages are placed in the listing file just before


the line containing the error. The format of the error line is


Line_number Description of error


or


Line_number Warning ---- Description of error


Errors in pass one cause cancellation of pass two. Warning do not


cause cancellation of pass two but are indications of a possible


problem. Error messages are meant to be self-explanatory.


If more than one file is being assembled, the file name precedes the


error


File_name,Line_number Description of error


Some errors are classed as fatal and cause an immediate termination


of the assembly. Generally this happens when a temporary file cannot


be created or is lost during assembly.


--------------------------------------------------------------------------------


CHAPTER 4


ASSEMBLER DIRECTIVES


4.1 INTRODUCTION


The Assembler directives are instructions to the Assembler, rather


than instructions to be directly translated into object code. This


chapter describes the directives that are recognized by the Freeware


Assemblers. Detailed descriptions of each directive are arranged


alphabetically. The notations used in this chapter are


( ) Parentheses denote an optional element.


XYZ The names of the directives are printed in capital letters.


The element names are printed in lower case and contained in


angle brackets. All elements outside of the angle brackets must


be specified as-is. For example, the syntactical element (number,)


requires the comma to be specified if the optional element number


is selected. The following elements are used in the subsequent


descriptions


comment A statements comment field


label A statement label


_expression An Assembler _expression


expr An Assembler _expression


number A numeric constant


string A string of ASCII characters


delimiter A string delimiter


OPTION An Assembler option


symbol An Assembler symbol


sym An Assembler symbol


sect A relocatable program section


reg list M680 register list


reg exp M680 register _expression


In the following descriptions of the various directives, the syntax,


or format, of the directive is given first. This will be followed


with the directives description.


4. BSZ - BLOCK STORAGE OF ZEROS


(label) BSZ _expression (comment)


The BSZ directive causes the Assembler to allocate a block of bytes.


Each byte is assigned the initial value of zero. The number of bytes


allocated is given by the _expression in the operand field. If the


_expression contains symbols that are either undefined or forward


referenced (i.e. the definition occurs later on in the file), or if


the _expression has a value of zero, an error will be generated.


4. EQU - EQUATE SYMBOL TO A VALUE


label EQU _expression (comment)


The EQU directive assigns the value of the _expression in the operand


field to the label. The EQU directive assigns a value other than the


program counter to the label. The label cannot be redefined anywhere


else in the program. The _expression cannot contain any forward


references or undefined symbols. Equates with forward references are


flagged with Phasing Errors.


4.4 FCB - FORM CONSTANT BYTE


(label) FCB expr(,expr,...,expr) (comment)


The FCB directive may have one or more operands separated by commas.


The value of each operand is truncated to eight bits, and is stored


in a single byte of the object program. Multiple operands are stored


in successive bytes. The operand may be a numeric constant, a


character constant, a symbol, or an _expression. If multiple operands


are present, one or more of them can be null (two adjacent commas),


in which case a single byte of zero will be assigned for that


operand. An error will occur if the upper eight bits of the evaluated


operands values are not all ones or all zeros.


4.5 FCC - FORM CONSTANT CHARACTER STRING


(label) FCC delimiterstringdelimiter (comment)


The FCC directive is used to store ASCII strings into consecutive


bytes of memory. The byte storage begins at the current program


counter. The label is assigned to the first byte in the string. Any


of the printable ASCII characters can be contained in the string.


The string is specified between two identical delimiters which can be


any printable ASCII character. The first non-blank character after


the FCC directive is used as the delimiter.


Example


LABEL1 FCC , ABC,


assembles ASCII ABC at location LABEL1


4.6 FDB - FORM DOUBLE BYTE CONSTANT


(label) FDB expr(,expr,...,expr) (comment)


The FDB directive may have one or more operands separated by commas.


The 16-bit value corresponding to each operand is stored into two


consecutive bytes of the object program. The storage begins at the


current program counter. The label is assigned to the first 16-bit


value. Multiple operands are stored in successive bytes. The operand


may be a numeric constant, a character constant, a symbol, or an


_expression. If multiple operands are present, one or more of them can


be null (two adjacent commas), in which case two bytes of zeros will


be assigned for that operand.


4.7 FILL - FILL MEMORY


(label) FILL _expression,_expression


The FILL directive causes the assembler to initialize an area of


memory with a constant value. The first _expression signifies the one


byte value to be placed in the memory and the second _expression


indicates the total number of successive bytes to be initialized.


The first _expression must evaluate to the range 0-55. Expressions


cannot contain forward references or undefined symbols.


4.8 OPT - ASSEMBLER OUTPUT OPTIONS


OPT OPTION(,OPTION,...,OPTION) (comment)


The OPT directive is used to control the format of the Assembler


output. The options are specified in the operand field, separated by


commas. All options have a default condition. Some options can be


initialized from the command line that invoked the Assembler, however


the options contained in the source file take precedence over any


entered on the command line. In the following descriptions, the


parenthetical inserts specify DEFAULT, if the option is the default


condition. All options must be entered in lower case.


c - Enable cycle counting in the listing. The total cycle count


for that instruction will appear in the listing after the assembled


bytes and before the source code.


cre - Print a cross reference table at the end of the source


listing. This option, if used, must be specified before the first


symbol in the source program is encountered. The cross reference


listing format may be found in Appendix D.


l - Print the listing from this point on. A description of the


listing format can be found in Appendix D.


noc - (DEFAULT) Disable cycle counting in the listing. If the c


option was used previously in the program, this option will cause


cycle counting to cease until the next OPT c statement.


nol - (DEFAULT) Do not print the listing from this point on. An


OPT l can re-enable listing at a later point in the program.


s - Print symbol table at end of source listing. The symbol table


format can be found in Appendix D.


4. ORG - SET PROGRAM COUNTER TO ORIGIN


ORG _expression (comment)


The ORG directive changes the program counter to the value specified


by the _expression in the operand field. Subsequent statements are


assembled into memory locations starting with the new program counter


value. If no ORG directive is encountered in a source program, the


program counter is initialized to zero. Expressions cannot contain


forward references or undefined symbols.


4.10 PAGE - TOP OF PAGE


PAGE


The PAGE directive causes the Assembler to advance the paper to the


top of the next page. If no source listing is being produced, the


PAGE directive will have no effect. The directive is not printed on


the source listing.


4.11 RMB - RESERVE MEMORY BYTES


(label) RMB _expression (comment)


The RMB directive causes the location counter to be advanced by the


value of the _expression in the operand field. This directive reserves


a block of memory the length of which in bytes is equal to the value


of the _expression. The block of memory reserved is not initialized to


any given value. The _expression cannot contain any forward references


or undefined symbols. This directive is commonly used to reserve a


scratchpad or table area for later use.


4.1 ZMB - ZERO MEMORY BYTES (same as BSZ)


(label) ZMB _expression (comment)


The ZMB directive causes the Assembler to allocate a block of bytes.


Each byte is assigned the initial value of zero. The number of bytes


allocated is given by the _expression in the operand field. If the


_expression contains symbols that are either undefined or forward


references, or if the _expression has a value of zero, an error will


be generated.


--------------------------------------------------------------------------------


APPENDIX A


CHARACTER SET


The character set recognized by the Freeware Assemblers is a subset


of ASCII. The ASCII code is shown in the following figure. The


following characters are recognized by the Assembler


1. The upper case letters A through Z and lower case letters


a through z.


. The digits 0 through .


. Five arithmetic operators +, -, , / and % (remainder


after division).


4. Three logical operators &, |, and ^.


5. The special symbol characters underscore (_), period (.),


and dollar sign ($). Only the underscore and period may be


used as the first character of a symbol.


6. The characters used as prefixes for constants and


addressing modes


# Immediate addressing


$ Hexadecimal constant


& Decimal constant


@ Octal constant


% Binary constant


ASCII character constant


7. The characters used as suffixes for constants and


addressing modes


,X Indexed addressing


,PCR M680 indexed addressing


,S M680 indexed addressing


,U M680 indexed addressing


,Y M680 and M68HC11 indexed addressing


8. Three separator characters space, carriage return, and


comma.


. The character to indicate comments. Comments may


contain any printable characters from the ASCII set.


10. The special symbol backslash to indicate line


continuation. When the assembler encounters the line


continuation character it fetches the next line and adds


it to the end of the first line. This continues until a


line is seen which doesnt end with a backslash or until


the system maximum buffer size has been collected


(typically greater or equal to 56).


11. For the M680 Assembler, the character preceding an


_expression to indicate direct addressing mode or 8-bit


offset in indexed mode, and the character preceding an


_expression to indicate extended addressing mode or 16-bit


offset in indexed mode.


1. For the M680 Assembler, the characters used to indicate


auto increment and auto decrement in the indexed mode +,


++, -, --.


ASCII CHARACTER CODES


BITS 4 to 6 -- 0 1 4 5 6 7


----------- -------------------------------------


0 NUL DLE SP 0 @ P ` p


B 1 SOH DC1 1 A Q a q


I STX DC ! B R b r


T ETX DC # C S c s


S 4 EOT DC4 $ 4 D T d t


5 ENQ NAK % 5 E U e u


0 6 ACK SYN & 6 F V f v


7 BEL ETB 7 G W g w


T 8 BS CAN ( 8 H X h x


O HT EM ) I Y i y


A LF SUB J Z j z


B VT ESC + ; K [ k {


C FF FS , L l ;


D CR GS - = M ] m }


E SO RS . N ^ n ~


F S1 US / ? O _ o DEL


--------------------------------------------------------------------------------


APPENDIX B


ADDRESSING MODES


B.1 M6800/M6801 ADDRESSING MODES.


INHERENT OR ACCUMULATOR ADDRESSING


The M6800 includes some instructions which require no operands. These


instructions are self-contained and employ the inherent addressing or


the accumulator addressing mode.


IMMEDIATE ADDRESSING


Immediate addressing refers to the use of one or two bytes of


information that immediately follow the operation code in memory.


Immediate addressing is indicated by preceding the operand field with


the pound sign or number sign character (#). The _expression following


the # will be assigned one or two bytes of storage, depending on the


instruction.


RELATIVE ADDRESSING


Relative addressing is used by branch instructions. Branches can only


be executed within the range -16 to +1 bytes relative to the first


byte of the branch instruction. For this mode, the programmer


specifies the branch address _expression and places it in the operand


field. The actual branch offset is calculated by the assembler and


put into the second byte of the branch instruction. The offset is


the twos complement of the difference between the location of the


byte immediately following the branch instruction and the location of


the destination of the branch. Branches out of bounds are flagged as


errors by the assembler.


INDEXED ADDRESSING


Indexed addressing is relative to the index register. The address is


calculated at the time of instruction execution by adding a one-byte


displacement (in the second byte of the instruction) to the current


contents of the X register. Since no sign extension is performed on


this one-byte displacement, the offset cannot be negative. Indexed


addressing is indicated by the characters ,X following the


_expression in the operand field. The special case of ,X, without a


preceding _expression, is treated as 0,X.


DIRECT AND EXTENDED ADDRESSING


Direct and extended addressing utilize one (direct) or two (extended)


bytes to contain the address of the operand. Direct addressing is


limited to the first 56 bytes of memory. Direct and extended


addressing are indicated by only having an _expression in the operand


field. Direct addressing will be used by the Assembler whenever


possible.


B. M6804/M68HC04 ADDRESSING MODES.


INHERENT OR ACCUMULATOR ADDRESSING


The M6800 includes some instructions which require no operands. These


instructions are self-contained and employ the inherent addressing or


the accumulator addressing mode.


IMMEDIATE ADDRESSING


Immediate addressing refers to the use of one byte of information


that immediately follows the operation code in memory. Immediate


addressing is indicated by preceding the operand field with the pound


sign or number sign character (#). The _expression following the #


will be assigned one byte of storage.


RELATIVE ADDRESSING


Relative addressing is used by branch instructions. Branches can only


be executed within the range -15 to +16 bytes relative to the first


byte of the branch instruction. For this mode, the programmer


specifies the branch address _expression and places it in the operand


field. The actual branch offset is calculated by the assembler and


put into the second byte of the branch instruction. The offset is


the twos complement of the difference between the location of the


byte immediately following the branch instruction and the location of


the destination of the branch. Branches out of bounds are flagged as


errors by the assembler.


DIRECT AND EXTENDED ADDRESSING


Direct and extended addressing utilize byte to contain the address of


the operand. Direct addressing is limited to the first 56 bytes of


memory. Extended addressing concatenates the four least-significant


bits of the opcode with the byte following the opcode to form a


1-bit address. Direct and extended addressing are indicated by only


having an _expression in the operand field. Direct addressing will be


used by the Assembler whenever possible.


SHORT DIRECT


Some opcodes allow 4 memory locations in data space ram ($80, $81,


$8, and $8 to be referenced as part of the opcode. The opcode


determines the data space RAM location, and the instruction is only


one byte. The X and Y registers are at locations $80 and $81,


respectively. An _expression used with short direct addressing must


not be forward referenced (that is its definition must occur before,


not after this point in the file) and must equate to the range $80-


$8.


BIT SET AND CLEAR


In the bit set/clear addressing mode, the bit to be set or cleared is


part of the opcode. The byte following the opcode specifies the


direct address of the byte which will have the bit set or cleared.


Any bit in the 56 byte data space memory that can be written (with


the exception of the data direction registers) can be set or cleared


with these two byte instructions.


BIT TEST AND BRANCH


The bit test and branch addressing mode is a combination of the


direct addressing and relative addressing. The bit to be tested, and


it condition (set or clear), is included in the opcode. The data


space address of the byte to be tested is in the single byte


immediately following the opcode byte and follows direct addressing


rules. The third byte is sign extended by the processor during


execution to form the 1-bit relative address which is added to the


program counter if the condition is true. This allows branches based


on any readable bit in the data space. The branch span is -15 to


+10 from the opcode address. The branch target address is used by


the programmer to signify the relative offset -- the assembler


calculates the offset value. Branches out of bounds are flagged as


errors by the assembler.


REGISTER INDIRECT


In the register indirect mode, the operand is at the address in data


space pointed to by the contents of one of the indirect registers, X


or Y. The particular indirect register is encoded in bit 4 of the


opcode by the assembler. The assembler operand syntax for register


indirect is


[X or Y]


MOVE IMMEDIATE


The MVI (move immediate) instruction has its own format


mvi _expression 1,#_expression


where _expression 1 is a direct address and _expression is the


data value to be written.


MISCELLANEOUS SYNTAX ISSUES


The registers in the 6804/HC6804 are memory locations and have


addresses assigned to them. The assembler has predefined


a = A = $FF


b = B = $80


c = C = $81


This also means that for the 04 assembler clr x is equivalent to


clrx since x is both a register and a memory location.


The 04 series has separate program and data spaces. There is no


program memory in the range $10-$7F. Bytes assembled into that range


will go into the data space.


B. M6805/68HC05 ADDRESSING MODES.


INHERENT OR ACCUMULATOR ADDRESSING


The M6805 includes some instructions which require no operands. These


instructions are self-contained, and employ the inherent addressing


or the accumulator addressing mode.


IMMEDIATE ADDRESSING


Immediate addressing refers to the use of one byte of information


that immediately follows the operation code in memory. Immediate


addressing is indicated by preceding the operand field with the pound


sign or number sign character (#). The _expression following the #


will be assigned one byte of storage.


RELATIVE ADDRESSING


Relative addressing is used by branch instructions. Branches can only


be executed within the range -16 to +1 bytes relative to the first


byte of the branch instruction. For this mode, the programmer


specifies the branch address _expression and places it in the operand


field. The actual branch offset is calculated by the assembler and


put into the second byte of the branch instruction. The offset is


the twos complement of the difference between the location of the


byte immediately following the branch instruction and the location of


the destination of the branch. Branches out of bounds are flagged as


errors by the assembler.


INDEXED ADDRESSING


Indexed addressing is relative to the index register. The address is


calculated at the time of instruction execution by adding a one- or


two-byte displacement to the current contents of the X register. The


displacement immediately follows the operation code in memory. If


the displacement is zero, no offset is added to the index register.


In this case, only the operation code resides in memory. Since no


sign extension is performed on a one-byte displacement, the offset


cannot be negative. Indexed addressing is indicated by the characters


,X following the _expression in the operand field. The special case


of ,X, without a preceding _expression, is treated as 0,X. Some


instructions do not allow a two-byte displacement.


DIRECT AND EXTENDED ADDRESSING


Direct and extended addressing utilize one (direct) or two (extended)


bytes to contain the address of the operand. Direct addressing is


limited to the first 56 bytes of memory. Direct and extended


addressing are indicated by only having an _expression in the operand


field. Some instructions do not allow extended addressing. Direct


addressing will be used by the Macro Assembler whenever possible.


BIT SET OR CLEAR


The addressing mode used for this type of instruction is direct,


although the format of the operand field is different from the direct


addressing mode described above. The operand takes the form


_expression 1, _expression . _expression 1 indicates which bit is


to be set or cleared. It must be an absolute _expression in the range


0-7. It is used in generating the operation code. _expression is


handled as a direct address, as described above. Since the bit


manipulation address is direct, only the first 56 locations may be


operated on by bit manipulation operations.


BIT TEST AND BRANCH


This combines two addressing modes direct and relative. The format


of the operand is _expression 1, _expression , _expression .


_expression 1 and _expression are handled in the same manner as


described above in bit set or clear. _expression is used to


generate a relative address, as described above in relative


addressing.


B.4 M680 ADDRESSING MODES.


INHERENT OR ACCUMULATOR ADDRESSING


The M680 includes some instructions which require no operands. These


instructions are self-contained, and employ the inherent addressing


or the accumulator addressing mode.


IMMEDIATE ADDRESSING


Immediate addressing refers to the use of one or two bytes of


information that immediately follow the operation code in memory.


Immediate addressing is indicated by preceding the operand field with


the pound sign or number sign (#) -- i.e., #_expression. The


_expression following the # will be assigned one or two bytes of


storage, depending on the instruction. All instructions referencing


the accumulator A or B, or the condition code register CC, will


generate a one-byte immediate value. Also, immediate addressing used


with the PSHS, PULS, PSHU, and PULU instructions generates a one-byte


immediate value. Immediate operands used in all other instructions


generate a two-byte value.


The register list operand does not take the form #_expression but


still generates one byte of immediate data. The form of the operand


is


R1,R,...,Rn


where Ri (i=1 to n) is one of the symbols A, B, CC, D, DP, PC, S, U,


X or Y. The number and type of symbols vary, depending on the


specific instruction.


For the instructions PSHS, PULS, PSHU, and PULU, any of the above


register names may be included in the register list. The only


restriction is that U cannot be specified with PSHU or PULU, and


S cannot be specified with PSHS or PULS. The one-byte immediate


value assigned to the operand is calculated by the assembler and is


determined by the registers specified. Each register name causes the


assembler to set a bit in the immediate byte as follows


Register Bit


-------- ---


PC 7


U,S 6


Y 5


X 4


DP


B,D


A,D 1


CC 0


For the instructions EXG and TFR, exactly two of the above register


names must be included in the register list. The other restriction is


the size of the registers specified. For the EXG instruction, the two


registers must be the same size. For the TFR instruction, the two


registers must be the same size, or the first can be a 16-bit


register and the second an 8-bit register. In the case where the


transfer is from a 16-bit register to an 8-bit register, the least


significant 8 bits are transferred. The 8-bit registers are A, B,


CC, and DP. The 16-bit registers are D, PC, S, U, X, and Y. The


one-byte immediate value assigned to the operand by the assembler is


determined by the register names. The most significant four bits of


the immediate byte contain the value of the first register name; the


least significant four bits contain the value of the second register,


as shown by the following table.


Register Value (hex)


-------- -----------


D 0


X 1


Y


U


S 4


PC 5


A 8


B


CC A


DP B


RELATIVE ADDRESSING


Relative addressing is used by branch instructions. There are two


forms of the branch instruction. The short branch can only be


executed within the range -16 to +1 bytes relative to the first


byte of the branch instruction. For this mode, the programmer


specifies the branch address _expression and places it in the operand


field. The actual branch offset is calculated by the assembler and


put into the second byte of the branch instruction. The long branch


can execute in the full range of addressing from 0000-FFFF


(hexadecimal) because a two- byte offset is calculated by the


assembler and put into the operand field of the branch instruction.


The offset is the twos complement of the difference between the


location of the byte immediately following the branch instruction and


the location of the destination of the branch.


DIRECT AND EXTENDED ADDRESSING


Direct and extended addressing utilize one (direct) or two (extended)


bytes to contain the address of the operand. Direct and extended


addressing are indicated by having only an _expression in the operand


field (i.e., _expression). Direct addressing will be used whenever


possible.


Regardless of the criteria described above, it is possible to force


the Assembler to use the direct addressing mode by preceding the


operand with the character. Similarly, extended addressing can be


forced by preceding the operand with the character. These two


operand forms are _expression and _expression.


INDEXED ADDRESSING


Indexed addressing is relative to one of the index registers. The


general form is _expression,R. The address is calculated at the time


of instruction execution by adding the value of _expression to the


current contents of the index register. The other general form is


[_expression,R]. In this indirect form, the address is calculated


at the time of instruction execution by first adding the value of


_expression to the current contents of the index register, and then


retrieving the two bytes from the calculated address and address+1.


This two-byte value is used as the effective address of the operand.


The allowable forms of indexed addressing are described below. In


the description below, R refers to one of the index registers S, U,


X, or Y.


The accumulator offset mode allows one of the accumulators to be


specified instead of an _expression. Valid forms are.


acc,R and [acc,R]


where acc is one of the accumulators A, B, or D. This form


generates a one-byte operand (post-byte only). When accumulator A or


B is specified, sign extension occurs prior to adding the value in


the accumulator to the index register.


The valid forms for the automatic increment/decrement mode are shown


below. For each row, the three entries shown are equivalent.


R+ ,R+ 0,R+


-R ,-R 0,-R


R++ ,R++ 0,R++


--R ,--R 0,--R


[R++] ,R++] [0,R++]


[--R] [,--R] [0,--R]


In this form, the only valid _expression is 0. Like the accumulator


offset mode, this form generates a one-byte operand (post-byte only).


The valid forms for the _expression offset mode are


R ,R _expression,R


[R] [,R] [_expression,R]


R ,R _expression,R


[R] [,R] [_expression,R]


R ,R _expression,R


[R] [,R] [_expression,R]


The and characters force an 8- or 16-bit offset,


respectively, and are described below. If no _expression is specified,


or if an _expression with a value of zero is specified, only the


postbyte of the operand is generated. If an _expression with a value


in the range -16 to +15 is specified without indirection, a one- byte


operand is generated which contains the _expressions value, as well


as the index register indicator. At execution time, the _expressions


value is expanded to 16 bits with sign extension before being added


to the index register.


All other forms will generate a post-byte, as well as either a one-


or two-byte offset which contains the value of the _expression. The


size of the offset is determined by the type and size of the


_expression. Expressions with values in the range -18 to +17


generate an 8-bit offset. All other cases will result in a 16-bit


offset being generated. In the case where an 8-bit offset is


generated, the value is expanded to 16 bits with sign extension at


execution time.


Regardless of the criteria described above, it is possible to force


the Assembler to generate an 8-bit offset by preceding the operand


with the character. Similarly, a 16-bit offset can be forced by


preceding the operand with the character.


If the relative address calculated is not in the range -18 to +17,


or if the _expression references a symbol that has not yet been


defined, a two-byte offset is generated after the post-byte. A one-


byte offset is generated if the relative address is in the range -18


to +17.


Like the _expression offset mode, a one-byte offset can be forced by


preceding the operand with a . A forces a two-byte offset. A


byte overflow error is generated if a one-byte offset is forced when


the relative address is not in the range -1 8 to +17.


The extended indirect mode has the form


[_expression]


Although extended indirect is a logical extension of the extended


addressing mode, this mode is implemented using an encoding of the


postbyte under the indexed addressing mode. A post-byte and a two-


byte offset which contains the value of the _expression is generated.


B.5 M68HC11 ADDRESSING MODES.


PREBYTE


The number of combinations of instructions and addressing modes for


the 68HC11 is larger than that possible to be encoded in an 8-bit


word (56 combinations). To expand the opcode map, certain opcodes


($18, $1A, and $CD) cause the processor to fetch the next address to


find the actual instruction. These opcodes are known as prebytes and


are inserted automatically by the assembler for those instructions


that require it.l In general the instructions contained in the


alternate maps are those involving the Y register or addressing modes


that involve the Y index register. Thus the programmer make the


tradeoff between the convenience of using the second index register


and the additional time and code space used by the prebyte.


INHERENT OR ACCUMULATOR ADDRESSING


The M68HC11 includes some instructions which require no operands.


These instructions are self-contained, and employ the inherent


addressing or the accumulator addressing mode.


IMMEDIATE ADDRESSING


Immediate addressing refers to the use of one or more bytes of


information that immediately follow the operation code in memory.


Immediate addressing is indicated by preceding the operand field with


the pound sign or number sign character (#). The _expression following


the # will be assigned one byte of storage.


RELATIVE ADDRESSING


Relative addressing is used by branch instructions. Branches can only


be executed within the range -16 to +1 bytes relative to the first


byte of the branch instruction. For this mode, the programmer


specifies the branch address _expression and places it in the operand


field. The actual branch offset is calculated by the assembler and


put into the second byte of the branch instruction. The offset is


the twos complement of the difference between the location of the


byte immediately following the branch instruction and the location of


the destination of the branch. Branches out of bounds are flagged as


errors by the assembler.


INDEXED ADDRESSING


Indexed addressing is relative one of the index registers X or Y.


The address is calculated at the time of instruction execution by


adding a one-byte displacement to the current contents of the X


register. The displacement immediately follows the operation code in


memory. If the displacement is zero, zero resides in the byte


following the opcode. Since no sign extension is performed on a


one-byte displacement, the offset cannot be negative. Indexed


addressing is indicated by the characters ,X following the


_expression in the operand field. The special case of ,X, without a


preceding _expression, is treated as 0,X.


DIRECT AND EXTENDED ADDRESSING


Direct and extended addressing utilize one (direct) or two (extended)


bytes to contain the address of the operand. Direct addressing is


limited to the first 56 bytes of memory. Direct and extended


addressing are indicated by only having an _expression in the operand


field. Direct addressing will be used by the Assembler whenever


possible.


BIT(S) SET OR CLEAR


The addressing mode used for this type of instruction is direct,


although the format of the operand field is different from the direct


addressing mode described above. The operand takes the form


_expression 1 _expression where the two expressions are separated


by a blank. _expression 1 signifies the operand address and may be


either a direct or an indexed address. When the address mode is


indexed, _expression 1 is followed by ,R where R is either X or Y.


This allows bit manipulation instructions to operate across the


complete 64K address map. _expression is the mask byte. The


bit(s) to be set or cleared are indicated by ones in the


corresponding location(s) in the mask byte. The mask byte must be an


_expression in the range 0-55 and is encoded by the programmer.


BIT TEST AND BRANCH


This combines two addressing modes direct or indexed and relative.


The format of the operand is _expression 1 _expression


_expression where the expressions are separated by blanks.


_expression 1 identifies the operand an may indicate either a direct


or indexed address. Indexed addresses are signified with ,R


following the _expression where R is either X or Y. _expression is


the mask byte. The bit(s) to be set or cleared are indicated by ones


in the corresponding location(s) in the mask byte. The mask byte


must be an _expression in the range 0-55 and is encoded by the


programmer. _expression is used to generate a relative address, as


described above in relative addressing.


--------------------------------------------------------------------------------


APPENDIX C


DIRECTIVE SUMMARY


A complete description of all directives appears in Chapter 4.


ASSEMBLY CONTROL


ORG Origin program counter


SYMBOL DEFINITION


EQU Assign permanent value


DATA DEFINITION/STORAGE ALLOCATION


BSZ Block storage of zero; single bytes


FCB Form constant byte


FCC Form constant character string


FDB Form constant double byte


FILL Initialize a block of memory to a constant


RMB Reserve memory; single bytes


ZMB Zero Memory Bytes; same and BSZ


LISTING CONTROL


OPT c Enable cycle counting


OPT cre Print cross reference table


OPT l Print source listing from this point


OPT nol Inhibit printing of source listing from this point


OPT s Print symbol table


PAGE Print subsequent statements on top of next page


--------------------------------------------------------------------------------


APPENDIX D


ASSEMBLER LISTING FORMAT


The Assembler listing has the following format


LINE# ADDR OBJECT CODE BYTES [ # CYCLES] SOURCE LINE


The LINE# is a 4 digit decimal number printed as a reference. This


reference number is used in the cross reference. The ADDR is the hex


value of the address for the first byte of the object code for this


instruction. The OBJECT CODE BYTES are the assembled object code of


the source line in hex. If an source line causes more than 6 bytes


to be output (e.g. a long FCC directive), additional bytes (up to 64)


are listed on succeeding lines with no address preceding them.


The # CYCLES will only appear in the listing if the c option is in


effect. It is enclosed in brackets which helps distinguish it from


the source listing. The SOURCE LINE is reprinted exactly from the


source program, including labels.


The symbol table has the following format


SYMBOL ADDR


The symbol is taken directly from the label field in the source


program. The ADDR is the hexadecimal address of the location


referenced by the symbol.


The cross reference listing has the following format


SYMBOL ADDR LOC1 LOC LOC ...


The SYMBOL and ADDR are the same as above. The indicates the start


of the line reference numbers. The LOCs are the decimal line numbers


of the assembler listing where the label occurs.


--------------------------------------------------------------------------------


APPENDIX E


S-RECORD INFORMATION


E.1 INTRODUCTION


The S-record output format encodes program and data object modules


into a printable (ASCII) format. This allows viewing of the object


file with standard tools and allows display of the module while


transferring from one computer to the next or during loads between a


host and target. The S-record format also includes information for


use in error checking to insure the integrity of data transfers.


E. S-RECORD CONTENT


S-Records are character strings made of several fields which identify


the record type, record lengtPlease note that this sample paper on HC11 is for your review only. In order to eliminate any of the plagiarism issues, it is highly recommended that you do not use it for you own writing purposes. In case you experience difficulties with writing a well structured and accurately composed paper on HC11, we are here to assist you. Your cheap custom college paper on HC11 will be written from scratch, so you do not have to worry about its originality.

Order your authentic assignment from cheap essay writing service and you will be amazed at how easy it is to complete a quality custom paper within the shortest time possible!



Leave a Reply

Note: Only a member of this blog may post a comment.