Assembly programming is low-level programming using some basic syntax to represent machine code for a specific CPU. An assembler is used to translate the assembly code into the machine code for the target computer.

A program created from assemblhy can be more efficient and faster than a program created with a compiler. One example of why this occurs is because a compiler will store intermediate values used in a calculation in memory whereas a program written in assembly can store the intermediate values in a register which is much faster. However, while there may be performance benefits to programming so close to the machine level, there is a great deal of added complexity which a high-level programming language can remove.

Table 5.1 Source Code Fields [1]

Label Field	Opcode Field	Operand(s) Field	Comment Field
Example:	ldaa	#$64	; Initialize A with hexadecimal 64

• A label must start with an alphabetic character
• The label must start in the first column of the source code line unless it ends with a colon.
• Uppercase and lowercase characters are distinct by default but case sensitivity may be turned off.
• A label may end with a colon (:)
• A label may appear on a line by itself
• The label is optional but when used it can provide a symbolic memory reference such as a branch instruction address, or a symbol for a constant.

• The opcode field contains either a mnemonic for the operation, an assembler directive or pseudo-operation, or a macro name. For the opcode field, the assembler will convert all uppercase letters to lowercase so this field is not case sensitive.

• The interpretation of the operand field depends on the opcode.
• The operand must follow the opcode.
• Operands can be the symbols, constants, or expressions that are evaluated by the assembler.
• The operand field also specifies the addressing mode for the instruction.

Using Macros

A macro can be used to give a symbolic name to a group of instructions that are used often. In the source code the macro should be given a name using the label field and then two commands (MACRO & ENDM) are used to indicate the start and finish of the macro. The assembler will then replace every occurrence of the macro with the set of instructions.

Add_B_and_C:	MACRO
	MOV A,C ADD A,B MOV C,A ENDM

Macro vs Sub-Routine

A macro and a sub-routine are similar except for the following differences:

• With a sub-routine the code is present only once. With a macro, the code is inserted in the place of the macro whenever it is used. Therefore, if macros are used instead of sub-routines, the code will end up being longer.
• With a sub-routine a jump must occur in order to find and execute the sub-routine code. With a macro, this is not required because the code has already been inserted directly. Therefore, a sub-routine will be slightly slower than a macro.

Using either a sub-routine or a macro makes changing the code much easier because changes can be done in one place rather than in each specific location where the code would be used. They also make the code easier to understand.

Assembler Instructions

ORG – Set the program counter to the origin of the program

EQU – Associate the value of an expression with a symbol

SET – Can be used instead of equal. With set, the value can be redefined

DC – Define a constant value

DCB – Define a constant block

DS – Define storage

Example 5-9 ORG – Set Program Counter to Origin for Absolute Assembly [1]

0000 c000	ROM:	EQU	$c000	; Location of ROM
0000 0800	RAM:	EQU	$0800	; Location of RAM
0000 0A00	STACK:	EQU	$0a00	; Location of stack
	;
		ORG	ROM	; Set program counter to ROM
	;
00c000 CF0a 00		lds	#STACK	; Initialize SP
00c003 B608 00		ldaa	Data_1	; Load from memory address RAM
	;
		ORG	RAM	; set program counter
				; to RAM for the data
000800	Data_1:	DS.B	$20	; Set aside $20 bytes

Software Development Process

When programming in any language, following a good development process is necessary in order to deliver a successful product. It is important to resist the urge to jump right into the code immediately, especially when programming in assembly which is extremely complex.

The first step should always be to clearly identify the problem and define a solution to solve that problem. Create and understand the solution in diagrams or pseudo-code before beginning to code in assembly. Translating these diagrams into code will be much easier than trying envision the solution entirely in your mind.

Debugging and tracing through your assembly program will also be a very good way at finding and correcting bugs.

Typical Bugs Include:

• Incorrect transfer to sub-routine
• Forgetting to initialize the stack pointer
• Not enough memory in the stack
• Sub-routines corrupting registers
• Forgetting to initialize index registers
• Modifying the condition code registers before branching
• Using the wrong branching instruction
• Using the wrong addressing mode

D-Bug12
The D-Bug12 is the debugging tool stored in the EEPROM of our microcontroller that will be used for debugging as well as for downloading programs onto the card and controlling the assembler.

D-Bug12 Commands

ASM – Assemble/Dissasemble

BF – Block Fill Memory

BR – Set Breakpoint

CALL – Call and execute subroutine

G – Go, run program

GT – Go till an address

HELP – Prints summary of available commands

LOAD – Set in state ready to accept program download from MiniIDE

MD – Display Contents of Memory

MM – Modify Memory

MOVE – Copy block of memory

NOBR – Remove breakpoints

RD – Display register contents

T – Trace through program

UPLOAD – Upload memory to PC

USEHDB – Use EVB/Target hardware breakpoints

VERIF – Compare memory to download file

—

[1] Fredrick M. Cady, Software and Hardware Engineering: Assembly and C Programming for the Freescale HCS12 Microcontroller
[2] Prof. Gilbert Arbez, University of Ottawa CSI3531 Course Notes, Module 3