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 programmingi
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 bbecause 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
then write new program.
p g
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 ((rememberb you llose iit when
h power
goes). Its also the stack (discussed later).
EEPROM
permanent storage of data like constants
somethingg you
y save during gpprogram
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) =refer to

16 bits=2^16=65,536 (0-65,535)

Line 0 1 byte

SRAM
Remember, everything starts with zero. So 4Kbytes x 8
we have 65,536 elements that range from 0
to 65,535

Line
4095=0xFFF 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 GGenerall PPurpose 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
Restore Program Stack Point (16 bit)
Program Counter (16 bit) counter using SP 10 FE
FF
01
00 BD
BE
00
03
02
01
04 as address to
retrieve value from
stack Internal Memory
Program Memory (Flash RAM) (Gen. Purpose Registers, I/O registers, SRAM)

0x0000 rjmp Main

0x0001 ldi R9, 0xFF ; (main label)
0x0002 ldi R10, 0x34
0x0003 call MySubroutine;
0x0100
0x0004 .more code 00
Call Subroutine 0x0101 00
jumps Program
counter and stores
return address in
stack 0x10FD 00
MySubroutine: 00
0x10FE
0x01BD .subroutine code here 0x10FF
00
04
0x01BE ret ; jump back to Main loop 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,
we would shove another program About
bou too ju
jumpp here
ee
counter value onto the stack
(SRAM). The stack pointer allows
us to retrace our steps, and exit
out of each subroutine in the 1 byte
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 0007
Stack Pointer
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 andd 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 free-
running 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 Outputp pports are the wayy 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
that analog g ((like 3.25 volts))
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
Must set this to enable interrupts
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
 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
andd 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.
External interruptsp have a similar operation
p except
p that their source
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.