A Quickstart Tutorial for ATMEL AVR

Microcontrollers

If you're at all like me, you learn best by example and by doing. If that also sounds like you and you're
interested in the popular AVR microcontrollers, this tutorial should be right up your alley.

The goal is to get you up and running as quickly as possible, so you can get to exploring and modifying
on your own without having to fiddle with hardware, software, parts, or settings.

If you can program in basic C and are familar with most concepts around microcontrollers (perhaps
you've used a Basic Stamp, for example) and basic electronics, you'll be up and running in no time.

The software and hardware presented here are suitable for beginners, but also entirely appropriate for Y
more advanced projects. s
p
A
What You Will Get Out Of This S
(
Most tutorials skim over a lot of information. Not this one. This tutorial assumes you have some basic D
knowledge, but tries not to make any other assumptions. The goal is to lower the barrier to entry for E
getting started with the AVR by starting at square one (i.e. you don't even own a programmer) and a
getting you using the tools as quickly as possible. t
S
You can then get on with learning on your own by exploring and modifying, instead of wasting time s
figuring out fundamentals or usage of the tools! s
C
b
Overview A
p
i
This tutorial will demonstrate the following development process:
m
w
1. Write C programs in AVR Studio. a
2. Compile them into a .hex file using the AVR-GCC compiler (which integrates into AVR Studio). p
f
3. Simulate the target AVR chip and debug the code within AVR Studio. A
u
4. Program the actual chip using the AVRISP mkII USB device, which is attached to our target chip (
with a special 6-pin cable. P
i
5. Once programmed, the chip runs the program in your circuit. p
c
u
i
c

Hardware and Software Setup

1. Purchase an ATMEL AVRISP mkII programmer, and an ATTINY45 (8pin) microcontroller. They are
both available from Digi-Key, among other places. (There are other programmer options out there, but
I'll use the AVRISP mkII)

The AVRISP mkII Programmer

2. Go to ATMEL.com and download AVRStudio and any service packs. At this writing (February 2008)
there was AVRStudio 4, and two service packs. This is the main IDE we will be using.

3. Go to AVR-GCC's homepage at sourceforge.net. Download WinAVR. This contains the C compiler for
the AVR.

4. Install AVRStudio. Install Service packs (if any) starting at 1, then 2, etc. The install is pretty
straightforward.
5. Install WinAVR. The install should also be straightforward. I simply used all the defaults.

6. Install the software for the AVRISP mkII. (Either it came with the programmer, or download the latest
version from atmel.com. Follow all directions and like most USB devices, only plug it in once directed to
do so by the install program.)

7. Get a breadboard and stick the ATTINY45 into it. Make the following connections, which are the bare
bones for the part to function:

ATTINY45 Pin Number Pin Function Connects to:

1 /RESET +5V through 4.7k resistor

2 PB3

3 PB4

4 GND Power supply GND

5 MOSI

6 MISO

7 SCK

8 +VCC +5V

These are the minimum connections required for the ATTINY45 to function. In our application, the MOSI
(Master Out Slave In) and MISO (Master In Slave Out) and SCK (Serial Clock) pins will be used for the
ISP programming header. That leaves two general purpose I/O pins (PB3 and PB4) for our use. The
chip will be using its built-in internal oscillator as its clock, so no external crystal needs to be attached.

Note: Many pins are multi-function, and there are different ways to configure what pin
does what. That's something you can explore on your own after this tutorial is done,
but for now just be aware that it can be done. For this tutorial, we'll be left with two I/O
pins on the ATTINY45.

8. Attach LEDs - one LED and one current-limiting resistor (300 ohms, but actually anything between
that and 1k should do the trick) from to each I/O pin (PB3 and PB4) to GND. These LEDs will be the
outputs for our simple program - we're going to make them blink on and off.

9. Make the ISP header and connections. The ISP header is a 6-pin (3x2) interface to the AVR
programmer hardware.

A header is tough to breadboard, but you can make your own with some long pin headers as shown.
The top left pin will be pin #1 (just like the location of pin #1 when looking down at a chip).

Make the necessary connections so that the 6-pin header connects to the ATTINY45 pins as follows:

ISP Header Pin # Signal Name Connect to ATTINY45 Pin:

Pin 1 MISO MISO (Pin 6)

Pin 2 VCC +VCC (Pin 8)

Pin 3 SCK SCK (Pin 7)

Pin 4 MOSI MOSI (Pin 5)

Pin 5 RESET /RESET (Pin 1)

Pin 6 GND GND (Pin 4)

You will notice that the pins are all named pretty much the same and the signals are connected 1-to-1
from ISP header to AVR microcontroller. This is true of all AVR microcontrollers - not just the ATTINY45
we are using. The only difference is that the signals may be on physically different pins on the AVR
device depending on which you are using. Here, we're just going to stick with the ATTINY45.
For some additional information about AVR programmers and target boards, you can visit this page at
Evil Mad Scientist Labs.

You should therefore now have the following wired up on your breadboard:

Now you're ready to

get started with the
software
development!

Software
Development
1. Start AVR Studio on
your workstation.
Select "New Project".
Type is "AVR-GCC".
Project name:
"MyFirstProject".
Check off the "create
folder" box. Modify
the location if desired.

Click "Next".

Debug platform
should be "AVR
Simulator". Device is
"ATTINY45".
 Click Finish. You will
now be in the IDE.

2. Write the following

code into the window in
the middle of the screen
(the window for
MyFirstProject.c):

This is a quick and dirty way to turn both LEDs on.

This code tells all of Port B to become outputs by writing 0xFF (binary 1111 1111) to DDRB which is the
data direction register for port B. Each bit is mapped to a port B pin - a '1' written means that pin should
be an output. A '0' means the pin is an input. So we're making all of Port B outputs.
The next statement is similar in that we're sending 0xFF to PORTB - again, each bit is mapped to a Port
B pin. So writing 0xFF sets all of Port B as high (logical '1').

Now as you may recall, the only two I/O pins we are using are PB3 and PB4. All other pins on the part
are being used for something else.

So we really only needed to make Port B bits 3 and 4 outputs, then logical 1's. But we're using a
shotgun approach for simplicity so we just used 0xFF in both cases.

3. Compile the code with "Build -> Build" from the menu, or the F7 shortcut for "Build". The bottom
window will show the progress and results. You should see "Build succeeded with 0 warnings."

If there is an error, check your code for typos. The error message should give you the offending line
number.

A successful compile will result in a .hex file being generated. This is the binary code in a format ready
to be burned into your AVR chip by the programmer. (Think of the .hex file as a program that the target
AVR chip can run once we put it on there, sort of like writing to a memory card.)

You should be able to locate MyFirstProject.hex in your project dir. For me, it was in
"AVR\src\MyFirstProject\default\".

4. Now let's debug the code in the simulator to get a feel for how it works.

Use "Build -> Build and Run" from the menu, or use the CTRL-F7 shortcut.

Note the following:

We have a yellow arrow at the current execution.

We have some debugging keys at the top (we want STOP and STEP INTO now).

We have "AVR SIMULATOR" at the bottom which is no longer greyed out.

Now click on the right pane on PORTB so we can look at it in the "I/O View". The bottom right window
will populate with DDRB, PINB, and PORTB. These represent some states of the simulator's virtual
ATTINY45 hardware.

5. Step through the program line by line with "STEP INTO (F11)" button.

Notice DDRB (direction of pins for PORTB: input or output) changes on the bottom right after "DDRB =
0xff" is executed.

6. Step again and notice that PORTB becomes set to 0xff (all logical 1 output) when "PORTB = 0xff" is
executed.

We are now at the end of the program. Click "STOP DEBUGGING" (the blue square button on the menu
bar ) or CTRL-SHIFT-F5 to stop the debugger and chip simulator and return to the coding view.
http://imakeprojects.com/Projects/avr-tutorial/

AVR Programming
Contents
[hide]

1 Anatomy of a C program for AVR

2 C Syntax

o 2.1 Comments

o 2.2 Variables

o 2.3 Arrays

o 2.4 Conditionals

o 2.5 Looping
2.5.1 while Loops

2.5.2 for Loops

o 2.6 Functions

o 2.7 Scope

3 AVR-Specific Commands

o 3.1 Types

o 3.2 Setting and Clearing Bits

o 3.3 Writing to and Reading from registers

o 3.4 AVR Registers

3.4.1 The DDRx Register

3.4.2 The PORTx Register

3.4.3 The PINx Register

3.4.4 Other Registers

o 3.5 AVRLib

o 3.6 rprintf

o 3.7 Program Memory Directives

4 Makefiles

Anatomy of a C program for AVR

The following presents a rough overview and breakdown of a demo program from the avrlib-demos. The code is in the
avrlib-demos in the button directory in the file button.c. Details of C syntax and AVR-specific commands will follow.
 The first portion of a C program is usually a bunch of comments that describe the file. Usually this includes the

name, author, and date of the file; a revision history; and directions on how to use the file.

//---------------------------------------------------
//---------------------------------------------------
//
// AVRLIB-DEMO
// For avrlib and avrmini development board.
//
//
// File: button.c
// Author: Wendy Ju
// based on code written by Michael Gurevich & Matt Wright
//
// Revision History:
// When Who Description of change
// ----------- ----------- -----------------------
// 04-Oct-2004 Wendy Ju Created a new instance
// 01-Jun-2006 Michael Gurevich makefile->mega32, superfluous #includes
//
//---------------------------------------------------
// USING THE AVRMINI DEVELOPMENT BOARD, CONNECT
// THE LED/PUSHBUTTON JUMPER TO THE PORT B JUMPER.
//---------------------------------------------------
//
//---------------------------------------------------
// This program will cause LED 0 to light when corresponding
// pushbutton 4 is pressed.
//---------------------------------------------------

Next are #includes. They tell the compiler where to look for other bits of code you are using that do not reside

in this file. They are normally ".h" or header files that contain macros and function prototypes. Before a the .c file is
compiled, the contents of the #includes are literally copied into the file.

// compiler includes
#include <avr/io.h>

// avrlib includes
#include "global.h"

#defines are "macros". Before the program is compiled, the argument of the #define is simply substituted
everywhere the name is used. They are handy for giving meaningful names to numbers and for changing a single
value that may be used numerous times in a program without having to change every instance.
 #define DELAY 1000

Function prototypes give the name, arguments and return type of functions that will be used later in the program.

They can be included in header files or in the .c file before the function is defined.

int checkButton(int whichButton);

void setLED(int whichLED, int on);

The main function is literally the main part of the code. There can only be one main function in the final compiled

program. The code inside the main function is executed sequentially, one line at a time.

int main(void) {

// set LED pins as outputs, button pins as inputs

outb(DDRB, 0x0F);

// Turn off LEDs - looking at the circuit

// you can see that they are off when pulled high
outb(PORTB, 0xFF);

while(1) { // loop forever

setLED(0, checkButton(4));
//sampling delay goes here
}

return 0;
}

Finally, there are function definitions. These are pieces of code that are called from the main function or from

other functions, that have a specific functionality that may want to be used over and over.

int checkButton(whichButton) {
// On our boards the four buttons are numbered 4, 5, 6, and 7

return (! bit_is_set(PINB,whichButton));
/* Logical negation is because when the button is pushed, the pin
is drawn to ground, so the button is "on" when the bit is zero. */
}
 void setLED(int whichLED, int on) {
// On our board the four buttons are numbered 0, 1, 2, and 3

if (on) {
//light the LED
cbi(PORTB,whichLED);
} else {
//turn off the LED
sbi(PORTB,whichLED);
}
}

C Syntax

This is a very basic overview of the essential parts of the C language that are frequently encountered when writing simple
programs for the AVR. It is obviously impossible to thoroughly cover the C language in a few pages, but this should
provide a brief explanation of most things that will be encountered in demo programs. If you know C, you can skip this
section. For a better reference, see Kernighan, B.W. and D. M. Richie (1988) The C Programming Language. Prentice
Hall.

Comments

Comments are not evaluated by the compiler. They are there to help the programmer. There are two styles of

comments that can be used:

// This is a C++-style 'slash-slash comment'

/* This is a C-style comment*/

/* These comments must be terminated with a star-slash */

Variables

Declaring a variable means allocating a chunk of RAM on the AVR and giving it a name. After a variable is

declared, the chunk of memory can be assigned a value, and that value can be recalled, using its name. A variable
declaration looks like this:

u08 myvar; // unsigned 8-bit integer named myvar

where u08 is the type and myvar<tt> is the name. Notice the statement ends with
a semicolon, like all C statements. A variable must be declared before it is used,
and before any executable statements in the function in which it is declared. Integer
types are:
u08 a; // unsigned 8-bit integer (0 to 255) or 0 to MAX_U08
 s08 b; // signed 8-bit integer (-128 to 127) or MIN_S08 to MAX_S08
u16 c; // unsigned 16-bit integer (0 to 65535) or 0 to MAX_U16
s16 d; // signed 16-bit integer (-32768 to 32767) or MIN_S16 to MAX_S16
u32 e; // unsigned 32-bit integer (0 to 4294967295) or 0 to MAX_U32
s32 f; // signed 32-bit integer (-2147483648 to 2147483647) or MIN_S32 to
MAX_S32

<tt>MAX_U08, etc. are macros that are #defined in the AVRLib.

An assignment gives a value to a variable, using the assignment operator = :

u08 foo, bar; // define 2 unsigned 8-bit integers

foo = 12; // assign the value 12 to the variable foo
bar = foo * 10; // assign the 10 times the value of foo to the variable bar

Arrays

Arrays are adjacent chunks of memory of the same size that allow convenient indexing. They are defined as

follows.

u08 myarray[5]; // define an array of 5 unsigned 8-bit integers

u08 myarray2[3] = {10, 12, 18}; // decfine an array of 3 unsigned 8-bit
integers
// and initialize their values to 10, 12 and
18

Arrays can be accessed for assignment or use in expressions with square

brackets as well. Note that array indices begin at 0:

myarray2[0] = 11; // assign the value 11 to the first element of the array
myarray2
myarray2[1] = myarray[0]; // assign the value of the first element of myarray
// to the second element of myarray2

Conditionals

The basic conditional statement is the if ... else statement. It looks like this:

if (a == 2) { // if a is equal to 2
foo++; // increment the variable foo
bar = foo + 10; // assign the value of foo plus 10 to bar
 }
else { // otherwise (a is not equal to 2)
foo--; // decrement foo
bar = foo - 10; // assign the value of foo minus 10 to bar
}

Note the increment and decrement operators, ++ and -. The keyword if is followed by an expression in parentheses

that evaluates to a number. If the expression evaluates to a number other than zero, then the statements in braces
immediately following are evaluated. If the expression evaluates to 0, anything following the else in braces will be
evaluated. If there are no braces, then only the next line will be evaluated. An if does not need to be followed by else:

you may only want something to be done in one case of the condition, and not in others.

The conditional expression normally has a relational operator. The relational operators take two arguments and evaluate
to 1 if the relation is true and 0 if it is false. The operators are:

== equality
!= inequality
< less than
> greater than
<= less than or equal to
>= greater than or equal to

Note the difference between the equality operator == and the assignment operator =. This is one of the most common

sources of bugs in C programming.

Looping
There are 2 looping structures in C: while and for loops.

while Loops

A while loop is a block of code that is executed repeatedly until some condition is met. Its structure is:

while(expression) {
statements
}

As with an if statement, the expression in parentheses is evaluated first. If it evaluates to non-zero, the statements in
the body of the loop are executed. At the end of the loop body, the expression is evaluated again, and the body is
executed until the expression evaluates to 0. The expression is normally relational, depending on some value that is
being updated in the loop.

u08 button;
while (button != 1) { // while the value of button is not equal to 1
button = checkButton(3); // call the function checkButton with
// argument 3, and assign its value to
// the variable button
}

This loop will execute until the function checkButton(3) returns a 1. This type of structure is common for polling an

input.

A common exception to using relational operators is the expression

while (1) { // loop forever

...
...
}

This never-ending loop is found in almost all of our AVR programs, because we have some functionality that we want to
repeat continuously.

for Loops

A for loop is normally used when you want to perform an action a specific number of times. Its structure is:

for (initialization; condition; update) {

statements
}

where initialization, condition, and update are expressions. Normally, the initialization and update are assignments or
function calls, and the condition is a relational expression. A typical for loop might look like this:

for (i=0; i<4; i++) { // for i from 0 to 3

checkButtons(i); // call function checkButtons with argument i
}

Here, the initialization sets the value of the variable i, the loop counter, to 0. This statement is executed only once, before

the loop is entered. The condition is normally a relational expression. If it evaluates to non-zero, the body of the loop is
evaluated. At the end of the loop body, the update expression is evaluated, before the condition is evaluated again, to
determine whether the loop body should be executed again. Normally, the condition will be violated after the update has
been evaluated a certain amount of times. The structure in the example above is most common.

Notice that

for (initialization; condition; update) {

statements
}

is equivalent to

initialization;
while(condition) {
statements
update
}

Functions

A function is defined as:

returntype FunctionName(arg1type arg1name, arg2type arg2name ...)

{
declarations
statements
}

A function definition specifies what the function does, and can occur in a few different places. Functions can be defined
after the main function, as long as a function prototype has first been declared. The prototype contains the name, return
type and arguments, but not the body of the function. Here, the term declaration is used for function prototypes that
declare that the function exists. The term definition is used where the body of the function is actually specified. Normally,
a .c file has a companion .h file that contains all the function prototypes. With the AVRlib, we normally use a number of .c
files (e.g. timer.c or a2d.c) that contain function definitions. The .c files are compiled together with the .c file you
write, and are specified in the makefile (see below). But, in order to use functions from those .c files, you first need to
declare their prototypes. This is done by including the corresponding .h file (e.g. timer.h or a2d.h). Look in a .h file in
the AVRlib to see what it looks like. Functions can also be defined before the main function, but this is generally
considered bad style.
 After a function is declared, it can be "called" or used, as long as its definition exists. If the function does not
return a value, its return type is declared as void. void is also used if there are no arguments. The example

program in the first section contains such a function:

void checkButton(void) {
...
}

The code inside the function is executed when it is "called" from the another function:

checkButton();

If the function returns a value, the keyword return must be present in the function, followed by the value to be returned.
Once return is reached, the function exits and evaluates to the return value. If a function has arguments, they are

normally passed as a value in parentheses after the function name in the function call. Inside the function, the arguments
act like variables that have the value that has been passed. Take the following program for example:

u16 timesten(u16 foo); // function prototype

int main(void) {
u16 bar; // declare an unsigned 16-bit variable
bar = timesten(9); // call the function timesten with the argument 9, store
the result in bar
...
}

u16 timesten(u16 foo) { //define the function timesten, takes 1 argument

return (foo * 10); //return the argument multiplied by 10
}

Here the variable bar will end up with the value 90.

You'll notice that the main function normally has a return type int, and returns a value of 0. This is mainly used

as a convention for our purposes. A return value of zero typically indicates that a program has exited normally, and
other numbers are used to specify different errors. The main function does not require a prototype.

Scope
 Scope refers to the region of a program in which a named entity can be used. In the previous example, the
variable bar cannot be used inside the definition of timesten. Similarly, the argument named foo has no meaning
inside the mainfunction. For variables and arguments defined within a function, their scope lasts only until the end of

the function. A special type of variable called a global variable is defined before the main function, and can be used
inside any function defined after the global variable is declared. In other contexts, global variables are often frowned
upon, but in microcontroller programming they can be useful. A distinction is often made between local scope, which
applies to the current function and global scope which applies to all functions. In the case of a local and global
variable with the same name, the locally-defined one is used. It is best to avoid using the same names for variables
even if they have different scope to avoid confusion.

When program execution exits a function, the memory assigned to the variables that are local to that function is

freed for use by other parts of the program. This means that the values of the local variables will not be the same the
next time the function is called. In cases where you want the values of variables to persist between function calls,
the static declaration is used before the variable type in the variable definition. In the example in the first
section, the debounce counterbuttonDownCounter is used to as a counter whose value needs to be maintained
across function calls, and is therefore declared to be static.

void checkButton(void) {
static u16 buttonDownCounter;
...

AVR-Specific Commands
Types

It is very important to keep track of how big your variables are. The following are defined in inttypes.h, part of the

avr-libc. When used in your program, they are created in RAM.

Data Type Length (bits/bytes) Values

Uint8_t 8/1 0 to 255
Int8_t 8/1 -128 to 127
Uint16_t 16 / 2 0 to 65535
Int16_t 16 / 2 -32768 to 32767
Uint32_t 32 / 4 0 to 4294967295
Int32_t 32 / 4 -2147483648 to 2147483647
 Uint64_t 64 / 8 0 to 1.8*1019
Int64_t 64 / 8 -9.2*1018 to 9.2*1018

There is another set of data types defined in the avrlib in global.h, that are sometimes easier to use. You will find

them more commonly in our demo programs.

Data Type Length (bits/bytes) Values

u08 8/1 0 to 255
s08 8/1 -128 to 127
u16 16 / 2 0 to 65535
s16 16 / 2 -32768 to 32767
u32 32 / 4 0 to 4294967295
s32 32 / 4 -2147483648 to 2147483647
u64 64 / 8 0 to 1.8*1019
s64 64 / 8 -9.2*1018 to 9.2*1018

Setting and Clearing Bits

Remember that setting a bit is setting it high or to 1, and clearing a bit is making it low or 0.

sbi - set a bit.

void sbi(u08 register, u08 bit)

Sets a bit in a register. For example, to set the 0th bit of Port D, you can use:

sbi(PORTD,0);

or

sbi(PORTD,PD0);

or

sbi(PORTD,PIND0);
 cbi - clear a bit.

void cbi(u08 register, u08 bit)

Clears a bit in a register. For example, to clear the 2nd bit of Port B, you can use:

cbi(PORTB,2);

Writing to and Reading from registers

The easiest way to write a byte to a register is with an assignment. To write the byte 0x0F (0000 1111 in binary)
to the PORTD register:

PORTD = 0x0F;

Direct assignment to registers is a recent addition to AVR C syntax. Previously, the outb function was used:

void outb(u08 port, u08 val)

writes the byte val to a port. To write the byte 0x0F to the PORTD register, you would do the following:

outb(PORTD,0x0F);

To read a byte from a register, you can also use an assignment.

u08 status;
status = PIND;

would read the value of the PIND register and store it in the variable status.

Similar to outb, the function u08 inb(u08 port) returns the value of the register port.

status = inb(PIND);
is equivalent to the previous statement.

AVR Registers

All information in the microcontroller, from the program memory, the timer information, to the state on any of input

or output pins, is stored in registers. Registers are like shelves in the bookshelf of processor memory. In an 8-bit
processor, like the AVR ATMega 16 we are using, the shelf can hold 8 books, where each book is a one bit binary
number, a 0 or 1. Each shelf has an address in memory, so that the controller knows where to find it.

The 32 IO pins of the ATMega32 are divided into 4 ports, A, B, C, and D. Each port has 3 associated registers.

For example, for port D, these registers are referred to in C-language by PORTD, PIND, and DDRD. For port B,
these would be PORTB, PINB, and DDRB, etc. In C-language, PORTD is really a macro, which refers to a number
that is the address of the register in the AVR, but it is much easier to remember PORTD than some arbitray
hexadecimal number.

The DDRx Register

DDR stands for Data Direction Register. There is one DDR register for each Data Input Port, and they are named

for the port they control: DDRA, DDRB, DDRC, DDRD.

The DDRD register sets the direction of Port D. Each bit of the DDRD register sets the corresponding Port D pin

to be either an input or an output. A 1 makes the corresponding pin an output, and a 0 makes the corresponding pin
an input. To set the first pin of Port D to be an output pin, you could use the sbi(reg,bit) function, which sets a bit
(makes it high or binary 1) in a register:

sbi(DDRD, 0); //these two statements are equivalent

sbi(DDRD, PD0); //both set the first pin of port D to be an input
//by setting the 0 bit of the DDRD register.

To set the second pin to be an input, you could use the cbi(reg,bit) function which clears a bit (makes it low or

binary 0) in a register:

cbi(DDRD, 1); //these two statements are equivalent

cbi(DDRD, PD1); //both set the second pin of port D to be an output
//by setting the 1 bit of the DDRD register.
 Note that in C, the bit indexing begins with 0. The bits in a register go from 0 to 7. This may be a source of

confusion, because when we talk about the "first pin" or "pin 1" of a port, we are referring to the 0 bit or P0 in C. The
AVRmini boards label the first pin as pin 1.

You can also set the value of all the bits in the DDRx register (or any register) using
the outb(reg,byte) command. It writes a byte (8 bits) to a register. For example, if you wanted to set pins 1-4 of

port B to output and pins 5-8 to input, you could use:

outb(DDRB, 0x0F); //Set the low 4 pins of Port B to output

//and the high 4 pins to input

An alternate way to write a value to a register is using the same syntax as a C assignment:

DDRB = 0x0F; //Set the low 4 pins of Port B to output

//and the high 4 pins to input

The PORTx Register

The PORTx register functions differently depending on whether a pin is set to input or output. The simpler case is

if a pin is set to output. Then, the PORTC register, for example, controls the value at the physical IO pins on Port C.
For example, we can set all the port C pins to output and then make 4 of them high (binary 1) and 4 of them low
(binary 0):

DDRC = 0xFF; //Set all Port C pins to output

PORTC = 0xF0; //Set first 4 pins of Port C low and next 4 pins high

When a pin is set to be an input, PORTx register DOES NOT contain the logic values applied to the pins. We use

the PINx register for that. If a pin is an input, a 1 in the PORTx register sets a pull-up resistor. This means that if no
other circuitry is connected to this physical pin that the voltage on this pin will be Vcc; that is, by default, this pin is set
high. This is helpful for a variety of circuits.

DDRC = 0x00; //Set all Port C pins to input

PORTC = 0xFF; //Set pull-up resistors on Port C

The PINx Register

 When a pin is set to input, the PINx register contains the value applied to the pin. The pins have an electrical

threshold of around 2.5 volts. If a voltage above this level is applied to an input pin, the corresponding bit of the PINx
register will be a 1. Below this voltage, the bit will be a zero. See the ATMega16 schematic for the specific threshold
voltages. To read the value of an input port, you can use the inb(reg) function or a direct assignment. It returns an

8-bit number that is the value of the 8 bits in the specified register.

u08 foo; // declare an 8-bit variable

DDRD = 0x00; // set port D pins to input
PORTD = 0xFF; // set pull-ups on port D
foo = PIND; // read the value of the port D pins
// and store in the variable foo

There is also a function available for checking the state of an individual bit, without reading the entire PINx
register. The function bit_is_set(reg,bit) returns a 1 if the given bit in the given register is set, and a 0 if the

bit is cleared.

u08 bar; // declare an 8-bit variable

DDRD = 0x00; // set port D pins to input
PORTD = 0xFF; // set pull-ups on port D
bar = bit_is_set(PIND,1);
// bar now contains the logic value at Port D pin 2

Other Registers

There are many other registers in the AVR. They can be accessed using the same functions above. Many, such

as the timers and A/D converters have associated high-level functions in the AVRlib that make accessing the
registers unnecessary. There are also a few 16-bit registers that may be encountered. For these, the functions
outw(reg,word) and inw(reg) replace their byte-wise counterparts.

AVRLib
The AVRLib is essentially a collection of functions and macros that make accessing the functionality of the AVR
microprocessor easier and more intuitive. The functions tend to have intuitive names, and follow a naming convention
offilenameActionToPerform(), where filename is the descriptive name, beginning with a lowercase letter of the .c
and .h file in which the function is contained (e.g. timer for timer functions or a2d for analog-to-digital conversion
functions). TheActionToPerform() portion of the name normally describes what the function does. Most AVRLib files
have an initialization function which must be called before the other functions for that file can be used, for
example timerInit(), uartInit()and midiInit().
rprintf

rprintf is an AVRLib module that we will use often. It is used for printing strings of characters, usually to an LCD
display or over a serial cable connection to a terminal. It was designed to function like the printf function commonly

used in other C environments.

The easiest way to use rprintf is to simply give it a string in quotes:

rprintf("Hello");

In order for this action to have any effect, the rprintf system must first have been initialized by calling rprintfInit(location),
where location is one of a set of pre-defined functions for specifying where to print to:

rprintfInit(lcdDataWrite); // initialize rprintf to print to the LCD

A "string" is really an array of characters. Characters have the type char, and are 8-bit numbers that use the

standard ASCII encoding where each number specifies a character. You can assign a character in single quotes to a
char variable, and it will evaluate to its ASCII code. The following chunk of code from lcdtest.c defines an array of
characters 41 elements long, then in a for loop sets the first 40 elements to be sequential ASCII characters beginning
with 'A'. Finally it sets the last element of the array to '$\backslash$0'. '$\backslash$0' is known as the "null
character", and must terminate or be the last element of a string in RAM to be printed correctly. The function
rprintfStr(stringinRAM) then prints a null-terminated character array from RAM.

#define MAXCOL 40
int main(void) {

char str2[MAXCOL+1];
// Allocate RAM for a test String
// but don't initialize the string.
rprintfInit(lcdDataWrite); // initialize rprintf to print to the LCD

// Store Characters in the test string in RAM

for (i=0; i<MAXCOL; i++) {
str2[i] = ('A' + i);
}
str2[MAXCOL] = '\0'; //RAM String must be NULL terminated
rprintfStr(str2); //print a string from RAM
}
 rprintf can also print numbers in a variety of ways. The %d special character can be inserted into a string,
where it acts as a placeholder for a decimal number. In this case, rprintf takes 2 arguments, the string and then
the number to replace %d. rprintf takes as many additional arguments as there are %d characters in the string.

u08 k;
...
rprintf("This is the number one: %d", 1); // print a decimal number
k=2;
rprintf("These are two other numbers: %d %d", k, 4); // print a decimal
number from a variable

Similar to %d, %x lets you print hexadecimal numbers and %c lets you print characters.

rprintfNum lets you print numbers with a variety of options:

// print a formatted decimal number

// - use base 10
// - use 8 characters
// - the number is signed [TRUE]
// - pad with '.' periods
rprintfNum(10, 8, TRUE, '.', 1234);

output will be

+...1234

There are a number of other rprintf functions and options. See lcdtest and vt100test avrlib-demos for

examples.

Program Memory Directives

The AVR microcontrollers generally have a lot more FLASH memory for storing programs than they have RAM for storing
data when the programs are running. Strings can quickly use up a lot of memory, therefore if you are using a lot of strings
that do not need to change during the course of program execution, it makes sense to store them in program memory,
and not in RAM. Several functions are available for this. One of the simplest to use is rprintfProgStrM():

rprintfProgStrM("Hello!"); // print a string that is automatically stored in

program memory