Embedded Systems

CMPE12 Cyrus Bazeghi
Fun with Motorola/Freescale HC11

Microcontrollers and
Embedded Systems
2
A microprocessor
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
What is a microcontroller?
3
What are microcontrollers used in?
Watches
Microwaves
Stereo Receivers
Some products that you might know:
NASAs 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)
Microcontrollers
ATMs
PDAs, MP3 players
Automobiles
4
Microcontrollers
Microcontroller unit sales are 15x higher than
microprocessors.
and are MUCH,
MUCH cheaper.
5
Microcontrollers
Microcontrollers are a large market
8-bit controllers are the largest, but not
growing the
fastest.
6
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 down to 56.76%
in 2003.
Source: Cahners In-Stat Group
7
16- and 32-bit and higher are on the rise.
They will double their unit market share
from 15.11% in 1998 up 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
Microcontrollers
8
Microcontrollers
So what languages are they being programmed
in?
Language 98-99 99-00
Assembly ~ 21% ~ 10%
C ~ 69% ~ 80%
C++ ~ 5% ~ 6%
Java ~ 1 % ~ 2%
Other ~ 3 % ~ 2%
Source: TRON Association Survey 1998/99 & 1999/2000
9
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
Motorola/Freescale M68HC11
10
HC11 Micro Kit
AC/DC
Power
adapter Serial
cable to PC
LCD Display
LEDs
Switches
HC11 C
11
Design environment:
Edit the source file on an PC
Assemble on UNIX machine
> hc11build file.asm
Download program to the PC with terminal program
Upload to the microkit using serial cable
To use kits at home
9-12V AC adapter
Serial download cable
Connection to ITS machines
Free serial communication software (e.g. TeraTerm)
HC11 Micro Kit
12
Micro Kit Usage
Always have #include <v2_18g3.asm> as part of
your program, this file:
Sets up memory, including the 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/cmpe012/Fall09/
In the handouts and links page under HC11 Stuff
13
HC11 Architecture
HC11
14
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 LC-3
Program Counter
Condition Codes
15
Check out the lab manual
It is online on the class website
Contains a section on the HC11
It is a great reference
Also get the programmer reference
guide, free at BELS (basement of BE)
16
M8601 CPU Core
ALU Arithmetic Logic Unit
17
HC11 Microcontroller
18
More present then in LC-3
Single-bit flags set appropriately for most instructions
(several instructions do not, including push and pop)
C Carry/Borrow
V Overflow
Z Zero
N Negative
H Half-Carry
Condition Codes
19
HC11 code What it does
cmpa #4 Subtract AccA - 4, set CCR
bge mylabel Branch if
(CCR[Z]=1 OR CCR[N]=0)
Example of how condition codes are used
20
HC11 Assembly Syntax
Have separate sections for data declarations
and for instructions
Use .sect .data for data sections
Use .sect .text for instructions sections.
Have more data types
.space for array declarations
.byte declares just a byte
.word declares 16-bits also
.asciz declares a string of characters
.ascii declares a string, no NULL terminator
Comments use a C++ style //
21
Data Declaration Examples
.sect .data
myvar: .word 0x1000 // init a word
myarray: .space 20 // 20 entries
mychar: .byte a // a character
mybyte: .byte 23 // DEC integer
myhi: .asciz Hi // a string
myhi2: .ascii Hi // a string
.sect .text
// Instructions would start here.
// Can have many .text and .data sections.
22
Bits set by the user to tell the processor how to do
things
I Interrupt Mask
X XIRQ mask
S Disable STOP instructions
Configuration Registers
23
Return to Addressing Modes
Addressing Modes:
LC-3 has:
PC-Relative
Base Displacement
Indirect
HC11 has many:
Check opcode listings to see what modes work
with what instructions
Also check what condition codes are set
24
HC11 Addressing Modes
Immediate (IMM)
Extended (EXT)
Direct (DIR)
Indexed (INDX and INDY)
Inherent (INH)
Relative (REL)
Supports these addressing modes:
25
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 (dont use !,$,@,%)
Decimal: LDAA #245
Hexadecimal: LDAA #0x61
Octal: LDAA #041
Binary: LDAA #0b11000011
ASCII: LDAA #a
26
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 M[x4000] from D
SUBD 0x4000 // Subtract M[x4000] from D
Extended and Direct addressing
27
Uses index register X or Y
Similar to LC-3 LDR R0, R2, #3
But can access memory and use it all at once!!
Example
#define mydef 4 // c preprocessor used
ldx #var // Like LC-3 load address
addd 0,X // add contents of M[0+X] to D
// (Note addd X doesnt work)
addd 2,X // add contents of M[2+X] to D
addd mydef*2, X // add contents of M[8+X] to D
Indexed addressing
28
Opcode fully specifies operation; no addressing
Examples:
INCB increment accumulator B
ASLA Arithmetic Shift Left accumulator A
PSHY Push index register Y onto stack
Inherent addressing
29
Used for branches by the assembler
Offsets from 128 to +128 bytes
Use jumps for longer branches
Relative addressing
30
HC11 Address Modes Review
ldab #0 // loads the number 0 into b
ldaa foo // loads the contents of byte
// variable foo into acc. A
ldy #foo // loads the address of foo into Y
ldab 0, x // loads the byte at address X+0
// into acc. B
ldx 0 // loads whatever is at memory
// address 0 into index reg. X
// You don't ever want to do this in
// CE12
31
HC11 Instructions have variable lengths (not like LC-3)
Careful coding can keep applications small and able to
fit in the EPROM
We dont have to worry about this since were 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
Motorola 68HC11
Instructions
32
Accumulator and Memory Instructions
Stack and Index Register Instructions
Condition Code Register Instructions
Program Control Instructions
Motorola 68HC11
Instruction Set
Four types of instructions available:
33
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
HC11 Instructions
34
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.
35
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.
36
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.
37
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.
38
HC11 Instructions
This group of instructions is used to perform the Boolean logical
operations AND, inclusive OR, exclusive OR, and ones complement.
39
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.
40
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.
41
Stack and Index Register
Instructions
HC11 Instructions
42
HC11 Instructions
This table summarizes the
instructions available for
the 16-bit index
registers (X and Y) and
the 16-bit stack pointer.
43
HC11 System Stack
The HC11 has a stack set up for us
Memory is byte addressable
Example:
PSHA // pushes accumulator A onto stack
// SP = SP 1 since a byte size
PSHY // pushes index register Y onto stack
// SP = SP 2 since a word size
PULA // Pops off a byte from the stack into A
// SP = SP + 1
PULY // Pops off a word from the stack into Y
// SP = SP + 2
44
HC11 Instructions
Condition Code Register
Instructions
These instructions allow a programmer to manipulate bits of the CCR.
45
Program Control
Instructions
1. Branches
2. Jumps
3. Subroutine calls and returns
4. Interrupt handling
5. Miscellaneous
HC11 Instructions
46
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
HC11 Instructions
47
HC11 Instructions
The jump instruction allows control to be passed to
any address in the 64-Kbyte memory map.
48
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
49
This group of instructions is related to interrupt operations, we will
get to there use later.
HC11 Instructions
50
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.
HC11 Instructions
51
C Conversions
C Addition
result = v0 + v1
// 8-bit variables
ldab v0
addb v1
stab result
HC11 Assembly
// 16-bit variables
ldd v0
addd v1
std result
52
C Conversions
HC11 Assembly
ldab v0
ldaa v1
aba
stab v0
C Addition
char V0, V1;
v0 = v0 + v1
53
C Multiplication
int Result // 16-bit
char Val0, Val1 // 8-bit
Result = Val0 * Val1
HC11 Assembly
ldaa Val0
ldab Val1
mul
std Result
C Conversions
54
C if statement:
if(a > 10)
y++;
HC11 Assembly:
// using Acc A & index Y
ldaa a
cmpa #10
ble endif
iny
sty y
endif:
C Conversions
55
C Conversions
C if/else
statement:
char a; // 8-bit
int y; // 16-bits
if(a > 10)
y++;
else
y--;
HC11 Assembly:
cmpa #10
bgt if
dey
bra endif
if: iny
endif:
56
C Conversions
C if/else
statement:
char foo; // 8-bits
int qux; // 16-bits
if(foo > 10)
qux++;
else
qux--;
HC11 Assembly:
ldaa foo
ldy qux
cmpa #10
bgt if
dey
bra endif
if: iny
endif: sty qux
57
C Conversions
C while
statement:
char a, b;
while(a > 20)
{
a--;
b *= 3;
}
HC11 Assembly:
// Using Acc A and B
while:
cmpa #20
ble endwhile
deca
psha
ldaa #3
mul
pula
bra while
endwhile:
58
C do/while
statement:
int foo, bar, qux;
do {
foo -= 3;
bar += qux;
}
while (foo > 7)
HC11 Assembly:
do:
ldd foo
subd #3
std foo
ldd bar
addd qux
std bar
ldd foo
cpd #7
bgt do
C Conversions
59
Summing the first 10 elements of a 16-bit
integer array, result in index register X:
array: .space 20
ldx #0
ldab #0
while: cmpb #18
bgt endwhile
ldy #array
aby
xgdx
addd 0,y
xgdx
incb
incb
bra while
endwhile:
HC11 Example
60
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)
61
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
62
Example recursive routine
Fibonacci on the switches and LEDs
/* Input: A. Returns Ath 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
rts
main: ldx #SWITCHES
ldaa 0,X
jsr fib
ldx #LEDS
staa 0,x
jmp main
63
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.

Embedded Systems

Uploaded by

Copyright:

Available Formats

Embedded Systems

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Embedded Systems

Uploaded by

Copyright:

Available Formats

CMPE12 Cyrus Bazeghi

Fun with Motorola/Freescale HC11

You might also like