Chapter 2 HCS12 Assembly Programming

1
Chapter 2HCS12 Assembly Programming
2
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 output 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

3
Fields of a HCS12 Instruction

• Label field
• Optional
• Starts with a letter and followed 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 from
  the operation field by at least one space
• Contains operands for instructions or arguments
  for assembler directives
• Comment field
• Any line starts with an or is a comment
• Separated from the operand and operation field
  for at least one space
• Optional

4
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 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 is a comment
5
Assembler Directives

• END
• Ends a program to be processed by an assembler
• Any statement following the END directive is
  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 1000
• LDAB FF
• places the opcode byte for the instruction LDAB
  FF at location 1000.

6
dc.b (define constant byte) 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 800 array dc.b
11,22,33,44 dc.w (define constant word) dw
(define word) fdb (form double bytes) - 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 123
4, abc-20
7
fcc (form constant character)

• Used to define a string of characters (a message)
• The first character (and the last character) is
  used as the delimiter.
• 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.
• Each character is represented by its ASCII code.
• Example
• msg fcc Please enter 1, 2 or 3

8
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 (reserve memory
byte) ds.b (define storage bytes) - Each of these
directives reserves a number of bytes given as
the arguments to the directive. - Example b
uffer ds 100 reserves 100 bytes
9
ds.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 ones program
more readable. - Examples arr_cnt equ
100 oc_cnt equ 50
10

• 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, one
  can write program segments like the
• following example, without thinking up new
  labels
• loc loc
• ldaa 2 ldaa 2
• loop deca same as loop001 deca
• bne loop bne loop001
• loc loc
• loop brclr 0,x,55,loop loop002 brclr
  0,x,55,loop002

11

• Macro
• A name assigned to a group of instructions
• Use macro and endm to define a macro.
• Example of macro
• sumOf3 macro arg1,arg2,arg3
• ldaa arg1
• adda arg2
• adda arg3
• endm
• Invoke a defined macro write down the name and
  the arguments of the macro
• sumOf3 1000,1001,1002
• is replaced by
• ldaa 1000
• adda 1001
• adda 1002

12
Software Development Process

• Problem definition Identify what should be done.
• Develop the algorithm.
• Algorithm is the overall plan for solving the
  problem at 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. Convert the algorithm or flowchart
  into programs.
• Program testing
• Program maintenance

13
Symbols of Flowchart
14
Programs to Do Simple Arithmetic (1 of 5)
Example 2.4 Write a program to add the values of
memory locations at 1000, 1001, and 1002, and
save the result at 1100. Solution Step 1 A ?
m1000 Step 2 A ? A m1001 Step 3 A ? A
m1002 Step 4 802 ? A org 1500 ldaa 1000 a
dda 1501 adda 1002 staa 1100 end
15
Programs to Do Simple Arithmetic (2 of 5)
Example 2.4 Write a program to subtract the
contents of the memory location at 1005 from the
sum of the memory locations at 1000 and 1002,
and store the difference at 1100. Solution
org 1500 ldaa 1000 adda 1002 suba
1005 staa 1000 end
16
Programs to Do Simple Arithmetic (3 of 5)
Example 2.6 Write a program to add two 16-bit
numbers that are stored at 1000-1001 and
1002-1003 and store the sum at
1100-1101. Solution org 1500 ldd
1000 addd 1002 std 1100 end The Carry
Flag - bit 0 of the CCR register - set to 1
when the addition operation produces a carry 1 -
set to 1 when the subtraction operation produces
a borrow 1 - enables the user to implement
multi-precision arithmetic
17
Programs to Do Simple Arithmetic (4 of 5)
Example 2.7 Write a program to add two 4-byte
numbers that are stored at 1000-1003 and
1004-1007, and store the sum at
1010-1013. Solution Addition starts from the
LSB and proceeds toward MSB. org 1500 ldd 1
002 add and save the least significant two
bytes addd 1006 std 1012 ldaa 10
01 add and save the second most significant
bytes adca 1005 staa 1011 ldaa
1000 add and save the most significant
bytes adca 1004 staa 1010 end
18
Programs to Do Simple Arithmetic (5 of 5)
Example 2.8 Write a program to subtract the hex
number stored at 1004-1007 from the the hex
number stored at 1000-1003 and save the result
at 1100-1103. Solution The subtraction starts
from the LSBs and proceeds toward the
MSBs. org 1500 ldd 1002 subtract and save the
least significant two bytes subd 1006 std 11
02 ldaa 1001 subtract and save the
difference of the second to most sbca 1005
significant bytes staa 1001 ldaa 1000
subtract and save the difference of the most
significant sbca 1004 bytes staa 1100 end
19
BCD Numbers and Addition

• Each digit is encoded by 4 bits.
• Two digits are packed into one byte
• The addition of two BCD numbers is performed by
  binary addition and an adjust operation using the
  DAA instruction.
• The instruction DAA can be applied after the
  instructions ADDA, ADCA, and ABA.
• Simplifies I/O conversion
• For example, the instruction sequence
• LDAA 1000
• ADDA 1001
• DAA
• STAA 1002
• adds the BCD numbers stored at 1000 and 1001
  and saves the sum at 1002.

20
Multiplication and Division (1 of 2)
21
Multiplication and Division (2 of 2)
Example 2.10 Write an instruction sequence to
multiply the 16-bit numbers stored at 1000-1001
and 1002-1003 and store the product at
1100-1103. Solution ldd 1000 ldy 1002 emul
sty 1100 std 1102 Example 2.11 Write an
instruction sequence to divide the 16-bit number
stored at 1020-1021 into the 16-bit number
stored at 1005-1006 and store the quotient and
remainder at 1100 and 1102, respectively. Soluti
on ldd 1005 ldx 1020 idiv stx 1100
store the quotient std 1102 store the
remainder
22
Illustration of 32-bit by 32-bit Multiplication

• Two 32-bit numbers M and N are divided into two
  16-bit halves
• M MHML
• N NHNL

23
Example 2.12 Write a program to multiply two
unsigned 32-bit numbers stored at MM3 and
NN3, respectively and store the product at
PP7. Solution org 1000 M ds.b 4 N ds.b 4 P ds
.b 8 org 1500 ldd M2 ldy N2 emul
compute MLNL sty P4 std P6 ldd M ldy N emul
compute MHNH sty P std P2 ldd M ldy N2
emul compute MHNL
24
add MHNL to memory locations P2P5 addd P4
std P4 tfr Y,D adcb P3 stab P3 adca P2 st
aa P2 propagate carry to the most significant
byte ldaa P1 adca 0 add carry to the
location at P1 staa P1 ldaa P add carry
to the location at P adca 0 staa P
compute MLNH ldd M2 ldy N emul
25
add MLNH to memory locations P2
P5 addd P4 std P4 tfr Y,D adcb P3 stab P
3 adca P2 staa P2 propagate carry to the
most significant byte clra adca P1 staa P1 l
daa P adca 0 staa P end
26
Example 2.13 Write a program to convert the
16-bit number stored at 1000-1001 to BCD format
and store the result at 1010-1014. Convert
each BCD digit into its ASCII code and store it
in one byte. Solution - A binary number can be
converted to BCD format by using repeated
division by 10. - The largest 16-bit binary
number is 65535 which has five decimal
digits. - The first division by 10 generates the
least significant digit, the second division by
10 obtains the second least significant digit,
and so on. org 1000 data dc.w 12345 data to
be tested org 1010 result ds.b 5 reserve
bytes to store the result org 1500 ldd data
ldy result ldx 10 idiv addb 30
convert the digit into ASCII code stab 4,Y
save the least significant digit xgdx ldx 10
27

idiv adcb 30 stab 3,Y save the second to
least significant digit xgdx ldx 10 idiv ad
db 30 stab 2,Y save the middle
digit xgdx ldx 10 idiv addb 30 stab 1,Y
save the second most significant
digit xgdx addb 30 stab 0,Y save the most
significant digit end
28
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
  downto n1 do statement S
• While C do statement 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.

29
(No Transcript)
30
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

31
(No Transcript)
32
(No Transcript)
33
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.

34
Loop Primitive Instructions

• HCS12 provides a group of instructions that
  either decrement or increment a loop count to
  determine if the looping should be continued.
• The range of the branch is from 80 (-128) to 7F
  (127).

35
Example 2.14 Write a program to add an array of N
8-bit numbers and store the sum at memory
locations 10001001. Use the For i n1 to n2
do looping construct. Solution
N equ 20 org 1000 sum rmb 2 i rmb 1 org 1500
ldaa 0 staa i staa sum sum ? 0 staa
sum1 loop ldab i cmpb N is i
N? beq done ldx array abx ldab 0,X sum ?
sum arrayi ldy sum aby sty sum
36
inc i increment the loop count by
1 bra loop done swi array dc.b 1,2,3,4,5,6,7,8,9,
10,11,12,13,14,15,16,17,18,19,20 end 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. Solution
37

38
N equ 20 org 1000 max_val ds.b 1 org 1500 lda
a array set array0 as the temporary max
max staa max_val ldx arrayN-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_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 20,54,64,74,29,33,41,45 end
39
Bit Condition Branch Instructions
ltlabelgt brclr (opr),(msk),(rel)
ltcommentgt ltlabelgt brset (opr),(msk),(rel)
ltcommentgt 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
brclr 66,e0,loop the branch will be
taken if the most significant three bits at 66
are all ones.
40
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. Solution A number divisible
by 4 would have the least significant two bits
equal 0s. N equ 20 org 1000 total ds.b 1 org
1500 clr total initialize total to
0 ldx array ldab N use B as the loop
count loop brclr 0,x,03,yes check bits 1 and
0 bra chkend yes inc total chkend inx dbne b,loo
p forever bra forever array db 2,3,4,8,12,13,19,2
4,33,32,20,18,53,52,80,82,90,94,100,102 end
41
Instructions for Variable Initialization

• ltlabelgt CLR opr ltcommentgtwhere opr is
  specified using the extended or index addressing
  modes. The specified memory location is cleared.
• ltlabelgt CLRA ltcommentgtAccumulator A is
  cleared to 0
• ltlabelgt CLRB ltcommentgtAccumulator B is
  cleared to 0

42
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. There
are three 8-bit arithmetic shift left
instructions ltlabelgt asl opr
ltcommentgt -- memory location opr is shifted
left one place ltlabelgt asla ltcommentgt --
accumulator A is shifted left one
place ltlabelgt aslb ltcommentgt -- accumulator B
is shifted left one place The operation is
43
The HCS12 has one 16-bit arithmetic shift left
instruction ltlabelgt asld ltcommentgt The
operation is
The HCS12 has arithmetic shift right instructions
that apply to a memory location and accumulators
A and B. ltlabelgt asr opr ltcommentgt --
memory location opr is shifted right one place
ltlabelgt asra ltcommentgt -- accumulator A is
shifted right one place ltlabelgt asrb ltcommentgt
-- accumulator B is shifted right one place The
operation is
44
The HCS12 has logical shift left instructions
that apply to a memory location and accumulators
A and B. ltlabelgt lsl opr ltcommentgt --
memory location opr is shifted left one place
ltlabelgt lsla ltcommentgt -- accumulator A is
shifted left one place ltlabelgt lslb ltcommentgt
-- accumulator B is shifted left one place The
operation is
The HCS12 has one 16-bit logical shift left
instruction ltlabelgt lsld ltcommentgt The
operation is
45
The HCS12 has three logical shift right
instructions that apply to 8-bit
operands. ltlabelgt lsr opr ltcommentgt --
memory location opr is shifted right one place
ltlabelgt lsra ltcommentgt -- accumulator A is
shifted right one place ltlabelgt lsrb ltcommentgt
-- accumulator B is shifted right one place The
operation is
The HCS12 has one 16-bit logical shift right
instruction ltlabelgt lsrd ltcommentgt The
operation is
46
The HCS12 has three rotate left instructions that
operate on 9-bit operands. ltlabelgt rol
opr ltcommentgt -- memory location opr is rotated
left one place ltlabelgt rola ltcommentgt --
accumulator A is rotated left one
place ltlabelgt rolb ltcommentgt -- accumulator B
is rotated left one place The operation is
The HCS12 has three rotate right instructions
that operate on 9-bit operands. ltlabelgt ror
opr ltcommentgt -- memory location opr is rotated
right one place ltlabelgt rora ltcommentgt --
accumulator A is rotated right one
place ltlabelgt rorb ltcommentgt -- accumulator B
is rotated right one place The operation is
47
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. Solution
Example 2.19 Suppose that m800 ED and C
0. Compute the new values of m800 and the C
flag after the execution of the instruction asr
1000. Solution
48
Example 2.20 Suppose that m1000 E7 and C
1. Compute the new contents of m1000 and the
C flag after the execution of the instruction lsr
1000. Solution
Example 2.21 Suppose that B BD and C 1.
Compute the new values of B and the C flag after
the execution of the instruction rolb. Solution
49
Example 2.22 Suppose that A BE and C 1.
Compute the new values of mem00 after the
execution of the instruction rora. Solution
50
Example 2.23 Write a program to count the number
of 0s in the 16-bit number stored at 1000-1001
and save the result in 1005. 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 1000 db 23,55 test
data org 1005 zero_cnt rmb 1 lp_cnt rmb 1 org
1500 clr zero_cnt initialize the 0s count to
0 ldaa 16 staa lp_cnt ldd 1000 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_cnt check to see if D is
already 0 bne loop forever bra forever end
51
Shift a Multi-byte Number (1 of 3)

• 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 byte will be
  lost.
• Suppose there is a k-byte number that is stored
  at loc to lock-1.
• Method for shifting right
• Step 1 Shift the byte at loc to the right one
  place.
• Step 2 Rotate the byte at loc1 to the right one
  place.
• Step 3 Repeat Step 2 for the remaining bytes.

52
Shift a Multi-byte Number (2 of 3)

• 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 byte will be
  lost.
• Suppose there is a k-byte number that is stored
  at loc to lock-1.
• Method for shifting left
• Step 1 Shift the byte at lock-1 to the left
  one place.
• Step 2 Rotate the byte at locK-2 to the left
  one place.
• Step 3 Repeat Step 2 for the remaining bytes.

53
Shift a Multi-byte Number (3 of 3)
Example 2.24 Write a program to shift the 32-bit
number stored at 820-823 to the right four
places. Solution ldab 4 set up the loop
count ldx 820 use X as the pointer to the
left most byte again lsr 0,X ror 1,X ror 2,X ro
r 3,X dbne b,again end
54
Boolean Logic Instructions

• Changing a few bits are often done in I/O
  applications.
• Boolean logic operation can be used to change a
  few I/O port pins easily.

55
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.
• For example, the instruction sequence on the next
  page takes 40 E cycles to execute. By repeating
  this instruction sequence a certain number of
  times, any time delay can be created.
• Assume that the HCS12 runs under a crystal
  oscillator with a frequency of 16 MHz, then the E
  frequency is 8 MHz and, hence, its clock period
  is 125 ns.
• Therefore, the instruction sequence on the next
  page will take 5 ms to execute.

56
Program Execution Time (2 of 2)
loop psha 2 E cycles pula 3 E
cycles psha pula psha pula psha pula
psha pula psha pula psha pula nop
1 E cycle nop 1 E cycle dbne x,loop 3 E
cycles
57
Example 2.25 Write a program loop to create a
delay of 100 ms. Solution A delay of 100 ms
can be created by repeating the previous loop
20,000 times. The following instruction sequence
creates a delay of 100 ms. ldx 20000 loop psha
2 E cycles pula 3 E cycles psha pula psha
pula psha pula psha pula psha pula psha
pula nop 1 E cycle nop 1 E
cycle dbne x,loop 3 E cycles
58
ldab 100 out_loop ldx 20000 in_loop psha 2
E cycles pula 3 E cycles psha pula psha pu
la psha pula psha pula psha pula psha pula
nop 1 E cycle nop 1 E cycle dbne x,in_lo
op 3 E cycles dbne b,out_loop 3 E cycles
Example 2.26 Write an instruction sequence to
create a delay of 10 seconds. Solution By
repeating the previous instruction sequence 100
times, we can create a delay of 10 seconds.