Motorola HC11

Fun with Microcontrollers and

Embedded Systems
Microcontrollers

What is a microcontroller?

•A processor
•Usually not cutting edge
•Dependable
•All major bugs well known
•Predictable
•Critical for real-time processing
•On-chip peripherals and memory
•Parallel and serial digital I/O
•Analog I/O
•Counters and timers
•Internal ROM and/or EPROM

CMPE12c 2 Gabriel Hugh Elkaim

Microcontrollers

What are microcontrollers used in?

• Watches • ATMs
• Microwaves • PDA’s, MP3 players
• Stereo Receivers • Automobiles

Some products that you might know:

• NASA’s Sojourner Rover – 8-bit Intel 80C85
• Palm Vx handheld – 32-bit Motorola Dragonball EZ
• Sonicare toothbrush – 8-bit Zilog Z8
• The Vendo V-MAX 720 Soda Machine – Motorola HC11
• Miele dishwasher – 8-bit Motorola 68HC05
• Hunter 44550 Programmable Thermostat – (4-bit cpu)

CMPE12c 3 Gabriel Hugh Elkaim

Microcontrollers

Microcontroller unit sales are 15x higher than

microprocessors.
• … and are MUCH
cheaper.

CMPE12c 4 Gabriel Hugh Elkaim

Microcontrollers

Microcontrollers are a large market

• 8-bit controllers are the largest, but not growing
the fastest.

CMPE12c 5 Gabriel Hugh Elkaim

Microcontrollers

• 8-bit microcontroller growth rate for 2003 is at

9.42%.
• Microcontroller growth rate in general is 11.5%.
• 8-bit controllers loosing market share in 2003.
Was 62.36% in 1998 to 56.76% in 2003.

Source: Cahners In-Stat Group

CMPE12c 6 Gabriel Hugh Elkaim

Microcontrollers

• 16- and 32-bit and higher are on the rise.

They will double their unit market share from
15.11% in 1998 to 31.56% in 2003,
decreasing 4-bit and 8-bit devices.

• But, in 2003, the 8-bit microcontrollers will

outnumber the higher bit units by almost 80%
in the market place.

Source: Cahners In-Stat Group

CMPE12c 7 Gabriel Hugh Elkaim

Microcontrollers

So what languages are they being programmed

in?
1998-1999 1999-2000

Assembly ~ 21% ~ 10%

C ~ 69% ~ 80%
C++ ~ 5% ~ 6%
Java ~1% ~ 2%
Other ~3% ~ 2%

Source: TRON Association Survey 1998/99 & 1999/2000

CMPE12c 8 Gabriel Hugh Elkaim

 Motorola M68HC11
•M6801 CPU core
•ROM (8KB), EEPROM (512B), RAM (256B)
•Counter/Timer system
•A/D converter
•D/A in kit
•Parallel I/O
•Serial I/O (SPI and SCI)
•Expansion bus
•To add more memory

CMPE12c 9 Gabriel Hugh Elkaim

HC11

HC11 Architecture
CMPE12c 10 Gabriel Hugh Elkaim
 M8601 CPU Core
• 8-bit
• CISC
• Accumulator-based
• Results wind up in a 8-bit accumulator A or B
• 16-bit results go to accumulator AB, called D
• Two index registers for addressing memory or for
counting - X and Y
• Dedicated stack pointer
• Push and Pop instructions use this – grows toward
smaller memory addresses like in MAL
• Program Counter
• Condition Codes
CMPE12c 11 Gabriel Hugh Elkaim
M8601 CPU Core

ALU – Arithmetic Logic Unit

CMPE12c 12 Gabriel Hugh Elkaim

HC11 Microcontroller

CMPE12c 13 Gabriel Hugh Elkaim

HC11 Microcontroller

Condition Codes

•Not present for MIPS integer instructions

•Single-bit flags set appropriately for most instruction
(several instructions do not, including push and pop)

C Carry/Borrow
V Overflow
Z Zero
N Negative
H Half-Carry

CMPE12c 14 Gabriel Hugh Elkaim

HC11 Microcontroller

Example of how condition codes are used

MAL code HC11 code What it does

bge $t0, 4, mylabel cmpa #4 Subtract AccA - 4, set CCR

bge mylabel Branch if

(CCR[Z]=1 OR CCR[N]=0)

CMPE12c 15 Gabriel Hugh Elkaim

HC11 Microcontroller

Configuration Registers

•Bits set by the user to tell the processor how to do

things

I Interrupt Mask
X XIRQ mask
S Disable STOP instructions

CMPE12c 16 Gabriel Hugh Elkaim

Return to Addressing Modes
Addressing Modes

MIPS (TAL) has:

• Register direct
• Base Displacement

HC11 has several:

•Check opcode listings to see what modes work
with what instructions
•Also check what condition codes are set

CMPE12c 17 Gabriel Hugh Elkaim

 HC11 Addressing Modes
Supports these addressing modes:
•Immediate (IMM)
•Extended (EXT)
•Direct (DIR)
•Indexed (INDX and INDY)
•Inherent (INH)
•Relative (REL)
CMPE12c 18 Gabriel Hugh Elkaim
HC11 Addressing Modes

Immediate addressing

•1 or 2 byte immediate depending on register involved

(LDAA vs. LDD)
•ALWAYS include a #
•Several formats for different bases -- C-style
constants instead of what is in the HC11
manual (don’t use !,$,@,%)
•Decimal: LDAA #245
•Hexadecimal: LDAA #0x61
•Octal: LDAA #041
•Binary: LDAA #0b11000011
•ASCII: LDAA #’a’

CMPE12c 19 Gabriel Hugh Elkaim

HC11 Addressing Modes

Extended and Direct addressing

•Access an absolute memory location

•Essentially the same mode, but with 8-bit (direct)
or 16-bit (enhanced or extended) addresses
•The assembler will decide on which to use based
on how many bits are needed
•Example
// Your data starts at address 0x4000:
.sect .data
var: .word 0x1000 // Allocate/initialize a word
// Note: a word is 16 bits!

.sect .text
SUBD var // Subtract [var] from D
SUBD 0x4000 // Subtract [var] from D
CMPE12c 20 Gabriel Hugh Elkaim
HC11 Addressing Modes

Indexed addressing

•Uses index register X or Y

•Similar to MAL “lw $t0, 4($sp)”
•But can access memory and use it all at once!!
•Example

#define mydef 4 // c preprocessor used

ldx #var // Like MAL load address
addd 0,X // add contents of 0($X) to D
// (Note “addd X” doesn’t work)
addd 2,X // add contents of 2($X) to D
addd mydef*2, X // add contents of 8($X) to D

CMPE12c 21 Gabriel Hugh Elkaim

HC11 Addressing Modes

Inherent addressing

•Opcode fully specifies operation; no addressing

•Examples:

INCB increment accumulator B

ASLA Arithmetic Shift Left accumulator A
PSHY Push index register Y onto stack

CMPE12c 22 Gabriel Hugh Elkaim

HC11 Addressing Modes

Relative addressing

•Used for branches by the assembler

•Offsets from –128 to +128 bytes
•Use jumps for longer branches

CMPE12c 23 Gabriel Hugh Elkaim

HC11 Address Modes Review
ldab #0 // loads the number 0 into b
ldaa foo // loads the contents of byte
// variable foo into “a” acc.
ldy #foo // loads the address of foo into y
ldab 0, x // loads the byte at address x+0
// into “b” acc.
ldx 0 // loads whatever is at memory
// address 0 into “x” index.
// You don't want this in 12c ever.

CMPE12c 24 Gabriel Hugh Elkaim

 Motorola 68HC11
Instructions
•HC11 Instructions have variable lengths (not like MAL)
•Careful coding can keep applications small and able to
fit in the EPROM
•We don’t have to worry about this since we’re using
Expansion Mode: there is extra memory in the microkits.
•The opcode is always 1 byte
•An additional 0-3 bytes specify the data to work with

CMPE12c 25 Gabriel Hugh Elkaim

Motorola 68HC11 Instruction
Set
•Accumulator and Memory Instructions
•Stack and Index Register Instructions
•Condition Code Register Instructions
•Program Control Instructions

CMPE12c 26 Gabriel Hugh Elkaim

HC11 Instructions

Accumulator and Memory

Instructions
Can be broken up into these 6 general types:
1. Loads, stores, and transfers
2. Arithmetic operations
3. Multiply and divide
4. Logical operations
5. Data testing and bit manipulation
6. Shifts and rotates

CMPE12c 27 Gabriel Hugh Elkaim

HC11 Instructions

Almost all MCU

activities involve
transferring data
from memories or
peripherals into the
CPU or transferring
results from the
CPU into
memory or I/O
devices.

CMPE12c 28 Gabriel Hugh Elkaim

HC11 Instructions

This group of
instructions supports
arithmetic operations
on a variety of
operands; 8- and 16-bit
operations are
supported directly and
can easily
be extended to support
multiple-word
operands. Twos-
complement
(signed) and binary
(unsigned) operations
are supported directly.

CMPE12c 29 Gabriel Hugh Elkaim

HC11 Instructions

Compare instructions
perform a subtract
within the CPU to
update the condition
code bits without
altering either
operand. Although
test instructions are
provided, they are
seldom needed since
almost all
other operations
automatically update
the condition code
bits.

CMPE12c 30 Gabriel Hugh Elkaim

HC11 Instructions

One multiply and two divide instructions are provided. The 8-bit by 8-bit
multiply produces a 16-bit result. The integer divide (IDIV) performs a
16-bit by 16-bit divide, producing a 16-bit result and a 16-bit remainder.
The fractional divide (FDIV) divides a 16-bit numerator by a larger 16-bit
denominator, producing a 16-bit result (a binary weighted fraction
between 0 and 0.99998) and a 16-bit remainder.

CMPE12c 31 Gabriel Hugh Elkaim

HC11 Instructions

This group of instructions is used to perform the Boolean logical

operations AND, inclusive OR, exclusive OR, and one’s complement.

CMPE12c 32 Gabriel Hugh Elkaim

HC11 Instructions

This group of instructions is used to operate on operands as small as a

single bit, but these instructions can also operate on any combination of
bits within any 8-bit location in the 64-Kbyte memory space.

CMPE12c 33 Gabriel Hugh Elkaim

HC11 Instructions

All the shift and rotate

functions in the
M68HC11 CPU involve
the carry
bit in the CCR in
addition to the 8- or
16-bit operand in the
instruction,
which permits easy
extension to multiple-
word operands.

CMPE12c 34 Gabriel Hugh Elkaim

HC11 Instructions

Stack and Index Register

Instructions

CMPE12c 35 Gabriel Hugh Elkaim

HC11 Instructions

This table summarizes the

instructions available for the
16-bit index
registers (X and Y) and the
16-bit stack pointer.

CMPE12c 36 Gabriel Hugh Elkaim

HC11 Instructions

Condition Code Register

Instructions

These instructions allow a programmer to manipulate bits of the CCR.

CMPE12c 37 Gabriel Hugh Elkaim

HC11 Instructions

Program Control Instructions

1. Branches
2. Jumps
3. Subroutine calls and returns
4. Interrupt handling
5. Miscellaneous

CMPE12c 38 Gabriel Hugh Elkaim

HC11 Instructions

These instructions allow

the CPU to make
decisions based on the
contents of the condition
code bits. All decision
blocks in a flow chart
would correspond to one
of the conditional branch
instructions summarized
here

CMPE12c 39 Gabriel Hugh Elkaim

HC11 Instructions

The jump instruction allows control to be passed to any

address in the 64-Kbyte memory map.

CMPE12c 40 Gabriel Hugh Elkaim

HC11 Instructions

These instructions provide an easy way to divide a programming task

into manageable blocks called subroutines. The CPU automates the
process of remembering the address in the main program where
processing should resume after the subroutine is finished. This address
is automatically pushed onto the stack when the subroutine is called and
is pulled off the stack during the RTS instruction that ends the
subroutine

CMPE12c 41 Gabriel Hugh Elkaim

HC11 Instructions

This group of instructions is related to interrupt operations, we will get to

there use later.

CMPE12c 42 Gabriel Hugh Elkaim

HC11 Instructions

NOP is a do nothing instruction, just wastes an instruction cycle. STOP is

used to put the CPU into a low power mode. TEST is a reserved instruction
only used at the factory when making the chips.

CMPE12c 43 Gabriel Hugh Elkaim

 “C” Conversions

“C” Addition
c = x + y;

HC11 Assembly
// Integer variables // Character variables
ldd x ldab x
addd y addb y
std c stab c

CMPE12c 44 Gabriel Hugh Elkaim

“C” Conversions

“C” Addition “C” Addition

c = x + y; x = x + y;

HC11 Assembly HC11 Assembly

// c goes in double acc // Using character registers

// x, y are the index regs // acc a = x, acc b = y.
pshx
xgdx aba
pshy
tsx
addd 0,x
puly
pulx
CMPE12c 45 Gabriel Hugh Elkaim
“C” Conversions

“C” Multiplication

// c = short variable
// a, b = char variables
c = a * b;

HC11 Assembly

ldaa a
ldab b
mul
std c

CMPE12c 46 Gabriel Hugh Elkaim

“C” Conversions

“C” if statement: “HC11” Assembly:

cmpa #10
if(a > 10) ble endif
y++; iny
endif:

CMPE12c 47 Gabriel Hugh Elkaim

“C” Conversions

“C” if/else “HC11” Assembly:

statement:
cmpa #10
char a; short y;
bgt if
if(a > 10) dey
y++; bra endif
else if: iny
y--; endif:

CMPE12c 48 Gabriel Hugh Elkaim

“C” Conversions

“C” if/else “HC11” Assembly:

statement:
ldaa foo
char foo;
cmpa #10
short qux;
bgt if
if(foo > 10) ldy qux
qux++; iny
else sty qux
qux--; bra endif
if: ldy qux
iny
sty qux
endif:

CMPE12c 49 Gabriel Hugh Elkaim

“C” Conversions

“C” while “HC11” Assembly:

statement:
while:
char a, b; cmpa #20
while(a > 20) ble endwhile
{ deca
a--;
b *= 3; psha
} ldaa #3
mul
pula

bra while
endwhile:
CMPE12c 50 Gabriel Hugh Elkaim
“C” Conversions

“C” if/else “HC11” Assembly:

statement:
ldaa foo
char foo;
cmpa #10
short qux;
bgt if
if(foo > 10) ldy qux
qux++; iny
else sty qux
qux--; bra endif
if: ldy qux
iny
sty qux
endif:

CMPE12c 51 Gabriel Hugh Elkaim

“C” Conversions

“C” do/while “HC11” Assembly:

statement:
do:
int foo, bar, qux; ldd foo
do { subd #3
foo -= 3; std foo
bar += qux;
} ldd bar
while (foo > 7) addd qux
std bar

ldd foo
cpd #7
bgt do
CMPE12c 52 Gabriel Hugh Elkaim
HC11 Example

Summing the first 10 elements of an integer

array, result in x:
array: .space 20

ldx #0 xgdx
ldab #0 addd 0,y
while: xgdx
cmpb #18
bgt endwhile incb
incb
ldy #array bra while
aby endwhile:

CMPE12c 53 Gabriel Hugh Elkaim

HC11 Example

/***********************************************************
* Program 1.
* A simple program to introduce the 68HC11 environment
***********************************************************/

#include <v2_18g3.asm> // sets stuff up for you, especially I/O

.sect .data

SIGNON: .asciz “CMPE12C Simulator”

PROMPT: .asciz “>”

// (continued…)

CMPE12c 54 Gabriel Hugh Elkaim

HC11 Example Continued

/*************************************************************
* Your program starts where indicated by the label “main”. After startup
* Code in v2_18g3.asm is done, it jumps to this label and continues running.
**************************************************************/

.sect .text

main:
ldx #SIGNON
jsr OUTSTRING

loop: ldx #PROMPT // address of prompt

jsr OUTSTRING // write out to serial communications
// interface (to PC)
jsr GETCHAR // get a character from SCI, returns in A
jsr OUTCHAR // write A to the SCI
jsr OUTCRLF // write CR/LF to SCI
jmp loop

CMPE12c 55 Gabriel Hugh Elkaim

 HC11 Micro Kit Usage
•Design environment:
•Edit & assemble on CATS machines
> hc11build file.asm
•Download program to the PC
•Upload to the microkit using serial cable

•To use kits at home

•9-12V AC adapter
•Serial download cable
•Connection to CATS machines
•Free serial communication software (e.g. TeraTerm)

CMPE12c 56 Gabriel Hugh Elkaim

Micro Kit Usage

Always #include <v2_18g3.asm> as part of your program

•Sets up memory, including stack pointer

•Jumps to your “main” label
•Also includes a basic library of I/O routines
•Take a look at it!
http://www.soe.ucsc.edu/classes/cmpe012c/Winter04/
In the handouts and links page under HC11 Stuff

CMPE12c 57 Gabriel Hugh Elkaim

Example recursive routine

Fibonacci on the switches and LEDs

/* Input: A. Returns A’th Fibonacci term in accumulator A */
fib: cmpa #2
bgt fibnot1
ldaa #1 // return 1 if n <= 2
rts
fibnot1: pshb // caller save protocol
deca
psha // save n-1
deca // call with n-2
jsr fib
tab // transfer F(n-2) to b
pula // a gets n-1
jsr fib
aba // add accumulators
pulb // restore B
jsr fib
rts
ldx #LEDS
staa 0,x
main: ldx #SWITCHES
jmp main
ldaa 0,X
CMPE12c 58 Gabriel Hugh Elkaim
 Microcontroller/HC11 Summary

•Microcontrollers are great little processors for I/O and data

manipulation
•The CISC-style programming makes assembly programming
easier
•Variable instruction length can be a problem for
•Word-aligned machines
•Super-scalar machines
•Pipelines
•The RISC philosophy is to
•Use simple instructions and let the compiler optimize
•Use loads and stores to support higher-speed registers
•Neither RISC, its CISC predecessors, nor CISCY RISCY has
the definitive advantage
•Depends on application, architecture, and implementation.

CMPE12c 59 Gabriel Hugh Elkaim