Introduction to the ATmega 16
Microcontroller
STK500
Development
Board
Description of STK500
• A row of eight
g p
pushbutton switches,, each of which has a
small LED lamp above it. These can be connected to the
microcontrollers using the array of connectors just
above.
above
• There is then a large white area, which is where the AVR
chips to be programmed are inserted.
• Usually, a STK500 comes with a Atmega 16L chip
mounted in the large socket on the right.
• The
Th green area att the
th top
t contains
t i the
th programming
i
electronics, and the connectors for power and
communications.
Atmega 16 bit Microcontroller
ATmega 16
Micro
Controller
ATmega 16
Atmega16 Features
Features
• High-performance, Low-power AVR® 8-bit Microcontroller
• Advanced RISC Architecture
– 131 Powerful Instructions – Most Single-clock Cycle Execution
– 32 x 8 General Purpose Working Registers
– Fully Static Operation
– Up to 16 MIPS Throughput at 16 MHz
– On-chip
O
2-cycle Multiplier
• High Endurance Non-volatile Memory segments
– 16K Bytes of In-System Self-programmable Flash program
memory
– 512 Bytes EEPROM
– 1K Byte Internal SRAM
– Write/Erase Cycles: 10,000 Flash/100,000 EEPROM
– Data
D t retention:
t ti
20 years att 85°C/100 years att 25°C(1)
– Optional Boot Code Section with Independent Lock Bits
In-System Programming by On-chip Boot Program
p
True Read-While-Write Operation
– Programming Lock for Software Security
complementary metal–oxide–semiconductor (CMOS)
Memory
•
ROM=Read Only Memory
– Called
C ll d nonvolatile
l til b
because it d
does nott require
i power tto retain
t i memory
•
RAM=Random Access memory
–
–
–
–
Read and write
Volatile=loses
Volatile
loses memory when power removed
SRAM=Static RAM: retains data in flip flops
DRAM=Dynamic RAM: data has to be refreshed because capacitors
hold charge (i.e. values)
– Many other variations on RAM
•
Battery backed up RAM
– Use a small battery (calculator size) to maintain charge to RAM after
power is removed.
– The power required to maintain data in a RAM chip is incredibly small
so that this little battery can easily maintain data for years (maybe 5
under optimal conditions).
Memory
•
EPROM=erasable programmable ROM
– U
Use a special
i lb
box th
thatt shines
hi
UV lilight
ht iinto
t window
i d
on chip
hi tto erase
contents.
– Can take up to 30 minutes. Removing too early results in only partially
erased memory
– No
N need
d to ever use this,
hi a relic
li off the
h past.
•
EEPROM=electrically erasable programmable ROM
– Uses a special programming pin (usually uses higher voltage) to erase
p g
then write new program.
– Development boards often setup so EEPROM does not have to be
removed (like EPROM does)
•
Flash ROM
– Like EEPROM but faster and cheaper
– Limited write cycles (but in the several thousands)
How to use Memory
• RAM-this is where the p
program
g
resides
• SRAM-this is your scratch pad for intermediate
results or anything that you want to save during
operation
i ((remember
b you llose iit when
h power
goes). It’s also the stack (discussed later).
• EEPROM
– permanent storage of data like constants
– something
g you
y save during
gp
program
g
execution yyou
want to be used during the next run.
Registers
• Register-a
Register a generic term with many meanings. At
the top level, it’s a group of bits (like a byte).
– I/O registers are set to configure the microcontroller
• 1 =Output
• 0=Input
– General Purpose Registers are used to perform
calculations
Internal Memory Map
Flash and EEPROM Map
Line 0
1 byte
EEPROM
Line 4095
In p
programming
g
g world, 4K does not equal
q
4000, it equals
q
4096=2^12. And we
would address 4096 bytes starting from zero and going up to 4095
The Atmega16 is called so because it has 16 kB of Flash RAM,
Addressing
• How many bytes can I address with an 8
or 16 bit register?
– 8 bits=2^8=256 (0-255)
– 16 bits=2^16=65,536 (0-65,535)
=refer to
Line 0
SRAM
4Kbytes x 8
Remember, everything starts with zero. So
we have 65,536 elements that range from 0
to 65,535
4095=0xFFF
1 byte
Line
4095
Program Flow
• A special
p
register
g
called the p
program
g
counter
keeps track of the address in the Flash RAM to
be executed.
• On each clock cycle,
cycle that address is decoded
and the appropriate values are taken from
memory and passed into the Arithmetic Logic
Unit (ALU) to be processed.
processed
• The value to be processed (operands) must
come from a special set of 32 registers called
the
h G
Generall P
Purpose R
Registers.
i
T
To access
SRAM or I/O, they must be brought in/out of the
registers.
g
Atmega 16 Core (“The Brain”)
Generall Purpose
G
P
Register
R i t
(“The Interface”)
Everything going in/out
must touch the registers
Program Memory:
(“The Planning Center”)
ALU: Arithmetic and Logic
g
Unit (“The Calculator”)
Input/Output: Eyes,
ears, and other
senses
Program Counter
• What element holds the address of the next line to be
executed in program memory?
– The program counter
• When an interrupt or subroutine occurs
occurs, the current
address in the program counter is copied into SRAM.
The program counter then jumps to the address of the
subroutine When completed
subroutine.
completed, the address in SRAM can
be restored to the program counter so that it can jump
back.
• The stack pointer is a special register that contains the
address (points to) the location in SRAM where the
Program counter address is located.
• Note:
N t Some
S
microcontrollers
i
t ll
use EEPROM ffor program
memory.
Program Counter/Stack Pointer
Program Counter (16 bit)
01
00
BD
BE
00
03
02
01
04
Program Memory (Flash RAM)
0x0000
rjmp Main
0x0001
ldi R9, 0xFF ; (main label)
0x0002
ldi R10, 0x34
0x0003
call MySubroutine;
0x0004
….more code
Restore Program
counter using SP
as address to
retrieve value from
stack
MySubroutine:
0x01BD
….subroutine code here
0x01BE
ret ; jump back to Main loop
Internal Memory
(Gen. Purpose Registers, I/O registers, SRAM)
0x0100
Call Subroutine
jumps Program
counter and stores
return address in
stack
Stack Point (16 bit)
10
FE
FF
0x0101
0x10FD
0x10FE
0x10FF
00
00
00
00
00
04
Stack Pointer
Initialized
Why the stack pointer?
•
•
•
We want to restore a value to the
program counter that we stored in
0007
SRAM, but where did we put it?
The stack pointer gives us the
Current Program Counter
address in SRAM where the
Program counter value is saved.
If we had a subroutine or interrupt
0100
occur within another subroutine,
About
bou to
o ju
jump
p here
ee
we would shove another program
counter value onto the stack
(SRAM). The stack pointer allows
us to retrace our steps, and exit
1 byte
out of each subroutine in the
proper order.
The stack pointer can also be
written to at any time and allows
us to track address in the stack
SRAM
(SRAM) to do other fancy things.
4Kbytes x 8
10FF
Stack Pointer
0007
Store Copy here
Timing (the heartbeat)
• Microprocessors uses oscillator (a quartz crystal) which
can produce
d
a constant
t t square wave to
t provide
id the
th
synchronization of everything on the chip. Each rising
edge of the square wave allows an operation to take
place such as loading instructions
instructions, executing
instructions, and saving results.
• Different operations take a different amount of cycles
(one period of the square wave)
wave). See Instruction set
summary for cycles.
• The oscillator source can be external or internal (on
some chips).
chips)
• The Atmega16 can be set to have a clock frequency of
8MHz. With many of the operations taking only 1 cycle,
that is approaching 8 million operations per second! You
could add the numbers from 1 to a million in .125
seconds!
Rising/Falling Edge
• Everything
y
g in a microcontroller happens
pp
on the
rising or falling edge of a signal.
• Most components with in the microcontroller
allow
ll
you to choose
h
which
hi h edge
d b
but d
default
f l iis
rising .
• The edge is the signal for a component to take in
new information and output the just processed
information.
• It also allows for registers, components, etc. to
be synchronized.
Prescale for a Timer
Main Clock (1 MHz)
Prescale=8, Divides Timer clock to 125 kHz
Each Rising (or falling) edge of timer clock
increments the timer count
If I had only a 3 bit timer (2^3=8 positions), I would
overflow at 7 (starts at 0) and wrap back to zero
Why the prescale is so important!
• For timers, the prescale allows me to set how fast the
ti
timer
counts
t and
d thus
th the
th resolution
l ti off titime th
thatt can be
b
measured
– For the fastest count, set prescale to 1 (default). The timer will
count at the same rate as main clock and have a resolution equal
to the period (1/frequency) of the main clock
– What if I were using an eight bit timer (max count=255, 2^8-1).
The counter would quickly fill up and overflow. I may decide to
either:
either
• Increase prescale so that it counts slower
• Switch over to a 16 bit timer (max count=65,535)
• Remember: Timers actually hold a count
count, but knowing the
prescale and main clock, we know what that count means
in time.
Time Counts TimerPeriod
• Actual Time=Counts*TimerPeriod
– TimerPeriod=MainclockPeriod*prescale
More prescale
• For devices like the A/D, the prescale will
determine how fast you sample (if in freerunning mode).
• You want to sample fast enough so that you do
not alias (refer to Alias lecture).
• But you may want to not set the prescale too
small (too fast sampling) because it wastes
power
– For small systems running on battery power,
reduction of power is critical
critical.
Timing
Most items have
prescalers that
p
divide the frequency
of the clock down
I/O ports
• Input
p and Output
p p
ports are the way
y the uC interfaces
with other components.
• Each port contains 8 pins.
• Ports can be input only
only, output only
only, or bi
bi-directional.
directional
The ATmega has all bi-directional ports. Bi-directional
ports means they have the capability to be both, but you
must choose one or the other at any given time
time.
– The direction of each pin is set through a special register for
each port.
• Several ports have dual functionality
functionality. With the proper
register setting, they can be used for special operations
such as A/D, external interrupts, SPI, etc.
I/O ports
•
Inputs
– External connections determine pin voltage
•
Outputs
– Microcontroller sets pin voltage
•
Controlled by three corresponding registers(memory locations)
– ‘Direction’set by Data Direction Register (DDRx) –bi-dir.
• 1 =Output
• 0=Input
– Pins are set to be ‘inputs’on reset
– Data Register (PORTx)
• As an output, write signal here
• Writing to PORTxwhen a pin is configured as an input turns on internal ‘pull up’resistor
(will read as logic 1 until pulled low)
– Port input pins (PINx) –Note: read only
Serial communication
• USART=Universal Synchronous
y
and Asynchronous
y
serial Receiver and Transmitter
– Serial communication
– Communicate serially
y back to a PC
• SPI=Serial Peripheral Interface
– Allows us to communicate to other devices using serial data.
The SPI controls allow us to enable certain devices, send and
receive serial data.
– Examples of things you might control with SPI: Other
microprocessors, external memory, A/D, LCD display, other
specialized chips.
– Advantage of using SPI is that you can control a device with a
single pin as opposed to connecting in parallel (using 8 pins to
send 8 bits)
bits).
A/D and D/A
•
Analog to Digital Converter
– C
Converts
t analog
l iinputt signals
i
l (t
(typically
i ll 0 tto 5 volts)
lt ) tto a di
digital
it l (bi
(binary))
representation that the mP can use.
– The Atmega128 has a 10 bit A/D. That means it can represent our
analog voltage with a 10 bit number. So what is our resolution?
– Resolution=5
R
l i
volts/2^10=0.0049
l /2^10 0 0049 volts
l
•
Digital to Analog Converter
– Allows the mP to specify a voltage with a binary number and then output
g voltage
g ((like 3.25 volts))
that analog
– Atmega 128 doesn’t have one and most mP don’t.
– Most often, we create an analog voltage by using pulse width
modulation (PWM).
•
We’ll learn more about the specific operation of A/D and D/A later in
the course
Timers
• Timers are really just counters
– A register that counts (up or down depending on
settings)
– The time runs using the main system clock and a
prescaler. A prescaler divides the main system clock.
Each of the four timers in the Atmega128 has its own
prescaler.
– So, if the system clock runs at 1 MHz, and I set the
prescaler to 1024, then my clock frequency will be ~1
kHz. In other words, I get 1 count every ~.001
seconds.
Pulse Width Modulation
• Pulse Width Modulation
– A method by which devices can be sent a voltage that is
equivalent to an analog voltage
– If I have a device that I want to give 2.5 volts, I could use and
D/A or I could use a 5 volt PWM signal with a 50% duty cycle.
cycle
– The effective voltage seen by the device is equal to the peak
value * the duty cycle (0-1)
• Veffective=5 volts*.5=2.5 volts
– The key is that the frequency of the PWM wave must be faster
than the device can respond too.
• If I have a small motor, and I suddenly step the voltage to 5 volts
and record the time it takes to come to steadyy state speed. And I
find that it takes .1 seconds to reach 63% of the steady state value,
this is called one time constant (1-e-1). Then, following a good rule
of thumb, I should make my PWM frequency at least 10 time faster
than it can react. .1 second=10 hz100 Hz (minimum)
PWM
Atmega 16 Circuit Diagram
Status Register
• Bit 7 – I: Global Interrupt
p Enable
• Bit 6 – T: Bit Copy Storage
• Bit 5 – H: Half Carry Flag
• Bit 4 – S: Sign Bit, S = N ْ V
• Bit 3 – V: Two’s Complement Overflow Flag
• Bit 2 – N: Negative Flag
• Bit 1 – Z: Zero Flag
• Bit 0 – C: Carry Flag
Must set this to enable interrupts
Interrupts
•
•
•
•
Interrupts are similar to subroutines except that you don’t call
interrupts they happen whenever a particular event happens
interrupts,
happens.
Internal interrupts are generated from several sources like
timer/counters. I could set up a counter to interrupt when it reaches
a certain value. When it interrupts, the main program would stop
and
d th
the iinterrupt
t
t routine
ti would
ld be
b executed.
t d After
Aft completion,
l ti
th
the
reti command (return from interrupt) would load our return location
into the program counter where it was stored from the stack.
p have a similar operation
p
except
p that their source
External interrupts
is from pins on the mP. I could set an interrupt to occur when a
certain pin on the chip went high.
You must set the Global Interrupt Enable in the SREG register to
allow interrupts
interrupts. This is easily done with the sei command
command. Further
Further,
you usually will need to clear the GIE when executing an interrupt.
Why? Because you don’t want another interrupt to “interrupt” you
while executing the first interupt’s code. Clearing GIE is done with
the cli
cli.