Chapter 2 HCS12 Assembly Programming

Chapter 2 

HCS12 Assembly Programming

Three Sections of a HCS12/MC9S12 

Assembly Program 

• Assembler directives 

– Defines data and symbol 

– Reserves and initializes memory locations 

– Sets assembler and linking condition 

– Specifies p output p format 

– Specifies the end of a program 

• Assembly language instructions 

– HCS12/MC9S12 instructions 

• Comments 

– Explains the function of a single or a group of instructions

Fields of a HCS12 Instruction 

• Label field 

– Optional 

– Starts with a letter and 

ffollowed 

by letters, digits, or 

special symbols (_ or .) 

– Can start from any column if 

ended with “:” 

– Must start from column 1 if not 

ended with “:” 

• Operation field 

– Contains the mnemonic of a 

machine instruction or an 

assembler directive 

– Separated from the label by at 

least one space 

• Operand field 

– Follows the operation field and 

is separated p from the 

operation field by at least one 

space 

– Contains operands for 

instructions or arguments for 

assembler bl di directives ti 

• Comment field 

– Any line starts with an * or ; is 

a comment 

– Separated from the operand 

and operation field for at least 

one space 

– Optional p

Identify the Four Fields of an Instruction 

Example 

loop ADDA #$40 ; add 40 to accumulator A 

(1) “loop” is a label 

(2) “ADDA” is an instruction mnemonic 

(3) “#$40” #$40 is the operand 

(4) “add #$40 to accumulator A” is a comment 

movb 0,X,0,Y ; memory to memory copy 

(1) no label field 

(b) “movb” is an instruction mnemonic 

(c) “0,X,0,Y” is the operand field 

(d) “; ; memory to memory copy” copy is a comment

Assembler Directives 

• END 

– Ends a program to be processed by an assembler 

– Any statement following the END directive is ignored ignored. 

• ORG 

– The assembler uses a location counter to keep track of the memory 

location where the next machine code byte should be placed. 

– This directive sets a new value for the location counter of the 

assembler. 

– The sequence 

ORG $2000 

LDAB #$FF 

places the opcode byte for the instruction LDAB #$FF at 

location $2000. $

dc.b (define ( constant byte) y ) 

db (define byte) 

fcb (form constant byte) 

- These three directives define the value of a byte or bytes that will be placed at a given 

location. 

- These directives are often preceded by the org directive. 

- For example, 

org $2000 

arrayy dc.b $11,$22,$33,$44 

dc.w (define constant word) 

dw (define word) 

fdb (form ( double bytes) y ) 

- Define the value of a word or words that will be placed at a given location. 

- The value can be specified by an expression. 

- For example, 

vec_tab _ 

dc.w $1234, abc-20

fcc (form constant character) 

• Used to define a string of characters (a message) 

• The first character (and the last character) is used as the 

ddelimiter. li it 

• The last character must be the same as the first 

character. 

• The delimiter must not appear in the string. 

• The space character cannot be used as the delimiter. 

• EEach h character h t iis represented t d bby it its ASCII code. d 

• Example 

msg fcc “Please Please enter 1, 2 or 3:” 3:

fill (fill memory) 

- This directive allows the user to fill a certain number of memory locations with a 

given value. 

- The syntax is fill value,count 

- Example 

space_line fill $20,40 

ds (define storage) 

rmb b( (reserve memory byte) b t ) 

ds.b (define storage bytes) 

- Each of these directives reserves a number of bytes given as the arguments to the 

di directive. ti 

- Example 

buffer ds 100 

reserves 100 bytes y

ds ds.w w (define storage word) 

rmw (reserve memory word) 

- Each of these directives increments the location counter by the value indicated in 

the number-of-words argument multiplied by two. 

- Example 

dbuf ds.w 20 

reserves 40 bytes starting from the current location counter 

equ (equate) 

- This directive assigns a value to a label. 

- Using this directive makes one’s one s program more readable readable. 

- Examples 

arr_cnt equ 100 

oc_cnt equ 50

loc 

- This directive increments and produces an internal counter used in conjunction with 

the backward tick mark (`). 

- By using the loc directive and the ` mark mark, one can write program segments like the 

following example, without thinking up new labels: 

loc loc 

ldaa #2 ldaa #2 

loop` deca same as loop1 deca 

bne loop` bne loop1 

loc loc 

loop` brclr 0,x,$55,loop` loop2 brclr 0, x, $55, loop2

Macro 

- A name a e ass assigned g ed to a ggroup oup of o instructions st uct o s 

- Use macro and endm to define a macro. 

- Example of macro 

sumOf3 macro arg1,arg2,arg3 

g , g , g 

ldaa arg1 

adda arg2 

adda 

endm 

arg3 

- Invoke a defined macro: write down the name and the arguments of the macro 

sumOf3 

is replaced p by y 

$1000,$1001,$1002 

ldaa $1000 

adda $1001 

adda $1002

Software Development Process 

• Problem definition: Identify what should be done. 

– Develop the algorithm. 

• Algorithm is the overall plan for solving the problem at hand hand. 

• An algorithm is often expressed in the following format: 

– Step 1 

– … 

– Step 2 

– … 

– Another way to express overall plan is to use flowchart. 

• Programming. g g Convert the algorithm g or flowchart into 

programs. 

• Program testing 

• Program maintenance

Symbols of Flowchart 

Terminal 

Process 

IInput t or 

output B 

Decision 

no 

yes 

A 

on-page connector 

A 

Subroutine 

off-page connector 

Figure 2.1 Flowchart symbols used in this book

Programs to Do Simple Arithmetic (1 of 5) 

Example 2.4 Write a program to add the values of memory locations at $1500, $1501, and 

$1502, and save the result at $1510. 

Solution: 

Step 1 

A ⇐ m[$1500] 

Step 2 

A ⇐ A + m[$1501] 

Step 3 

A ⇐ A + m[$1502] 

Step 4 

m[$1510] ⇐ A 

org $2000 

ldaa $1500 

adda $1501 

adda $1502 

staa 

end 

$1510


Example 2.4 Write a program to subtract the contents of the memory 

location at $1505 from the sum of the memory locations at $1500 and 

$1502, and store the difference at $1510. 

Solution: 

org $2000 

ldaa $1500 

adda $1502 

suba $1505 

staa $1510 

end


Example 2.6 Write a program to add two 16-bit 16 bit numbers that are stored at 

$1500-$1501 and $1502-$1503 and store the sum at $1510-$1511. 

Solution: 

org og $2000 $ 000 

ldd $1500 ; D


Example 2.7 Write a program to add two 4-byte numbers that are stored at 

$1500-$1503 and $1504-$1507, and store the sum at $1510-$1513. 

Solution: Addition starts from the LSB and proceeds toward MSB. 

org $2000 

ldd $1502 ; add and save the least significant two bytes 

addd $1506 ; “ 

std $1512 ; “ 

ldaa $1501 ; add and save the second most significant bytes 

adca $1505 ; “ 

staa $1511 ; “ 

ldaa $1500 ; add and save the most significant bytes 

adca $1504 ; “ 

staa 

end 

$1510 ; “


Example 2.8 Write a program to subtract the hex number stored at $1504-$1507 

from the hex number stored at $1500-$1503 and save the result at $1510-$1513. 

Solution: The subtraction starts from the LSBs and proceeds toward the MSBs. 

org $2000 

ldd $1502 ; subtract and save the least significant two bytes 

subd $1506 ; “ 

std $1512 ; “ 

ldaa $1501 ; subtract and save the difference of the second to most 

sbca $1505 ; significant bytes 

staa $1511 ; “ 

ldaa $1500 ; subtract and save the difference of the most significant 

sbca $1504 ; bytes 

staa 

end 

$1510 ; “

Multiplication and Division (1 of 2) 

Table 2.1 Summary of HCS12 multiply and divide instructions 

Mnemonic Function 

Operation 

emul unsigned 16 by 16 multiply (D) × (Y) → Y:D 

emuls signed 16 by 16 multiply 

(D) × (Y) → Y:D 

mul unsigned 8 by 8 multiply (A) × (B) → A:B 

(Y:D) ÷ (X) 

ediv unsigned 32 by 16 divide quotient → Y 

remainder → D 

(Y (Y:D) D)÷(X) ÷ (X) 

edivs signed 32 by 16 divide quotient → Y 


fdiv 16 by 16 fractional divide (D) ÷ (X) → X 


idiv unsigned 16 by 16 integer 

(D)÷ (D) ÷ (X) → X 

divide 


idivs signed 16 by 16 integer (D) ÷ (X) → X 

divide 

remainder → D

Program Loops 

• Types of program loops: finite and infinite loops 

• Looping mechanisms: 

– do statement S forever 

– For i = n1 to n2 do statement S or For i = n2 down to n1 do 

statement S 

– Whil While C ddo statement t t t S 

– Repeat statement S until C 

• Program loops are implemented by using the conditional 

branch instructions and the execution of these 

instructions depends on the contents of the CCR 

register.

I ← i 1 

I ≤ i 2 ? 

S 

S 

Figure 2.4 An infinite loop 

yes 

I ← I + 1 

no 

I ← i 2 

I ≥ i 1 ? 

S 

yes 

I ← I - 1 

no 

true 

C S 

false 

Figure 2.6 The While ... Do looping construct 

initialize C 

(a) For I = i 1 to i 2 DO S (b) For I = i 2 downto i 1 DO S Figure 2.7 The Repeat ... Until looping construct 

Figure 2.5 For looping construct 

S 

C 

false 

true

Condition Code Register 

7 6 5 4 3 2 1 0 

S X H I N Z V C 

Figure 2.8 Condition code register 

• Four types of branch instructions 

– Unary (unconditional) branch: always execute 

– Simple branches: branch is taken when a specific bit of CCR is in a 

specific status 

– Unsigned branches: branches are taken when a comparison or test of 

unsigned numbers results in a specific combination of CCR bits 

– Signed branches: branches are taken when a comparison or test of 

signed quantities are in a specific combination of CCR bits 

• Two categories of branches 

– Short branches: in the range of -128 ~ +127 bytes 

– Long branches: in the range of 64KB

Condition Code Register 

• C: the carry flag. flag C=1, C=1 implies a carry is generated generated. 

• V: the overflow flag. V=1, implies the result of a 2’s 

complement arithmetic operation is out of range. 

• Z: the zero flag. Z=1, the result of an operation is zero. 

• N: the negative flag. N=1, the most significant bit of the 

result of an operation is 1. 

• H: the half-carry flag. H=1, there is a carry from the lower 

four bits to the upper four bits as the result of an 

operation operation.

Mnemonic 

Table 2.2 Summary of short branch instructions 

Function 

Unary Branches 

BRA Branch always 

BRN Branch never 

Simple Branches 


BCC Branch if carry clear 

BCS Branch if carry set 

BEQ Branch if equal 

BMI Branch if minus 

BNE Branch if not equal 

BPL Branch if plus 

BVC Branch if overflow clear 

BVS Branch if overflow set 

Unsigned Branches 


BHI 

BHS 

BLO 

BLS 

Branch if higher 

BBranch h if higher hi h or same 

Branch if lower 

Branch if lower or same 

Signed Branches 

Equation or Operation 

1 = 1 

1 = 0 


C = 0 

C = 1 

Z = 1 

N = 1 

Z = 0 

N = 0 

V = 0 

V = 1 


C + Z = 0 

C = 0 

C = 1 

C + Z = 1 

Mnemonic Function Equation q or Operation p 

BGE 

BGT 

BLE 

BLT 

Branch if greater than or equal 

Branch if greater than 

Branch if less than or equal 

Branch if less than 

N ⊕ V = 0 

Z + (N ⊕ V) = 0 

Z + (N ⊕ V) = 1 

N ⊕ V = 1

Mnemonic 

Table 2.3 Summary of long branch instructions 

Function 

Unary Branches 

LBRA Long branch always 

LBRN Long branch never 

Simple Branches 


LBCC Long branch if carry clear 

LBCS 

LBEQ 

LBMI 

LBNE 

LBPL 

LBVC 

LBVS 

Long branch if carry set 

Long branch if equal 

Long branch if minus 

Long branch if not equal 

Long branch if plus 

Long branch if overflow overflowis is clear 

Long branch if overflow set 

Unsigned Branches 


LBHI Long branch if higher 

LBHS 

LBLO 

LBLS 

Long branch if higher or same 

Long branch if lower 

Long branch if lower or same 

Signed Branches 


1 = 1 

1 = 0 


C = 0 

C = 1 

Z = 1 

N = 1 

Z = 0 

N = 0 

V=0 V = 0 

V = 1 


C + Z = 0 

C = 0 

C = 1 

C + Z = 1 

Mnemonic Function Equation or Operation 

LBGE 

LBGT 

LBLE 

LBLT 

Long branch if greater than or equal 

Long branch if greater than 

Long branch if less than or equal 

Long branch if less than 

N ⊕ V = 0 

Z + (N ⊕ V) = 0 

Z + (N ⊕ V) = 1 

N ⊕ V = 1

Compare and Test Instructions 

• Condition flags need to be set up before conditional branch 

instruction should be executed. 

• The HCS12 provides a group of instructions for testing the condition 

flags flags. 

Table 2.4 Summary yof compare p and test instructions 


CBA Compare A to B 

CMPA 

CMPB 

CPD 

CPS 

CPX 

CPY 

Compare A to memory 

Compare B to memory 

Compare D to memory 

Compare SP to memory 

Compare X to memory 

Compare Y to memory 

Compare instructions 

Test instructions 

Operation 

(A) - (B) 

(A) - (M) 

(B) - (M) 

(D) - (M:M+1) 

(SP) - (M:M+1) 

(X) - (M:M+1) 

(Y) - (M:M+1) 

Mnemonic Function Operation 

TST 

TSTA 

TSTB 

Test memory for zero or minus 

Test A for zero or minus 

Test B for zero or minus 

(M) - $00 

(A) - $00 

(B) - $00

• HCS12 provides 

a group of 

instructions that 

either decrement 

or increment a 

loop count to 

ddetermine t i if th the 

looping should be 

continued. 

• The range of the 

branch is from 

$80 (-128) to $7F 

(+127). 

Loop Primitive Instructions 

Table 2.5 2 5 Summary of loop primitive instructions 


DBEQ cntr, rel 

DBNE cntr, rel 

IBEQ cntr, rel 

IBNE cntr, rel 

• The range of the TBEQ cntr, rel 

TBNE cntr, rel 

Decrement counter and branch if = 0 

(counter = A, B, D, X, Y, or SP) 

Decrement counter and branch if ≠ 0 


Increment counter and branch if = 0 


Increment counter and branch if ≠ 0 


Test counter and branch if = 0 


Test counter and branch if ≠ 0 



counter ← (counter) - 1 

If (counter) = 0, then branch 

else continue to next instruction 

counter ← (counter) - 1 

If (counter) ≠ 0, then branch 


counter ← (counter) + 1 



counter ← (counter) + 1 







NNote. 11. cntr t iis the h loop l counter and dcan be b accumulator l A, A B, B or D and dregister i X, X Y, Y or SP. SP 

2. rel is the relative branch offset and is usually a label

Implementation of Looping Constructs 

ffor i = n1 1tto n2 2ddo S 

n1 equ xx ; starting index 

n2 equ yy ; ending index 

… 

i ds.b 1 ; loop index variable 

… 

movb #n1,i ; initialize i to n1 

loopf ldaa i ; check index i 

cmpa #n2 

bgt next ; if i is greater than n2, exit the loop 

… ; performs loop operations 

… ; “ 

inc i ; increment loop index 

bra loopf 

next …

for i = n2 downto n1 do S 

n1 equ xx ; starting index 

n2 equ 

… 

yy ; ending index 

i ds ds.b b 1 ; loop index variable 

… 

movb #n2,i ; initialize i to n1 

loopf ldaa i ; check index i 

cmpa #n2 

blt next ; if i is greater than n2, exit the loop 

… ; perform loop operations 

… ; “ 

dec i ; increment loop index 

bra loopf 

next …

While loop 

� Loop terminating condition is checked at the start of the loop 

� In the following example, icount == 0 is the condition to be check. 

� The update of icount is done by an interrupt service routine (not shown below). 

N equ 

… 

xx 

icount ds.b 

… 

1 

movb #N,icount 

wloop ldaa #0 

cmpa icount 

beq next 

… 

… 

bra wloop 

next …

While loop 

�� Loop terminating condition is checked at the start of the loop 

� In the following example, icount == 0 is the condition to be check. 

� The update of icount is done by an interrupt service routine (not shown below). 

N equ 

… 

xx 

icount ds.b 

… 

1 

movb #N #N,icount icount 

wloop ldaa #0 

cmpa icount 

beq next 

… 

… 

bra wloop 

next …

Example 2.14 Write a program to add an array of N 8-bit numbers and store the 

sum at memory locations $1500~$1501. Use the For i = n1 to n2 do looping 

construct. 

Solution: 

N equ 20 

org $1500 

sum rmb 2 ;sum is @ $1500:$1501 

i rmb 1 ;i is @ $1502 

org $2000 

movb #0, i ; i ← 0 

movw #0, sum ; sum ← 0 

lloop ld ldab b i ; B = i 

cmpb #N ; is i = N? 

beq done ; if equal, branch to done 

ldx #array ; X = address of array 

abx ; X = B + X, , array y pointer p 

ldab 0,X ; B = [x]=array(i) 

ldy sum ; Y = sum 

aby ; sum = array(i) + sum 

sty sum ; sum = Y, the new sum 

Start 

i ← 0 

sum ← 0 

yes 

i = N? 

Stop 

no 

sum ← sum + array[i] 

i ← i + 1 

Figure 2.9 Logic flow of example 2.14

inc i ; increment the loop count by 1 

bra loop ; branch back to loop 

done swi ; software interrupt 

array dc dc.b b 

end 

1234567891011121314151617181920 

1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20 

Example 2.15 Write a program to find the maximum element from an array of N 8- 

bit elements using the repeat S until C looping construct. construct 

Solution:

no 

Start 

max_val ← array[0] 

i ← N-1 

max_val < array[i] ? 

yes 

max max_val val ← array[i] 

i ← i - 1 

i = 0? 

Stop 

yes 

Figure 2.10 Logic flow of example 2.15 

no

N equ 20 

org $1500 

max max_val val ds ds.b b 1 

org $2000 

ldaa array ; set array[0] as the temporary max max 

staa max_val ; “ 

ldx #array+N-1 #array N 1 ; start from the end of the array 

ldab #N-1 ; set loop count to N - 1 

loop ldaa max_val 

cmpa 0,x 

bge chk chk_end end 

ldaa 0,x 

staa max_val 

chk_end dex 

dbne b,loop ; finish all the comparison yet? 

forever bra forever 

array db 1,3,5,6,19,41,53,28,13,42,76,14 

db 

end 

20,54,64,74,29,33,41,45

Example 2.14 Write a program to add an array of N 8-bit numbers and store the sum 

at memory locations $1500~$1501. Use the For i = n2 to n1 do looping construct. 

SSolution: l ti 

N equ 20 ; N=20 

org $1500 

sum ds ds.b b 2 ;sum is @ $1500:$1501 

i ds.b 1 ;i is @ $1502 

org $2000 

movb #N, i ; i ← N 

movw #0,sum ; sum ← 0 

ld ldab b #N #N−1 1 ; B = N −1 1 or 19 

ldx #array ; X = address of array(1) 

loop abx ; X = B + addr. of array(1) 

ldab 0,X ; B ← [array(i)] 

ldyy sum ; Y = sum 

aby ; sum=array(i)+sum 

sty sum ; refresh sum to Y 

dbne b,loop ; i = I−1, branch if B ≠ 0 

done swi ; software interrupt 

array dc dc.b b 123456789101112131415 

1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, 

dc.b 

end 

16,17,18,19,20

Bit Condition Branch Instructions 

[] brclr (opr) , (msk),(rel) [] 

[] brset (opr) , (msk),(rel) [] 

where 

opr specifies the memory location to be checked and must be specified using 

either the direct, extended, or index addressing mode. 

msk is an 8-bit mask that specifies the bits of the memory location to be checked. 

The bits of the memory byte to be checked correspond to those bit positions 

that are 1s in the mask. 

rel is the branch offset and is specified in the 8-bit relative mode. 

For example, in the sequence 

loop inc count 

… 

brset $66,$E0,loop 

… 

the branch will be taken if f the most significant f three bits at $66 $ are all ones.

Example 2.17 Write a program to compute the number of elements that are 

divisible by 4 in an array of N 8-bit elements. Use the repeat S until C looping 

construct. t t 

Solution: A number divisible by 4 would have the least significant two bits equal 0s. 

N equ 20 

org $1500 

total ds.b 1 

org $2000 

clr total ; initialize total to 0 

ld ldx # #array ; lload d th the starting t ti address dd of f array tto RReg. X 

ldab #N ; use B as the loop count 

loop brclr 0,x,$03,yes ; if bit-1 & 0 are 0s then branch to yes 

bra chkend ; if the above condition is not met, branch to chkend 

yes iinc ttotal t l ; iincrement t the th total t t l counter t 

chkend inx ; increment the Reg. X, so it points to the next addr. 

dbne b,loop 

forever bra forever 

array db 

end 

23481213192433322018535280829094100102 

2,3,4,8,12,13,19,24,33,32,20,18,53,52,80,82,90,94,100,102

Instructions for Variable Initialization 

• [] CLR opr [] 

where opr is specified using the extended or index 

addressing modes. The specified memory location is 

cleared. 

• [] CLRA [] 

Accumulator A is cleared to 0 

• [] CLRB [] 

Accumulator B is cleared to 0

Shift and Rotate Instructions 

The HCS12 has shift and rotate instructions that apply to a memory 

location, accumulators A, B, and D. A memory operand must be 

specified using the extended or index addressing modes modes. 

There are three 8-bit arithmetic shift left instructions: 

[] asl opr [] -- memory location opr is shifted left one place 

[] asla [] -- accumulator A is shifted left one place 

[] aslb [] -- accumulator B is shifted left one place 

The operation is 

C 

b7 ----------------- b0 

0

The HCS12 has one 16-bit arithmetic shift left instruction: 

[] asld [] 


C b7 ----------------- b0 b7 ----------------- b0 0 

accumulator A accumulator B 

The HCS12 has arithmetic shift right g instructions that apply ppy to a memory y location 

and accumulators A and B. 

[] asr opr [] -- memory location opr is shifted right one place 

[] asra [] -- accumulator A is shifted right one place 

[] asrb [] -- accumulator B is shifted right one place 


b7 ----------------- b0 

C

The HCS12 has logical shift left instructions that apply to a memory 

location and accumulators A and BB. 

[] lsl opr [] -- memory location opr is shifted left one place 

[] lsla [] -- accumulator A is shifted left one place 

[] [ label ] lslb [] [ comment ] -- accumulator B is shifted left one place 


C b7 ----------------- b0 0 

The HCS12 has one 16-bit logical shift left instruction: 

[] lsld [] 


C b7 ----------------- b0 b7 ----------------- b0 0 

accumulator A 

accumulator B

The HCS12 has three logical shift right instructions that apply to 8-bit 

operands operands. 

[] lsr opr [] -- memory location opr is shifted right one place 

[] lsra [] -- accumulator A is shifted right one place 

[] [ label ] lsrb [] [ comment ] -- accumulator B is shifted right one place 


0 

b7 ----------------- b0 

The HCS12 has one 16-bit logical shift right instruction: 

[] lsrd [] 


0 b7 ----------------- b0 b7 ----------------- b0 

accumulator A 

C 

accumulator B 

C

The HCS12 has three rotate left instructions that operate on 9-bit 

operands. 

[] rol opr 

place 

[] -- memory location opr is rotated left one 

[] [ ] rola [] [ ] -- accumulator A is rotated left one place p 

[] rolb [] -- accumulator B is rotated left one place 


b7 ----------------- b0 

The HCS12 has three rotate right instructions that operate on 9-bit 

operands. 

[] [ ] ror opr p 

place 

[] [ ] -- memory y location opr p is rotated right g one 

[] rora [] -- accumulator A is rotated right one place 

[] rorb [] -- accumulator B is rotated right one place 


C b7 ----------------- b0 

C

Example 2.18 Suppose that [A] = $95 and C = 1. Compute the new values of 

A and C after the execution of the instruction asla asla. 

Solution: 

accumulator A 

C flag 

1 0 0 1 0 1 0 1 

1 0 0 1 0 1 0 1 0 

Figure 2.11a Operation of the ASLA instruction 

0 

Original value New value 

[A] = 10010101 [A] = 00101010 

C = 1 

C = 1 

Figure 2.11b Execution result of the ASLA instruction 

Example 219 2.19 S Suppose that m[$800] $800 = $ $ED and C = 00. CCompute 

the new 

values of m[$800] and the C flag after the execution of the instruction asr 

$1000. 

Solution: 

memory location 

$1000 

1 1 1 0 1 1 0 1 

1 1 1 1 0 1 1 0 

1 

C flag 


[$1000] = 11101101 

C = 0 

[$1000] = 11110110 

C = 1 

Figure 2.12a Operation of the ASR $1000 instruction Figure 2.12b Result of the asr $1000 instruction

Example 2.20 Suppose that m[$1000] = $E7 and C = 1. Compute the new 

contents of m[$1000] and the C flag after the execution of the instruction lsr 

$1000 $1000. 

Solution: 1 1 1 0 0 1 1 1 

memory 

location 

$800 

0 

0 1 1 1 0 0 1 1 

Figure 2.13a Operation of the LSR $800 instruction 

1 

C flag Original value New value 

[$800] = 11100111 

[$800] = 01110011 

C = 1 

C = 1 

Figure 2.13b Execution result of LSR $800 

EExample l 2.21 2 21 SSuppose that h [B] = $BD and d C = 11. CCompute the h new values l of f 

B and the C flag after the execution of the instruction rolb. 

Solution: 

accumulator B 

1 0 1 1 1 1 0 1 

0 1 1 1 1 0 1 1 1 

Figure 2.14a Operation of the instruction ROLB 

1 

C flag 


[B] = 10111101 

C = 1 

[B] = 01111011 

C = 1 

Figure 14b. Execution result of ROLB

Example 2.22 Suppose that [A] = $BE and C = 1. Compute the new 

values l of f mem[$00] [$00] after ft the th execution ti of f the th instruction i t ti rora. 

Solution: 

C flag 

1 1 0 1 1 1 1 1 0 

0 1 1 0 1 1 1 1 1 accumulator A 

Figure 2.15a Operation of the instruction rora 


[A] = 10111110 

C = 1 

[A] = 11011111 

C = 0 

Figure 2.15b Execution result of rora

Example 2.23 Write a program to count the number of 0s in the 16-bit 

number stored at $1500-$1501 and save the result in $1505. 

Solution: 

* The 16-bit number is shifted to the right 16 time. 

* If the bit shifted out is a 0 then increment the 0s count by 1. 

org $1500 

db $23 $23,$55 $55 ; test data 

org $1505 

zero_cnt rmb 1 

lp_cnt rmb 1 

org $2000 

clr zero_cnt ; initialize the 0s count to 0 

ldaa #16 

staa lp_cnt 

ldd $1500 ; place the number in D 

loop lsrd ; shift the lsb of D to the C flag 

bcs chkend ; is the C flag a 0? 

inc zero_cnt ; increment 1s count if the lsb is a 1 

chkend dec lp lp_cnt cnt ; check to see if D is already 0 

bne loop 

forever bra 

end 

forever

Shift a Multi-byte Number (1 of 4) 

• For shifting right 

– The bit 7 of each byte will receive the bit 0 of its immediate left 

byte with the exception of the most significant byte which will 

receive a 0. 

– Each byte will be shifted to the right by 1 bit. The bit 0 of the 

least significant g byte y will be lost. 

• Suppose there is a k-byte number that is stored at loc to 

loc+k-1. 

– Method for shifting right 

• Step 1: Shift the byte at loc to the right one place. 

• Step 2: Rotate the byte at loc+1 to the right one place. 

• Step 3: Repeat Step 2 for the remaining bytes.


• For shifting left 

– The bit 0 of each byte will receive the bit 7 of its immediate right 

byte with the exception of the least significant byte which will 

receive a 0. 

– Each byte will be shifted to the left by 1 bit. The bit 7 of the most 

significant g byte y will be lost. 

• Suppose there is a k-byte number that is stored at loc to 

loc+k-1. 

– Method for shifting left 

• Step 1: Shift the byte at loc+k-1 to the left one place. 

• Step 2: Rotate the byte at loc+K-2 to the left one place. 

• Step 3: Repeat Step 2 for the remaining bytes.


Example 2.24 Write a program to shift the 32-bit number stored at 

$1520-$1523 to the right four places. 

Solution: 

ldab #4 ; set up the loop count 

ldx #$1520 ; use X as the pointer to the left most byte 

again lsr 0,X ; logical shift right the MSB, bit 0 moves to C flag 

ror 1,X ; rotate right with the C bit 



dbne 

end 

b,again

Shift a Multi-byte Number (4 of 4)

• Changing a few 

bits are often 

done in I/O 

applications. 

• Boolean logic 

operation can 

be used to 

change h a ffew 

I/O port pins 

easily. 

Boolean Logic Instructions (1 of 4)

Boolean Logic Instructions (2 of 4) 

• The AND function can be used to clear bits. 

• 

• Example: 

Clears the upper four pins of the I/O or Input/Output port located 

at $56. $0056 is for one of I/O ports in 9S12. 

ldaa $56 ; A


The OR function can be used to set bits (change from 0 to 1 and 

from a 1 to 1) 

Note: X+1= X + 1 1 set bit) X+0= X + 0 X (no 

change) 

Example: p 

Set the upper three pins of the I/O or Input/Output port located at 

$56. 

ldaa $56 ; A


The EOR function can be used to toggle bits (change from 0 to 1 

and from a 1 to 0) 

Note: 0 ⊕ 0 = 0 ; 0 ⊕ 1 = 1 

1 ⊕ 0 = 1 ; 1 ⊕ 1 = 0 

Example: 

Toggle the lower four bits of the I/O or Input/Output port located at 

$56 or $0056 

ldaa $56 ;A

Program Execution Time (1 of 2) 

• The HCS12 uses the E clock as a timing reference. 

• The frequency of the E clock is half of that of the crystal oscillator. 

• There are many applications that require the generation of time 

delays. 

• The creation of a time delay involves two steps: 

– Select a sequence of instructions that takes a certain amount of time to 

execute. 

– Repeat the selected instruction sequence for an appropriate number of 

times. 

• FFor example, l the th instruction i t ti sequence on th the next t page takes t k 40 E cycles l tto 

execute. By repeating this instruction sequence a certain number of times, 

any time delay can be created. 

– Assume the bus clock frequency is 24 MHz, each cycle = 41.67 ns 

– Therefore, the instruction sequence on the next page will take 5 μs to 

execute. (35+1+1+3)×41.67 ns = 40 ×41.67 ns = 1.7 μs

Program Execution Time (2 of 2) 

For example, p the instruction sequence q below takes 40 E cycles y to execute. 

Assume the bus clock frequency is 24 MHz, each cycle = 

Therefore, the instruction sequence will take 

loop psha ; 2 E cycles 

pula ; 3 E cycles 

psha ; 2 E cycles 






nop ; 1 E cycle 

dbne x,loop ; 3 E cycles 

24 24 MHz = 1 μs 

1 24 MHz ≈ 41.67ns

Example 2.25 Write a program loop to create a delay of 1 ms = 1000 ×1 μs. 

Solution: A delay of 1 ms can be created by repeating the previous loop 1000 times. 

The following instruction sequence creates a delay of 1 ms. 

ldx #1000 ; 2 E cycles 

loop psha ; 2 E cycles 




psha ; 2 E cycles 21 E cycles 

pula ; 3 E cycles 24 E cycles 



nop ; 1 E cycle 

dbne x, loop ; 3 E cycles 

Note: The 2 E cycles for the ldx #1000 is insignificant. 

1 1 

⎡⎣2+ 1000× ( 21+ 3) ⎤⎦× 

= [ 2+ 1000× 24] × ≈1ms 

24MHz 24MHz

Example: p Write an instruction 

ldab #100 ; 1 E cycle 

sequence to create a delay of 1 second. out_loop 

in_loop 

ldx 

psha 

#10000 ; 2 E cycles 

; 2 E cycles 

Solution: By repeating the previous 

pula 

psha 

; 3 E cycles 

; 2 E cycles 

instruction sequence 100 times times, we can 


create a delay of 1 second. 

psha 

pula 

; 2 E cycles 

; 3 E cycles 

1 

{1+ 100× ⎡⎣2+ 10000 × ( 21+ 3) + 3 ⎤⎦} 

× ≈1s 

24MHz 

psha 

pula 

nop 

; 2 E cycles 

; 3 E cycles 

; 1 E cycle 

dbne x, in_loop ; 3 E cycles 

dbne b, out_loop ; 3 E cycles 

1E cycles for 

ldab #100 

2E cycles for 

ldx #10000 

3E cycles for 

dbne x, in_loop 

Note: # of E cycles for one iteration of 

th the out_loop t l = [2 [2+10000×(21+3)+3] 

10000 (21 3) 3] 

3E cycles for 

dbne b, out_loop

Chapter 2 HCS12 Assembly Programming

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?