The 68HC11 Microcontroller
Chapter 2: 68HC11 Assembly Programming
The 68HC11 Microcontroller
H. Huang Transparency No.2-1
The 68HC11 Microcontroller
Assembly Program
(1) * Data storage declaration section
(2)
ORG $00
(3) i
RMB 1
; variable i
(4) j
RMB 1
; variable j
(5) k
RMB 1
; variable k
(6) * program instruction section
(7) start ORG $C000
; starting address of program
(8)
LDAA #75
(9)
STAA i
; initialize i to 75
(10)
LDAA #10
(11)
STAA j
; initialize j to 10
(12)
ADDA i
; compute i + j
(13)
SUBA #6
; compute i + j -6
(14)
STAA k
; store i + j - 6 to k
(15)
END
H. Huang Transparency No.2-2
The 68HC11 Microcontroller
Global View of a 68HC11 Assembly Program
1. Assembler Directives
-
define data and symbol
reserve and initialize memory locations
set assembler and linking condition
specify output format
etc.
2. Assembly Language Instructions
3. END directive
-
last statement of a program
any statement after END will be ignored
4. Comments
-
explain the function of a single or a group of instructions
H. Huang Transparency No.2-3
The 68HC11 Microcontroller
Fields of a 68HC11 Instruction
1.
-
Label field
is optional
starts with a letter and followed by letters, digits, or special symbols (_ or .)
can start from any column if ended with “:” (not true for Motorola freeware as11)
must start from column 1 if not ended with “:”
2. Operation field
- contains the mnemonic of a machine instruction or a directive
- is separated from the label by at least one space
3. 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
4. Comment field
- a whole line comment starts with a *
- is separated from the operand and operation field for at least one space
H. Huang Transparency No.2-4
The 68HC11 Microcontroller
Identify the Four Fields of an Instruction
Example 2.3
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
H. Huang Transparency No.2-5
The 68HC11 Microcontroller
Assembler Directives -- a sample
1.
-
END
ends a program to be processed by an assembler
any statement following the END directive is ignored
not supported by the Motorola freeware as11
2. ORG
- sets a new value for the location counter of the assembler
- tells the assembler where to put the next byte it generates after the ORG directive
The sequence
ORG $C000
LDAB #$FF
will put the opcode byte for the instruction LDAB #$FF at location $C000.
3. RMB -- reserve memory bytes
- reserve memory bytes without initialization
- syntax is
[<label>] RMB <expression> [<comment>]
The statement
buffer RMB 100
allocates 100 bytes for data and can be referred to by the label “buffer”.
H. Huang Transparency No.2-6
The 68HC11 Microcontroller
BSZ -- block storage of zeros
- causes the assembler to allocate a block of bytes that are initialized to zeros
- syntax is
[<label>] BSZ <expression> [<comment>]
The statement
buffer
BSZ 80
reserves a block of 80 bytes and their value are initialized to 0.
FCB -- form constant byte
- reserves as many bytes as the number of arguments in the directive
- each argument specifies the initial value of the corresponding byte
- syntax is
[<label>] FCB [<expression>][,<expression>,...,<expression>][<comment>]
The statement
ABC
FCB
$11,$22,$33
reserves three consecutive memory bytes and initializes their values to $11, $22, and $33.
H. Huang Transparency No.2-7
The 68HC11 Microcontroller
FDB -- form double byte
- reserves 2 bytes for each argument of the directive
- each argument specifies the initial value of the corresponding double bytes
- syntax is
[<label>]
FDB [<expression>][,<expression>,...,<expression>] [comment>]
The directive
ABC
FDB $11,$22,$33
will initialize 6 consecutive bytes in memory to $00 $11 $00 $22 $00 $33
FCC -- form constant character
- generates ASCII code bytes for the letters in the arguments
- syntax is
[label]
FCC “<string>“ [<comment>]
The directive
ALPHA
FCC “DEF”
will generate the values $44 $45 $46 in memory
H. Huang Transparency No.2-8
The 68HC11 Microcontroller
DCB -- define constant block
- reserve an area of memory and initialize each byte to the same constant value
- syntax is
[label] DCB <length>,<value>
- not supported by the Motorola freeware as11
The directive
space
DCB 80,$20
will generate a line of 80 space characters.
FILL -- fill a block of constant values
- serve as the same purpose as does the DCB directive
- syntax
[<label>] FILL <value>,<length>
The directive
ones
FILL 1,40
will force the freeware assembler to fill each of the 40 memory locations with a 1.
H. Huang Transparency No.2-9
The 68HC11 Microcontroller
EQU -- equate
- allows the user to use a symbolic name in place of a number
- syntax is
<label>
EQU
<expression> [<comment>]
The directive
ROM EQU
$E000
tells the assembler that wherever ROM appears in the program, the value $E000
is to be substituted.
H. Huang Transparency No.2-10
The 68HC11 Microcontroller
Flowchart
- is a form of program documentation
- is a tool for developing program logic flow
Symbols of Flowchart
Terminal
A
Process
Subroutine
Input or
output
Decision
no
B
Off-page connector
yes
A
On-page
connector
H. Huang Transparency No.2-11
The 68HC11 Microcontroller
Procedure of Using Computer in Solving the Problem
start
analyze the problem
Express the solution to the
problem using flowchart or
other method
Convert the flowchart into
source code
Compile or assemble to
generate machine code
Refine the solution
Place the executable code
in the computer
Run the program and
evaluate the result
No
Is the result
satisfactory?
Yes
Stop
H. Huang Transparency No.2-12
The 68HC11 Microcontroller
Programs to do simple arithmetic
Example 2.4 Write a program to add the values of memory locations at $00, $01, and $02, and
save the result at $03.
LDAA
ADDA
ADDA
STAA
$00
$01
$02
$03
; load the contents of memory location at $00 into A
; add the contents of memory location at $01 to A
; add the contents of memory location at $02 to A
; save the result at memory location at $03
Example 2.5 Write a program to subtract 6 from three 8-bit numbers stored at $00, $01, and
$02 respectively.
LDAA
SUBA
STAA
LDAA
SUBA
STAA
LDAA
SUBA
STAA
$00
#06
$00
$01
#06
$01
$02
#06
$02
; load the first number into A
; subtract 6 from the first number
; store the decremented value back to $00
; load the second number into A
; subtract 6 from the second number
; store the decremented value back to $01
; load the third number into A
; subtract 6 from the third number
; store the decremented value back to $02
H. Huang Transparency No.2-13
The 68HC11 Microcontroller
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
Example 2.6 Write a program to add the 3-byte numbers stored at $00-$02 and
$03-$05 and save the result at $06-$08.
Solution: The addition starts from the least significant byte.
LDAA $02
ADDA $05
STAA $08
LDAA $01
ADCA $04
STAA $07
LDAA $00
ADCA $03
STAA $06
; add the LSBs
; “
; “
; add the middle bytes
; “
; “
; add the MSBs
; “
; “
H. Huang Transparency No.2-14
The 68HC11 Microcontroller
Example 2.7 Write a program to subtract the 3-byte number stored at $03-$05
from the 3-byte number stored at $00-$02 and save the result at $10-$12.
Solution: The subtraction starts from the LSBs.
LDAA
SUBA
STAA
LDAA
SUBA
STAA
LDAA
SUBA
STAA
$02
$05
$12
$01
$04
$11
$00
$03
$10
; subtract the LSBs
; “
; “
; subtract the middle bytes
; “
; “
; subtract the MSBs
; “
; “
H. Huang Transparency No.2-15
The 68HC11 Microcontroller
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
ADDA
DAA
STAA
$00
$01
$02
adds the BCD numbers stored at $00 and $01 and saves the sum at $02.
H. Huang Transparency No.2-16
The 68HC11 Microcontroller
Program Loops
Types of program loops: finite and infinite loops
Looping mechanisms:
1.
DO statement S forever
2.
FOR i = n1 to n2 DO statement S or FOR i = n2 downto n1 DO statement S
3.
WHILE C DO statement S
4.
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.
H. Huang Transparency No.2-17
The 68HC11 Microcontroller
Condition Code Register
S
-
C:
V:
Z:
N:
H:
X
H
I
N
Z
V
C
carry flag
overflow flag
zero flag
negative flag
half carry flag
Conditional Branch Instruction
[<label>]
Bcc rel
[<comment>]
where cc is a condition code listed in Table 2.1.
Unconditional Branch Instruction
[<label>]
BRA rel
[<comment>]
H. Huang Transparency No.2-18
The 68HC11 Microcontroller
Table 2.1 Branch Condition Codes
Condition code
CC
CS
EQ
GE
GT
HI
HS
LE
LO
LS
LT
MI
NE
PL
VC
VS
Meaning
carry clear
carry set
equal to 0
greater than or equal to 0 (signed comparison)
greater than 0 (signed comparison)
higher (unsigned comparison)
higher or same (unsigned comparison)
less than or equal to 0
lower (unsigned comparison)
lower or same (unsigned comparison)
less than 0 (signed comparison)
minus (signed comparison)
not equal to 0
plus (signed comparison)
overflow bit clear
overflow bit set
H. Huang Transparency No.2-19
The 68HC11 Microcontroller
Conditional Branch Instructions that check only one condition flag
-
C flag:
-
Z flag
-
N flag
-
V flag
BCC
BCS
BLO
BHS
BEQ
BNE
BPL
BMI
BVS
BVC
branch if C flag is 0
branch if C flag is 1
branch if C flag is 1
branch if C flag is 0
branch if Z flag is 1
branch if Z flag is 0
branch if N flag is 0
branch if N flag is 1
branch if V flag is 1
branch if V flag is 0
Conditional Branch Instructions that check more than one condition flag
-
BGE
BGT
BHI
BLE
BLS
BLT
branch if (N V) = 0
branch if (Z + (N V)) = 0
branch if (C + Z) = 0
branch if (Z + (N V)) = 1
branch if (C + Z) = 1
branch if (N V) = 1
H. Huang Transparency No.2-20
The 68HC11 Microcontroller
Decrementing and Incrementing Instructions
-
DECA:
DECB:
DEC opr:
DES:
DEX:
DEY:
INCA:
INCB:
INC opr:
INS:
INX:
INY:
A  [A] - 1
B  [B] - 1
mem[opr]  [mem[opr]] - 1
SP  [SP] - 1
X  [X] - 1
Y  [Y] - 1
A A]+1
B B] +1
mem[opr] [mem[opr]] + 1
SP  [SP] + 1
X  [X] + 1
Y  [Y] + 1
Note 1. Incrementing and decrementing instructions can be used to update the loop
indices.
Note 2. The memory operand opr is specified in either extended or index addressing mode.
H. Huang Transparency No.2-21
The 68HC11 Microcontroller
Example 2.15 Write a program to compute 1 + 2 + ... + 20 and save the sum at $00.
Solution:
Start
i =0
sum = 0
* The following program use accumulator B as the loop index
* i and A as the sum.
N
i=i+1
sum = sum + i
no
i = 20 ?
yes
Stop
again
equ 20
ldab #0 ; initialize loop index i to 0
ldaa #0 ; initialize sum to 0
incb
; increment i
aba
; add i to sum
cmpb #20 ; compare i with the upper limit
bne again ; continue if i is less than 20
staa $00 ; save the sum
end
H. Huang Transparency No.2-22
The 68HC11 Microcontroller
Example 2.16 Write a program to find the largest number from an array of 20
8-bit numbers. The array is stored at $00-$13. Save the result at $20.
Solution:
Start
array max  array [0]
i1
ii+1
array max < array [i] ?
yes
array max  array [i]
no
no
i = array count - 1?
yes
Stop
H. Huang Transparency No.2-23
The 68HC11 Microcontroller
* The following program uses A to hold the temporary array max and uses B
* as the loop index.
N
array
loop
chkend
exit
equ
org
fcb
20
$00
....
; array count
ldaa
ldab
ldx
abx
cmpa
bhs
ldaa
cmpb
beq
incb
bra
staa
end
array
#1
#array
; set array[0] as the temporary array max
; initialize loop index to 1
; point X to array[0]
; compute the address of array[i]
; compare temp. array max to the next element
; do we need to update the temporary array max?
; update the temporary array max
; compare loop index with loop limit
; is the whole array checked yet?
; increment loop index
0,X
chkend
0,X
#N-1
exit
loop
$20
; array
; save the array max
H. Huang Transparency No.2-24
The 68HC11 Microcontroller
Compare Instructions
-
are executed to set the condition flags of the CCR register
are often used to implement the program loop
Table 2.2 68HC11 Compare Instructions
Instruction format
[<label>]
[<label>]
[<label>]
[<label>]
[<label>]
[<label>]
[<label>]
[<label>]
[<label>]
CBA
CMPA opr
CMPB opr
CPD opr
CPX opr
CPY opr
TST opr
TSTA
TSTB
[<comment>]
[<comment>]
[<comment>]
[<comment>]
[<comment>]
[<comment>]
[<comment>]
[<comment>]
[<comment>]
compare A to B
compare A to a memory location or value
compare B to a memory location or value
compare D to a memory location or value
compare X to a memory location or value
compare Y to a memory location or value
test a memory location for negative or zero
test A for negative or zero
test B for negative or zero
opr is specified in one of the following addressing modes:
- EXT
- INDX
- INDY
- IMM
(not applicable to “TST opr”)
- DIR
(not applicable to “TST opr”)
H. Huang Transparency No.2-25
The 68HC11 Microcontroller
Special Conditional Branch Instructions
[<label>] BRCLR (opr) (msk) (rel) [<comment>]
[<label>] BRSET (opr) (msk) (rel) [<comment>]
where
opr specifies the memory location to be checked and must be specified using either
the direct 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 relative mode.
For example, the sequence
here
ldx #$1000
brclr $30,X %10000000 here
ldaa $31,X
will force the 68HC11 continue to execute the second instruction until the bit 7 is set to 1.
H. Huang Transparency No.2-26
The 68HC11 Microcontroller
Example 2.17 Write a program to compute the sum of the odd numbers in an array
with 20 8-bit elements. The array is stored at $00-$13. Save the sum at
$20-$21.
Solution:
Start
sum 0
ptr  0
bit 0 of mem[ptr] = 0?
no
sum  sum + [mem[ptr]]
ptr  ptr + 1
no
ptr = $13?
yes
Stop
H. Huang Transparency No.2-27
The 68HC11 Microcontroller
* The index register X is used as the pointer to the array element.
N
sum
loop
chkend
exit
equ
org
rmb
$13
$20
2
org
ldaa
staa
staa
ldx
brclr
ldd
addb
adca
std
cpx
bhs
inx
bra
end
$C000
#$00
sum
; initialize sum to 0
sum+1
;
“
#$00
; point X to array[0]
0,X $01 chkend ; is it an odd number?
sum
; add the odd number to the sum
0,X
;
“
#0
;
“
sum
;
“
#N
; compare the pointer to the address of the last element
exit
; is this the end?
loop
; not yet done, continue
H. Huang Transparency No.2-28
The 68HC11 Microcontroller
Instructions for Variable Initialization
1. [<label>] CLR
opr [<comment>]
where opr is specified using the extended or index addressing mode. The
specified memory location is cleared.
2. [<label>] CLRA [<comment>]
Accumulator A is cleared to 0
3. [<label>] CLRB [<comment>]
Accumulator B is cleared to 0
H. Huang Transparency No.2-29
The 68HC11 Microcontroller
Shift and Rotate Instructions
The 68HC11 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 mode.
There are three 8-bit arithmetic shift left instructions:
[<label>] ASL opr [<comment>]
[<label>] ASLA
[<comment>]
[<label>] ASLB
[<comment>]
-- memory location opr is shifted left one place
-- accumulator A is shifted left one place
-- accumulator B is shifted left one place
The operation is
C
b7 ----------------- b0
0
H. Huang Transparency No.2-30
The 68HC11 Microcontroller
The 68HC11 has one 16-bit arithmetic shift left instruction:
[<label>] ASLD
[<comment>]
The operation is
C
b7 ----------------- b0
accumulator A
b7 ----------------- b0
accumulator B
0
The 68HC11 has arithmetic shift right instructions that apply to a memory location and
accumulators A and B.
[<label>] ASR opr [<comment>]
[<label>] ASRA
[<comment>]
[<label>] ASRB
[<comment>]
-- memory location opr is shifted right one place
-- accumulator A is shifted right one place
-- accumulator B is shifted right one place
The operation is
b7 ----------------- b0
C
H. Huang Transparency No.2-31
The 68HC11 Microcontroller
The 68HC11 has logical shift left instructions that apply to a memory location and
accumulators A and B.
[<label>] LSL opr [<comment>]
[<label>] LSLA
[<comment>]
[<label>] LSLB
[<comment>]
-- memory location opr is shifted left one place
-- accumulator A is shifted left one place
-- accumulator B is shifted left one place
The operation is
C
0
b7 ----------------- b0
The 68HC11 has one 16-bit logical shift left instruction:
[<label>] LSLD
[<comment>]
The operation is
C
b7 ----------------- b0
b7 ----------------- b0
accumulator A
accumulator B
0
H. Huang Transparency No.2-32
The 68HC11 Microcontroller
The 68HC11 has three logical shift right instructions that apply to 8-bit operands.
[<label>] LSR opr [<comment>]
[<label>] LSRA
[<comment>]
[<label>] LSRB
[<comment>]
-- memory location opr is shifted right one place
-- accumulator A is shifted right one place
-- accumulator B is shifted right one place
The operation is
0
b7 ----------------- b0
C
The 68HC11 has one 16-bit logical shift right instruction:
[<label>] LSRD
[<comment>]
The operation is
0
b7 ----------------- b0
b7 ----------------- b0
accumulator A
accumulator B
C
H. Huang Transparency No.2-33
The 68HC11 Microcontroller
The 68HC11 has three rotate left instructions that operate on 9-bit operands.
[<label>] ROL opr [<comment>]
[<label>] ROLA
[<comment>]
[<label>] ROLB
[<comment>]
-- memory location opr is rotated left one place
-- accumulator A is rotated left one place
-- accumulator B is rotated left one place
The operation is
b7 ----------------- b0
C
The 68HC11 has three rotate right instructions that operate on 9-bit operands.
[<label>] ROR opr [<comment>]
[<label>] RORA
[<comment>]
[<label>] RORB
[<comment>]
-- memory location opr is rotated right one place
-- accumulator A is rotated right one place
-- accumulator B is rotated right one place
The operation is
C
b7 ----------------- b0
H. Huang Transparency No.2-34
The 68HC11 Microcontroller
Example 2.18 Suppose that [A] = $74 and C = 1. Compute the new values of A and C
after the execution of the instruction ASLA.
Solution:
The operation is
0 1 1 1 0 1 0 0 0
0
C
1 1 1 0 1 0 0 0
A
Result: [A] = %11101000 C = 0
Example 2.19 Suppose that [mem[$00]] = $F6 and C = 1. Compute the new values of
mem[$00] and the C flag after the execution of the instruction ASR $00.
Solution:
The operation is
1 1 1 1 0 1 1 0
1 1 1 1 1 0 1 1
0
mem[$00]
C
Result: [mem[$00]] = %11111011 C = 0
H. Huang Transparency No.2-35
The 68HC11 Microcontroller
Example 2.20 Suppose that [mem[$00]] = $F6 and C = 1. Compute the new contents of
mem[$00] and the C flag after the execution of the instruction LSR $00.
Solution:
The operation is
0 1 1 1 1 0 1 1 0
0 1 1 1 1 0 1 1
0
mem[$00]
C
Result: [mem[$00]] = % 01111011 C = 0
Example 2.21 Suppose that [B] = $BE and C = 1. Compute the new values of
B after the execution of the instruction ROLB.
Solution:
The operation is
1 0 1 1 1 1 1 0
1
0 1 1 1 1 1 0 1
1
B
C
Result: [B] = % 01111101 C = 1
H. Huang Transparency No.2-36
The 68HC11 Microcontroller
Example 2.22 Suppose that [B] = $BE and C = 1. Compute the new values of
mem[$00] after the execution of the instruction RORB.
Solution:
The operation is
1
1 0 1 1 1 1 1 0
0
1 1 0 1 1 1 1 1
C
B
Result: [B] = % 11011111 C = 0
H. Huang Transparency No.2-37
The 68HC11 Microcontroller
Example 2.23 Write a program to count the number of 1s in the 16-bit number stored
at $00-$01 and save the result in $02.
Solution:
* The 16-bit number is shifted to the right up to 16 time or until the shifted value becomes 0.
* If the bit shifted out is a 1 then increment the 1s count by 1.
loop
testzero
org
ldaa
staa
ldd
lsrd
bcc
inc
cpd
bne
end
$C000
#$00
$02
$00
testzero
$02
#0
loop
; initialize the 1s count to 0
;
“
; place the number in D
; shift the lsb of D to the C flag
; is the C flag a 0?
; increment 1s count if the lsb is a 1
; check to see if D is already 0
H. Huang Transparency No.2-38
The 68HC11 Microcontroller
Shift a multi-byte number
For shifting right
1. 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.
2. 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 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.
H. Huang Transparency No.2-39
The 68HC11 Microcontroller
For shifting left
1. 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.
2. 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 loc+k-1.
method for shifting left
Step 1: Shift the byte at loc+k-1 to the leftt 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.
H. Huang Transparency No.2-40
The 68HC11 Microcontroller
Example 2.24 Write a program to shift the 32-bit number stored at $20-$23 to the
right four places.
Solution:
again
ldab #4
ldx #$20
lsr 0,X
ror 1,X
ror 2,X
ror 3,X
decb
bne again
end
; set up the loop count
; use X as the pointer to the left most byte
H. Huang Transparency No.2-41
The 68HC11 Microcontroller
Program Execution Time
An easy way to create a delay is to use program loops. Use the instructions in Table 2.3 as
an example.
Table 2.3 Execution times of a sample of instructions
Execution time (E clock cycles)
Instruction
BNE <rel>
3
DECB
2
DEX
3
LDAB <imme>
2
LDX <imme>
3
NOP
2
The following instruction sequence takes 5 ms to execute for 2 MHz E clock signal.
again
nop
nop
dex
bne again
; 2 E cycles
; 2 E cycles
; 3 E cycles
; 3 E cycles
H. Huang Transparency No.2-42
The 68HC11 Microcontroller
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 20000 times.
The following instruction sequence creates a delay of 100 ms.
ldx
#20000
again
nop
nop
dex
bne
again
Longer delays can be created by using nested program loops.
Example 2.26 Write a program to create a 10-second delay.
Solution: A 10-second delay can be created by repeating the loop in example 2.25 100 times.
outer
inner
ldab
ldx
nop
nop
dex
bne
decb
bne
#100
#20000
inner
outer
H. Huang Transparency No.2-43