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 85C/100 years att 25C(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 metaloxidesemiconductor (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). Its 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, its 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)

Directionset by Data Direction Register (DDRx) bi-dir.
1 =Output
0=Input

Pins are set to be inputson reset

Data Register (PORTx)
As an output, write signal here
Writing to PORTxwhen a pin is configured as an input turns on internal pull upresistor
(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 doesnt have one and most mP dont.
Most often, we create an analog voltage by using pulse width
modulation (PWM).

Well 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 hz100 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: Twos 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 dont 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 dont want another interrupt to interrupt you
while executing the first interupts code. Clearing GIE is done with
the cli
cli.