Embedded

Systems
Engr. Rashid Farid Chishti
chishti@iiu.edu.pk
Chapter 07: AVR Programming in C
International Islamic University H-10, Islamabad, Pakistan
http://www.iiu.edu.pk

Why program the AVR in C ?

1.
2.
3.
4.

5.
6.
7.

It is easier and less time consuming to

write in C than in Assembly.
C is easier to modify and update.
You can use code available in function
libraries.
C code is portable to other
microcontrollers with little or no
modification.
While Assembly language produces a hex
file that is much smaller than C.
Programming in Assembly language is often
tedious and time consuming.
C programming is less time consuming and
much easier to write, but the hex file
size produced is much larger than if we
used Assembly language.

Data Types Used by C Compilers

Data Type

Size

Data Range

unsigned char

8-bit

0 to 255

char

8-bit

-128 to +127

unsigned int

16-bit 0 to 65,535

int

16-bit -32,768 to +32,767

unsigned long

32-bit 0 to 4,294,967,295

long

32-bit -2,147,483,648 to
+2,147,483,648

float

32-bit 1.175e-38 to 3.402e38

double

32-bit 1.175e-38 to 3.402e38

Example 7-1
// The following program sends values 00-FF to Port B.
#include <avr/io.h>
//standard AVR header
int main(void) {
unsigned char z;
DDRB = 0xFF;
//PORTB is output
for(z = 0; z <= 255; z++)
PORTB = z;
return 0;
}
// Notice that the program never exits the for
// loop because if you //increment an unsigned
// char variable when it is OxFF, it will become 0.

I/O Ports in AVR

ATmega32 is 40-pin chip

A total of 32 pins are
set aside for the 4 ports
PORTA, PORTB, PORTC, PORTD.
Each port has 3 I/O registers associated with it
They are designated as
DDRx (Data Direction Register), PORTx(Data Register), and PINx(Port INput pins).
For example, for Port B we have PORTB, DDRB,
PINB registers.
each of the I/O registers is 8 bits wide, and
each port has a maximum of 8 pins.

I/O Ports in AVR

Port

Address

Usage

Port

Address

Usage

PORTA

$3B

Output

PORTC

$35

Output

DDRA

$3A

Direction

DDRC

$34

Direction

PINA

$39

Input

PINC

$33

Input

PORTB

$38

Output

PORTD

$32

Output

DDRB

$37

Direction

DDRD

$31

Direction

PINB

$36

Input

PIND

$30

Input

Data Direction Register

( DDRx
DDRx
)
register
is used for the purpose

of
making a given port an input or output
port.
Setting (writing a one) to a bit in the
DDRx configures the pin as an Output.
Clearing (writing a zero) to a bit in the
DDRx configures the pin as an Input. e.g.
Imagine a person who has 0 dollars, he can
only get money, not give it. Similarly when
DDR contains 0s the port gets data.

DDRC = 0xFF;
// Configure PRTC as output
DDRA = 0x00;
// Configure PRTA for input

Port Input Pin Register ( PINx )

To read the data present at the

should read the PINx register.
To send data out to pins we use
register .
There is a pull-up resistor for
the AVR pins.

pins, we
the PORTx
each of

Different States of a Pin in the AVR Microcontroller

DDRx
PORTx

Input & high impedance

Out 0

Input & Pull-up

Out 1

Data Register ( PORTx )

The PORTx register controls if the pull-up
is activated or not
Writing a 1 to the PORTx register will
activate the internal pull-up resistor
Writing a 0 to the PORTx register will
deactivate or turn off the internal pull-up
resistor
DDRA = 0x00;
//configure PORTA for input

PORTA = 0xFF;
//turn-on the pull-up resistors

Example 7-2
// this program sends hex values for ASCII
// characters of 0,1,2,3,4,5,A,B,C,D to Port B.
#include <avr/io.h>

//standard AVR header

int main(void){

//the code starts from here

unsigned char myList[] = "012345ABCD";

unsigned char z;
DDRB = 0xFF;

//PORTB is output

for(z=0; z<10; z++)

z

//repeat 10 times and increment

PORTB = myList[z] ; //send the character to PORTB

while(1);
trainer
return 0;
}

//needed if running on a

Example 7-3
// this program toggles all the bits of Port B 200 times.
#include <avr/io.h>

// standard AVR header

int main(void){

// the code starts from here

DDRB = 0xFF;

// PORTB is output

PORTB = 0xAA;

// PORTB is 10101010

unsigned char z;
for(z=0; z < 200; z++)
PORTB = ~ PORTB;
while(1);
return 0;
}

// run the next line 200 times

// toggle PORTB
// stay here forever

Example 7-4
// A program to send values of -4 to +4 to Port B.
#include <avr/io.h>
//standard AVR header
int main(void){
char mynum[] = {-4,-3,-2,-1,0,+1,+2,+3,+4} ;
unsigned char z;
DDRB = 0xFF;
// PORTB
is
output
for( z=0 ; z<=8 ; z++)
PORTB = mynum[z];
while(1);
// stay here
forever
return 0;
}
// Run the above program on your simulator to see how
// PORTB displays values of FCH, FDH, FEH, FFH, 00H, 01H,
// 02H, 03H, and 04H (the hex values for -4, -3, -2, -1,0,
// 1, etc.). numbers.

Example 7-5
// program to toggle all bits of Port B 50,000 times.
#include <avr/io.h>
//standard AVR header
int main(void){
unsigned int z;
DDRB = 0xFF;
//PORTB
is
output
for( z=0 ; z<50000 ; z++){
PORTB = 0x55;
PORTB = 0xAA;
}
while(1);
//stay here forever
return 0;
}
// Run the above program on your simulator to see how Port
// B toggles continuously. Notice that the maximum value
// for unsigned int is 65,535.

Example 7-6
// A program to toggle all bits of Port B 100,000 times.
//toggle PB 100,00 times
#include <avr/io.h> // standard AVR header
int main(void){
unsigned long z; // long is used because it should
// store more than 65535
DDRB = 0xFF;
// PORTB is output
for( z=0 ; z<100000 ; z++){
PORTB = 0x55;
PORTB = 0xAA;
}
while(1);
//stay here forever
return 0;
}

Example 7-7
// A program to toggle all the bits of Port B continuously
// with a 100 ms delay. Assume that the system is ATmega32
// with XTAL = 8 MHz.
#include <avr/io.h> // standard AVR header
void delay100ms(void){
// try different numbers on your
unsigned int i;
// compiler and examine the
for(i=0; i<42150; i++); // result.
}
int main(void){
DDRB = 0xFF;
while(1){
PORTB = 0xAA;
delay100ms() ;

PORTB = 0x55;
delay100ms();
}
return 0;

// PORTB is output

Example 7-8
// Write an AVR C program
// continuously with a 10
// function in Win AVR.
#include <util/delay.h>
#include <avr/io.h>
int main(void){
DDRB
=
0xFF;
while(1)
{
PORTB
=
0xAA;
_delay_ms(10);
PORTB = 0x55;
_delay_ms(10);

}
return

0;

to toggle all the pins of Port B

ms delay. Use a predefined delay
//delay loop
functions
//standard AVR header
//PORTB

is

output

I/O PROGRAMMING IN C:
//
LEDs are connected
Example
7-9 to pins of Port B. Write

an AVR C

// program that shows the count from 0 to FFH (0000 0000

// to 1111 1111 in binary) on the LEDs.
#include <avr/io.h>
int main(void)
{
DDRB = 0xFF;
while (1)
{
PORTB = PORTB + 1;
}
return 0;
}

I/O PROGRAMMING IN C:
//
Write an AVR 7-10
C program to get a byte of data
Example

from Port

// B, and then send it to Port C.

#include <avr/io.h>
int main(void){
unsigned char temp;
DDRB = 0x00;
DDRC = 0xFF;
while(1){
temp = PINB;
PORTC = temp;
}
return 0;
}

// standard AVR header

// Port B is input
// Port C is output

I/O PROGRAMMING IN C:
//
Write an AVR 7-11
C program to get a byte of data
Example

from
// Port C. If it is less than 100, send it to Port B;
// otherwise, send it to Port D.
#include <avr/io.h> //standard AVR header
int main(void){
DDRC = 0x00;
//Port C is
input
DDRB = 0xFF;
//Port B is output
DDRD = 0xFF;
//Port D is output
unsigned char temp;
while(1){
temp = PINC;
//read from PINB
if(temp < 100 )
PORTB = temp;
else
PORTD = temp;
}
return
0;
}

BITWISE OPERATIONS IN C: Example

7-12
// Run the following program on your simulator and examine
// the results.
#include <avr/io.h>
int main(void) {
DDRA
=
0xFF; //make
DDRB
=
0xFF; //make
DDRC
=
0xFF; //make
DDRD
=
0xFF; //make
PORTA =
0x35 & 0x0F;
PORTB =
0x04 | 0x68;
PORTC =
0x54 ^ 0xF0;
PORTD = ~ 0x55;
while(1);
return 0;
}

//standard AVR
Port A output
Port B output
Port C output
Port D output
// bitwise AND
// bitwise OR
// bitwise XOR
// bitwise NOT

header

BITWISE OPERATIONS IN C: Example

7-13
// Write an AVR C program to toggle only bit 4 of

Port B
// continuously without disturbing the rest of the
pins of
// Port B.
#include <avr/io.h>
//standard AVR header
int main(void)
{
DDRB = 0xFF;
//PORTB is output
while(1)
{
PORTB = PORTB ^ 0b00010000;
//set bit
4 (5th bit) of PORTB
}
return 0;
}

BITWISE OPERATIONS IN C: Example

7-14
// Write an AVR C program to monitor bit 5 of port C. If
// it is HIGH, send 55H to Port B; otherwise, send AAH to
// Port B.
#include <avr/io.h> // standard AVR header
int main(void){
DDRB = 0xFF;
// PORTB is output
DDRC = 0x00;
// PORTC is input
DDRD = 0xFF;
// PORTB is output
while(1){
if (PINC & 0b00100000) // check bit 5 (6th bit)
// of PINC
PORTB = 0x55;
else
PORTB = 0xAA;
}
return 0;
}

BITWISE OPERATIONS IN C: Example

7-15
// A door sensor is connected to bit 1 of Port B, and an
// LED is connected to bit 7 of Port C. Write an AVR C
// program to monitor the door sensor and, when it opens,
// turn on the LED.
#include <avr/io.h>
//standard AVR header
int main(void){
DDRB = DDRB & 0b11111101;
//pin 1 of Port B is input
DDRC = DDRC | 0b10000000;
//pin 7 of Port C is output
while(1){
if (PINB & 0b00000010)//check pin 1(2nd pin) of PINB
PORTC = PORTC | 0b10000000;
//set pin 7 (8th pin) of PORTC
else
PORTC = PORTC & 0b01111111;
//clear pin 7 (8th pin) of PORTC
}
return 0;
}

BITWISE OPERATIONS IN C: Example

7-16
// The data pins of an LCD are connected to Port B. The
// information is latched into the LCD whenever its Enable
// pin goes from HIGH to LOW. The enable pin is connected
// to pin 5 of Port C (6th pin). Write a C program to send
// "The Earth is but One Country" to this LCD.
#include <avr/io.h> //standard AVR header
int main(void){
unsigned char message[] = "The Earth is but One Country";
unsigned char z;
DDRB = 0xFF; //Port B is output
DDRC = DDRC | 0b00100000; //pin 5 of Port C is output
for ( z = 0; z < 28; z++){
PORTB = message[z] ;
PORTC = PORTC | 0b00100000; //pin LCD_EN of Port C is 1
PORTC = PORTC & 0b11011111; //pin LCD_EN of Port C is 0
}
while (1); return 0;
} //In Chapter 12 we will study more about LCD interfacing

BITWISE OPERATIONS IN C: Example

//
Write an AVR C program to read pins 1 and 0 of Port B
7-17
// and issue an ASCII character to Port D
#include <avr/io.h>
//standard AVR header
int main(void){
unsigned char z;
DDRB = 0;
// make Port B an input
DDRD = 0xFF;
// make Port D an output
while(1){
// repeat forever
z = PINB;
// read PORTB
z = z & 0b00000011;
// mask the unused bits
switch(z){
// make decision
case(0): PORTD = '0'; break; // issue ASCII
case(1): PORTD = '1'; break; // issue ASCII
case(2): PORTD = '2'; break; // issue ASCII
case(3): PORTD = '3'; break; // issue ASCII
}
}
return 0;
}

0
1
2
3

BITWISE OPERATIONS IN C: Example

//
Write an AVR C program to monitor bit 7 of Port B. If
7-18
// it is 1 make bit 4 of Port B input; otherwise, change
// pin 4 of Port B to output.
#include <avr/io.h>
//standard AVR header
int main(void){
DDRB = DDRB & 0b01111111; //bit 7 of Port B is input
// DDRB &= 0b01111111;
while (1){
if(PINB & 10000000)
//bit 4 of Port B is input
DDRB = DDRB & 0b11101111;
// DDRB &= 0b11101111;
else
//bit 4 of Port B is output
DDRB = DDRB | 0b00010000;
// DDRB |= 0b00010000;
}
return 0;
}

BITWISE OPERATIONS IN C: Example

//
Write an AVR C program to get the status of bit 5 of
7-19

// Port B and send it to bit 7 of port C continuously.

#include <avr/io.h>
//standard AVR header
int main(void){
DDRB = DDRB & 0b11011111; // bit 5 of Port B is input
// DDRB &= 0b11011111;
// using compound Assignment
DDRC = DDRC | 0b10000000; // bit 7 of Port C is output
// DDRC |= 0b10000000;
// using compound Assignment
while (1){
if(PINB & 0b00100000) //set bit 7 of Port C to 1
PORTC = PORTC | 0b10000000;
PORTC |= 0b10000000;
else
//clear bit 7 of Port C to 0
PORTC = PORTC & 0b01111111;
PORTC &= 0b01111111;
}
return 0;
}

BITWISE OPERATIONS IN C: Example

7-20
//
Write an AVR C program to toggle all the pins of
// Port B continuously.
#include <avr/io.h> // standard AVR header
int main(void){
DDRB = 0xFF;
// Port B is output
PORTB = 0xAA;
while(1)
{ PORTB = ~ PORTB; }
// toggle PORTB
return 0;
}

#include <avr/io.h>
// standard AVR header
int main(void){
DDRB = 0xFF; PORTB = 0xAA; // Port B is output
while(1)
PORTB = PORTB ^ 0xFF;
return 0;
}

Bitwise Shift Operators in C: Example

7-23
//
Write an AVR C program to monitor bit 7 of Port B. If
// it is 1, make bit 4 of Port B input; else, change pin
// 4 of Port B to output.
#include <avr/io.h>
// standard AVR header
int main(void) {
DDRB = DDRB & ~(1<<7);

// bit 7 of Port B is input

while (1){
if(PINB & (1<<7))

// if bit 7 of Port B is 1

DDRB = DDRB & ~(1<<4);// bit 4 of Port B is input

else
DDRB = DDRB | (1<<4); //bit 4 of Port B is output
}
return 0;
}

Bitwise Shift Operators in C: Example

7-24
//
Write an AVR C program to get the status of bit 5 of
// Port B and send it to bit 7 of port C continuously.
#include <avr/io.h>
// standard AVR header
int main(void){
DDRB = DDRB & ~(1<<5); // bit 5 of Port B is input
DDRC = DDRC | (1<<7); // bit 7 of Port C is output
while (1){
if(PINB & (1<<5))
// set bit 7 of Port C to 1
PORTC = PORTC | (1<<7);
else
// clear bit 7 of Port C to 0
PORTC = PORTC & ~(1<<7);
}
return 0;
}

Bitwise Shift Operators in C: Example

7-25
//
A door sensor is connected to the port B pin 1, and an
// LED is connected to port C pin 7. Write an AVR C
// program to monitor the door sensor and, when it opens,
// turn on the LED.
#include <avr/io.h>
// standard AVR header
#define LED 7
#define SENSOR 1
int main(void){
DDRB
=
DDRB & ~(1<<SENSOR); // SENSOR pin is input
DDRC
=
DDRC | (1<<
LED); // LED pin is output
while(1){
if(PINB & (1<<SENSOR)) // check SENSOR pin of PINB
// set LED pin of Port C
PORTC
=
PORTC | (1<<LED);
else
// clear LED pin of Port C
PORTC
=
PORTC & ~(1<<LED);
}
return 0;
}

Data Conversion Programs in C:

Example
7-26
//
Write an AVR
C program to convert packed BCD

0x29 to

// ASCII and display the bytes on PORTB and PORTC.

#include <avr/io.h>

// standard AVR header

int main(void){
unsigned char
unsigned

char mybyte = 0x29;

DDRB = DDRC = 0xFF;

// make

x = mybyte & 0x0F;

// mask upper

PORTB

// make

it ASCII

y = mybyte & 0xF0;

// mask

lower

y =

// shift

it

x | 0x30;

y >> 4;

PORTC

y | 0x30;

while(1);
return
}

x, y;

// make

Ports

and C

bits

bits

to

lower

it ASCII

// stay here
0;

output

bits

Data Conversion Programs in C:

Example
//Write
an AVR7-27
C program to convert ASCII digits

of '4
// and '7' to packed BCD and display them on PORTB.
#include <avr/io.h> //standard AVR header
int main(void){
unsigned char bcdbyte;
unsigned char w = '4';
unsigned char z = '7';
DDRB
=
0xFF; // make Port B an output
w &= 0x0F;
// mask 3
w <<= 4;
// shift left to make upper BCD digit
z &= 0x0F;
// mask 3
bcdbyte = w | z; // combine to make packed BCD
PORTB = bcdbyte;
while(1);
return 0;
}

Checksum byte in ROM

Add the bytes together and drop the carries.

Take the 2's complement of the total sum.
This is the checksum byte, which becomes the
last byte of the series.
E.g. For 25H, 62H, 3FH, and 52H
sum = 25H, 62H, 3FH, and 52H = 118H
discard caries, sum = 18H
checksum = ~sum + 1
= ~(18H) + 1
= E7 + 1
= E8
Error = 25H + 62H + 3FH + 52H + E8 = 200
After discarding carries if remaining 8-bit
answer is zero that means no error.

Data Conversion Programs in C:

Example
7-29
//
Write an AVR
C program to calculate the checksum

byte

// for the data given in Example 7-28.

#include <avr/io.h>
int main(void){
// standard AVR header
unsigned char mydata[] = { 0x25, 0x62, 0x3F, 0x52};
unsigned char sum = 0;
unsigned char x; unsigned char chksumbyte;
DDRA = 0xFF;
// make Port A output
DDRB = 0xFF;
// make Port B output
DDRC = 0xFF;
// make Port C output
for(x=0; x<4; x++){
PORTA = mydata[x]; // issue each byte to PORTA
sum = sum + mydata[x] ; // add them together
} PORTB = sum;
// issue the sum to PORTB
chksumbyte = ~sum + 1; PORTC = chksumbyte;
return 0;
}

Data Conversion Programs in C:

Example
7-30 to perform step (b) of Example
//
Write a C program

7-28.
// If the data is good, send ASCII character 'G' to PORTD.
// Otherwise, send 'B' to PORTD.
#include <avr/io.h>
// standard AVR header
int main(void){
unsigned char mydata[] = {0x25,0x62,0x3F,0x52,0xE8};
unsigned char chksum = 0;
unsigned char x;
DDRD = 0xFF;
// make
Port D an output
for( x=0 ; x<5 ; x++ ) // add them together
chksum = chksum + mydata[x] ;
if(chksum == 0)
PORTD = 'G';
else
PORTD = 'B';
while(1); return 0;
}

Data Conversion Programs in C:

Example
7-31
//
Write an AVR
C program to convert 11111101 (FD

hex) to
// decimal and display the digits on PORTB, PORTC, PORTD.
#include <avr/io.h>
//standard AVR header
int main(void){
unsigned char x, binbyte, d1, d2, d3;
DDRB = DDRC = DDRD = 0xFF; //Ports B, C and D are output
binbyte = 0xFD;
//binary (hex) byte
x = binbyte / 10;
// divide by 10
d1 = binbyte % 10;
// find remainder
(LSD)
d2 = x % 10;
// middle digit
d3 = x / 10;
// most-significant digit(MSD)
PORTB = d1;
PORTC = d2;
PORTD = d3;
while(1);
return 0;
}

Data Types Conversion Functions in C

stdlib.h header file has some useful

functions to convert integer to string or
string to integer.

Function Name

Description

int atoi(char *str)

Converts the string str to

integer

long atol(char *str)

Converts the string str to

long

void itoa(int n, char

*str)

Converts the integer n to

characters in string str

void ltoa(int n, char

*str)

Converts the long n to

characters in string str

float atof(char *str)

Converts the characters

from string str to float

Accessing EEPROM in AVR

Every member of the AVR microcontrollers has

some amount of on-chip EEPROM.
The data in SRAM will be lost if the power is
disconnected.
EEPROM memory can save stored data even when
the power is cut off.
The Size of EEPROM in different AVR Microcontrollers is given below
Chip

Bytes

Chip

Bytes

Chip

Bytes

ATmega8

512

ATmega 16

512

ATmega32

1024

ATmega64

2048

ATmegal28

4096

ATmega256RZ

4096

ATmega640

4096

ATmegal280

4096

ATmega2560

4096

EEPROM Registers

There are three I/O registers that are

directly related to EEPROM. These are
EECR (EEPROM Control Register)
EEDR (EEPROM Data Register)
EEARH-EEARL (EEPROM Address Register High-Low)
EEPROM Data Register (EEDR)
To Read/write data to EEPROM, you have to
Read/write to the EEDR register.
EEPROM Address Register (EEARH and EEARL)
The EEARH:EEARL registers together make a 16bit register to address each location in
EEPROM memory space.
When you want to read from or write to EEPROM,
you should load the EEPROM location address in
EEARs.

EEPROM Registers

Only 10 bits of the EEAR registers are used

in ATmega32. Because ATmega32 has 1024-byte
EEPROM locations,
ATmega16 has 512 bytes of EEPROM So 9 bits of
the EEAR registers are used

EEPROM Control Register (EECR)

The EECR register is used to select the kind
of operation to perform on. The operation can
be start, read, and write.

EEPROM Registers

The bits of the EECR register are as follows:

EEPROM Read Enable (EERE): Setting this bit to
one will cause a read operation if EEWE is
zero. When a read operation starts, one byte
of EEPROM will be read into the EEPROM Data
Register (EEDR). The EEAR register specifies
the address of the desired byte.
EEPROM Write Enable (EEWE) and EEPROM Master
Write Enable (EEMWE): When EEMWE is set,then
within four clock cycles setting EEWE will
start a write operation. If EEMWE is zero,
setting EEWE to one will have no effect.

EEPROM Registers

The When you set EEMWE to one, the hardware

clears the bit to zero after four clock
cycles. This prevents unwanted write
operations on EEPROM contents.
Notice that you cannot start read or write
operations before the last write operation is
finished. You can check for this by polling
the EEWE bit. If EEWE is zero it means that
EEPROM is ready to start a new read or write
operation.
EEPROM Ready Interrupt Enable (EERIE): This
will be explained in Chapter 10 Figure 6-16,
bits 4 to 7 of EECR are unused at the present
time and are reserved.

Programming the AVR to write on

EEPROM

To write on EEPROM the following steps should

be followed. Notice that steps 2 and 3 are
optional, and the order of the steps is not
important. Also note that you cannot do
anything between step 4 and step 5 because the
hardware clears the EEMWE bit to zero after
four clock cycles.
1.
Wait until EEWE becomes zero.
2.
Write new EEPROM address to EEAR (optional).
3.
Write new EEPROM data to EEDR (optional).
4.
Set the EEMWE bit to 1, and Within four clock
cycles after setting EEMWE, set EEWE to one.
5.
Wait until EEWE becomes zero.

EEPROM Access in C: Example 7-36

// Write an AVR C program to store a' into location
// Ox005F of EEPROM.
#include <avr/io.h> //standard AVR header
int main(void){
while(EECR&(1<<EEWE)); //wait for last write to finish
EEAR

= 0x5F; //write

EEDR

= a; //write

0x5F to address register

a to data register

// EECR |= 0x06;
EECR |= (1<<EEMWE)|(1<<EEWE);
while(EECR&(1<<EEWE)); //wait for last write to finish
while(1);
return
}

0;

EEPROM Access in C: Example 7-37

// Write an AVR C program to read the content of location
// 0x005F of EEPROM into PORTB.
#include <avr/io.h> //standard AVR header
int main(void){
DDRB = 0xFF;
//make PORTB an output
while(1){
//wait for last write to finish
while (EECR & (1<<EEWE));
EEAR = 0x5F; // write 0x5F to address

register

//start EEPROM read by writing EERE

EECR |= (1<<EERE);
//move data from data
PORTB = EEDR;
}
while(1); return 0;
}

register

to

PORTB

EEPROM Access in C
// Write an AVR C program to store a' into location
// Ox005F of EEPROM then read from EEPROM.
#include <avr/io.h> //standard AVR header
int main(void){
DDRB = 0xFF;
//make PORTB an output
while(EECR&(1<<EEWE)); //wait for last write to finish
EEAR = 0x5F; //write 0x5F to address register
EEDR = 'a'; //write a to data register
// EECR |= 0x06;
EECR |= (1<<EEMWE)|(1<<EEWE);
while (EECR & (1<<EEWE));
EEAR = 0x5F;
// write 0x5F to address register
EEDR = 0x00;
//start EEPROM read by writing EERE
EECR |= (1<<EERE);
//move data from data register to PORTB
PORTB = EEDR;
while(1);
return 0;
}